icontainer.h

Go to the documentation of this file.

#pragma once
 
#include "base/src/basei.h"
#include "shared/interface/signal.h"
#include "ithing.h"
 
namespace itasca {
    class IContainer  {
    public:
        inline static const TType type_ = 0x51cdf4ed;
 
        using signal_type = shared::Signal<const IThing *,const IContainer *>;
        signal_type thingAdded;
        signal_type thingRemoved;
        signal_type aboutToDestroy;
 
        class IOpaqueIterator { };
 
        virtual IThing *      getIThing()=0;
        virtual const IThing *getIThing() const=0;
        virtual IContainer *      getIContainer()=0;
        virtual const IContainer *getIContainer() const=0;
        virtual bool          getValueBased() const=0;
        virtual bool          isPartitioned() const=0;
        virtual uint64       getSize() const=0;
        virtual uint64       getNumberHidden() const=0;
        virtual uint64       getNumberSelected() const=0;
        virtual uint64       getNextID() const=0;
        virtual void         setNextID(uint64)=0;
        virtual IThing *      remove(IThing *t)=0;
        virtual void          erase(IThing *t)=0;
        virtual IThing *      add(IThing *t,uint64 id=0)=0;
        virtual void          clear()=0;
        virtual IThing *      findWithID(uint64 id)=0;
        virtual const IThing *findWithID(uint64 id) const=0;
        virtual uint64       getInstance(uint64 id) const=0;
        virtual IThing *      findWithName(const IString &s)=0;
        virtual const IThing *findWithName(const IString &s) const=0;
        virtual const signal_type *getAddedSignal() const=0;
        virtual const signal_type *getRemovedSignal() const=0;
        virtual const signal_type *getDestroySignal() const=0;
 
        virtual IOpaqueIterator *acquire() const=0;
        virtual void             release(IOpaqueIterator *i) const=0;
        virtual bool             atEnd(IOpaqueIterator *i) const=0;
        virtual IThing *         get(IOpaqueIterator *i)=0;
        virtual const IThing *   get(IOpaqueIterator *i) const=0;
        virtual bool             increment(IOpaqueIterator *i) const=0;
        virtual bool             copy(IOpaqueIterator *iSrc,IOpaqueIterator *iDst) const=0;
        virtual IThing *         doSilentRemove(IThing *t)=0;
    };
 
    template <class T> class ICIterator {
    public:
        ICIterator(const IContainer *c) : c_(c), i_(nullptr) { if (c_) i_ = c_->acquire(); }
        ~ICIterator() { if (c_&&i_) c_->release(i_); }
        void setContainer(const IContainer *c) { if (c_&&i_) c_->release(i_);  i_ = 0; c_ = c;  if (c_) i_ = c_->acquire(); }
        const IContainer *getContainer() const { return c_; }
        bool atEnd() const { if (!c_ || !i_) return true; return c_->atEnd(i_); }
        const ICIterator<T> &operator++() { if (c_&&i_) c_->increment(i_); return *this; }
 
        //const ICIterator<T> &operator+=(int i) { assert(i>=0); if (c_&&i_) c_->incrementBy(i_, i); return *this; }
        //uint64 operator-(const ICIterator& earlier) { if (c_&&i_) return c_->subtract(this, &earlier); return 0; }
 
        const T *get() const { if (!c_ || !i_) return 0;  return convert_cast<T>(c_->get(i_)); }
        const T *operator->() const { return get(); }
        const T &operator*() const { return *get(); }
        operator const T *() const { return get(); }
        void copy(const ICIterator<T> &c) { if (c_&&i_) c_->release(i_);  i_ = 0; c_ = c.c_;  if (c_) i_ = c_->acquire(); if (c_&&c.i_) c_->copy(c.i_,i_); }
    private:
        ICIterator(const ICIterator &);     // DISALLOWED
        void operator=(const ICIterator &); // DISALLOWED
        const IContainer *           c_;
        IContainer::IOpaqueIterator *i_;
    };
 
    template <class T> class IIterator : public ICIterator<T> {
    public:
        IIterator(IContainer *c) : ICIterator<T>(c) { }
        const IIterator<T> &operator++() { ICIterator<T>::operator++();  return *this; }
        void setContainer(IContainer *c) { ICIterator<T>::setContainer(c); }
        T *get() const { return const_cast<T *>(ICIterator<T>::get()); }
        T *operator->() const { return get(); }
        T &operator*() const { return *get(); }
        operator T *() const { return get(); }
    private:
        IIterator(const IIterator &);     // DISALLOWED
        void operator=(const IIterator &); // DISALLOWED
    };
 
} 
namespace utility {
    using itasca::IContainer;
    using itasca::ICIterator;
    using itasca::IIterator;
}
// EoF