ithing.h

Go to the documentation of this file.

#pragma once

#include "ideletenotice.h"
#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 {
#ifdef ITHINGMUTEX
        using LockType = std::mutex;
#else
        using LockType = spinlock;
#endif
    public:
        class Lock : public std::lock_guard<LockType> {
        public:
            inline Lock(const IThing *t) : std::lock_guard<LockType>(t->thingLock_) {  }
        };

        class LockIf : public conditional_lock<LockType> {
        public:
            inline LockIf(const IThing *t, bool b) : conditional_lock<LockType>(t ? &t->thingLock_ : nullptr,b) { }
        };

        class BreakLock : public reverse_lock<LockType> {
        public:
            inline BreakLock(const IThing *t) : reverse_lock<LockType>(t->thingLock_) {}
        };

        inline static const TType type_ = 0x4c815a59;
        inline static const uint maxGroupSlot_ = 128;
        inline static const uint maxExtraIndex_ = 128;

        inline IThing() { }
        //inline ~IThing() {  sendDeleteNotice(); }

        virtual const IThing *getIThing() const=0;
        virtual IThing *      getIThing()=0;   

        virtual TType getType() const=0;

        virtual QString getTypeName() const=0;

        virtual TType getGeneralType() const=0;

        virtual const void *convertToType(const TType &id) const=0;
        virtual void *      convertToType(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 quint64 getID() const=0;

        virtual quint64 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 QString 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(bool mech=true,bool therm=false,bool fluid=false,bool _or=false) const=0;

        virtual const IContainer *getContainer() const=0;
        virtual IContainer *      getContainer()=0;

        //virtual bool addGroup(IGroupID *id)=0;
        virtual bool addGroup(const IGroupID &id) = 0;
        virtual bool removeGroup(const IGroupID &id)=0;
        virtual uint isInGroup(const FArray<IGroupID> &ids,TType type=0,bool only=false) const=0;
        virtual const IGroup *getGroup(const ISlotID &slot) const=0;
        virtual QString       getGroupName(const ISlotID &slot=ISlotID()) const=0;
        virtual uint          getGroupList(FArray<IGroupID> *list) const=0;
        virtual void          copyGroups(const IThing *t)=0;
        virtual void          clearGroup()=0;

        virtual uint                    getExtraSize()  const=0;
        virtual const fish::IParameter *getExtra(uint index) const=0;
        virtual void                    setExtra(uint 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;

        // MPI Support functions
        virtual bool getGhost() const=0;
        virtual void setGhost(bool b)=0;
        virtual quint64 getContainerOrder() const = 0;
        virtual void    setContainerOrder(quint64 i) = 0;

        virtual void    save(Archive2 &) const=0;
        virtual bool    restore(Archive2 &,quint64)=0;
        virtual void    remap(Archive2 &)=0;
        virtual quint64 getRemapHandle(Archive2 &) const=0;
        //virtual void    clearRemapHandle()=0;

        virtual void destroy()=0;

        inline void addDeleteNotice(IDeleteNotice *delnot) const;
        inline void removeDeleteNotice(IDeleteNotice *delnot) const;
        inline void sendDeleteNotice();
        inline void changeToNewPointer(IThing *newPnt);
    private:
        mutable IDeleteNotice *head_ = nullptr;
        mutable LockType thingLock_;        // Generic spin lock for access to this IThing
        mutable LockType deleteNoticeLock_; // Specific to delete notice - using the same one was causing race conditions in intrinsics
    };

    inline void IThing::addDeleteNotice(IDeleteNotice *delnot) const {
        std::lock_guard<LockType> l(deleteNoticeLock_);
        delnot->insert(&head_);
    }

    inline void IThing::removeDeleteNotice(IDeleteNotice *delnot) const {
        std::lock_guard<LockType> l(deleteNoticeLock_);
        delnot->remove(&head_);
    }

    inline void IThing::sendDeleteNotice() {
        std::lock_guard<LockType> l(deleteNoticeLock_);
        while (head_) {
            auto dn = head_;
            dn->remove(&head_);
            reverse_lock<LockType> r(deleteNoticeLock_);
            dn->onDelete(this);
        }
    }

    inline void IThing::changeToNewPointer(IThing *newPnt) {
        std::vector<IDeleteNotice *> all;
        {
            std::lock_guard<LockType> l(deleteNoticeLock_);
            for (auto *dn = head_; dn; dn = dn->nextDeleteNotice())
                all.push_back(dn);
        }
        for (auto *dn : all)
            dn->changeToNewPointer(this,newPnt);
    }

    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; } 
} // namespace itasca

// EoF