verovio-doxygen/html/object_8h_source.html

 // Name:        object.h

 // Author:      Laurent Pugin

 // Created:     2005

 // Copyright (c) Authors and others. All rights reserved.


 #ifndef __VRV_OBJECT_H__

 #define __VRV_OBJECT_H__


 #include <cstdlib>

 #include <functional>

 #include <iterator>

 #include <map>

 #include <memory>

 #include <string>


 //----------------------------------------------------------------------------


 #include "attclasses.h"

 #include "attmodule.h"

 #include "boundingbox.h"

 #include "vrvdef.h"


 namespace vrv {


 class AltSymInterface;

 class AreaPosInterface;

 class Doc;

 class DurationInterface;

 class EditorialElement;

 class Output;

 class Filters;

 class Functor;

 class Functor;

 class ConstFunctor;

 class LinkingInterface;

 class FacsimileInterface;

 class PitchInterface;

 class PositionInterface;

 class Resources;

 class ScoreDefInterface;

 class StemmedDrawingInterface;

 class TextDirInterface;

 class TimePointInterface;

 class TimeSpanningInterface;

 class VisibilityDrawingInterface;

 class Zone;


 #define UNLIMITED_DEPTH -10000

 #define FORWARD true

 #define BACKWARD false


 //----------------------------------------------------------------------------

 // Object

 //----------------------------------------------------------------------------


 class Object : public BoundingBox {

 public:

     Object();

     Object(ClassId classId);

     virtual ~Object();

     ClassId GetClassId() const final { return m_classId; }

     virtual std::string GetClassName() const { return "[MISSING]"; }


     void SetAsReferenceObject();

     bool IsReferenceObject() const { return m_isReferenceObject; }


     bool IsFloatingObject() const { return (this->IsSystemElement() || this->IsControlElement()); }


     bool IsMilestoneElement() const;

     Object *GetMilestoneEnd();


     bool IsControlElement() const { return Object::IsControlElement(m_classId); }

     bool IsEditorialElement() const { return Object::IsEditorialElement(m_classId); }

     bool IsLayerElement() const { return Object::IsLayerElement(m_classId); }

     bool IsPageElement() const { return Object::IsPageElement(m_classId); }

     bool IsRunningElement() const { return Object::IsRunningElement(m_classId); }

     bool IsScoreDefElement() const { return Object::IsScoreDefElement(m_classId); }

     bool IsSystemElement() const { return Object::IsSystemElement(m_classId); }

     bool IsTextElement() const { return Object::IsTextElement(m_classId); }


     static bool IsControlElement(ClassId classId)

     {

         return ((classId > CONTROL_ELEMENT) && (classId < CONTROL_ELEMENT_max));

     }

     static bool IsEditorialElement(ClassId classId)

     {

         return ((classId > EDITORIAL_ELEMENT) && (classId < EDITORIAL_ELEMENT_max));

     }

     static bool IsLayerElement(ClassId classId) { return ((classId > LAYER_ELEMENT) && (classId < LAYER_ELEMENT_max)); }

     static bool IsPageElement(ClassId classId) { return ((classId > PAGE_ELEMENT) && (classId < PAGE_ELEMENT_max)); }

     static bool IsRunningElement(ClassId classId)

     {

         return ((classId > RUNNING_ELEMENT) && (classId < RUNNING_ELEMENT_max));

     }

     static bool IsScoreDefElement(ClassId classId)

     {

         return ((classId > SCOREDEF_ELEMENT) && (classId < SCOREDEF_ELEMENT_max));

     }

     static bool IsSystemElement(ClassId classId)

     {

         return ((classId > SYSTEM_ELEMENT) && (classId < SYSTEM_ELEMENT_max));

     }

     static bool IsTextElement(ClassId classId) { return ((classId > TEXT_ELEMENT) && (classId < TEXT_ELEMENT_max)); }


     void RegisterAttClass(AttClassId attClassId) { m_attClasses.push_back(attClassId); }

     bool HasAttClass(AttClassId attClassId) const

     {

         return std::find(m_attClasses.begin(), m_attClasses.end(), attClassId) != m_attClasses.end();

     }

     void RegisterInterface(std::vector<AttClassId> *attClasses, InterfaceId interfaceId);

     bool HasInterface(InterfaceId interfaceId) const

     {

         return std::find(m_interfaces.begin(), m_interfaces.end(), interfaceId) != m_interfaces.end();

     }


     virtual AltSymInterface *GetAltSymInterface() { return NULL; }

     virtual const AltSymInterface *GetAltSymInterface() const { return NULL; }

     virtual AreaPosInterface *GetAreaPosInterface() { return NULL; }

     virtual const AreaPosInterface *GetAreaPosInterface() const { return NULL; }

     virtual BeamDrawingInterface *GetBeamDrawingInterface() { return NULL; }

     virtual const BeamDrawingInterface *GetBeamDrawingInterface() const { return NULL; }

     virtual DurationInterface *GetDurationInterface() { return NULL; }

     virtual const DurationInterface *GetDurationInterface() const { return NULL; }

     virtual LinkingInterface *GetLinkingInterface() { return NULL; }

     virtual const LinkingInterface *GetLinkingInterface() const { return NULL; }

     virtual FacsimileInterface *GetFacsimileInterface() { return NULL; }

     virtual const FacsimileInterface *GetFacsimileInterface() const { return NULL; }

     virtual PitchInterface *GetPitchInterface() { return NULL; }

     virtual const PitchInterface *GetPitchInterface() const { return NULL; }

     virtual PlistInterface *GetPlistInterface() { return NULL; }

     virtual const PlistInterface *GetPlistInterface() const { return NULL; }

     virtual PositionInterface *GetPositionInterface() { return NULL; }

     virtual const PositionInterface *GetPositionInterface() const { return NULL; }

     virtual ScoreDefInterface *GetScoreDefInterface() { return NULL; }

     virtual const ScoreDefInterface *GetScoreDefInterface() const { return NULL; }

     virtual StemmedDrawingInterface *GetStemmedDrawingInterface() { return NULL; }

     virtual const StemmedDrawingInterface *GetStemmedDrawingInterface() const { return NULL; }

     virtual TextDirInterface *GetTextDirInterface() { return NULL; }

     virtual const TextDirInterface *GetTextDirInterface() const { return NULL; }

     virtual TimePointInterface *GetTimePointInterface() { return NULL; }

     virtual const TimePointInterface *GetTimePointInterface() const { return NULL; }

     virtual TimeSpanningInterface *GetTimeSpanningInterface() { return NULL; }

     virtual const TimeSpanningInterface *GetTimeSpanningInterface() const { return NULL; }

     virtual VisibilityDrawingInterface *GetVisibilityDrawingInterface() { return NULL; }

     virtual const VisibilityDrawingInterface *GetVisibilityDrawingInterface() const { return NULL; }


     const Resources *GetDocResources() const;


     virtual void Reset();


     Object(const Object &object);


     Object &operator=(const Object &object);


     void MoveChildrenFrom(Object *sourceParent, int idx = -1, bool allowTypeChange = false);


     void ReplaceChild(Object *currentChild, Object *replacingChild);


     void InsertBefore(Object *child, Object *newChild);

     void InsertAfter(Object *child, Object *newChild);


     typedef bool (*binaryComp)(Object *, Object *);

     void SortChildren(binaryComp comp);


     void MoveItselfTo(Object *targetParent);


     virtual Object *Clone() const;


     virtual bool CopyChildren() const { return true; }


     virtual void CloneReset();


     const std::string &GetID() const { return m_id; }

     void SetID(const std::string &id) { m_id = id; }

     void SwapID(Object *other);

     void ResetID();


     std::string GetComment() const { return m_comment; }

     void SetComment(std::string comment) { m_comment = comment; }

     bool HasComment() const { return !m_comment.empty(); }

     std::string GetClosingComment() const { return m_closingComment; }

     void SetClosingComment(std::string endComment) { m_closingComment = endComment; }

     bool HasClosingComment() const { return !m_closingComment.empty(); }


     int GetChildCount() const { return (int)m_children.size(); }

     int GetChildCount(const ClassId classId) const;

     int GetChildCount(const ClassId classId, int depth) const;

     int GetDescendantCount(const ClassId classId) const;


     Object *GetChild(int idx);

     const Object *GetChild(int idx) const;

     Object *GetChild(int idx, const ClassId classId);

     const Object *GetChild(int idx, const ClassId classId) const;


     ArrayOfConstObjects GetChildren() const;

     const ArrayOfObjects &GetChildren() { return m_children; }


     ArrayOfObjects &GetChildrenForModification() { return m_children; }


     void CopyAttributesTo(Object *target) const;


     int GetAttributes(ArrayOfStrAttr *attributes) const;


     bool HasAttribute(std::string attribute, std::string value) const;


     Object *GetFirst(const ClassId classId = UNSPECIFIED);

     const Object *GetFirst(const ClassId classId = UNSPECIFIED) const;

     Object *GetNext();

     const Object *GetNext() const;


     Object *GetNext(const Object *child, const ClassId classId = UNSPECIFIED);

     const Object *GetNext(const Object *child, const ClassId classId = UNSPECIFIED) const;

     Object *GetPrevious(const Object *child, const ClassId classId = UNSPECIFIED);

     const Object *GetPrevious(const Object *child, const ClassId classId = UNSPECIFIED) const;


     Object *GetLast(const ClassId classId = UNSPECIFIED);

     const Object *GetLast(const ClassId classId = UNSPECIFIED) const;


     Object *GetParent() { return m_parent; }

     const Object *GetParent() const { return m_parent; }


     void SetParent(Object *parent);


     void ResetParent() { m_parent = NULL; }


     virtual bool IsSupportedChild(ClassId classId);


     virtual void AddChild(Object *object);


     virtual bool AddChildAdditionalCheck(Object *) { return true; };


     virtual int GetInsertOrderFor(ClassId) const { return VRV_UNSET; }


     int GetInsertOrderForIn(ClassId classId, const std::vector<ClassId> &order) const;


     int GetIdx() const;


     int GetDrawingX() const override;

     int GetDrawingY() const override;


     void ResetCachedDrawingX() const override;

     void ResetCachedDrawingY() const override;


     int GetChildIndex(const Object *child) const;


     int GetDescendantIndex(const Object *child, const ClassId classId, int depth);


     void InsertChild(Object *element, int idx);


     void RotateChildren(int first, int middle, int last);


     Object *DetachChild(int idx);


     void ReplaceWithCopyOf(Object *object);


     bool HasDescendant(const Object *child, int deepness = UNLIMITED_DEPTH) const;


     Object *FindDescendantByID(const std::string &id, int deepness = UNLIMITED_DEPTH, bool direction = FORWARD);

     const Object *FindDescendantByID(

         const std::string &id, int deepness = UNLIMITED_DEPTH, bool direction = FORWARD) const;


     Object *FindDescendantByType(ClassId classId, int deepness = UNLIMITED_DEPTH, bool direction = FORWARD);

     const Object *FindDescendantByType(ClassId classId, int deepness = UNLIMITED_DEPTH, bool direction = FORWARD) const;


     Object *FindDescendantByComparison(

         Comparison *comparison, int deepness = UNLIMITED_DEPTH, bool direction = FORWARD);

     const Object *FindDescendantByComparison(

         Comparison *comparison, int deepness = UNLIMITED_DEPTH, bool direction = FORWARD) const;


     Object *FindDescendantExtremeByComparison(

         Comparison *comparison, int deepness = UNLIMITED_DEPTH, bool direction = FORWARD);

     const Object *FindDescendantExtremeByComparison(

         Comparison *comparison, int deepness = UNLIMITED_DEPTH, bool direction = FORWARD) const;


     ListOfObjects FindAllDescendantsByType(

         ClassId classId, bool continueDepthSearchForMatches = true, int deepness = UNLIMITED_DEPTH);

     ListOfConstObjects FindAllDescendantsByType(

         ClassId classId, bool continueDepthSearchForMatches = true, int deepness = UNLIMITED_DEPTH) const;


     void FindAllDescendantsByComparison(ListOfObjects *objects, Comparison *comparison, int deepness = UNLIMITED_DEPTH,

         bool direction = FORWARD, bool clear = true);

     void FindAllDescendantsByComparison(ListOfConstObjects *objects, Comparison *comparison,

         int deepness = UNLIMITED_DEPTH, bool direction = FORWARD, bool clear = true) const;


     void FindAllDescendantsBetween(ListOfObjects *objects, Comparison *comparison, const Object *start,

         const Object *end, bool clear = true, int depth = UNLIMITED_DEPTH);

     void FindAllDescendantsBetween(ListOfConstObjects *objects, Comparison *comparison, const Object *start,

         const Object *end, bool clear = true, int depth = UNLIMITED_DEPTH) const;


     Object *Relinquish(int idx);


     void ClearRelinquishedChildren();


     void ClearChildren();


     bool DeleteChild(Object *child);


     int DeleteChildrenByComparison(Comparison *comparison);


     ListOfObjects GetAncestors();

     ListOfConstObjects GetAncestors() const;


     Object *GetFirstAncestor(const ClassId classId, int maxSteps = -1);

     const Object *GetFirstAncestor(const ClassId classId, int maxSteps = -1) const;


     Object *GetFirstAncestorInRange(const ClassId classIdMin, const ClassId classIdMax, int maxDepth = -1);

     const Object *GetFirstAncestorInRange(const ClassId classIdMin, const ClassId classIdMax, int maxDepth = -1) const;


     Object *GetLastAncestorNot(const ClassId classId, int maxSteps = -1);

     const Object *GetLastAncestorNot(const ClassId classId, int maxSteps = -1) const;


     Object *GetFirstChildNot(const ClassId classId);

     const Object *GetFirstChildNot(const ClassId classId) const;


     void FillFlatList(ListOfConstObjects &list) const;


     bool IsModified() const { return m_isModified; }


     void Modify(bool modified = true) const;


     bool IsAttribute() const { return m_isAttribute; }

     void IsAttribute(bool isAttribute) { m_isAttribute = isAttribute; }


     bool IsExpansion() const { return m_isExpansion; }

     void IsExpansion(bool isExpansion) { m_isExpansion = isExpansion; }


     bool HasEditorialContent();


     bool HasNonEditorialContent();


     void SaveObject(Output *output);


     template <class Compare> void StableSort(Compare comp)

     {

         std::stable_sort(m_children.begin(), m_children.end(), comp);

     }


     void ReorderByXPos();


     Object *FindNextChild(Comparison *comp, Object *start);


     Object *FindPreviousChild(Comparison *comp, Object *start);


     bool HasPlistReferences() const { return static_cast<bool>(m_plistReferences); }

     void ResetPlistReferences() { m_plistReferences.reset(); }

     const ListOfConstObjects *GetPlistReferences() const { return m_plistReferences.get(); }

     void AddPlistReference(const Object *object);


     void Process(Functor &functor, int deepness = UNLIMITED_DEPTH, bool skipFirst = false);

     void Process(ConstFunctor &functor, int deepness = UNLIMITED_DEPTH, bool skipFirst = false) const;


     virtual FunctorCode Accept(Functor &functor);

     virtual FunctorCode Accept(ConstFunctor &functor) const;

     virtual FunctorCode AcceptEnd(Functor &functor);

     virtual FunctorCode AcceptEnd(ConstFunctor &functor) const;


     void LogDebugTree(int maxDepth = UNLIMITED_DEPTH, int level = 0);

     virtual std::string LogDebugTreeMsg() { return this->GetClassName(); }


     //----------------//

     // Static methods //

     //----------------//


     static void SeedID(uint32_t seed = 0);


     static std::string GenerateHashID();


     static uint32_t Hash(uint32_t number, bool reverse = false);


     static bool sortByUlx(Object *a, Object *b);


     static bool IsPreOrdered(const Object *left, const Object *right);


 private:

     void GenerateID();


     void Init(ClassId classId);


     bool SkipChildren(bool visibleOnly) const;

     bool FiltersApply(const Filters *filters, Object *object) const;


 public:

     ArrayOfStrAttr m_unsupported;


 protected:

     //

 private:

     ArrayOfObjects m_children;


     Object *m_parent;


     ClassId m_classId;


     std::string m_id;


     bool m_isReferenceObject;


     mutable bool m_isModified;


     mutable ArrayOfObjects::const_iterator m_iteratorEnd, m_iteratorCurrent;

     mutable ClassId m_iteratorElementType;


     std::vector<AttClassId> m_attClasses;


     std::vector<InterfaceId> m_interfaces;


     std::string m_comment;

     std::string m_closingComment;


     bool m_isAttribute;


     bool m_isExpansion;


     std::unique_ptr<ListOfConstObjects> m_plistReferences;


     //----------------//

     // Static members //

     //----------------//


     static thread_local unsigned long s_objectCounter;


     static thread_local uint32_t s_xmlIDCounter;

 };


 //----------------------------------------------------------------------------

 // ObjectListInterface

 //----------------------------------------------------------------------------


 class ObjectListInterface {

 public:

     // constructors and destructors

     ObjectListInterface() = default;

     virtual ~ObjectListInterface() = default;

     ObjectListInterface(const ObjectListInterface &listInterface); // copy constructor;

     ObjectListInterface &operator=(const ObjectListInterface &listInterface); // copy assignment;


     int GetListIndex(const Object *listElement) const;


     const Object *GetListFirst(const Object *startFrom, const ClassId classId = UNSPECIFIED) const;

     Object *GetListFirst(const Object *startFrom, const ClassId classId = UNSPECIFIED);

     const Object *GetListFirstBackward(const Object *startFrom, const ClassId classId = UNSPECIFIED) const;

     Object *GetListFirstBackward(const Object *startFrom, const ClassId classId = UNSPECIFIED);


     const Object *GetListPrevious(const Object *listElement) const;

     Object *GetListPrevious(const Object *listElement);


     const Object *GetListNext(const Object *listElement) const;

     Object *GetListNext(const Object *listElement);


     const ListOfConstObjects &GetList() const;

     ListOfObjects GetList();


     void ResetList() const;


     bool HasEmptyList() const;

     int GetListSize() const;

     const Object *GetListFront() const;

     Object *GetListFront();

     const Object *GetListBack() const;

     Object *GetListBack();


 protected:

     virtual void FilterList(ListOfConstObjects &) const {};


 private:

     const Object *GetInterfaceOwner() const;


 public:

     //

 private:

     // The flat list of children

     mutable ListOfConstObjects m_list;

     // The owner object

     mutable const Object *m_owner = NULL;

 };


 //----------------------------------------------------------------------------

 // TextListInterface

 //----------------------------------------------------------------------------


 class TextListInterface : public ObjectListInterface {

 public:

     // constructors and destructors

     TextListInterface() = default;

     virtual ~TextListInterface() = default;


     std::u32string GetText() const;


     void GetTextLines(std::vector<std::u32string> &lines) const;


 protected:

     void FilterList(ListOfConstObjects &childList) const override;


 private:

     //

 public:

     //

 private:

     //

 };


 //----------------------------------------------------------------------------

 // ObjectComparison

 //----------------------------------------------------------------------------


 class ObjectComparison {


 public:

     ObjectComparison(const ClassId classId) { m_classId = classId; }


     bool operator()(const Object *object)

     {

         if (m_classId == UNSPECIFIED) {

             return true;

         }

         return (object->GetClassId() == m_classId);

     }


 private:

     //

 public:

     //

 private:

     ClassId m_classId;

 };


 //----------------------------------------------------------------------------

 // ObjectFactory

 //----------------------------------------------------------------------------


 class ObjectFactory {


 public:

     static ObjectFactory *GetInstance();


     Object *Create(std::string name);


     Object *Create(ClassId classId);


     void Register(std::string name, ClassId classId, std::function<Object *(void)> function);


     ClassId GetClassId(std::string name);


     void GetClassIds(const std::vector<std::string> &classStrings, std::vector<ClassId> &classIds);


 public:

     static thread_local MapOfClassIdConstructors s_ctorsRegistry;

     static thread_local MapOfStrClassIds s_classIdsRegistry;

 };


 //----------------------------------------------------------------------------

 // ClassRegistrar

 //----------------------------------------------------------------------------


 template <class T> class ClassRegistrar {

 public:

     ClassRegistrar(std::string name, ClassId classId)

     {

         ObjectFactory::GetInstance()->Register(name, classId, []() -> Object * { return new T(); });

     }

 };


 } // namespace vrv


 #endif

vrv::BoundingBox
This class represents a basic object in the layout domain.
Definition: boundingbox.h:32

vrv::ClassRegistrar
Definition: object.h:1099

vrv::ClassRegistrar::ClassRegistrar
ClassRegistrar(std::string name, ClassId classId)
The contructor registering the name / constructor map.
Definition: object.h:1104

vrv::Comparison
Definition: comparison.h:31

vrv::ConstFunctor
This abstract class is the base class for all const functors.
Definition: functor.h:126

vrv::Filters
This class is used to store comparison filters and apply them when necessary.
Definition: comparison.h:588

vrv::Functor
This abstract class is the base class for all mutable functors.
Definition: functor.h:101

vrv::ObjectComparison
Unary predicate for comparing object types.
Definition: object.h:1032

vrv::ObjectFactory
Definition: object.h:1057

vrv::ObjectFactory::GetClassIds
void GetClassIds(const std::vector< std::string > &classStrings, std::vector< ClassId > &classIds)
Get the correspondings ClassIds from the vector of MEI element string names.

vrv::ObjectFactory::Create
Object * Create(ClassId classId)
Create the object from the ClassId by making a lookup in the register.

vrv::ObjectFactory::GetClassId
ClassId GetClassId(std::string name)
Get the ClassId from the MEI element string name by making a lookup in the register.

vrv::ObjectFactory::Create
Object * Create(std::string name)
Create the object from the MEI element string name by making a lookup in the register.

vrv::ObjectFactory::Register
void Register(std::string name, ClassId classId, std::function< Object *(void)> function)
Add the name / constructor map entry to the static register.

vrv::ObjectFactory::GetInstance
static ObjectFactory * GetInstance()
A static method returning a static object in order to guarantee initialisation.

vrv::Object
This class represents a basic object.
Definition: object.h:61

vrv::Object::FindDescendantByID
Object * FindDescendantByID(const std::string &id, int deepness=UNLIMITED_DEPTH, bool direction=FORWARD)
Look for a descendant with the specified id (returns NULL if not found) This method is a wrapper for ...

vrv::Object::FindAllDescendantsByComparison
void FindAllDescendantsByComparison(ListOfObjects *objects, Comparison *comparison, int deepness=UNLIMITED_DEPTH, bool direction=FORWARD, bool clear=true)
Return all the objects matching the Comparison functor Deepness allow to limit the depth search (Edit...

vrv::Object::ReplaceWithCopyOf
void ReplaceWithCopyOf(Object *object)
Replace an object with a copy of the other.

vrv::Object::HasAttribute
bool HasAttribute(std::string attribute, std::string value) const
Check if an Object has an attribute with the specified value.

vrv::Object::ClearChildren
void ClearChildren()
Clear the children vector and delete all the objects.

vrv::Object::GetFirstChildNot
Object * GetFirstChildNot(const ClassId classId)
Return the first child that is NOT of the specified type.

vrv::Object::RotateChildren
void RotateChildren(int first, int middle, int last)
Rotates the child elements of the object leftwards, using std::rotate() with the given indices.

vrv::Object::HasDescendant
bool HasDescendant(const Object *child, int deepness=UNLIMITED_DEPTH) const
Return true if the object has the child Object as descendant (reference of direct).

vrv::Object::IsSupportedChild
virtual bool IsSupportedChild(ClassId classId)
Base method for checking if a child can be added.

vrv::Object::FillFlatList
void FillFlatList(ListOfConstObjects &list) const
Fill the list of all the children LayerElement.

vrv::Object::GetInsertOrderFor
virtual int GetInsertOrderFor(ClassId) const
Return the child order for a the given ClassId.
Definition: object.h:421

vrv::Object::CloneReset
virtual void CloneReset()
Reset pointers after a copy and assignment constructor call.

vrv::Object::AddChild
virtual void AddChild(Object *object)
Base method for adding children.

vrv::Object::GetIdx
int GetIdx() const
Return the index position of the object in its parent (-1 if not found)

vrv::Object::FindDescendantByType
Object * FindDescendantByType(ClassId classId, int deepness=UNLIMITED_DEPTH, bool direction=FORWARD)
Look for a descendant with the specified type (returns NULL if not found) This method is a wrapper fo...

vrv::Object::Modify
void Modify(bool modified=true) const
Mark the object and its parent (if any) as modified.

vrv::Object::IsFloatingObject
bool IsFloatingObject() const
Wrapper for checking if an element is a floating object (system elements and control elements)
Definition: object.h:87

vrv::Object::GetFirstAncestor
Object * GetFirstAncestor(const ClassId classId, int maxSteps=-1)
Return the first ancestor of the specified type.

vrv::Object::GetChild
Object * GetChild(int idx)
Child access (generic)

vrv::Object::GetDocResources
const Resources * GetDocResources() const
Resource access from the document.

vrv::Object::Relinquish
Object * Relinquish(int idx)
Give up ownership of the child at the idx position (NULL if not found) This is a method to be used on...

vrv::Object::AddChildAdditionalCheck
virtual bool AddChildAdditionalCheck(Object *)
Additional check when adding a child.
Definition: object.h:414

vrv::Object::CopyChildren
virtual bool CopyChildren() const
Indicate whereas children have to be copied in copy / assignment constructors.
Definition: object.h:268

vrv::Object::IsModified
bool IsModified() const
Check if the content was modified or not.
Definition: object.h:645

vrv::Object::Accept
virtual FunctorCode Accept(Functor &functor)
Interface for class functor visitation.

vrv::Object::FindAllDescendantsByType
ListOfObjects FindAllDescendantsByType(ClassId classId, bool continueDepthSearchForMatches=true, int deepness=UNLIMITED_DEPTH)
Return all the objects with specified type.

vrv::Object::ResetParent
void ResetParent()
Reset the parent of the Object.
Definition: object.h:397

vrv::Object::CopyAttributesTo
void CopyAttributesTo(Object *target) const
Copy all the attributes of an obejct to target.

vrv::Object::GetChildren
ArrayOfConstObjects GetChildren() const
Return the children as const reference or copy.

vrv::Object::GetChildrenForModification
ArrayOfObjects & GetChildrenForModification()
Return a reference to the children that allows modification.
Definition: object.h:326

vrv::Object::ClearRelinquishedChildren
void ClearRelinquishedChildren()
Removes all the children that were previously relinquished.

vrv::Object::operator=
Object & operator=(const Object &object)
Copy assignement - see copy constructor.

vrv::Object::GetDescendantIndex
int GetDescendantIndex(const Object *child, const ClassId classId, int depth)
Look for all Objects of a class and return its position (-1 if not found)

vrv::Object::GetChildIndex
int GetChildIndex(const Object *child) const
Look for the Object in the children and return its position (-1 if not found)

vrv::Object::m_unsupported
ArrayOfStrAttr m_unsupported
Keep an array of unsupported attributes as pairs.
Definition: object.h:779

vrv::Object::FindDescendantByComparison
Object * FindDescendantByComparison(Comparison *comparison, int deepness=UNLIMITED_DEPTH, bool direction=FORWARD)
Return the first element matching the Comparison functor Deepness allow to limit the depth search (Ed...

vrv::Object::SaveObject
void SaveObject(Output *output)
Saves the object (and its children) using the specified output stream.

vrv::Object::Object
Object(const Object &object)
Copy constructor that also copy the children.

vrv::Object::IsMilestoneElement
bool IsMilestoneElement() const
Wrapper for checking if an element has a milestone start interface and also if is set as a milestone ...

vrv::Object::GetLastAncestorNot
Object * GetLastAncestorNot(const ClassId classId, int maxSteps=-1)
Return the last ancestor that is NOT of the specified type.

vrv::Object::GetAncestors
ListOfObjects GetAncestors()
Returns all ancestors.

vrv::Object::FindDescendantExtremeByComparison
Object * FindDescendantExtremeByComparison(Comparison *comparison, int deepness=UNLIMITED_DEPTH, bool direction=FORWARD)
Return the element matching the extreme value with an Comparison functor Deepness allow to limit the ...

vrv::Object::SetAsReferenceObject
void SetAsReferenceObject()
Make an object a reference object that do not own children.

vrv::Object::SetParent
void SetParent(Object *parent)
Set the parent of the Object.

vrv::Object::DeleteChild
bool DeleteChild(Object *child)
Remove and delete the child.

vrv::Object::binaryComp
bool(* binaryComp)(Object *, Object *)
Sort children by a function that takes two arguments and returns true if the first argument is less t...
Definition: object.h:249

vrv::Object::GetLast
Object * GetLast(const ClassId classId=UNSPECIFIED)
Return the last child of the object (if any, NULL otherwise)

vrv::Object::MoveChildrenFrom
void MoveChildrenFrom(Object *sourceParent, int idx=-1, bool allowTypeChange=false)
Move all the children of the object passed as parameter to this one.

vrv::Object::GetComment
std::string GetComment() const
Methods for setting / getting comments.
Definition: object.h:285

vrv::Object::LogDebugTree
void LogDebugTree(int maxDepth=UNLIMITED_DEPTH, int level=0)
Output the class name of the object (or a custom msg) and of its children recursively.

vrv::Object::Process
void Process(Functor &functor, int deepness=UNLIMITED_DEPTH, bool skipFirst=false)
Main method that processes functors.

vrv::Object::Clone
virtual Object * Clone() const
Method call for copying child classes.

vrv::Object::ReplaceChild
void ReplaceChild(Object *currentChild, Object *replacingChild)
Replace the currentChild with the replacingChild.

vrv::Object::InsertChild
void InsertChild(Object *element, int idx)
Insert an element at the idx position.

vrv::Object::MoveItselfTo
void MoveItselfTo(Object *targetParent)
Move an object to another parent.

vrv::Object::DetachChild
Object * DetachChild(int idx)
Detach the child at the idx position (NULL if not found) The parent pointer is set to NULL.

vrv::Object::StableSort
void StableSort(Compare comp)
Sort the child elements using std::stable_sort.
Definition: object.h:686

vrv::Object::HasEditorialContent
bool HasEditorialContent()
Return true if the object contains any editorial content.

vrv::Object::DeleteChildrenByComparison
int DeleteChildrenByComparison(Comparison *comparison)
Delete the children that match the comparison.

vrv::Object::FindAllDescendantsBetween
void FindAllDescendantsBetween(ListOfObjects *objects, Comparison *comparison, const Object *start, const Object *end, bool clear=true, int depth=UNLIMITED_DEPTH)
Return all the objects matching the Comparison functor and being between start and end in the tree.

vrv::Object::Reset
virtual void Reset()
Reset the object, that is 1) removing all children and 2) resetting all attributes.

vrv::Object::GetParent
Object * GetParent()
Get the parent of the Object.
Definition: object.h:383

vrv::Object::HasNonEditorialContent
bool HasNonEditorialContent()
Return true if the object contains anything that is not editorial content.

vrv::Object::GetAttributes
int GetAttributes(ArrayOfStrAttr *attributes) const
Fill an array of pairs with all attributes and their values.

vrv::Object::IsPreOrdered
static bool IsPreOrdered(const Object *left, const Object *right)
Return true if left appears before right in preorder traversal.

vrv::Object::GetInsertOrderForIn
int GetInsertOrderForIn(ClassId classId, const std::vector< ClassId > &order) const
Find the order from an overriden GetInsertOrderFor method.

vrv::ObjectListInterface
This class is an pseudo interface for elements maintaining a flat list of children LayerElement for p...
Definition: object.h:893

vrv::ObjectListInterface::GetListIndex
int GetListIndex(const Object *listElement) const
Look for the Object in the list and return its position (-1 if not found)

vrv::ObjectListInterface::GetListPrevious
const Object * GetListPrevious(const Object *listElement) const
Returns the previous object in the list (NULL if not found)

vrv::ObjectListInterface::GetListNext
const Object * GetListNext(const Object *listElement) const
Returns the next object in the list (NULL if not found)

vrv::ObjectListInterface::FilterList
virtual void FilterList(ListOfConstObjects &) const
Filter the list for a specific class.
Definition: object.h:965

vrv::ObjectListInterface::GetList
const ListOfConstObjects & GetList() const
Return the list.

vrv::ObjectListInterface::GetListFirst
const Object * GetListFirst(const Object *startFrom, const ClassId classId=UNSPECIFIED) const
Gets the first item of type elementType starting at startFrom.

vrv::ObjectListInterface::ResetList
void ResetList() const
Reset the list of children and call FilterList().

vrv::ObjectListInterface::HasEmptyList
bool HasEmptyList() const
Convenience functions that check if the list is up-to-date If not, the list is updated before returni...

vrv::Output
This class is a base class for output classes.
Definition: iobase.h:31

vrv::Resources
This class provides resource values.
Definition: resources.h:30

vrv::TextListInterface
This class is an pseudo interface for elements maintaining a flat list of children LayerElement for p...
Definition: object.h:992

vrv::TextListInterface::GetText
std::u32string GetText() const
Returns a contatenated version of all the text children.

vrv::TextListInterface::FilterList
void FilterList(ListOfConstObjects &childList) const override
Filter the list for a specific class.

vrv::TextListInterface::GetTextLines
void GetTextLines(std::vector< std::u32string > &lines) const
Fill an array of lines with concatenated content of each line.