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