GroupItem.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_GroupItem_h
#define smtk_attribute_GroupItem_h
 
#include "smtk/CoreExports.h"
#include "smtk/attribute/Item.h"
#include <cassert>
#include <vector>
namespace smtk
{
namespace attribute
{
class GroupItemDefinition;
 
class SMTKCORE_EXPORT GroupItem : public Item
{
  friend class GroupItemDefinition;
 
public:
  typedef std::vector<std::vector<smtk::attribute::ItemPtr>>::const_iterator const_iterator;
 
  smtkTypeMacro(smtk::attribute::GroupItem);
  ~GroupItem() override;
  Item::Type type() const override;
 
  std::size_t numberOfRequiredGroups() const;
  std::size_t maxNumberOfGroups() const;
  void visitChildren(
    std::function<void(smtk::attribute::ItemPtr, bool)> visitor,
    bool activeChildren = true) override;
 
  bool isExtensible() const;
 
  std::size_t numberOfGroups() const { return m_items.size(); }
  bool setNumberOfGroups(std::size_t newSize);
  std::size_t numberOfItemsPerGroup() const;
  bool appendGroup();
  bool prependGroup();
  bool insertGroups(std::size_t pos, std::size_t num);
  bool removeGroup(std::size_t element);
 
  smtk::attribute::ItemPtr item(std::size_t ith) const { return this->item(0, ith); }
  smtk::attribute::ItemPtr item(std::size_t element, std::size_t ith) const
  {
    assert(m_items.size() > element);
    assert(m_items[element].size() > ith);
    return m_items[element][ith];
  }
 
  smtk::attribute::ItemPtr
  find(std::size_t element, const std::string& name, SearchStyle style = IMMEDIATE);
  smtk::attribute::ConstItemPtr
  find(std::size_t element, const std::string& name, SearchStyle style = IMMEDIATE) const;
  using Item::find;
 
  template<typename T>
  typename T::Ptr
  findAs(std::size_t element, const std::string& name, SearchStyle style = IMMEDIATE);
  template<typename T>
  typename T::ConstPtr
  findAs(std::size_t element, const std::string& name, SearchStyle style = IMMEDIATE) const;
  using Item::findAs;
 
  void detachOwningResource() override;
 
  void reset() override;
 
  bool rotate(std::size_t fromPosition, std::size_t toPosition) override;
 
  bool isConditional() const;
 
  bool conditionalsSatisfied(bool useActiveCategories = true) const;
 
  void setMinNumberOfChoices(unsigned int value) { m_minNumberOfChoices = value; }
  unsigned int minNumberOfChoices() const { return m_minNumberOfChoices; }
 
  void setMaxNumberOfChoices(unsigned int value) { m_maxNumberOfChoices = value; }
  unsigned int maxNumberOfChoices() const { return m_maxNumberOfChoices; }
 
  const_iterator begin() const;
  const_iterator end() const;
 
  using Item::assign;
  Item::Status assign(
    const smtk::attribute::ConstItemPtr& sourceItem,
    const CopyAssignmentOptions& options,
    smtk::io::Logger& logger) override;
 
  bool hasRelevantChildren(
    bool includeCategories = true,
    bool includeReadAccess = false,
    int readAccessLevel = 0) const;
 
protected:
  GroupItem(Attribute* owningAttribute, int itemPosition);
  GroupItem(Item* owningItem, int myPosition, int mySubGroupPosition);
  bool setDefinition(smtk::attribute::ConstItemDefinitionPtr def) override;
  smtk::attribute::ItemPtr findInternal(const std::string& name, SearchStyle style) override;
  smtk::attribute::ConstItemPtr findInternal(const std::string& name, SearchStyle style)
    const override;
  // This method will detach all of the items directly owned by
  // this group
  void detachAllItems();
  bool isValidInternal(bool useCategories, const std::set<std::string>& categories) const override;
  std::vector<std::vector<smtk::attribute::ItemPtr>> m_items;
  unsigned int m_maxNumberOfChoices;
  unsigned int m_minNumberOfChoices;
 
private:
};
 
template<typename T>
typename T::Ptr GroupItem::findAs(std::size_t element, const std::string& iname, SearchStyle style)
{
  return smtk::dynamic_pointer_cast<T>(this->find(element, iname, style));
}
 
template<typename T>
typename T::ConstPtr
GroupItem::findAs(std::size_t element, const std::string& iname, SearchStyle style) const
{
  return smtk::dynamic_pointer_cast<const T>(this->find(element, iname, style));
}
 
} // namespace attribute
} // namespace smtk
 
#endif /* __GroupItem_h */