Item.h

//=========================================================================
//  Copyright (c) Kitware, Inc.
//  All rights reserved.
//  See LICENSE.txt for details.
//
//  This software is distributed WITHOUT ANY WARRANTY; without even
//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
//  PURPOSE.  See the above copyright notice for more information.
//=========================================================================
 
#ifndef smtk_attribute_Item_h
#define smtk_attribute_Item_h
 
#include "smtk/CoreExports.h"
#include "smtk/PublicPointerDefs.h"
#include "smtk/SharedFromThis.h"
#include "smtk/attribute/Categories.h"
#include "smtk/attribute/CopyAssignmentOptions.h"
#include "smtk/attribute/SearchStyle.h"
#include "smtk/common/Status.h"
#include <algorithm>
#include <map>
#include <queue>
#include <string>
#include <vector>
 
namespace smtk
{
 
namespace io
{
class Logger;
};
 
namespace attribute
{
class ItemDefinition;
class GroupItem;
class Attribute;
 
class SMTKCORE_EXPORT Item : public smtk::enable_shared_from_this<Item>
{
  friend class Definition;
  friend class GroupItemDefinition;
  friend class ReferenceItemDefinition;
  friend class ValueItemDefinition;
 
public:
  smtkTypeMacroBase(smtk::attribute::Item);
 
  typedef std::function<
    bool(const Item*, bool includeCatagories, bool includeReadAccess, unsigned int readAccessLevel)>
    RelevanceFunc;
 
  enum Type
  {
    AttributeRefType, 
    DoubleType,
    GroupType,
    IntType,
    StringType,
    VoidType,
    FileType,
    DirectoryType,
    ColorType,
    ModelEntityType,
    MeshEntityType, 
    DateTimeType,
    ReferenceType,
    ResourceType,
    ComponentType,
    NUMBER_OF_TYPES
  };
 
  virtual ~Item();
  std::string name() const;
  std::string label() const;
  virtual Item::Type type() const = 0;
 
  bool isValid(bool useActiveCategories = true) const;
  bool isValid(const std::set<std::string>& categories) const
  {
    return (!this->isEnabled()) || this->isIgnored() || this->isValidInternal(true, categories);
  }
 
  void setCustomIsRelevant(RelevanceFunc func) { m_customIsRelevant = func; }
  RelevanceFunc customIsRelevant() const { return m_customIsRelevant; }
 
  bool isRelevant(
    bool includeCatagories = true,
    bool includeReadAccess = false,
    unsigned int readAccessLevel = 0) const;
 
  virtual bool defaultIsRelevant(
    bool includeCatagories,
    bool includeReadAccess,
    unsigned int readAccessLevel) const;
 
  smtk::attribute::ItemPtr find(const std::string& name, SearchStyle style = RECURSIVE_ACTIVE);
  smtk::attribute::ConstItemPtr find(const std::string& name, SearchStyle style = RECURSIVE_ACTIVE)
    const;
 
  template<typename T>
  typename T::Ptr findAs(const std::string& name, SearchStyle style = RECURSIVE_ACTIVE);
 
  template<typename T>
  typename T::ConstPtr findAs(const std::string& name, SearchStyle style = RECURSIVE_ACTIVE) const;
 
  virtual void visitChildren(
    std::function<void(smtk::attribute::ItemPtr, bool)> visitor,
    bool activeChildren = true)
  {
    (void)visitor;
    (void)activeChildren;
  }
  const smtk::attribute::ConstItemDefinitionPtr& definition() const { return m_definition; }
 
  template<typename DefType>
  std::shared_ptr<const DefType> definitionAs() const
  {
    return std::dynamic_pointer_cast<const DefType>(m_definition);
  }
 
  smtk::attribute::AttributePtr attribute() const;
  smtk::attribute::ItemPtr owningItem() const
  {
    return (m_owningItem ? m_owningItem->shared_from_this() : smtk::attribute::ItemPtr());
  }
  int position() const { return m_position; }
 
  int subGroupPosition() const;
 
  std::string path(const std::string& sep = "/") const;
 
  bool isOptional() const;
 
  bool isEnabled() const;
 
  bool localEnabledState() const { return m_isEnabled; }
  void setIsEnabled(bool isEnabledValue) { m_isEnabled = isEnabledValue; }
 
  void setForceRequired(bool val) { m_forceRequired = val; }
  bool forceRequired() const { return m_forceRequired; }
 
  const smtk::attribute::Categories& categories() const;
 
  unsigned int advanceLevel(int mode = 0) const;
  void setLocalAdvanceLevel(int mode, unsigned int level);
  unsigned int localAdvanceLevel(int mode = 0) const
  {
    return (mode == 1 ? m_localAdvanceLevel[1] : m_localAdvanceLevel[0]);
  }
  // unsetAdvanceLevel causes the item to return its
  // definition advance level information for the specified mode when calling
  // the advanceLevel(mode) method
  void unsetLocalAdvanceLevel(int mode = 0);
  // Returns true if the item is returning its local
  // advance level information
  bool hasLocalAdvanceLevelInfo(int mode = 0) const
  {
    return (mode == 1 ? m_hasLocalAdvanceLevelInfo[1] : m_hasLocalAdvanceLevelInfo[0]);
  }
 
  void setUserData(const std::string& key, smtk::simulation::UserDataPtr value)
  {
    m_userData[key] = value;
  }
  smtk::simulation::UserDataPtr userData(const std::string& key) const;
  void clearUserData(const std::string& key) { m_userData.erase(key); }
  void clearAllUserData() { m_userData.clear(); }
 
  virtual void reset();
 
  virtual bool rotate(std::size_t fromPosition, std::size_t toPosition);
 
  virtual void detachOwningResource() {}
 
  void detachOwningAttribute() { m_attribute = nullptr; }
  void detachOwningItem() { m_owningItem = nullptr; }
 
  using Status = smtk::common::Status;
 
  virtual Status assign(
    const smtk::attribute::ConstItemPtr& sourceItem,
    const CopyAssignmentOptions& options = CopyAssignmentOptions());
 
  virtual Status assign(
    const smtk::attribute::ConstItemPtr& sourceItem,
    const CopyAssignmentOptions& options,
    smtk::io::Logger& logger);
 
  void setIsIgnored(bool val) { m_isIgnored = val; }
 
  bool isIgnored() const { return m_isIgnored; }
 
  static std::string type2String(Item::Type t);
  static Item::Type string2Type(const std::string& s);
 
protected:
  Item(Attribute* owningAttribute, int itemPosition);
  Item(Item* owningItem, int myPosition, int mySubGroupPosition);
  virtual bool setDefinition(smtk::attribute::ConstItemDefinitionPtr def);
  virtual smtk::attribute::ItemPtr findInternal(const std::string& name, SearchStyle style);
  virtual smtk::attribute::ConstItemPtr findInternal(const std::string& name, SearchStyle style)
    const;
  // Internal method for rotate()
  template<typename T>
  bool rotateVector(std::vector<T>& v, std::size_t fromPosition, std::size_t toPosition);
  virtual bool isValidInternal(bool useCategories, const std::set<std::string>& categories)
    const = 0;
  Attribute* m_attribute;
  Item* m_owningItem;
  int m_position;
  int m_subGroupPosition;
  bool m_isEnabled;
  bool m_isIgnored;
  smtk::attribute::ConstItemDefinitionPtr m_definition;
  std::map<std::string, smtk::simulation::UserDataPtr> m_userData;
  RelevanceFunc m_customIsRelevant = nullptr;
 
private:
  bool m_hasLocalAdvanceLevelInfo[2];
  unsigned int m_localAdvanceLevel[2];
  bool m_forceRequired;
};
 
inline smtk::simulation::UserDataPtr Item::userData(const std::string& key) const
{
  std::map<std::string, smtk::simulation::UserDataPtr>::const_iterator it = m_userData.find(key);
  return ((it == m_userData.end()) ? smtk::simulation::UserDataPtr() : it->second);
}
 
template<typename T>
typename T::Ptr Item::findAs(const std::string& iname, SearchStyle style)
{
  return smtk::dynamic_pointer_cast<T>(this->find(iname, style));
}
 
template<typename T>
typename T::ConstPtr Item::findAs(const std::string& iname, SearchStyle style) const
{
  return smtk::dynamic_pointer_cast<const T>(this->find(iname, style));
}
 
template<typename T>
bool Item::rotateVector(std::vector<T>& v, std::size_t fromPosition, std::size_t toPosition)
{
  if (fromPosition == toPosition) // no-op
  {
    return true;
  }
 
  std::size_t lastPosition = v.size() - 1;
  if ((fromPosition > lastPosition) || (toPosition > lastPosition))
  {
    return false;
  }
 
  auto first = v.begin();
  auto middle = v.begin();
  auto last = v.begin();
  if (fromPosition < toPosition)
  {
    first += fromPosition;
    last += toPosition + 1;
    middle += fromPosition + 1;
  }
  else
  {
    first += toPosition;
    last += fromPosition + 1;
    middle += fromPosition;
  }
  std::rotate(first, middle, last);
  return true;
}
} // namespace attribute
} // namespace smtk
 
#endif /* smtk_attribute_Item_h */