Item.h

Go to the documentation of this file.

 
#ifndef CNOID_BASE_ITEM_H
#define CNOID_BASE_ITEM_H
 
#include <cnoid/Referenced>
#include <cnoid/Signal>
#include <string>
#include <vector>
#include <ctime>
#include "exportdecl.h"
 
namespace cnoid {
 
class Item;
typedef ref_ptr<Item> ItemPtr;
 
template<class ItemType = Item> class ItemList;
    
class ItemAddon;
class RootItem;
class Archive;
class Mapping;
class ExtensionManager;
class PutPropertyFunction;
 
class CNOID_EXPORT Item : public Referenced
{
protected:
    Item();
    Item(const std::string& name);
    Item(const Item& item);
    
public:
    enum Attribute {
        SubItem,
        Attached,
        Temporal,
        LoadOnly,
        NumAttributes,
        SUB_ITEM = SubItem,
        TEMPORAL = Temporal,
        LOAD_ONLY = LoadOnly
    };
 
    virtual ~Item();
 
    Item& operator=(const Item& rhs) = delete;
 
    int classId() const {
        if(classId_ < 0) validateClassId();
        return classId_;
    }
 
    Item* createNewInstance() const;
 
    void assign(Item* srcItem);
 
    Item* duplicate(Item* duplicatedParentItem = nullptr) const;
 
    Item* duplicateSubTree() const;
 
    [[deprecated("Use Item::duplicateSubTree.")]]
    Item* duplicateAll() const { return duplicateSubTree(); }
 
    const std::string& name() const { return name_; }
    virtual bool setName(const std::string& name);
    virtual std::string displayName() const;
    void setDisplayNameModifier(std::function<std::string(const Item* item)> modifier);
    SignalProxy<void(const std::string& oldName)> sigNameChanged();
    void notifyNameChange();
 
    void setAttribute(Attribute attribute);
    void unsetAttribute(Attribute attribute);
    bool hasAttribute(Attribute attribute) const;
 
    bool isSubItem() const;
    void setSubItemAttributes();
 
    bool isTemporal() const;
    
    void setTemporal(bool on = true);
 
    bool isSelected() const { return isSelected_; }
    void setSelected(bool on, bool isCurrent = false);
    void setSubTreeItemsSelected(bool on);
 
    enum CheckId { LogicalSumOfAllChecks = -1, PrimaryCheck = 0 };
    
    bool isChecked(int checkId = PrimaryCheck) const;
    void setChecked(bool on); // for PrimaryCheck
    void setChecked(int checkId, bool on);
    int numCheckStates() const;
 
    int numChildren() const { return numChildren_; }
    int countDescendantItems() const;
 
    Item* childItem() const { return firstChild_; }
    Item* prevItem() const { return prevItem_; }
    Item* nextItem() const { return nextItem_; }
    Item* lastChildItem() const { return lastChild_; }
    Item* parentItem() const { return parent_; }
 
    Item* headItem() const;
 
    RootItem* findRootItem() const;
    bool isConnectedToRoot() const;
    Item* localRootItem() const;
 
    bool addChildItem(Item* item, bool isManualOperation = false);
 
    [[deprecated("Use Item::insertChild(Item* position, Item* item, bool isManualOperation).")]]
    bool insertChildItem(Item* item, Item* nextItem, bool isManualOperation = false);
 
    bool insertChild(Item* position, Item* item, bool isManualOperation = false);
 
    bool addSubItem(Item* item);
 
    [[deprecated("Use Item::setSubItemAttributes and Item::insertChild(Item* position, Item* item, bool isManualOperation).")]]
    bool insertSubItem(Item* item, Item* nextItem);
 
    void removeFromParentItem();
 
    [[deprecated("Use Item::removeFromParentItem.")]]
    void detachFromParentItem() { removeFromParentItem(); }
    
    void clearChildren();
 
    typedef std::function<bool(Item* item)> ItemPredicate;
 
    template<class ItemType>
    static ItemPredicate getItemPredicate() {
        return [](Item* item) -> bool { return dynamic_cast<ItemType*>(item); };
    }
    template<class ItemType>
    static ItemPredicate getItemPredicate(std::function<bool(ItemType* item)> pred) {
        return [pred](Item* item){
            if(auto casted = dynamic_cast<ItemType*>(item)){
                return pred ? pred(casted) : true;
            }
            return false;
        };
    }
 
    static Item* find(const std::string& path) {
        return find(path, nullptr);
    }
    template<class ItemType>
    ItemType* find(const std::string& path = "") {
        return static_cast<ItemType*>(find(path, getItemPredicate<ItemType>()));
    }
    
    Item* findItem(const std::string& path) const {
        return findItem(path, nullptr, true);
    }
    template<class ItemType>
    ItemType* findItem(const std::string& path) const {
        return static_cast<ItemType*>(
            findItem(path, getItemPredicate<ItemType>(), true));
    }
    template<class ItemType>
    ItemType* findItem(std::function<bool(ItemType* item)> pred = nullptr) const {
        return static_cast<ItemType*>(
            findItem("", getItemPredicate<ItemType>(pred), true));
    }
    
    Item* findChildItem(const std::string& path, std::function<bool(Item* item)> pred = nullptr) const {
        return findItem(path, pred, false);
    }
    template<class ItemType>
    ItemType* findChildItem(const std::string& path, std::function<bool(ItemType* item)> pred = nullptr) const {
        return static_cast<ItemType*>(
            findItem(path, getItemPredicate<ItemType>(pred), false));
    }
    template<class ItemType>
    ItemType* findChildItem(std::function<bool(ItemType* item)> pred = nullptr) const {
        return static_cast<ItemType*>(
            findItem("", getItemPredicate<ItemType>(pred), false));
    }
 
    [[deprecated("Use Item::findChildItem with the pred function")]]
    Item* findSubItem(const std::string& path) const {
        return findItem(path, [](Item* item){ return item->isSubItem(); }, false);
    }
 
    template<class ItemType>
    [[deprecated("Use Item::findChildItem with the pred function")]]
    ItemType* findSubItem(const std::string& path = "") const {
        return static_cast<ItemType*>(
            findItem(
                path,
                getItemPredicate<ItemType>([](ItemType* item){ return item->isSubItem(); }),
                false));
    }
    
    template <class ItemType> ItemType* findOwnerItem(bool includeSelf = false) const {
        Item* parentItem__ = includeSelf ? const_cast<Item*>(this) : parentItem();
        while(parentItem__){
            if(ItemType* ownerItem = dynamic_cast<ItemType*>(parentItem__)){
                return ownerItem;
            }
            parentItem__ = parentItem__->parentItem();
        }
        return nullptr;
    }
 
    bool isOwnedBy(Item* item) const;
 
    ItemList<> childItems(std::function<bool(Item* item)> pred = nullptr) const;
 
    template <class ItemType>
    ItemList<ItemType> childItems(std::function<bool(ItemType* item)> pred = nullptr) const {
        return getDescendantItems(getItemPredicate<ItemType>(pred), false);
    }
 
    ItemList<> descendantItems(std::function<bool(Item* item)> pred = nullptr) const;
 
    template <class ItemType>
    ItemList<ItemType> descendantItems(std::function<bool(ItemType* item)> pred = nullptr) const {
        return getDescendantItems(getItemPredicate<ItemType>(pred), true);
    }
 
    ItemList<> selectedDescendantItems(std::function<bool(Item* item)> pred = nullptr) const;
 
    template <class ItemType>
    ItemList<ItemType> selectedDescendantItems(std::function<bool(Item* item)> pred = nullptr) const {
        return selectedDescendantItems(getItemPredicate<ItemType>(pred));
    }
 
    bool traverse(std::function<bool(Item*)> pred);
 
    template<class ItemType>
    bool traverse(std::function<bool(ItemType* item)> pred = nullptr){
        return Item::traverse(getItemPredicate<ItemType>(pred));
    }
 
    SignalProxy<void()> sigTreePathChanged();
 
    SignalProxy<void()> sigTreePositionChanged();
 
    SignalProxy<void(Item* topItem, Item* prevTopParentItem)> sigTreePositionChanged2();
 
    [[deprecated("Use sigTreePositionChanged")]]
    SignalProxy<void()> sigPositionChanged();
 
    SignalProxy<void()> sigSubTreeChanged();
 
    SignalProxy<void()> sigDisconnectedFromRoot();
 
    [[deprecated("Use Item::sigDisconnectedFromRoot.")]]
    SignalProxy<void()> sigDetachedFromRoot() { return sigDisconnectedFromRoot(); }
 
    SignalProxy<void(bool on)> sigSelectionChanged();
    SignalProxy<void(int checkId, bool on)> sigAnyCheckToggled();
    SignalProxy<void(bool on)> sigCheckToggled(int checkId = PrimaryCheck);
 
    virtual void notifyUpdate();
    SignalProxy<void()> sigUpdated();
 
    bool setAddon(ItemAddon* addon);
    void removeAddon(ItemAddon* addon);
    template<class AddonType> AddonType* findAddon(){
        return static_cast<AddonType*>(findAddon_(typeid(AddonType)));
    }
    template<class AddonType> AddonType* getAddon(){
        return static_cast<AddonType*>(getAddon_(typeid(AddonType)));
    }
    std::vector<ItemAddon*> addons();
 
    bool load(
        const std::string& filename, const std::string& format = std::string(),
        const Mapping* options = nullptr);
 
    bool load(
        const std::string& filename, Item* parent, const std::string& format = std::string(),
        const Mapping* options = nullptr);
    
    bool save(const std::string& filename, const std::string& format = std::string(),
              const Mapping* options = nullptr);
 
    bool overwrite(bool forceOverwrite = false, const std::string& format = std::string());
 
    const std::string& filePath() const;
    std::string fileName() const;
    const std::string& fileFormat() const;
    const Mapping* fileOptions() const;
    std::time_t fileModificationTime() const;
    bool isConsistentWithFile() const;
 
    void updateFileInformation(const std::string& filename, const std::string& format, Mapping* options = nullptr);
    void setConsistentWithFile(bool isConsistent);
    void suggestFileUpdate();
 
    void clearFileInformation();
 
    bool reload();
    bool replace(Item* originalItem);
    Item* findOriginalItem() const;
    Item* findReplacementItem() const;
 
#ifdef CNOID_BACKWARD_COMPATIBILITY
    const std::string& lastAccessedFilePath() const;
    const std::string& lastAccessedFileFormatId() const;
#endif
 
    void putProperties(PutPropertyFunction& putProperty);
 
    virtual bool store(Archive& archive);
    virtual bool restore(const Archive& archive);
 
protected:
 
    virtual void doAssign(Item* srcItem);
 
    virtual Item* doDuplicate() const;
 
    virtual Item* doDuplicate(Item* duplicatedParentItem) const;
 
    virtual bool onNewTreePositionCheck(bool isManualOperation, std::function<void()>& out_callbackWhenAdded);
    virtual void onAddedToParent();
 
    virtual void onTreePathChanged();
 
    virtual void onTreePositionChanged();
 
    virtual void onPositionChanged();
 
    virtual void onConnectedToRoot();
 
    virtual void onRemovedFromParent(Item* parentItem, bool isParentBeingDeleted);
    virtual void onDisconnectedFromRoot();
 
    virtual bool onChildItemAboutToBeAdded(Item* childItem, bool isManualOperation);
 
    virtual void doPutProperties(PutPropertyFunction& putProperty);
 
private:
    class Impl;
    Impl* impl;
 
    mutable int classId_;
    Item* parent_;
    ItemPtr firstChild_;
    ItemPtr nextItem_;
    Item* prevItem_;
    Item* lastChild_;
    int numChildren_;
    std::string name_;
    bool isSelected_;
 
    static Item* find(const std::string& path, const std::function<bool(Item* item)>& pred);
    Item* findItem(
        const std::string& path, std::function<bool(Item* item)> pred, bool isRecursive) const;
    ItemList<Item> getDescendantItems(std::function<bool(Item* item)> pred, bool isRecursive) const;
    void validateClassId() const;
    ItemAddon* findAddon_(const std::type_info& type);
    ItemAddon* getAddon_(const std::type_info& type);
};
 
#ifndef CNOID_BASE_MVOUT_DECLARED
#define CNOID_BASE_MVOUT_DECLARED
CNOID_EXPORT std::ostream& mvout(bool doFlush = true);
#endif
 
}
 
#endif