cinoscontainer.h

Go to the documentation of this file.

//******************************************************************************
//******************************************************************************
//
#ifndef INC_CINOSCONTAINER_H
#define INC_CINOSCONTAINER_H
//
//------------------------------------------------------------------------------
// defines
//------------------------------------------------------------------------------
//
// --- container errors ---------------------------------------------------------
//
#define ER_INOS_CONTAINER_OK            0x00000000  // command ok
#define ER_INOS_CONTAINER_REJECTED  0x00000001  // command rejected
#define ER_INOS_CONTAINER_FAILED    0x00000002  // command failed
#define ER_INOS_CONTAINER_TYPE_UNKNOWN  0x00000003  // command type unknown
#define ER_INOS_CONTAINER_CHECK_FAILED  0x00000004  // command check failed
//
//------------------------------------------------------------------------------
// includes
//------------------------------------------------------------------------------
//
// system
#include <inos.h>
#include <inos_lib.h>
#include <cinoseventlogger.h>
//
// C++
//
// project
//
//------------------------------------------------------------------------------
// class definition
//------------------------------------------------------------------------------
//
template <class T> class CINOSContainer
{
    //--- user interface ---------------------------------------------------
 
    public:
 
        CINOSContainer(const char* apName, const char* apElementBases);
        CINOSContainer(const char* apName, const char* apElementBases, void* apParent);
        virtual ~CINOSContainer();
        
        void SetParent(void* apParent);
        void SetBase(const char* apElementBases);
        void SetName(const char* apName) {
            inos_strncpy(m_cName, apName, sizeof(m_cName));
        }
 
        uint32 Create(const char* apName);
        uint32 Create(const char* apName, const char* apType);
        uint32 Create(const char* apName, const char* apType, const char* apParam);
        uint32 Destroy(const char* apName);
 
        uint32 Check(const char* apType, const char* apParam);
 
        virtual void Add(T* apEntity);
        virtual void Remove(T* apEntity, bool abDelete=true);
 
        virtual T* Find(const char* apName);
        virtual T* GetAt(uint32 auIndex);
        virtual uint32 GetNumber();
 
        typedef int(*tForEach)(T&, void *);
        virtual void ForEach( tForEach cond, void *args );
        template <typename F>
        void ForEach( F cond );
 
        void RegisterHook(void* apObject, void* apMethod);
 
        CINCOObject* GetRegister(bool abLight=false);
 
    //--- internals --------------------------------------------------------
 
    // internal methods
    private :
 
    // protected members
    protected:
        char m_cName[32];
        char m_cBase[256];
        void* m_pParent;
        void* m_pHookObj;
        void* m_pHookMtd;
        TINOSNameBalancedBinaryTree<T>* m_pEntities;
        CINCOObject* m_pRegister;
        CINCOObject* m_pCmd;
        CINCOObject* m_pEntity;
        CINCOObject* m_pProp;
        int16 m_iOrder;
        
        char m_ceName[64];
        char m_ceType[32];
        char m_ceParam[256];
 
    // allow dynamic object handling (new/delete)
    DECLARE_DYNAMIC_T(CINOSContainer, T);
};
 
// allow dynamic object handling (new/delete)
IMPLEMENT_DYNAMIC_T(CINOSContainer, T);
 
//------------------------------------------------------------------------------
// container entity registration
//------------------------------------------------------------------------------
 
typedef void* (*TCreateEntity)(const char* apName, const char* apParam);
typedef bool (*TCheckCheckTarget)(const char* apParam);
 
class CINOSContainerEntityRegister 
{   
    //--- internals --------------------------------------------------------
 
    friend class CINOSHwTarget;
 
    // private members 
    private:
        // pointer to the first registered entity
        static CINOSContainerEntityRegister* m_pFirst; 
        // pointer to the next entity
        CINOSContainerEntityRegister* m_pNext; 
        // create function of the entity
        TCreateEntity m_pCreate;
        // check function, if != 0 -> the entity is only created if 'CheckTarget' returns true
        TCheckCheckTarget m_pCheck;
        // entity type name
        const char* m_pType;
        // entity base name
        const char* m_pBase;
        
    //--- user interface ---------------------------------------------------
 
    public:
        // register a new entity type
        CINOSContainerEntityRegister(TCreateEntity apFunction, 
            const char* apType, const char* apBase, TCheckCheckTarget apCheck=0);
        // create and return and instance
        static void* GetInstance(const char* apName, const char* apType,
            const char* apParam, const char* apAllowedBases = NULL);
        // check if instance of given type can be created
        static uint32 Check(const char* apType, const char* apParam, const char* apAllowedBases = NULL);
};
 
//------------------------------------------------------------------------------
// container inco object
//------------------------------------------------------------------------------
 
class CINCOConObject : public CINCOObject
{
    char m_cName[128];
    bool m_bIsFolder;
    public:
        CINCOConObject(char* apName, void* apData, bool abIsFolder)
            : CINCOObject(&m_cName[0], apData, 0, defCharObjectOwnBitmap),
              m_bIsFolder(abIsFolder)
        {
            // copy name
            inos_strncpy(m_cName, apName, sizeof(m_cName));
        }
 
        // is this just a folder object created by a container
        virtual bool IsContainerFolder() override { return m_bIsFolder; };
    DECLARE_DYNAMIC(CINCOConObject);
};
 
//------------------------------------------------------------------------------
// class implementation
//------------------------------------------------------------------------------
//
template <class T> CINOSContainer<T>::CINOSContainer(const char* apName, 
    const char* apElementBases)
    :   m_pCmd(NULL),
        m_pEntity(NULL),
        m_pProp(NULL)
{
    // init members
    inos_strncpy(m_cName, apName, sizeof(m_cName));
    inos_strncpy(m_cBase, apElementBases, sizeof(m_cBase));
    m_pParent = 0;
    m_pHookObj = 0;
    m_pHookMtd = 0;
    m_pRegister = 0;
    m_iOrder = 0;
    m_ceName[0] = 0;
    m_ceType[0] = 0;
    m_ceParam[0] = 0;
    // create binary tree
    m_pEntities = new TINOSNameBalancedBinaryTree<T>;
}
 
template <class T> CINOSContainer<T>::CINOSContainer(const char* apName, 
    const char* apElementBases, void* apParent)
    :   m_pCmd(NULL),
        m_pEntity(NULL),
        m_pProp(NULL)
{
    // init members
    inos_strncpy(m_cName, apName, sizeof(m_cName));
    inos_strncpy(m_cBase, apElementBases, sizeof(m_cBase));
    m_pParent = apParent;
    m_pHookObj = 0;
    m_pHookMtd = 0;
    m_pRegister = 0;
    m_iOrder = 0;
    m_ceName[0] = 0;
    m_ceType[0] = 0;
    m_ceParam[0] = 0;
    // create binary tree
    m_pEntities = new TINOSNameBalancedBinaryTree<T>;
}
 
template <class T> CINOSContainer<T>::~CINOSContainer()
{
    // we remove each entity one by one to ensure that any intermediate 
    // CINCOObject, that may have been created, will be destroyed as well. 
    // This is the case e.g. when the name of the entity is "Parent.Name"
    T* entity = m_pEntities->GetAt(0);
    while( entity ) {
        Destroy(entity->GetName());
        entity = m_pEntities->GetAt(0);
    }
    // destroy binary tree
    delete m_pEntities;
    // delete inco registration
    if (m_pRegister){
        // do it
        delete m_pRegister;
    }
}
 
template <class T> void CINOSContainer<T>::SetParent(void* apParent)
{
    // set parent pointer
    m_pParent = apParent;
}
 
template <class T> void CINOSContainer<T>::SetBase(const char* apElementBases)
{
    // set allowed element bases
    inos_strncpy(m_cBase, apElementBases, sizeof(m_cBase));
}
 
template <class T> void CINOSContainer<T>::Add(T* apEntity)
{
    // and add it to inco tree
    ASSERT_ALWAYS(m_pEntity && "INCOObject not created. Did you forget to call GetRegister?");
    CINCOObject* obj = m_pEntity;
    char* name = (char *) apEntity->GetName();
    do {
        // get '.' in name
        char* p = strchr(name, '.');
        // did we find one
        if (p) {
            // yes -> clear '.'
            *p++ = 0;
 
            // obj already created ?
            CINCOItem* tmp = obj->Find(name);
            if (tmp && (tmp->GetType() == defType_Object)){
                // yes          
                obj = (CINCOObject*) tmp;           
            }
            else{
                // no -> create one
                CINCOConObject* o = new CINCOConObject(name, apEntity, true);
                obj->Add(o, m_iOrder++);
                obj = o;
            }
            *(p-1) = '.';
            name = p;
        }
        else {
            // check if folder already available
            ASSERT_ALWAYS(obj->Find(name) == NULL && "It is not allowed to add a container element with a name that is already used as parent of another container element.")
 
            // add entity registration to inco tree
            CINCOObject* o = new CINCOConObject(name, apEntity, false);
            obj->Add(o, m_iOrder++);
            apEntity->GetRegister(o);
 
            // add entity to tree
            m_pEntities->Add(apEntity);
            return;
        }
    
    } while (1);
}
 
template <class T> void CINOSContainer<T>::Remove(T* apEntity, bool abDelete)
{
    // get entity name
    char cName[256];
    inos_strncpy(cName, apEntity->GetName(), sizeof(cName)); 
    char* p = strrchr(cName, '.');
    if (p) {
        // hierachically organised  
        bool bDone=false;
        do {
            *p=0;
            CINCOObject* obj = (CINCOObject *) m_pEntity->Find(cName);
            if (obj){
                CINCOObject* sub = (CINCOObject *) obj->Find(++p);
                bool bDelete = sub && sub->IsContainerFolder()
                        && sub->GetBinaryTree()->GetItemsInContainer() == 0;
                // remove entity from obj
                obj->Remove(p, bDelete);
                // check if still member left on this level
                if (obj->GetBinaryTree()->mItemsInContainer){
                    // yes -> done
                    bDone = true;
                } // end if
                else {
                    // no -> go further
                    p = strrchr(cName, '.');
                    if (!p) {
                        // no more levels -> remove it direct from 'Entity' folder
                        m_pEntity->Remove(cName);
                        // done
                        bDone = true;
                    } // end if
                } // end else
            } // end if 
            else {
                // not found -> done (should not occur)
                bDone = true;
            } // end else
        } while (!bDone);
    } // end if
    else {
        // flat -> remove entity from 'Entity' folder
        m_pEntity->Remove((char *) apEntity->GetName(), false);
    } // end else
 
    // remove entity from tree
    m_pEntities->Remove(apEntity, abDelete);
}
 
template <class T> T* CINOSContainer<T>::Find(const char* apName)
{
    // find entity in tree
    return m_pEntities->Find(apName);
}
 
template <class T> T* CINOSContainer<T>::GetAt(uint32 auIndex)
{
    // find entity in tree
    return m_pEntities->GetAt(auIndex);
}
 
template <class T> uint32 CINOSContainer<T>::GetNumber()
{
    // find entity in tree
    return (uint32)m_pEntities->GetItemsInContainer();
}
 
template <class T> void CINOSContainer<T>::ForEach( tForEach cond, void *args )
{
    m_pEntities->ForEach(cond, args);
}
 
template <class T> template <typename F> void CINOSContainer<T>::ForEach( F cond )
{
    m_pEntities->ForEach(cond);
}
 
template <class T> void CINOSContainer<T>::RegisterHook(void* apObject, void* apMethod)
{
    // set members
    m_pHookObj = apObject;
    m_pHookMtd = apMethod;
}
 
template <class T> uint32 CINOSContainer<T>::Create(const char* apName)
{
    // call main create with base type (only makes sense if we have a single base and it also names a type)
    return Create(apName, m_cBase);
    
    // end CINOSContainer::Create
}
 
template <class T> uint32 CINOSContainer<T>::Create(const char* apName, 
    const char* apType)
{
    // call main create
    return Create(apName, apType, 0);
    
    // end CINOSContainer::Create
}
 
template <class T> uint32 CINOSContainer<T>::Create(const char* apName, 
    const char* apType, const char* apParam)
{
    // check name pointer
    if (!apName || !*apName){
        // no valid name
        return ER_INOS_CONTAINER_FAILED;
    }
 
    // check if non destructive requested
    bool bNonDest=false;
    if (apParam && strstr(apParam, "NoD")){
        bNonDest=true;
    } // end if
    
    // try to get entity
    T* ent = m_pEntities->Find(apName);
    // check name
    if (ent){
        // entity with this name already exists -> destruction allowed ?
        if (!bNonDest){     
            // yes -> destroy it
            Destroy(apName);
        } // end if
        else {
            // we have already such an entity an non destruction requested
            // just return ok
            return 0;
        } // end else
    } // end if
 
    // try to create entity
    ent = (T*) CINOSContainerEntityRegister::GetInstance(apName, apType, 
        apParam, m_cBase); 
    // did we get one ?
    if (ent){
        // yes -> add it to the tree
        Add(ent);
        // call post create method
        ent->PostCreate(m_pParent);
        // check if we have to call hook
        if (m_pHookObj && m_pHookMtd){
            // yes -> call it
            INOSCallClassMember(m_pHookObj, m_pHookMtd, (uintptr) ent);
        } // end if
        // ok
        return 0;
    } // end if
    else {
        // no -> failed
        return ER_INOS_CONTAINER_FAILED;    
    } // end if
    
    // end CINOSContainer::Create
}
 
template <class T> uint32 CINOSContainer<T>::Destroy(const char* apName)
{
    // check name pointer
    if (!apName || !*apName){
        // no valid name
        return ER_INOS_CONTAINER_FAILED;
    }
  
    // check if single or multiple
    T* ent = m_pEntities->Find(apName);
    if (ent) {
        // single   
        bool bDeleteSelf = false;
        if (!ent->PreDestroy(bDeleteSelf)){
            //destroy not allowed
            return ER_INOS_CONTAINER_REJECTED;
        }
        // and remove it but
        Remove(ent, !bDeleteSelf);
    } // end if 
    else {
        // multiple 
        bool bDone = false;
        uint32 l = (uint32)strlen(apName);
        uint32 i = 0;       
        uint32 n = 0;
        do {
            // get container entry
            T* ent = m_pEntities->GetAt(i);
            if (ent) {
                if (strncmp(apName, ent->GetName(), l)==0){
                    // we found one
                    n++;
                    bool bDeleteSelf = false;
                    if (!ent->PreDestroy(bDeleteSelf)){
                        //destroy not allowed
                        return ER_INOS_CONTAINER_REJECTED;
                    } // end if
                    // and remove it but
                    Remove(ent, !bDeleteSelf);
                    // reset index
                    i = 0;
                } // end if
                else {
                    // increment index
                    i++;
                } // end else
            } // end if
            else {
                // no more entries
                bDone = true;           
            } // end else
 
        } while (!bDone);
 
        // check name
        if (!n){
            // no entry with this name -> return failed
            return ER_INOS_CONTAINER_FAILED;    
        } // end if
    } // end else   
    
    // ok 
    return 0;
 
    // end CINOSContainer::Destroy
}
 
//------------------------------------------------------------------------------
//
template <class T> uint32 CINOSContainer<T>::Check(const char* apType, const char* apParam)
{
    return CINOSContainerEntityRegister::Check(apType, apParam, m_cBase);
 
    // end CINOSContainer::Check
}
 
//------------------------------------------------------------------------------
//
template <class T> CINCOObject* CINOSContainer<T>::GetRegister(bool abLight)
{
    // did we create inco object already ?
    if (m_pRegister){
        // yes -> return pointer
        return m_pRegister;
    } // end if
    
    // create main folder
    m_pRegister = new CINCOObject((char*) &m_cName[0], this, 0, defCharObjectOwnBitmap);
    m_pRegister->Add(new CINCOuint32((char*) &m_cName[0], &m_pEntities->mItemsInContainer,
        0,0,"", defCharShowDec | defCharReadOnly));
    // light registration (without Cmd and Entity folder)
    if (!abLight) {
        // no -> add entity folder
        m_pEntity = new CINCOObject("Entity", 0);
        m_pRegister->Add(m_pEntity);
        // and add cmd folder
        m_pCmd = new CINCOObject("Cmd", 0);
        m_pRegister->Add(m_pCmd);
    
        // create entity
        CINCOObject* cmdCreate = new CINCOObject("Create", 0);
        cmdCreate->Add(new CINCOProcedure(REG_TYP_CLS_FCT_NAME_OVLD(Create,
            CINOSContainer<T>, this, uint32, Create,(const char*))), 0);
        cmdCreate->Add(new CINCOstring("Name", m_ceName, sizeof(m_ceName)), 0); 
        m_pCmd->Add(cmdCreate);
        // create entity
        cmdCreate = new CINCOObject("Create", 0);
        cmdCreate->Add(new CINCOProcedure(REG_TYP_CLS_FCT_NAME_OVLD(Create,
            CINOSContainer<T>, this, uint32, Create,(const char*, const char*))), 0);
        cmdCreate->Add(new CINCOstring("Name", m_ceName, sizeof(m_ceName)), 0); 
        cmdCreate->Add(new CINCOstring("Type", m_ceType, sizeof(m_ceType)), 1); 
        m_pCmd->Add(cmdCreate);
        // create entity
        cmdCreate = new CINCOObject("Create", 0);
        cmdCreate->Add(new CINCOProcedure(REG_TYP_CLS_FCT_NAME_OVLD(Create,
            CINOSContainer<T>, this, uint32, Create,(const char*, const char*, const char*))), 0);
        cmdCreate->Add(new CINCOstring("Name", m_ceName, sizeof(m_ceName)), 0); 
        cmdCreate->Add(new CINCOstring("Type", m_ceType, sizeof(m_ceType)), 1); 
        cmdCreate->Add(new CINCOstring("Param", m_ceParam, sizeof(m_ceParam)), 2); 
        m_pCmd->Add(cmdCreate);
 
        // destroy entity
        CINCOObject* cmdDestroy = new CINCOObject("Destroy", 0);
        m_pCmd->Add(cmdDestroy);
        cmdDestroy->Add(new CINCOProcedure(REG_TYP_CLS_FCT_NAME_OVLD(Destroy,
            CINOSContainer<T>, this, uint32, Destroy,(const char*))), 1);
        cmdDestroy->Add(new CINCOstring("Name", m_ceName, sizeof(m_ceName)), 0); 
 
        // add prop folder
        m_pProp=new CINCOObject("Prop", 0);
        m_pRegister->Add(m_pProp);
        m_pProp->Add(new CINCOstring("Base", m_cBase, sizeof(m_cBase)), 0); 
 
    } // end if
    else {
        // yes -> easy
        m_pEntity = m_pRegister;    
    } // end else
    
    // return pointer to my inco object
    return m_pRegister;   
 
    // end CINOSContainer::Register
}
 
//------------------------------------------------------------------------------
// container class registration
//------------------------------------------------------------------------------
 
#define INOS_CONTAINER_CLASS(aClass,aType,aBase)                            \
    void* Create##aClass(const char* apName, const char* apParam)           \
        { return new aClass(apName, apParam);};                             \
    static CINOSContainerEntityRegister l_##aClass##Create(Create##aClass, aType, aBase);
#define INOS_CONTAINER_CLASS_CHECK(aClass,aType,aBase)                      \
    void* Create##aClass(const char* apName, const char* apParam)           \
        { return new aClass(apName, apParam);};                             \
    static CINOSContainerEntityRegister l_##aClass##Create(Create##aClass, aType, aBase, &aClass::CheckTarget);
 
#define INOS_CONTAINER_CLASS_MI(aClass,aBaseClass,aType,aBase)              \
    template <typename T>                                                   \
    void* Create##aClass(const char* apName, const char* apParam)           \
        /* cast to T* (not just void*) is important, if T* is not the first base class from which aClass derives. See http://stackoverflow.com/questions/2379427/multiple-inheritance-unexpected-result-after-cast-from-void-to-2nd-base-class */ \
        { return static_cast<T*>(new aClass(apName, apParam));};            \
    static CINOSContainerEntityRegister l_##aClass##Create(Create##aClass<aBaseClass>, aType, aBase);
 
//------------------------------------------------------------------------------
// end of file
//------------------------------------------------------------------------------
 
#endif  // INC_CINOSCONTAINER_H