Changes between Version 8 and Version 9 of code/doc/SubclassIdentifier

Timestamp:

Sep 29, 2008, 2:44:16 AM (16 years ago)

Author:

landauf

Comment:

—

code/doc/SubclassIdentifier

@@ -4 +4 @@
 == Description ==
 
-The [wiki:SubclassIdentifier] acts like an [wiki:Identifier]. You can assign a [wiki:ClassIdentifier] and compare it with other [wiki:Identifier Identifiers] by using isA(...), isChildOf(...) and other functions.
+!SubclassIdentifier acts like a pointer to an [wiki:Identifier] with the difference that you can only assign Identifiers of classes inheriting from a given baseclass.
 
-[wiki:SubclassIdentifier] is a [wiki:template]. The [wiki:template]-class defines the needed base-class of an assigned Identifier. You can only assign [wiki:Identifier Identifiers] representing a class which is derived from the given base-class (or the base-class itself). If you try to assign an Identifier that's not derived from the base-class, you get an error.
+!SubclassIdentifier is a [wiki:template]. The template-argument defines the needed base-class of an assigned Identifier. You can only assign Identifiers representing a class which is derived from the given base-class (or the base-class itself). If you try to assign an Identifier that's not derived from the base-class, you get an error.
 
-Usage: !SubclassIdentifier<!BaseClass> name = Class(!SubClass); where !SubClass isA !BaseClass.
+== Usage ==
+=== Assignment ===
+You can assign an Identifier either through the constructor or by using the assignment operator=:
+{{{
+// SubClass isA BaseClass:
+SubclassIdentifier<BaseClass> identifier = Class(SubClass);
+}}}
+
+=== Function calls ===
+the operator-> is overloaded an returns the assigned Identifier. That way you can just call functions of the assigned Identifier by using ->function():
+{{{
+SubclassIdentifier<BaseClass> identifier = Class(SubClass);
+identifier->getName(); // returns "SubClass"
+}}}
+
+=== fabricate() ===
+There are two possibilities to create an object out of a !SubclassIdentifier. Either you just use the fabricate() function of the assigned Identifier through the overloaded operator->. Remember: This function returns a BaseObject* pointer:
+{{{
+// creates a SubClass, returns a BaseObject* pointer
+identifier->fabricate();
+}}}
+
+Or you use the function of !SubclassIdentifier, this time by using operator., which returns a BaseClass* pointer (BaseClass is the baseclass specified by the template argument):
+{{{
+// creates a SubClass, returns a BaseClass* pointer
+identifier.fabricate();
+}}}
 
 == Examples ==
@@ -16 +42 @@
 {{{
 #!cpp
-SubclassIdentifier<A1> myidentifier = Class(A1);             // This works
-SubclassIdentifier<A1> myidentifier = Class(A1B1);           // This works
-SubclassIdentifier<A1> myidentifier = Class(A1B1C1);         // This works
-SubclassIdentifier<A1> myidentifier = Class(BaseObject);     // This doesn't work
-SubclassIdentifier<A1> myidentifier = Class(A3);             // This doesn't work
+SubclassIdentifier<A1> myidentifier = Class(A1);         // This works
+SubclassIdentifier<A1> myidentifier = Class(A1B1);       // This works
+SubclassIdentifier<A1> myidentifier = Class(A1B1C1);     // This works
+SubclassIdentifier<A1> myidentifier = Class(BaseObject); // This doesn't work
+SubclassIdentifier<A1> myidentifier = Class(A3);         // This doesn't work
 
 
 SubclassIdentifier<Interface1> myidentifier = Class(A3);     // This works
 SubclassIdentifier<Interface1> myidentifier = Class(A2B2C1); // This works
+}}}
 
+{{{
+SubclassIdentifier<A1> myidentifier = Class(A1B1);
 
-SubclassIdentifier<A1> myidentifier = Class(A1B1);
-myidentifier.isExactlyA(Class(A1));       // Returns false
-myidentifier.isExactlyA(Class(A1B1));     // Returns true
-(*myidentifier)->getName();               // Returns "A1B1"
-myidentifier->getName();                  // Returns "A1B1" (Yes, the "->" is correct. It's overloaded.)
+myidentifier->isExactlyA(Class(A1));       // Returns false
+myidentifier->isExactlyA(Class(A1B1));     // Returns true
+(*myidentifier)->getName();                // Returns "A1B1"
+myidentifier->getName();                   // Returns "A1B1"
 
-A1* newobject = myidentifier.fabricate(); // Returns a new instance of A1B1, downcasted to A1
+A1* newobject = myidentifier.fabricate();  // Returns a new instance of A1B1, casted to A1
 }}}