igroup.h

#pragma once
 
#include "base/src/istring.h"
 
namespace itasca {
    class IThing;
 
    class IGroup {
    public:
        static constexpr TType type_ = 0x4ecd4d65;
        inline static IString nullName() { return "None"; }
        static constexpr uint32 null_ = 0xFFFFFFFF;
        virtual IThing *      getIThing()=0;
        virtual const IThing *getIThing() const=0; 
        virtual IString       getName() const=0;
    };
 
    class ISlot {
    public:
        static constexpr TType type_ = 0x4ecd4d66;
        static constexpr uint32 any_ = 0xFFFFFFFF;
        static constexpr uint32 invalid_ = 0xFFFFFFFE;
        static constexpr uint32 unresolved_ = 0xFFFFFFFD;
        inline static IString anyName() { return "Any"; }
        inline static IString defaultName() { return "Default"; }
        inline static IString invalidName() { return "Invalid"; }
        virtual IThing *      getIThing()=0;
        virtual const IThing *getIThing() const=0; 
        virtual IString       getName() const=0;
        virtual uint32       getIndex() const = 0;
    };
 
    class ISlotID {
    public:
        static constexpr uint32 any_ = ISlot::any_;
        static constexpr uint32 unresolved_ = ISlot::unresolved_;
        static constexpr uint32 invalid_ = ISlot::invalid_;
        inline static IString anyName() { return ISlot::anyName(); }
        inline static IString defaultName() { return ISlot::defaultName(); }
        inline static IString invalidName() { return ISlot::invalidName(); }
 
        inline ISlotID(const ISlot *slot) : slot_(slot), slotIndex_(slot ? ISlot::unresolved_ : ISlot::invalid_) { }
        inline ISlotID(uint32 slot=any_) : slotIndex_(slot) { } // Any slot for read, default slot for write.
        inline ISlotID(const IString &name) : slotIndex_(name.length() ? ISlot::unresolved_ : ISlot::any_), slotName_(name)  { }
        inline ISlotID(const ISlotID &id) : slot_(id.slot_), slotIndex_(id.slotIndex_), slotName_(id.slotName_), thread_(id.thread_) {}
        inline ISlotID(ISlotID &&id) noexcept : slot_(id.slot_), slotIndex_(id.slotIndex_), slotName_(std::move(id.slotName_)), thread_(id.thread_) {}
 
        inline const ISlotID &operator=(const ISlotID &id) { slot_ = id.slot_;  slotIndex_ = id.slotIndex_;  slotName_ = id.slotName_;  thread_ = id.thread_;  return *this; }
        inline const ISlotID &operator=(ISlotID &&id) noexcept { slot_ = id.slot_;  slotIndex_ = id.slotIndex_;  slotName_ = std::move(id.slotName_);  thread_ = id.thread_;  return *this; }
        inline bool           anySlot() const { return slot_ ? slot_->getIndex()==any_ : (slotIndex_!=unresolved_ ? slotIndex_==ISlot::any_ : slotName_.compare(anyName(), IString::Case::Insensitive)==0 ); }
        inline bool           unresolvedSlot() const { return slot_==nullptr && (slotIndex_!=unresolved_ || slotName_.length()); }
        inline bool           invalidSlot() const {  return slotIndex_ == invalid_; }
        inline bool           hasSlot() const { return slot_ || slotIndex_!=unresolved_ || slotName_.length(); }
        inline void           setSlot(uint32 slot) { slot_ = nullptr;  slotIndex_ = slot;  slotName_ = IString(); }
        inline void           setSlot(const IString &name) { slot_ = nullptr;  slotName_ = name;  slotIndex_ = name.length() ? unresolved_ : any_; }
        inline void           setSlot(const ISlot *slot) { slot_ = slot;  slotName_ = IString(); slotIndex_ = slot ? unresolved_ : invalid_;  }
        inline void           setSlot(const ISlotID &id) { operator=(id);  }
        inline void           setAny() { slot_ = nullptr; slotIndex_ = any_;  slotName_ = IString();  }
        inline const ISlot *  slot() const { return slot_;  }
        inline uint32         slotIndex() const { return slot_ ? slot_->getIndex() : slotIndex_; }
        inline IString        slotName() const { return slot_ ? slot_->getName() : slotName_; }
        inline const IString &givenSlotName() const { return slotName_;  }
        inline bool operator <(const ISlotID &slot) const { return slotIndex()<slot.slotIndex(); }
        inline uint32 thread() const { return thread_;  }
        inline void   thread(uint32 t) { thread_ = t;  }
    private:
        // Used to determine slot in this order of priority
        const ISlot *slot_ = nullptr; // If non-null
        uint32       slotIndex_ = ISlot::unresolved_; // if not unresolved
        IString      slotName_;       // Last resort
        uint32       thread_ = 0;
    };
 
    class IGroupID : public ISlotID {
    public:
        inline static IString nullName() { return IGroup::nullName(); }
 
        inline IGroupID() { }
        inline IGroupID(const IGroup *group) : group_(group) { }
        inline IGroupID(const IGroup *group,const ISlot *slot) : ISlotID(slot), group_(group) { }
        inline IGroupID(const IString &groupName) : groupName_(groupName) {}
        inline IGroupID (const IGroup *group,const ISlotID &slot) : ISlotID(slot), group_(group) { }
        inline IGroupID(const IString &groupName,const IString &slotName) : ISlotID(slotName), group_(nullptr), groupName_(groupName) { }
        inline IGroupID(const IString &groupName,uint32 slot) : ISlotID(slot), groupName_(groupName) { }
        inline IGroupID(const IGroupID &id) : ISlotID(id), group_(id.group_), groupName_(id.groupName_) {}
        inline IGroupID(IGroupID &&id) noexcept : ISlotID(std::move(id)), group_(id.group_), groupName_(std::move(id.groupName_)) {}
        inline IGroupID(const ISlotID &s) : ISlotID(s) {}
        inline IGroupID(ISlotID &&s) noexcept : ISlotID(std::move(s)) {}
        inline const IGroupID &operator=(const IGroupID &id) { ISlotID::operator=(id); group_ = id.group_;  groupName_ = id.groupName_;  return *this; }
        inline const IGroupID &operator=(IGroupID &&id) noexcept { ISlotID::operator=(std::move(id));  group_ = id.group_;  groupName_ = std::move(id.groupName_);  return *this; }
        inline bool           hasGroup() const { if (group_ || groupName_.length()) return true;  return false; }
        inline bool           unresolvedGroup() const { return !group_ && groupName_.length();  }
        inline bool           unresolved() const { return unresolvedGroup() || unresolvedSlot();  }
        inline void           setGroup(const IGroup *group) { group_ = group;  groupName_ = IString();  }
        inline void           setGroup(const IString &name) { groupName_ = name; group_ = nullptr; }
        inline const IGroup * group() const { return group_; }
        inline IString        groupName() const { return group_ ? group_->getName() : groupName_; }
        inline const IString &givenGroupName() const { return groupName_;  }
        inline bool operator <(const IGroupID &group) const { if (slotIndex()!=group.slotIndex()) return slotIndex()<group.slotIndex(); return groupName().compare(group.groupName(),IString::Case::Insensitive)<0; }
    private:
        const IGroup *group_ = nullptr;     // If non-null groupName_ is ignored.
        IString       groupName_; // Used to find group_, must be non-null if group_ is null.
    };
} // namespace itasca
namespace utility {
    using itasca::IGroup;
    using itasca::ISlot;
    using itasca::IGroupID;
    using itasca::ISlotID;
}
// EoF