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;
 
#if !ML_DEPRECATED_SINCE(3,5,0)
private:
#endif
    [[nodiscard]]
    [[deprecated]] char *getPersistentState () const override;
 
    [[deprecated]] void setPersistentState (const char *state) override;
 
#if !ML_DEPRECATED_SINCE(3,5,0)
public:
#endif
    [[deprecated]] void clearPersistentState(char *state) const 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