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