object.h

// 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 <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 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();
    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; }
 
    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 *child) { return true; };
 
    virtual int GetInsertOrderFor(ClassId 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, bool basic);
 
    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);
 
    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;
 
    //----------------//
    // 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 &childList) 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