mlBaseList.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2007, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#ifndef ML_BASE_LIST_H
#define ML_BASE_LIST_H
 

 
// Defines the classes:
//
// - BaseContainerItem: BaseItem-derived container class for Base-derived objects.
// - BaseList         : BaseListTemplate<BaseContainer*>-derived container class for
//                      BaseContainer objects.
 
 
// ML includes
#include "mlModuleIncludes.h"
 
 
#include "mlBaseInit.h"
#include "mlListBase.h"
 
 
ML_START_NAMESPACE
 
 
 
// ------------------------------------------------------------------
// Base object class BaseContainerItem
// ------------------------------------------------------------------


class MLBASEEXPORT BaseContainerItem : public BaseItem
{
public:

 
    BaseContainerItem();

    BaseContainerItem(MLssize_t idParam, const char* nameParam = nullptr, Base* baseP = nullptr);
 
    BaseContainerItem(const BaseContainerItem &other, bool useDeepCopy = false);
 
    BaseContainerItem(BaseContainerItem &&other) noexcept;
 
    ~BaseContainerItem() override;


    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 = nullptr);

    BaseContainerItem& operator=(const BaseContainerItem& other);

    virtual BaseContainerItem& copyFrom(const BaseContainerItem& other, bool performDeepCopy = true);

    std::string persistentState() const override;

    void setPersistentState(const std::string& state) override;

    void addStateToTree(TreeNode* parent) const override;

    ML_SET_ADDSTATE_VERSION(0);

    void readStateFromTree(TreeNode* parent) override;

 
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*/) = 0;
    virtual ~BaseListSortParameters(){ } /* Make destructor virtual to avoid warnings on GCC */
};
 
 
 
 
// ------------------------------------------------------------------
// Class BaseList
// ------------------------------------------------------------------

class MLBASEEXPORT BaseList : public BaseListTemplate<BaseContainerItem>
{
 
public:

    BaseList () : BaseListTemplate<BaseContainerItem>(true) {}
 
    BaseList( const BaseList& other ) : BaseListTemplate<BaseContainerItem>(other) {}

    BaseList* deepCopy() const override;
 
private:

    ML_CLASS_HEADER(BaseList);
 
};
 
ML_END_NAMESPACE
 
namespace std {
 

    template<>
    struct less<ML_NAMESPACE::BaseContainerItem>
    {
        using value_type = bool;
 
        less(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