icontainer.h

Go to the documentation of this file.

#pragma once

#include "base/src/baseqt.h"
#include "isignalbase.h"
#include "ithing.h"


namespace itasca {
    class IThing;

    class IContainer  {
    public:
        inline static const TType type_ = 0x51cdf4ed;

        typedef Signal2<const IThing *,const IContainer *> signal_type;

        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 quint64      getSize() const=0;
        virtual quint64      getNumberHidden() const=0;
        virtual quint64      getNumberSelected() const=0;
        virtual quint64      getNextID() const=0;
        virtual void         setNextID(quint64)=0;
        virtual IThing *      remove(IThing *t)=0;
        virtual void          erase(IThing *t)=0;
        virtual IThing *      add(IThing *t,quint64 id=0)=0;
        virtual void          clear()=0;
        virtual IThing *      findWithID(quint64 id)=0;
        virtual const IThing *findWithID(quint64 id) const=0;
        virtual quint64       getInstance(quint64 id) const=0;
        virtual IThing *      findWithName(const QString &s)=0;
        virtual const IThing *findWithName(const QString &s) const=0;
        virtual signal_type *getAddedSignal() const=0;
        virtual signal_type *getRemovedSignal() const=0;
        virtual 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) { if (c_&&i_) c_->incrementBy(i_, i); return *this; }
        //quint64 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
    };

} 
// EoF