Accessing a member of a Type once I've found it?

For Platform:TypPlatform=EachIn PlatformList
	If ImagesCollide2 (TextureMousePointerTip, MX, MY, 0, 0, 1.0, 1.0, PlatformsFramesArray[Platform.IDNumber], Platform.XCurrentPosition, Platform.YCurrentPosition, 0, 0, 1.0, 1.0) Then
		Platform.XCurrentPosition=MX
		Platform.YCurrentPosition=MY

'What do I do here?
'->		'I need to set a variable or reference to this type instance here so I can access it later

		Exit	'leave the For loop, as a match was found and stored
	EndIf
Next


'later on,
Platform (the platform Type instance from before).Access it like I did when I was in the EachIn For loop
'do stuff to the platform

Type myType

    Field value:Int

    Method run()
        Print value
	myFunctionA(value) 'value could have been of any other type except self
	Print value
	myFunctionB(Self)
	Print value
    End Method
End Type

Function myFunctionA(o:Int Var) 'this function work's
    o = 10
End Function

Function myFunctionB(o:Object) 'this one not no matter I set o:Object or o:myType ...
    myType(o).value = 20           'Casting won't help too
End Function

Local t:myType = New myType
t.run

SuperStrict
Global List:TList = CreateList()
Global theoneyouwant:Object


Type Test
	Field str:String
EndType



For Local enum:Int = 0 To 3
	Local A:Test = New Test
	
	If enum = 2 Then
		A.str = "testing"
	Else
		A.str = "lewl"
	EndIf
	
	ListAddLast List, A
Next


For Local e:Test = EachIn List
	If e.str = "testing" Then
		theoneyouwant = e
	EndIf
Next

Print Test(theoneyouwant).str

Test(theoneyouwant).str = "lewl"


For Local e:Test = EachIn List
	Print e.str
Next

For Local e:Test = EachIn List
	If e.str = "testing" Then
		theoneyouwant = e
		Exit
	EndIf
Next

Global theoneyouwant:Object
'and
Test(theoneyouwant).str =

SuperStrict
Global List:TList = CreateList()
Global theoneyouwant:Test


Type Test
	Field str:String
EndType


Print "The List:"
For Local enum:Int = 0 To 3
	Local A:Test = New Test
	
	If enum = 2 Then
		A.str = "testing"
	Else
		A.str = "lewl"
	EndIf
	
	ListAddLast List, A
	Print A.str
Next


Print "~n~n~n"

For Local e:Test = EachIn List
	If e.str = "testing" Then
		theoneyouwant = e
		Exit
	EndIf
Next

Print theoneyouwant.str

theoneyouwant.str = "lewl"

Print "~n~n~nNew List:"
For Local e:Test = EachIn List
	Print e.str
Next

Type TMyType '<- This defines the type, nothing is actually created until you call new
   Field a:int
   Field b:int
   Field c:int
End Type

Local MyType:TMyType = New TMyType 'an instance of TMyType is created.  A table containing a:int, b:int, c:int is created and MyType holds a reference to that table.
Local YourType:TMyType = New TMyType 'another table is created and the reference to that one is held here.
Local OtherType:TMyType = YourType 'nothing is created here.  The reference to YourType is copied to OtherType.  They both point to the same values.

MyType.a = 10 'The a:int contained within the table pointed to by MyType is changed to 10
YourType.a = 5 'YourType a:int is changed to 5, but since YourType points to the same place as OtherType, OtherType is affected as well.

Print "MyType.a = "+MyType.a
Print "YourType.a = "+YourType.a
Print "OtherType.a = "+OtherType.a

'**** STORING THE STRING INTO POINTER ****

Global MyPointer:String(v:String)

MyPointer = StoreString

Type My
	Global List:TList = CreateList()
	Field str:String
End Type

Function StoreString:String(v:String)
	For m:My = Eachin My.List
		if m.str = v Then Return m.str
	Next
End Function

'.... Run your code ....

string:String = MyPointer("lewl")


'**** STORING THE OBJECT INTO POINTER ****

Global MyPointer:My(v:String)

MyPinter = StoreObject

Type My
	Global List:TList = CreateList()
	Frield str:String
End Type

Function StoreObject:My(v:String)
	For m:My = Eachin My.List
		If m.str = v Then Return m
	Next
End Function

'.... Run Your Code ....

Object:My = MyPointer("lewl")

Local MyObject:TMyObject = new TMyObject
Local SameObject:TMyObject = MyObject
'There is only one object in memory.  Both MyObject and SameObject point to it.

'We remove one reference.  The object is still in memory because SameObject still points to it.
MyObject = Null

'We now remove the second reference
SameObject = Null

'After removing the reference held by SameObject, there are no more pointing to the object, so the GC then removes the object from memory.  It no longer exists.

Local MyType:TMyType = New TMyType
Local OtherType:TMyType = New TMyType
'Two objects are created, and a reference to each are created

'Another point of the code not shown here defines TMyType with a field Sibling pointing to a TMyType.
'We will use that field to point one object to the other
MyType.Sibling = OtherType
OtherType.Sibling = MyType

'At this point of the code, we still only have 2 objects in memory, but each object is referenced twice.

'now we don't need the objects anymore, lets get rid of them in the conventional way.
MyType = Null
OtherType = Null

'Wait a minute, the objects are not being removed from memory.  The reason is because
'there still is a reference to each object within the other object, and there is no longer any way to access
'those objects!  That is a memory leak.
'No need to worry too much.  if you are only talking about a couple of objects, they will be removed when the program ends
'but when you have a list with thousands of objects, getting recreated over and over again,
'then you have problems.

'To avoid this problem, you should remove the reference inside the types before removing the main references.
'
'MyType.Sibling = Null
'OtherType.Sibling = Null
'MyType = Null
'OtherType = Null
'
'Or avoid using circular references when you can.

Global oldobject:My = New My.Set("lewl")

Type My

	Field str:String
	Global List:TList = CreateList()

	Method Set:My(value:String)
		self.str = value
		My.List.AddLast(Self)
		Return Self
	End Method

	'No Fields
	Function Get:My(value:String)
		For m:My = Eachin My.List
			If value = m.str
				My.List.Remove(m)
				Return New My.Set(value)
			EndIf
		Next
	End Function

	Function Clone:My(Value:String)
		For m:My = Eachin My.List
			If value = m.str
				Return m
			EndIf
		Next
	End Function

	Function Modify(m:My var, value:String)
		For i:My = Eachin My.List
			If value = i.str
				m.str = value
			Endif
		Next
	End Function

	Function Store(value:String Var, test:String)
		For m:My = Eachin My.List
			If test = m.str
				value = m.str
			Endif
		Next
	End Function

End Type

local test:String = "lewl"

local newobject:My = My.Get(test) ' Creates a new one removes old one from list based on the value.

local tmpobject:My = My.Clone(test) ' Creates a new one and clones it base don the value.

''' ALTERN '''''

My.Modify(oldobject, test) ' Modifies the oldobject istead of creating a new one based on the value.

local test2:String

My.Store(test2, test) ' This stores the value (you can use any variable you want Int, Float, etc), into a local or global to be used later.