MeVisLab/Standard/Sources/ML/MLBase/mlBaseList.h

Go to the documentation of this file.

// **InsertLicense** code
//----------------------------------------------------------------------------------

//
// Defines the classes:
//
// - BaseContainerItem    : BaseItem-derived container class for Base-derived objects.
// - BaseList             : BaseListTemplate<BaseContainer*>-derived container class for 
//                          BaseContainer objects.
//----------------------------------------------------------------------------------



#ifndef __mlBaseList_H
#define __mlBaseList_H


// ML includes
#ifndef __mlModuleIncludes_H
#include "mlModuleIncludes.h"
#endif

// Local includes
#ifndef __mlBaseInit_H
#include "mlBaseInit.h"
#endif
#ifndef __mlListBase_H
#include "mlListBase.h"
#endif


ML_START_NAMESPACE


  
// ------------------------------------------------------------------
// Base object class BaseContainerItem
// ------------------------------------------------------------------


class MLBASEEXPORT BaseContainerItem : public BaseItem
{
public:
    

    
    BaseContainerItem (); 
    
    BaseContainerItem (MLssize_t idParam, const char* nameParam = 0, Base* baseP = 0);
    
    BaseContainerItem (const BaseContainerItem &other);
    
    bool operator <(const BaseContainerItem &) const { return false; }
    
    bool operator ==(const BaseContainerItem &) const { return false; }
    
    

    
    virtual ~BaseContainerItem();
    

    virtual void setObject(Base& object);

    virtual Base* getObjectPointer() const {
      return _baseObjectP;
    }

    virtual const Base* getConstObjectPointer() const {
      return const_cast<const Base*>(_baseObjectP);
    }

    virtual Base* removeObjectPointer();
    
    static BaseContainerItem* toBaseContainerItem(Base& baseObj, MLssize_t id = 0, const char* name = NULL);
    
    virtual BaseContainerItem& operator=(const BaseContainerItem& other);
    
    virtual BaseContainerItem& copyFrom(const BaseContainerItem& other, bool performDeepCopy = true);
    

    
    virtual char *getPersistentState () const;
    
    virtual void setPersistentState (const char *state);
    
    virtual void clearPersistentState (char *state) const;  
    
    virtual void addStateToTree(TreeNode* parent) const;
    
    ML_SET_ADDSTATE_VERSION(0);
    
    virtual void readStateFromTree(TreeNode* parent);
    

protected:

    void _setObjectPointer(Base* objectP, bool isOwner = true);

    Base* _baseObjectP;
    
    bool _ownsBaseObject;

    bool _baseObjectIsRefCounted;
    
private:
    
    ML_CLASS_HEADER(BaseContainerItem);

};


// ------------------------------------------------------------------
// ------------------------------------------------------------------
class MLBASEEXPORT BaseListSortParameters {
public:
    virtual bool isLessThan(const Base& /*x*/, const Base& /*y*/) { return false;};
    virtual ~BaseListSortParameters(){ } /* Make destructor virtual to avoid warnings on GCC */
};




// ------------------------------------------------------------------
// Class BaseList 
// ------------------------------------------------------------------

class MLBASEEXPORT BaseList : public BaseListTemplate<BaseContainerItem>
{
    
public:
    
    BaseList () : BaseListTemplate<BaseContainerItem>(true) {}

    virtual BaseList* deepCopy() const { /* TBI: copy each base object */ return NULL; };
        
private:
    
    ML_CLASS_HEADER(BaseList);
    
};

ML_END_NAMESPACE

namespace std {


    template<>
        struct less <ML_NAMESPACE::BaseContainerItem> : public binary_function <ML_NAMESPACE::BaseContainerItem ,ML_NAMESPACE::BaseContainerItem, bool>
    {
        
        less<ML_NAMESPACE::BaseContainerItem> (ML_NAMESPACE::BaseListSortParameters* sortParams) {
            _sortParams = sortParams;
        }
        
        bool operator()(const ML_NAMESPACE::BaseContainerItem &x, const ML_NAMESPACE::BaseContainerItem &y) const
        {    
            // An item containing an object defined to be less than an item without one:
            if (!x.getConstObjectPointer()) { return false; }
            if (!y.getConstObjectPointer()) { return true;  }
            
            if (!_sortParams) { return false; }
            
            return _sortParams->isLessThan(*x.getConstObjectPointer(), *y.getConstObjectPointer());
        };
        
        ML_NAMESPACE::BaseListSortParameters* _sortParams;
        
    };

}



#endif // __mlBaseList_H