January 15, 2021, 05:00:41 PM

Author Topic: [bb] Push/Pop Data Functions 2 by N [ 1+ years ago ]  (Read 485 times)

Offline BlitzBot

  • Jr. Member
  • **
  • Posts: 1
[bb] Push/Pop Data Functions 2 by N [ 1+ years ago ]
« on: June 29, 2017, 12:28:38 AM »
Title : Push/Pop Data Functions 2
Author : N
Posted : 1+ years ago

Description : These functions are a revised version of my previous push/pop stack functions.  Instead of using banks, they now use types so that you can push and pop to and from the front and the back of the stacks without worrying about memory access violations.

Code :
Code: BlitzBasic
  1. ;#Region DESCRIPTION
  2.         ;; Stack sub-system used for organization of objects
  3. ;#End Region
  4.  
  5. ;#Region CLASSES
  6.         Type Stack
  7.                 Field F.StackObject
  8.                 Field L.StackObject
  9.                 Field Objects%
  10.         End Type
  11.        
  12.         Type StackObject
  13.                 Field Content$
  14.                 Field Class$
  15.                 Field N.StackObject
  16.                 Field P.StackObject
  17.  
  18.                 Field Parent.Stack
  19.                 Field z
  20.         End Type
  21.        
  22.         Global STACK_Class$
  23.         Global STACK_Content$
  24. ;#End Region
  25.  
  26. ;#Region PROCEDURES
  27.         Function CreateStack( )
  28.                 Local s.Stack = New Stack
  29.                
  30.                 Return Handle( s )
  31.         End Function
  32.        
  33.         Function PushObject( Stack , Content$ , Class$="", ToFront = 0 )
  34.                 Local s.Stack = Object.Stack (Stack )
  35.                
  36.                 If s = Null Then Return 0
  37.                
  38.                 Local Index = sObjects
  39.                
  40.                 Local i.StackObject = New StackObject
  41.                
  42.                 iContent = Content
  43.                 iClass = Class
  44.                 iParent = s
  45.                
  46.                 If ToFront <= 0 Then
  47.                         Local l.StackObject = sL
  48.                         If l <> Null Then
  49.                                 lN = i
  50.                                 iP = l
  51.                         EndIf
  52.                         sL = i
  53.                         If sF = Null Then sF = i
  54.                 Else
  55.                         Local f.StackObject = sF
  56.                         If f <> Null Then
  57.                                 fP = i
  58.                                 iN = f
  59.                         EndIf
  60.                         sF = i
  61.                         If sL = Null Then sL = i
  62.                 EndIf
  63.                
  64.                 i = sObjects
  65.                
  66.                 sObjects = sObjects + 1
  67.                
  68.                 If DEVELOP And LOG_STACK Then DebugLog "Push "+Stack +" "+ Index +" "+ Content
  69.                
  70.                 Return Index
  71.         End Function
  72.        
  73.         Function PopObject$( Stack , FromFront = 0 )
  74.                 Local s.Stack = Object.Stack( Stack )
  75.                
  76.                 Local Content$ = "",Class$ = ""
  77.                
  78.                 If s = Null Then Return Content
  79.                
  80.                 If FromFront <= 0 Then
  81.                         If sL = Null Then Return Content
  82.                        
  83.                         Local l.StackObject = sL
  84.                        
  85.                         If lP <> Null Then
  86.                                 lPN = Null
  87.                                 sL = lP
  88.                         EndIf
  89.                        
  90.                         If sL = Null Then sL = sF
  91.                        
  92.                         Content = lContent
  93.                         Class = lClass
  94.                        
  95.                         Delete l
  96.                 Else
  97.                         If sF = Null Then Return Content
  98.                        
  99.                         Local f.StackObject = sF
  100.                        
  101.                         If fP <> Null Then
  102.                                 fNP = Null
  103.                                 sF = fN
  104.                         EndIf
  105.                        
  106.                         If sF = Null Then sF = sL
  107.                        
  108.                         Content = fContent
  109.                         Class = fClass
  110.                        
  111.                         Delete f
  112.                 EndIf
  113.                
  114.                 If DEVELOP And LOG_STACK Then DebugLog "Pop "+Stack+" "+Content
  115.                 STACK_Content = Content
  116.                 STACK_Class = Class
  117.                 Return Content
  118.         End Function
  119.        
  120.         Function GetObject$( Stack, Index, RemoveData=0 )
  121.                 Local Content$ = "",Class$ = ""
  122.                
  123.                 Local s.Stack = Object.Stack( Stack )
  124.                
  125.                 If s = Null Then Return Content
  126.                
  127.                 Local i
  128.                 Local f.StackObject = sF
  129.                
  130.                 If f = Null Then Return Contents
  131.                
  132.                 For i = 0 To Index-1
  133.                         If fN = Null Then Exit
  134.                         f = fN
  135.                 Next
  136.                
  137.                 Content = fContent
  138.                 Class = fClass
  139.                
  140.                 If RemoveData > 0 Then
  141.                         If fN <> Null Then fNP = fP
  142.                         If fP <> Null Then fPN = fN
  143.                        
  144.                         If sL = f Then sL = fP
  145.                         If sF = f Then sF = fN
  146.                        
  147.                         sObjects = sObjects - 1
  148.                        
  149.                         Delete f
  150.                 EndIf
  151.                
  152.                 If DEVELOP And LOG_STACK Then DebugLog "Get "+Stack+" "+Index+" "+Content+" "+RemoveData
  153.                
  154.                 STACK_Class = Class
  155.                 STACK_Content = Content
  156.                
  157.                 Return Content
  158.         End Function
  159.        
  160.         Function GetObjectF#( Stack, Index, RemoveData=0 )
  161.                 Return Float(GetObject(Stack,Index,RemoveData))
  162.         End Function
  163.        
  164.         Function GetObjectI%( Stack, Index, RemoveData=0 )
  165.                 Return Int(GetObject(Stack,Index,RemoveData))
  166.         End Function
  167.        
  168.         Function InsertObject( Stack, At, Content$, Class$="" )
  169.                 Local s.Stack = Object.Stack( Stack )
  170.                
  171.                 If s = Null Then Return -1
  172.                
  173.                 Local i
  174.                 Local f.StackObject = sF
  175.                
  176.                 If f = Null Then Return PushObject( Stack, Content)
  177.                
  178.                 For i = 0 To At-1
  179.                         If fN = Null Then Exit
  180.                         f = fN
  181.                 Next
  182.                
  183.                 Local n.StackObject = New StackObject
  184.                 nContent = Content
  185.                 nClass = Class
  186.                 nParent = s
  187.                
  188.                 If f <> Null Then
  189.                         nN = fN
  190.                         nP = f
  191.                         fN = n
  192.                 EndIf
  193.                
  194.                 sObjects = sObjects + 1
  195.                
  196.                 If DEVELOP And LOG_STACK Then DebugLog "Insert "+Stack+" "+At+" "+Content
  197.                
  198.                 Return i
  199.         End Function
  200.        
  201.         Function MoveObject( Stack, TakeFrom, MoveTo )
  202.                 Local cont$ = GetObject(Stack,TakeFrom,1)
  203.                 Return InsertObject(Stack, MoveTo-1,cont$,STACK_Class)
  204.         End Function
  205.        
  206.         Function MoveObjectToFront( Stack, Index )
  207.                 Local cont$ = GetObject(Stack,Index,1)
  208.                 Return PushObject(Stack,cont$,1)
  209.         End Function
  210.        
  211.         Function MoveObjectToBack( Stack, Index )
  212.                 Local cont$ = GetObject(Stack,Index,1)
  213.                 Return PushObject(Stack,cont$,0)
  214.         End Function
  215.        
  216.         Function Objects( Stack )
  217.                 Local s.Stack = Object.Stack( Stack )
  218.                
  219.                 If s = Null Then Return -1
  220.                
  221.                 Return sObjects
  222.         End Function
  223.        
  224.         Function FreeStack( Stack )
  225.                 Local s.Stack = Object.Stack( Stack )
  226.                
  227.                 If s = Null Then Return 0
  228.                
  229.                 Delete s
  230.                
  231.                 Local i.StackObject = Null
  232.                
  233.                 For i = Each StackObject
  234.                         If iParent = Null Then
  235.                                 Delete i
  236.                         EndIf
  237.                 Next
  238.                
  239.                 If DEVELOP And LOG_STACK Then DebugLog "Free "+Stack
  240.                
  241.                 Return 1
  242.         End Function
  243.        
  244.         Function Debug_StackContents(stack)
  245.                 For i = 0 To Objects(stack)-1
  246.                         s$ = s$+" | "+GetObject(stack,i)
  247.                 Next
  248.                
  249. ;               If Right(s$,2) = "| " Then s$ = Left(s$,Len(s)-3)
  250.                 DebugLog s$
  251.         End Function
  252. ;#End Region


Comments :


Drey(Posted 1+ years ago)

 hey, it's intersesting u made this.  I'm making something similiar too.  I'm calling it a DataTree. I started it about a month ago before i read this. It works off banks inside types.Tell me how u handle your stack system exactly.  Y did u make it?  I have my reasons for the DataTree.  i want to see if we had similar reasons.


N(Posted 1+ years ago)

 Well, how do you mean 'handle it', as in how I push/pop/insert data?  Basically, it's the same concept behind a linked list (you may want to look up some 'simple linked list' examples on Google).As for my reasons, I use it for a lot of stuff.  First thing I wrote it for was my GL engine for Blitz, in which I used it to store vertices, polygons, and textures in a large pseudo-dynamic array.  Now I use it for my scripting engines, GUI systems, shader system, and general organization and storing (for easy retrieval at a later time) of any data.


Drey(Posted 1+ years ago)

 Well, maybe datatree system is something similar.  I'll let u check it out sometime.  It more like a network now, but that's ok.  It's extremely flexible and easy for scripting too.  One could access any variable.  Also with it's search system..it doesn't search, it just gets direct by the name instead.  So it process only takes as long as how many characters are in the name.  Basicly, it's used to replace types too. The only type ever used is the branch type, which is the tree.  U create your own types and properities through it's branches.The reason i ask "how u handle it" is because i was thining about testing it out myself.  but i was looking at it an i wasn't sure how the whole system work for inputting data and such.  that's all. Maybe u should have an example in your code.


 

SimplePortal 2.3.6 © 2008-2014, SimplePortal