ithing.h

Go to the documentation of this file.

#pragma once
 
#include "igroup.h"
#include "base/src/farray.h"
#include "base/src/spinlock.h"
 
namespace fish {
 class IParameter;
}
 
namespace itasca {
#ifndef DOXYGEN
 class Archive2;
 class IContainer;
 class IGroup;
#endif
 
//#define ITHINGMUTEX
 
 class IThing {
 public:
#ifdef ITHINGMUTEX
 using LockType = std::mutex;
#else
 using LockType = SpinLock;
#endif
 
 class Lock : public std::lock_guard<LockType> {
 public:
 inline Lock(const IThing *t) : std::lock_guard<LockType>(t->thingLock_) { }
 };
 
 class LockIf : public ConditionalLock<LockType> {
 public:
 inline LockIf(const IThing *t, bool b) : ConditionalLock<LockType>(t ? &t->thingLock_ : nullptr,b) { }
 };
 
 class BreakLock : public ReverseLock<LockType> {
 public:
 inline BreakLock(const IThing *t) : ReverseLock<LockType>(t->thingLock_) {}
 };
 
 struct Handle { // Used in the Handle system, so we have some opacity and flexibility in the future
 Handle() {}
 explicit Handle(uint64 h) : val_(h) { }
 bool operator<(const Handle &h) const { return val_<h.val_; }
 bool operator==(const Handle &h) const { return val_==h.val_; }
 bool valid() const { return val_ ? true : false; }
 uint64 val_ = 0;
 };
 
 inline static const TType type_ = 0x4c815a59;
 inline static const uint32 maxGroupSlot_ = 128;
 inline static const uint32 maxExtraIndex_ = 128;
 
 inline IThing() { }
 virtual ~IThing() { }
 //inline ~IThing() { sendDeleteNotice(); }
 
 virtual const IThing *getIThing() const=0;
 virtual IThing * getIThing()=0; 
 
 virtual TType getType() const=0;
 
 virtual IString getTypeName() const=0;
 
 virtual TType getGeneralType() const=0;
 
 virtual const void *convertToType(const TType &id) const=0;
 virtual void * convertToTypeNC(const TType &id)=0; 
 
 template <class T> const T *convert() const { return (const T *)convertToType(T::type_); }
 template <class T> T * convert() { return (T *)convertToType(T::type_); } 
 
 virtual uint64 getID() const=0;
 virtual void setID(uint64)=0;
 
 virtual uint64 getCollectionID() const=0;
 
 virtual bool getIsSet() const=0;
 
 virtual const IThing * getSet() const=0;
 
 virtual void getAssociatedThings(const TType &type,FArray<const IThing*> *ret) const=0;
 
 virtual void resetAssociatedThings(FArray<const IThing*> *ret) = 0;
 
 virtual IString getName() const=0;
 
 virtual DVect3 getLocation() const=0;
 
 virtual DExtent3 getExtent() const=0;
 
 virtual DVect3 getClosest(const DVect3 &pos) const=0;
 
 virtual DVect3 getNormal() const=0;
 
 virtual DVect3 getDisplacementThing() const=0;
 
 virtual DVect3 getVelocityThing() const=0;
 
 virtual double getVolume() const=0;
 
 virtual bool isWithinOrientation(const Orientation3 &orientation,const DVect2 &tol) const=0;
 
 virtual bool isOnSurface() const=0;
 
 virtual const IContainer *getContainer() const=0;
 virtual IContainer * getContainer()=0;
 virtual uint64 getContainerOrder() const=0;
 
 //virtual bool addGroup(IGroupID *id)=0;
 virtual bool addGroup(const IGroupID &id) = 0;
 virtual bool removeGroup(const IGroupID &id)=0;
 virtual uint32 isInGroup(const FArray<IGroupID> &ids,TType type=0,bool only=false) const=0;
 virtual const IGroup *getGroup(const ISlotID &slot) const=0;
 virtual IString getGroupName(const ISlotID &slot=ISlotID()) const=0;
 virtual uint32 getGroupList(FArray<IGroupID> *list) const=0;
 virtual void copyGroups(const IThing *t)=0;
 virtual void clearGroup()=0;
 
 virtual std::vector<uint32> getExtraIndices() const=0;
 virtual const fish::IParameter *getExtra(uint32 index) const=0;
 virtual void setExtra(uint32 index,const fish::IParameter &p)=0; 
 virtual void clearExtra()=0;
 
 virtual bool getHidden() const=0;
 virtual bool setHidden(bool b)=0;
 
 virtual bool getSelected() const=0;
 virtual bool setSelected(bool b)=0;
 
 virtual void save(Archive2 &) const=0;
 virtual bool restore(Archive2 &,uint64)=0;
 virtual void remap(Archive2 &)=0;
 virtual Handle getRemapHandle(bool allowCreate,uint32 thread) const=0;
 //virtual void clearRemapHandle()=0;
 
 virtual void destroy()=0;
 
 private:
 mutable LockType thingLock_; // Generic spin lock for access to this IThing
 };
 
 template <class Dest> inline const Dest *convert_cast(const IThing *src) { return src ? src->convert<Dest>() : 0; }
 template <class Dest> inline Dest * convert_cast(IThing *src) { return src ? src->convert<Dest>() : 0; } 
 
 template <class Dest, class Src> inline const Dest* convert_getcast(const Src* src) { return src ? src->getIThing()->template convert<Dest>() : 0; }
 template <class Dest, class Src> inline Dest* convert_getcast(Src* src) { return src ? src->getIThing()->template convert<Dest>() : 0; } 
 
 inline int64 pointCompare(const IThing *p1,const IThing *p2) {
 int64 i1 = p1 ? p1->getType() : 0;
 int64 i2 = p2 ? p2->getType() : 0;
 if (i1 == i2) {
 i1 = p1 ? p1->getID() : 0;
 i2 = p2 ? p2->getID() : 0;
 }
 return i1 - i2;
 }
} // namespace itasca
namespace std {
 template <>
 struct hash<itasca::IThing::Handle> {
 std::size_t operator()(const itasca::IThing::Handle &h) const { return hash<uint64>()(h.val_); }
 };
} // namespace std
namespace utility {
 using itasca::IThing;
 using itasca::convert_cast;
 using itasca::convert_getcast;
}
 
// EoF