-/*\r
- * Object.hpp\r
- *\r
- * This file contains the declaration of the wrapper class of the native MSG task type.\r
- *\r
- * Copyright 2006,2007 Martin Quinson, Malek Cherier \r
- * All right reserved. \r
- *\r
- * This program is free software; you can redistribute \r
- * it and/or modify it under the terms of the license \r
- *(GNU LGPL) which comes with this package. \r
- *\r
- */ \r
-#ifndef MSG_OBJECT_H\r
-#define MSG_OBJECT_H\r
-\r
-// Compilation C++ recquise\r
-#ifndef __cplusplus\r
- #error Object.hpp requires C++ compilation (use a .cxx suffix)\r
-#endif\r
-\r
-#include <stdlib.h>\r
-\r
-#include <ClassNotFoundException.hpp>\r
-\r
-namespace SimGrid\r
-{\r
- namespace Msg\r
- {\r
- //////////////////////////////////////////////////////////////////////////////\r
- // Macros\r
- \r
- // Returns the runtime class of the class_name object.\r
- #define MSG_GET_CLASS(class_name) \\r
- ((Class*)(&class_name::class##class_name))\r
- \r
- // Declare the class class_name as dynamic\r
- #define MSG_DECLARE_DYNAMIC(class_name) \\r
- public: \\r
- static Class class##class_name; \\r
- virtual Class* getClass() const; \\r
- static Object* createObject() \\r
-\r
- // The runtime class implementation. \r
- #define MSG_IMPLEMENT_CLASS(class_name, base_class_name, pfn,class_init) \\r
- Class class_name::class##class_name = { \\r
- #class_name, sizeof(class class_name),pfn, \\r
- MSG_GET_CLASS(base_class_name), NULL,class_init}; \\r
- Class* class_name::getClass() const \\r
- { return MSG_GET_CLASS(class_name); } \\r
- \r
- // CreateObject implementation. \r
- #define MSG_IMPLEMENT_DYNAMIC(class_name, base_class_name) \\r
- Object* class_name::createObject() \\r
- { return (Object*)(new class_name); } \\r
- DeclaringClass _declaringClass_##class_name(MSG_GET_CLASS(class_name)); \\r
- MSG_IMPLEMENT_CLASS(class_name, base_class_name, \\r
- class_name::createObject, &_declaringClass_##class_name) \\r
-\r
- //////////////////////////////////////////////////////////////////////////////\r
- // Classes declared in this file.\r
-\r
- class Object; // The msg object.\r
-\r
- //////////////////////////////////////////////////////////////////////////////\r
- // Structures declared in this files.\r
-\r
- struct Class; // used during the rtti operations\r
- struct DeclaringClass; // used during the instances registration.\r
-\r
-\r
- class DeclaringClasses;\r
-\r
- //////////////////////////////////////////////////////////////////////////////\r
- // Global functions\r
-\r
- // Used during the registration.\r
- void DeclareClass(Class* c);\r
-\r
- //////////////////////////////////////////////////////////////////////////////\r
- // DeclaringClass\r
-\r
- struct SIMGRIDX_EXPORT DeclaringClass\r
- {\r
- // Constructor : add the runtime classe in the list.\r
- DeclaringClass(Class* c);\r
- \r
- // Destructor\r
- virtual ~DeclaringClass(void);\r
-\r
- // Attributes :\r
- // the list of runtime classes.\r
- static DeclaringClasses* declaringClasses;\r
- };\r
-\r
- #define MSG_DELCARING_CLASSES (*(DeclaringClass::declaringClasses))\r
- \r
- \r
- struct SIMGRIDX_EXPORT Class\r
- {\r
- \r
- // Attributes\r
- \r
- const char* name; // class name.\r
- size_t typeSize; // type size. \r
- Object* (*createObjectFn)(void); // pointer to the create object function. \r
- Class* baseClass; // the runtime class of the runtime class.\r
- Class* next; // the next runtime class in the list.\r
- const DeclaringClass* declaringClass; // used during the registration of the class.\r
- \r
- // Operations\r
- \r
- // Create the runtime class from its name.\r
- static Class* fromName(const char* name)\r
- throw (ClassNotFoundException);\r
- \r
- // Create an object from the name of the its class.\r
- static Object* createObject(const char* name);\r
- \r
- // Create an instance of the class.\r
- Object* createObject(void);\r
- \r
- // Return true is the class is dervived from the base class baseClass.\r
- bool isDerivedFrom(const Class* baseClass) const;\r
-\r
- };\r
-\r
- // Create an instance of the class.\r
- inline Object* Class::createObject(void)\r
- {\r
- return (*createObjectFn)();\r
- }\r
- \r
- \r
- class SIMGRIDX_EXPORT Object\r
- {\r
- public:\r
- \r
- // Default constructor.\r
- Object(){}\r
- \r
- // Destructor.\r
- virtual ~Object(){}\r
- \r
- // Operations.\r
- \r
- // Get the runtime class.\r
- virtual Class* getClass(void) const;\r
- \r
- // Returns true if the class is derived from the class baseClass. Otherwise\r
- // the method returns false.\r
- bool isDerivedFrom(const Class* baseClass) const;\r
- \r
- // Returns true if the object is valid. Otherwise the method returns false.\r
- virtual bool isValid(void) const;\r
-\r
- // Returns true is the object is an instance of the class specified as parameter.\r
- bool isInstanceOf(const char* className);\r
- \r
- // Operators.\r
-\r
- // Attributes.\r
- \r
- // The runtime class.\r
- static const Class classObject;\r
- };\r
-\r
- // inline member functions of the class Object.\r
- \r
- // Returns the runtime class of the object.\r
- inline Class* Object::getClass(void) const\r
- {\r
- return MSG_GET_CLASS(Object);\r
- }\r
-\r
- // Returns true if the class is derived from the class pBaseClass. Otherwise\r
- // the method returns false.\r
- inline bool Object::isDerivedFrom(const Class* baseClass) const\r
- {\r
- return (getClass()->isDerivedFrom(baseClass));\r
- }\r
- \r
- // Returns true if the object is valid. Otherwise the method returns false.\r
- inline bool Object::isValid(void) const\r
- {\r
- // returns always true.\r
- return true; \r
- }\r
-\r
- \r
- class DeclaringClasses \r
- {\r
- public:\r
- \r
- // Constructor.\r
- DeclaringClasses();\r
-\r
- // Destructor.\r
- virtual ~DeclaringClasses(){}\r
- \r
- // Operations.\r
- \r
- // Add the class at the head of the list.\r
- void addHead(Class* c);\r
- \r
- // Get the runtime class of the head of the list.\r
- Class* getHead(void) const ;\r
- \r
- // Remove the class from the list (don't destroy it).\r
- bool remove(Class* c);\r
- \r
- // Remove the head of the list.\r
- Class* removeHead(void);\r
- \r
- // Return true if the list is empty.\r
- \r
- bool isEmpty(void) const;\r
- \r
- // Remove of the elements of the list.\r
- void removeAll(void);\r
- \r
- // Get the number of classes in the list.\r
- unsigned int getCount(void);\r
- \r
- void lock(void){}\r
- \r
- void unlock(void){}\r
- \r
- //Attributes\r
- \r
- // The head of the list.\r
- Class* head;\r
-\r
- private:\r
- \r
- // Attributes\r
- \r
- // The number of elements of the list.\r
- unsigned int count;\r
- };\r
-\r
- typedef Object* ObjectPtr;\r
-\r
-\r
- // Constructor (Add the class in the list).\r
- inline DeclaringClass::DeclaringClass(Class* c)\r
- {\r
- if(!declaringClasses)\r
- declaringClasses = new DeclaringClasses();\r
-\r
- DeclareClass(c);\r
- }\r
-\r
- // Destructor.\r
- inline DeclaringClass::~DeclaringClass()\r
- {\r
- /*if(NULL != declaringClasses)\r
- delete declaringClasses;\r
-\r
- declaringClasses=NULL;*/\r
-\r
- }\r
-\r
- // Returns the number of elements of the list.\r
- inline unsigned int DeclaringClasses::getCount()\r
- {\r
- return count;\r
- }\r
- \r
- // Returns the head of the list.\r
- inline Class* DeclaringClasses::getHead() const\r
- {\r
- return head;\r
- }\r
- \r
- // Returns true if the list is empty. Otherwise this function\r
- // returns false.\r
- inline bool DeclaringClasses::isEmpty() const\r
- {\r
- return(!head);\r
- }\r
- \r
- // Removes all the elements of the list.\r
- inline void DeclaringClasses::removeAll()\r
- {\r
- head = 0;\r
- count=0;\r
- }\r
- \r
- } // namespace Msg \r
-} // namespace SimGrid\r
-\r
-\r
-using namespace SimGrid::Msg;\r
-\r
-#define instanceOf(class_name) reinterpret_cast<class_name*>(Class::createObject(#class_name))\r
-\r
-#endif // !MSG_OBJECT_H\r
-\r
+/*
+ * Object.hpp
+ *
+ * This file contains the declaration of the wrapper class of the native MSG task type.
+ *
+ * Copyright 2006,2007 Martin Quinson, Malek Cherier
+ * All right reserved.
+ *
+ * This program is free software; you can redistribute
+ * it and/or modify it under the terms of the license
+ *(GNU LGPL) which comes with this package.
+ *
+ */
+#ifndef MSG_OBJECT_H
+#define MSG_OBJECT_H
+
+// Compilation C++ recquise
+#ifndef __cplusplus
+ #error Object.hpp requires C++ compilation (use a .cxx suffix)
+#endif
+
+#include <stdlib.h>
+
+#include <ClassNotFoundException.hpp>
+
+namespace SimGrid
+{
+ namespace Msg
+ {
+ //////////////////////////////////////////////////////////////////////////////
+ // Macros
+
+ // Returns the runtime class of the class_name object.
+ #define MSG_GET_CLASS(class_name) \
+ ((Class*)(&class_name::class##class_name))
+
+ // Declare the class class_name as dynamic
+ #define MSG_DECLARE_DYNAMIC(class_name) \
+ public: \
+ static Class class##class_name; \
+ virtual Class* getClass() const; \
+ static Object* createObject() \
+
+ // The runtime class implementation.
+ #define MSG_IMPLEMENT_CLASS(class_name, base_class_name, pfn,class_init) \
+ Class class_name::class##class_name = { \
+ #class_name, sizeof(class class_name),pfn, \
+ MSG_GET_CLASS(base_class_name), NULL,class_init}; \
+ Class* class_name::getClass() const \
+ { return MSG_GET_CLASS(class_name); } \
+
+ // CreateObject implementation.
+ #define MSG_IMPLEMENT_DYNAMIC(class_name, base_class_name) \
+ Object* class_name::createObject() \
+ { return (Object*)(new class_name); } \
+ DeclaringClass _declaringClass_##class_name(MSG_GET_CLASS(class_name)); \
+ MSG_IMPLEMENT_CLASS(class_name, base_class_name, \
+ class_name::createObject, &_declaringClass_##class_name) \
+
+ //////////////////////////////////////////////////////////////////////////////
+ // Classes declared in this file.
+
+ class Object; // The msg object.
+
+ //////////////////////////////////////////////////////////////////////////////
+ // Structures declared in this files.
+
+ struct Class; // used during the rtti operations
+ struct DeclaringClass; // used during the instances registration.
+
+
+ class DeclaringClasses;
+
+ //////////////////////////////////////////////////////////////////////////////
+ // Global functions
+
+ // Used during the registration.
+ void DeclareClass(Class* c);
+
+ //////////////////////////////////////////////////////////////////////////////
+ // DeclaringClass
+
+ struct SIMGRIDX_EXPORT DeclaringClass
+ {
+ // Constructor : add the runtime classe in the list.
+ DeclaringClass(Class* c);
+
+ // Destructor
+ virtual ~DeclaringClass(void);
+
+ // Attributes :
+ // the list of runtime classes.
+ static DeclaringClasses* declaringClasses;
+ };
+
+ #define MSG_DELCARING_CLASSES (*(DeclaringClass::declaringClasses))
+
+
+ struct SIMGRIDX_EXPORT Class
+ {
+
+ // Attributes
+
+ const char* name; // class name.
+ size_t typeSize; // type size.
+ Object* (*createObjectFn)(void); // pointer to the create object function.
+ Class* baseClass; // the runtime class of the runtime class.
+ Class* next; // the next runtime class in the list.
+ const DeclaringClass* declaringClass; // used during the registration of the class.
+
+ // Operations
+
+ // Create the runtime class from its name.
+ static Class* fromName(const char* name)
+ throw (ClassNotFoundException);
+
+ // Create an object from the name of the its class.
+ static Object* createObject(const char* name);
+
+ // Create an instance of the class.
+ Object* createObject(void);
+
+ // Return true is the class is dervived from the base class baseClass.
+ bool isDerivedFrom(const Class* baseClass) const;
+
+ };
+
+ // Create an instance of the class.
+ inline Object* Class::createObject(void)
+ {
+ return (*createObjectFn)();
+ }
+
+
+ class SIMGRIDX_EXPORT Object
+ {
+ public:
+
+ // Default constructor.
+ Object(){}
+
+ // Destructor.
+ virtual ~Object(){}
+
+ // Operations.
+
+ // Get the runtime class.
+ virtual Class* getClass(void) const;
+
+ // Returns true if the class is derived from the class baseClass. Otherwise
+ // the method returns false.
+ bool isDerivedFrom(const Class* baseClass) const;
+
+ // Returns true if the object is valid. Otherwise the method returns false.
+ virtual bool isValid(void) const;
+
+ // Returns true is the object is an instance of the class specified as parameter.
+ bool isInstanceOf(const char* className);
+
+ // Operators.
+
+ // Attributes.
+
+ // The runtime class.
+ static const Class classObject;
+ };
+
+ // inline member functions of the class Object.
+
+ // Returns the runtime class of the object.
+ inline Class* Object::getClass(void) const
+ {
+ return MSG_GET_CLASS(Object);
+ }
+
+ // Returns true if the class is derived from the class pBaseClass. Otherwise
+ // the method returns false.
+ inline bool Object::isDerivedFrom(const Class* baseClass) const
+ {
+ return (getClass()->isDerivedFrom(baseClass));
+ }
+
+ // Returns true if the object is valid. Otherwise the method returns false.
+ inline bool Object::isValid(void) const
+ {
+ // returns always true.
+ return true;
+ }
+
+
+ class DeclaringClasses
+ {
+ public:
+
+ // Constructor.
+ DeclaringClasses();
+
+ // Destructor.
+ virtual ~DeclaringClasses(){}
+
+ // Operations.
+
+ // Add the class at the head of the list.
+ void addHead(Class* c);
+
+ // Get the runtime class of the head of the list.
+ Class* getHead(void) const ;
+
+ // Remove the class from the list (don't destroy it).
+ bool remove(Class* c);
+
+ // Remove the head of the list.
+ Class* removeHead(void);
+
+ // Return true if the list is empty.
+
+ bool isEmpty(void) const;
+
+ // Remove of the elements of the list.
+ void removeAll(void);
+
+ // Get the number of classes in the list.
+ unsigned int getCount(void);
+
+ void lock(void){}
+
+ void unlock(void){}
+
+ //Attributes
+
+ // The head of the list.
+ Class* head;
+
+ private:
+
+ // Attributes
+
+ // The number of elements of the list.
+ unsigned int count;
+ };
+
+ typedef Object* ObjectPtr;
+
+
+ // Constructor (Add the class in the list).
+ inline DeclaringClass::DeclaringClass(Class* c)
+ {
+ if(!declaringClasses)
+ declaringClasses = new DeclaringClasses();
+
+ DeclareClass(c);
+ }
+
+ // Destructor.
+ inline DeclaringClass::~DeclaringClass()
+ {
+ /*if(NULL != declaringClasses)
+ delete declaringClasses;
+
+ declaringClasses=NULL;*/
+
+ }
+
+ // Returns the number of elements of the list.
+ inline unsigned int DeclaringClasses::getCount()
+ {
+ return count;
+ }
+
+ // Returns the head of the list.
+ inline Class* DeclaringClasses::getHead() const
+ {
+ return head;
+ }
+
+ // Returns true if the list is empty. Otherwise this function
+ // returns false.
+ inline bool DeclaringClasses::isEmpty() const
+ {
+ return(!head);
+ }
+
+ // Removes all the elements of the list.
+ inline void DeclaringClasses::removeAll()
+ {
+ head = 0;
+ count=0;
+ }
+
+ } // namespace Msg
+} // namespace SimGrid
+
+
+using namespace SimGrid::Msg;
+
+#define instanceOf(class_name) reinterpret_cast<class_name*>(Class::createObject(#class_name))
+
+#endif // !MSG_OBJECT_H
+
