[bb] Push/Pop Data Functions 2 by N [ 1+ years ago ]

[BlitzBot]

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.