fsfw/objectmanager/ObjectManagerIF.h

100 lines
3.7 KiB
C
Raw Normal View History

/**
* @file ObjectManagerIF.h
* @brief This file contains the implementation of the ObjectManagerIF interface
* @date 19.09.2012
* @author Bastian Baetz
*/
#ifndef OBJECTMANAGERIF_H_
#define OBJECTMANAGERIF_H_
#include <framework/objectmanager/frameworkObjects.h>
#include <config/objects/systemObjectList.h>
#include <framework/objectmanager/SystemObjectIF.h>
#include <framework/returnvalues/HasReturnvaluesIF.h>
/**
* @brief This class provides an interface to the global object manager.
* @details This manager handles a list of available objects with system-wide
* relevance, such as device handlers, and TM/TC services. They can be
* inserted, removed and retrieved from the list. On getting the
* object, the call checks if the object implements the requested
* interface.
* \ingroup system_objects
*/
class ObjectManagerIF : public HasReturnvaluesIF {
public:
static const uint8_t INTERFACE_ID = CLASS_ID::OBJECT_MANAGER_IF;
static const ReturnValue_t INSERTION_FAILED = MAKE_RETURN_CODE( 1 );
static const ReturnValue_t NOT_FOUND = MAKE_RETURN_CODE( 2 );
protected:
/**
* @brief This method is used to hide the template-based get call from
* a specific implementation.
* @details So, an implementation only has to implement this call.
* @param id The object id of the requested object.
* @return The method returns a pointer to an object implementing (at
* least) the SystemObjectIF, or NULL.
*/
virtual SystemObjectIF* getSystemObject( object_id_t id ) = 0;
public:
/**
* @brief This is the empty virtual destructor as requested by C++ interfaces.
*/
virtual ~ObjectManagerIF( void ) {};
/**
* @brief With this call, new objects are inserted to the list.
* @details The implementation shall return an error code in case the
* object can't be added (e.g. the id is already in use).
* @param id The new id to be added to the list.
* @param object A pointer to the object to be added.
* @return @li INSERTION_FAILED in case the object could not be inserted.
* @li RETURN_OK in case the object was successfully inserted
*/
virtual ReturnValue_t insert( object_id_t id, SystemObjectIF* object ) = 0;
/**
* @brief With the get call, interfaces of an object can be retrieved in
* a type-safe manner.
* @details With the template-based call, the object list is searched with the
* getSystemObject method and afterwards it is checked, if the object
* implements the requested interface (with a dynamic_cast).
* @param id The object id of the requested object.
* @return The method returns a pointer to an object implementing the
* requested interface, or NULL.
*/
template <typename T> T* get( object_id_t id );
/**
* @brief With this call, an object is removed from the list.
* @param id The object id of the object to be removed.
* @return \li NOT_FOUND in case the object was not found
* \li RETURN_OK in case the object was successfully removed
*/
virtual ReturnValue_t remove( object_id_t id ) = 0;
virtual void initialize() = 0;
/**
* @brief This is a debug function, that prints the current content of the
* object list.
*/
virtual void printList() = 0;
};
/**
* Used to retrieve Target Interface Pointers of objects.
* The object has to implement the SystemObject or SystemObjectIF at the very least,
* otherwise NULL will be returned.
* @param id
* @return NULL or pointer to target interface specified by template object
*/
template <typename T>
T* ObjectManagerIF::get( object_id_t id ) {
SystemObjectIF* temp = this->getSystemObject(id);
return dynamic_cast<T*>(temp);
}
/**
* @brief This is the forward declaration of the global objectManager instance.
*/
extern ObjectManagerIF *objectManager;
#endif /* OBJECTMANAGERIF_H_ */