How to copy a Type

Normally, I wouldn't have a problem with a memcopy between two types using VarPtr and SizeOf... but what happens if there's a reference inside the type...

That gets memcopied, but there would be no way for the garbage collector to know that has happenned... so I'm thinking there's probably some inbuilt way to copy a type, that for the life of me I can't find in the manual. Does anyone know if that's the case/what it is? =]

I think you need to make your own copy method.

This is standard in OOP systems. Implement a clone command or something :)

That sucks. All these built in commands in the language and no CopyType... how hard could it be...

You need a deepCopy Command, so that an objects returns copies of its object.
Normaly a simple task to code if it would be possible to access methodnames and fieldnames in a Type.
All you would need then is a deepCopy method in your superclass that iterates over Methods and calls them dynamically.
But i think this is only possible with an Interpreter Language or is there a way to call a function when i only have a string representation ?

Like (psyeudocode)
func$="getName"
Object.call(func$)

Copytype
type copy
type copy2

Thanks tonyg, but all three of those methods use a straight memcopy, which suffers from new references not being picked up by the garbage collector.

I still don't understand why there isn't a built in method for this - surprisingly, FlameDuck's answer in one of those threads didn't help.

Without runtime reflection? Impossible.

Impossible. Here is a more thorough example:

Strict

Type aType
	Field aField:Int
	
	Method deepClone:aType()
		Local temp:aType = New aType
		temp.aField = aField
		Return temp
	EndMethod
EndType

Type bType
	Field bField:Int
	
	Method deepClone:bType()
		Local temp:bType = New bType
		temp.bField = bField
		Return temp
	EndMethod
EndType


Type compositeType
	Field myAType:aType
	Field myBType:bType
	
	Function Create:compositeType( aVal , bVal )
		Local temp:compositeType = New compositeType
		temp.myAType = New aType
		temp.myAtype.aField = aVal
		temp.myBType = New bType
		temp.myBType.bField = bVal
		Return temp
	EndFunction

	Method toString:String()
		Return "aType.aField = " + myAType.aField + " - bType.bField = " + myBType.bField
	EndMethod'
	
	Method deepClone:compositeType()
		Local temp:compositeType = New compositeType
		temp.myAType = myAType.deepClone()
		temp.myBType = myBType.deepClone()
		Return temp
	EndMethod
EndType

Local compType1:compositeType = compositeType.Create( 1 , 2 )
Local compType2:compositeType = compType1.deepClone()
Print "Before alteration: "
Print "compType1: " + compType1.toString()
Print "compType2: " + compType2.toString()
compType2.myAType.aField = 3
compType2.myBType.bField = 4
Print 
Print "After alteration: "
Print "compType1: " + compType1.toString()
Print "compType2: " + compType2.toString()
End

Because BlitzMAX doesn't support runtime reflection.

I don't think you are talking about reflection, see this article: http://en.wikipedia.org/wiki/Reflection_(computer_science)

You can't memcopy a class in any languages and it has nothing to do with reflection.
Even java which is heavily class based has a clone function that you have to override.

Deeply wrong. Impossible for us BlitzMax users, certainly (without refelection). But not for Mark. A special command to copy an object is entirely doable. At least a shallow copy. For a deep copy, the problem is more that you'd need at least a way to tell the compiler which reference fields have to be taken into account in the deep copy (or else you'd very soon have an infinite recursion while deep-copying; not to say you are the only one to know which sub-objects would
simply make sense to deep copy).
So again, wrong. Especially interesting is the fact that what you quoted specifically mentions a "built-in" method, not something the BlitzMax users would write.

I am. If you can examine the structure of the object you want to copy at runtime - you can deep clone it.

But if you had reflection, you could "rebuild" the class from scrap, and copy over it simple datatypes.

It has an interface (IClonable) that you have to implement. That doesn't mean that by using reflection you can't make your own "CloneAnything" functionality, as long as you're careful.

Is there some significant difference, between a "built-in" shallow copy, and the memcopy methods mentioned above?

The new references will be visible to the garbage collector.

Yes. Thank you peoples, I'm not just dreaming here =]

I don't see any reason why the compiler can't crate a Clone method inside every type which could basically do a shallow copy exactly the same way we do it now - field by field. The compiler can figure out which fields are going to be used as references and as a result the garbage collector can know when those references have been duplicated.

Would save a shedload of typing.