Added conversion & iteration methods with tests

Author: Alokzh

src/Containers-Stack-Tests/CTStackTest.class.st

@@ -28,6 +28,28 @@ CTStackTest >> testAlternatingPushPop [
 	self assert: stack size equals: 2
 ]
 
+{ #category : 'tests' }
+CTStackTest >> testAsArray [
+
+	| result |
+	stack push: 'first'; push: 'second'; push: 'third'.
+	result := stack asArray.
+	
+	self assert: result equals: #('third' 'second' 'first').
+	"Elements from top to bottom"
+]
+
+{ #category : 'tests' }
+CTStackTest >> testAsOrderedCollection [
+
+	| result |
+	stack push: 'a'; push: 'b'; push: 'c'.
+	result := stack asOrderedCollection.
+	
+	self assert: result class equals: OrderedCollection.
+	self assert: result asArray equals: #('c' 'b' 'a').
+]
+
 { #category : 'tests' }
 CTStackTest >> testAvailableSpace [
 
@@ -48,6 +70,29 @@ CTStackTest >> testCapacity [
 	self assert: stack capacity equals: 5. "Capacity doesn't change"
 ]
 
+{ #category : 'tests' }
+CTStackTest >> testCopyCreatesNewObject [
+
+	| copy |
+	stack
+		push: 'a';
+		push: 'b'.
+	copy := stack copy.
+	self deny: stack identicalTo: copy
+]
+
+{ #category : 'tests' }
+CTStackTest >> testCopyHasSameContents [
+
+	| copy |
+	stack push: 'first'; push: 'second'; push: 'third'.
+	copy := stack copy.
+	
+	self assert: copy size equals: stack size.
+	self assert: copy top equals: stack top.
+	self assert: copy capacity equals: stack capacity
+]
+
 { #category : 'tests' }
 CTStackTest >> testDefaultStackCreation [
 
@@ -60,6 +105,18 @@ CTStackTest >> testDefaultStackCreation [
 	self assert: defaultStack availableSpace equals: 10
 ]
 
+{ #category : 'tests' }
+CTStackTest >> testDoIteration [
+
+	| elements |
+	stack push: 'first'; push: 'second'; push: 'third'.
+	elements := OrderedCollection new.
+	
+	stack do: [ :each | elements add: each ].
+	
+	self assert: elements asArray equals: #('third' 'second' 'first')
+]
+
 { #category : 'tests' }
 CTStackTest >> testIsEmpty [
 
@@ -80,6 +137,45 @@ CTStackTest >> testIsFull [
 	self deny: stack isFull
 ]
 
+{ #category : 'tests' }
+CTStackTest >> testLIFOOrdering [
+
+	stack push: 'first'; push: 'second'; push: 'third'; push: 'fourth'.
+	
+	self assert: stack pop equals: 'fourth'.
+	self assert: stack pop equals: 'third'.
+	self assert: stack pop equals: 'second'.
+	self assert: stack pop equals: 'first'
+]
+
+{ #category : 'tests' }
+CTStackTest >> testLargeCapacityStack [
+
+	| largeStack |
+	largeStack := CTStack new: 1000000.
+	
+	1 to: 1000000 do: [ :i | largeStack push: i ].
+	self assert: largeStack isFull.
+	self assert: largeStack top equals: 1000000.
+	
+	1000000 to: 1 by: -1 do: [ :i |
+		self assert: largeStack pop equals: i
+	].
+	self assert: largeStack isEmpty
+]
+
+{ #category : 'tests' }
+CTStackTest >> testPopAllElements [
+
+	stack push: 'a'; push: 'b'; push: 'c'.
+	
+	stack pop; pop; pop.
+	
+	self assert: stack isEmpty.
+	self assert: stack size equals: 0.
+	self assert: stack availableSpace equals: 5
+]
+
 { #category : 'tests' }
 CTStackTest >> testPopMultipleElements [
 
@@ -189,6 +285,44 @@ CTStackTest >> testPushToFullStack [
 	self should: [ stack push: 'overflow' ] raise: Error
 ]
 
+{ #category : 'removing' }
+CTStackTest >> testRemoveAll [
+
+	stack push: 'a'; push: 'b'; push: 'c'.
+	stack removeAll.
+	
+	self assert: stack isEmpty.
+	self assert: stack size equals: 0.
+	self assert: stack availableSpace equals: 5
+]
+
+{ #category : 'tests' }
+CTStackTest >> testRemoveAllOnEmptyStack [
+
+	stack removeAll.
+	
+	self assert: stack isEmpty.
+	self assert: stack size equals: 0
+]
+
+{ #category : 'tests' }
+CTStackTest >> testSearchExistingElement [
+
+	stack push: 'a'; push: 'b'; push: 'c'; push: 'b'.
+	
+	self assert: (stack search: 'b') equals: 1. "Top element"
+	self assert: (stack search: 'c') equals: 2.
+	self assert: (stack search: 'a') equals: 4. "Bottom element"
+]
+
+{ #category : 'tests' }
+CTStackTest >> testSearchNonExistentElement [
+
+	stack push: 'a'; push: 'b'; push: 'c'.
+	
+	self assert: (stack search: 'x') equals: -1
+]
+
 { #category : 'tests' }
 CTStackTest >> testSize [
 

src/Containers-Stack/CTStack.class.st

@@ -34,6 +34,28 @@ CTStack class >> new: anInteger [
 		yourself
 ]
 
+{ #category : 'converting' }
+CTStack >> asArray [
+
+	| result |
+	self isEmpty ifTrue: [ ^ #() ].
+	
+	result := Array new: self size.
+	1 to: self size do: [ :i |
+		result at: i put: (elements at: topIndex - i + 1)
+	].
+	^ result
+]
+
+{ #category : 'converting' }
+CTStack >> asOrderedCollection [
+
+	| result |
+	result := OrderedCollection new: self size.
+	self do: [ :each | result add: each ].
+	^ result
+]
+
 { #category : 'accessing' }
 CTStack >> availableSpace [
 
@@ -46,6 +68,30 @@ CTStack >> capacity [
 	^ capacity 
 ]
 
+{ #category : 'copying' }
+CTStack >> copy [
+
+	
+	| copy |
+	copy := self class new: capacity.
+	self isEmpty ifTrue: [ ^ copy ].
+	
+	1 to: topIndex do: [ :i |
+		copy push: (elements at: i)
+	].
+	^ copy
+]
+
+{ #category : 'enumerating' }
+CTStack >> do: aBlock [ 
+
+	self isEmpty ifTrue: [ ^ self ].
+	
+	topIndex to: 1 by: -1 do: [ :i |
+		aBlock value: (elements at: i)
+	]
+]
+
 { #category : 'initialization' }
 CTStack >> initializeWithCapacity: anInteger [
 
@@ -92,13 +138,37 @@ CTStack >> push: anObject [
 	^ anObject
 ]
 
+{ #category : 'showing' }
+CTStack >> pushAll: aCollection [
+
+	aCollection do: [ :each | self push: each ].
+	^ aCollection isEmpty ifFalse: [ aCollection last ] ifTrue: [ nil ]
+]
+
 { #category : 'removing' }
 CTStack >> removeAll [
 
 	1 to: topIndex do: [ :i | elements at: i put: nil ].
 	topIndex := 0
 ]
 
+{ #category : 'accessing' }
+CTStack >> search: anObject [
+
+	"Return the 1-based position of anObject from the top of the stack.
+	Return -1 if the object is not found.
+	The top element is at position 1."
+	
+	self isEmpty ifTrue: [ ^ -1 ].
+	
+	topIndex to: 1 by: -1 do: [ :i |
+		(elements at: i) = anObject ifTrue: [ 
+			^ topIndex - i + 1 
+		]
+	].
+	^ -1
+]
+
 { #category : 'accessing' }
 CTStack >> size [