Managers are auxiliary objects that hold extra information about a RoseObject. Your application can define RoseManager subclasses to store temporary translation results, reverse-pointers, and other cached values. Information in managers is never written to a Part 21 file.

The ROSE library uses managers to hold extra database information such as overflow attributes and external references. Both persistent and non-persistent objects can have managers.

The RoseObject::find_manager(), add_manager(), and remove_manager() functions find, attach, and delete managers from RoseObjects. In addition, the DECLARE/IMPLEMENT macros below can provide simplified find and make functions. There is also additional discussion in Manager Objects.




These DECLARE and IMPLEMENT macros provide identification and search functions needed by manager objects. Use the DECLARE macros within the class declaration of a manager subclass, and place the IMPLEMENT macro with the other function definitions for the class. The COMMON macro is required, the FIND and MAKE are optional.

The COMMON macro declares a virtual manager_type() function that returns the RoseManagerType type code identifying the class of an instance. It also declares a static type() function that provides the type code for that particular class, which is used by to RoseObject::find_manager() and RoseObject::remove_manager().


virtual RoseManagerType manager_type();
static  RoseManagerType type();

The FIND macro declares a static find() function that calls RoseObject::find_manager() to search a RoseObject for that type of manager, and returns it, cast as the appropriate type, if found.

ROSE_DECLARE_MANAGER_FIND(MySpecialManager) expands to:

static MySpecialManager * find (RoseObject * obj);

The MAKE macro declares a static make() function that searches a RoseObject for that type of manager as above, but creates a new manager and adds it to the RoseObject, if one is not already present. The IMPLEMENT macro uses the default constructor for the manager.

ROSE_DECLARE_MANAGER_MAKE(MySpecialManager) expands to:

static MySpecialManager * make (RoseObject * obj);

The Example below defines the CountManager class to associate a count variable with STEP objects. It also defines static find() and make() functions for it.

/* in your header file */
class CountManager : public RoseManager
    unsigned long m_count;

    CountManager() { m_count=0; }

/* In your cxx file */


virtual RoseManagerType manager_type();

The manager_type() function identifies the type of a manager instance. It returns the value of the type() static function for the class. This function is defined for each subclass by the COMMON macros.

This is used by find_manager() and remove_manager() when scanning the managers associated with a RoseObject.

type() (subclass static fn)

static RoseManagerType type();

Every subclass has a static type() function that returns a unique RoseManagerType value. This value is used to search the managers by the RoseObject::find_manager() or RoseObject::remove_manager() functions.

The COMMON macros create this function for each subclass.

Consider a CountManager subtype. The following code adds a manager and finds it again using the type()

cartesian_point * pt;
CountManager * mgr;

// find a previously added manager on the point.  If none
// is present, then add a new one */
mgr = (CountManager*) pt-> find_manager (CountManager::type());
if (!mgr) {
    mgr = new CountMagager;
    pt-> add_manager (mgr);

// use or change a count value on the manager
mgr-> m_count++;

The find() and make() functions declared by the FIND and MAKE macros make this process even simpler:

cartesian_point * pt;
CountManager * mgr = CountManager::make(pt);

// use or change a count value on the manager
mgr-> m_count++;

When the cartesian point is deleted, any associated managers are deleted as well. We can remove managers explicitly as shown below:

/* remove any CountManager on the object */
pt-> remove_manager (CountManager::type());