findfunctor.h

// Name:        findfunctor.h
// Author:      David Bauer
// Created:     2022
// Copyright (c) Authors and others. All rights reserved.
 
#ifndef __VRV_FINDFUNCTOR_H__
#define __VRV_FINDFUNCTOR_H__
 
#include "functor.h"
 
namespace vrv {
 
class Comparison;
class Object;
 
//----------------------------------------------------------------------------
// FindAllByComparisonFunctor
//----------------------------------------------------------------------------
 
class FindAllByComparisonFunctor : public Functor {
public:
    FindAllByComparisonFunctor(Comparison *comparison, ListOfObjects *elements);
    virtual ~FindAllByComparisonFunctor() = default;
 
    /*
     * Abstract base implementation
     */
    bool ImplementsEndInterface() const override { return false; }
 
    /*
     * Configure depth search
     */
    void SetContinueDepthSearchForMatches(bool continueDepthSearchForMatches);
 
    /*
     * Functor interface
     */
    FunctorCode VisitObject(Object *object) override;
 
protected:
    //
private:
    //
public:
    //
private:
    // The comparison
    Comparison *m_comparison;
    // True if search should be continued for matches
    bool m_continueDepthSearchForMatches;
    // The element list where the search result is appended
    ListOfObjects *m_elements;
};
 
//----------------------------------------------------------------------------
// FindAllConstByComparisonFunctor
//----------------------------------------------------------------------------
 
class FindAllConstByComparisonFunctor : public ConstFunctor {
public:
    FindAllConstByComparisonFunctor(Comparison *comparison, ListOfConstObjects *elements);
    virtual ~FindAllConstByComparisonFunctor() = default;
 
    /*
     * Abstract base implementation
     */
    bool ImplementsEndInterface() const override { return false; }
 
    /*
     * Configure depth search
     */
    void SetContinueDepthSearchForMatches(bool continueDepthSearchForMatches);
 
    /*
     * Functor interface
     */
    FunctorCode VisitObject(const Object *object) override;
 
protected:
    //
private:
    //
public:
    //
private:
    // The comparison
    Comparison *m_comparison;
    // True if search should be continued for matches
    bool m_continueDepthSearchForMatches;
    // The element list where the search result is appended
    ListOfConstObjects *m_elements;
};
 
//----------------------------------------------------------------------------
// FindAllBetweenFunctor
//----------------------------------------------------------------------------
 
class FindAllBetweenFunctor : public ConstFunctor {
public:
    FindAllBetweenFunctor(Comparison *comparison, ListOfConstObjects *elements, const Object *start, const Object *end);
    virtual ~FindAllBetweenFunctor() = default;
 
    /*
     * Abstract base implementation
     */
    bool ImplementsEndInterface() const override { return false; }
 
    /*
     * Functor interface
     */
    FunctorCode VisitObject(const Object *object) override;
 
protected:
    //
private:
    //
public:
    //
private:
    // The comparison
    Comparison *m_comparison;
    // The start and end object
    const Object *m_start, *m_end;
    // The element list where the search result is appended
    ListOfConstObjects *m_elements;
};
 
//----------------------------------------------------------------------------
// FindByComparisonFunctor
//----------------------------------------------------------------------------
 
class FindByComparisonFunctor : public ConstFunctor {
public:
    FindByComparisonFunctor(Comparison *comparison);
    virtual ~FindByComparisonFunctor() = default;
 
    /*
     * Abstract base implementation
     */
    bool ImplementsEndInterface() const override { return false; }
 
    /*
     * Retrieve the search result
     */
    const Object *GetElement() const { return m_element; }
 
    /*
     * Functor interface
     */
    FunctorCode VisitObject(const Object *object) override;
 
protected:
    //
private:
    //
public:
    //
private:
    // The comparison
    Comparison *m_comparison;
    // The search result
    const Object *m_element;
};
 
//----------------------------------------------------------------------------
// FindByIDFunctor
//----------------------------------------------------------------------------
 
class FindByIDFunctor : public ConstFunctor {
public:
    FindByIDFunctor(const std::string &id);
    virtual ~FindByIDFunctor() = default;
 
    /*
     * Abstract base implementation
     */
    bool ImplementsEndInterface() const override { return false; }
 
    /*
     * Retrieve the search result
     */
    const Object *GetElement() const { return m_element; }
 
    /*
     * Functor interface
     */
    FunctorCode VisitObject(const Object *object) override;
 
protected:
    //
private:
    //
public:
    //
private:
    // The id we are looking for
    std::string m_id;
    // The search result
    const Object *m_element;
};
 
//----------------------------------------------------------------------------
// FindNextChildByComparisonFunctor
//----------------------------------------------------------------------------
 
class FindNextChildByComparisonFunctor : public ConstFunctor {
public:
    FindNextChildByComparisonFunctor(Comparison *comparison, const Object *start);
    virtual ~FindNextChildByComparisonFunctor() = default;
 
    /*
     * Abstract base implementation
     */
    bool ImplementsEndInterface() const override { return false; }
 
    /*
     * Retrieve the search result
     */
    const Object *GetElement() const { return m_element; }
 
    /*
     * Functor interface
     */
    FunctorCode VisitObject(const Object *object) override;
 
protected:
    //
private:
    //
public:
    //
private:
    // The comparison
    Comparison *m_comparison;
    // The object to start with
    const Object *m_start;
    // The search result
    const Object *m_element;
};
 
//----------------------------------------------------------------------------
// FindPreviousChildByComparisonFunctor
//----------------------------------------------------------------------------
 
class FindPreviousChildByComparisonFunctor : public ConstFunctor {
public:
    FindPreviousChildByComparisonFunctor(Comparison *comparison, const Object *start);
    virtual ~FindPreviousChildByComparisonFunctor() = default;
 
    /*
     * Abstract base implementation
     */
    bool ImplementsEndInterface() const override { return false; }
 
    /*
     * Retrieve the search result
     */
    const Object *GetElement() const { return m_element; }
 
    /*
     * Functor interface
     */
    FunctorCode VisitObject(const Object *object) override;
 
protected:
    //
private:
    //
public:
    //
private:
    // The comparison
    Comparison *m_comparison;
    // The object to start with
    const Object *m_start;
    // The search result
    const Object *m_element;
};
 
//----------------------------------------------------------------------------
// FindExtremeByComparisonFunctor
//----------------------------------------------------------------------------
 
class FindExtremeByComparisonFunctor : public ConstFunctor {
public:
    FindExtremeByComparisonFunctor(Comparison *comparison);
    virtual ~FindExtremeByComparisonFunctor() = default;
 
    /*
     * Abstract base implementation
     */
    bool ImplementsEndInterface() const override { return false; }
 
    /*
     * Retrieve the search result
     */
    const Object *GetElement() const { return m_element; }
 
    /*
     * Functor interface
     */
    FunctorCode VisitObject(const Object *object) override;
 
protected:
    //
private:
    //
public:
    //
private:
    // The comparison
    Comparison *m_comparison;
    // The search result
    const Object *m_element;
};
 
//----------------------------------------------------------------------------
// FindAllReferencedObjectsFunctor
//----------------------------------------------------------------------------
 
class FindAllReferencedObjectsFunctor : public Functor {
public:
    FindAllReferencedObjectsFunctor(SetOfObjects *elements, ListOfObjectAttNamePairs *listWithAttName);
    virtual ~FindAllReferencedObjectsFunctor() = default;
 
    /*
     * Abstract base implementation
     */
    bool ImplementsEndInterface() const override { return false; }
 
    /*
     * Include milestone references?
     */
    void IncludeMilestoneReferences(bool included) { m_milestoneReferences = included; }
 
    /*
     * Functor interface
     */
    FunctorCode VisitObject(Object *object) override;
 
protected:
    //
private:
    //
    void AddObject(Object *object, const std::string &attribute);
 
public:
    //
private:
    // The set of all matching objects
    SetOfObjects *m_elements;
    // The list of pairs of matching objects with the attribute name
    ListOfObjectAttNamePairs *m_listWithAttName;
    // A flag indicating if milestone references should be included as well
    bool m_milestoneReferences;
};
 
//----------------------------------------------------------------------------
// FindAllReferringObjectsFunctor
//----------------------------------------------------------------------------
 
class FindAllReferringObjectsFunctor : public Functor {
public:
    FindAllReferringObjectsFunctor(const Object *object, ListOfObjectAttNamePairs *elements);
    virtual ~FindAllReferringObjectsFunctor() = default;
 
    /*
     * Abstract base implementation
     */
    bool ImplementsEndInterface() const override { return false; }
 
    /*
     * Functor interface
     */
    FunctorCode VisitObject(Object *object) override;
 
protected:
    //
private:
    //
public:
    //
private:
    // The object referred to
    const Object *m_object;
    // The set of all objects with the attribute name they are referring through
    ListOfObjectAttNamePairs *m_elements;
};
 
//----------------------------------------------------------------------------
// FindElementInLayerStaffDefFunctor
//----------------------------------------------------------------------------
 
class FindElementInLayerStaffDefFunctor : public ConstFunctor {
public:
    FindElementInLayerStaffDefFunctor(const std::string &xmlId);
    virtual ~FindElementInLayerStaffDefFunctor() = default;
 
    /*
     * Abstract base implementation
     */
    bool ImplementsEndInterface() const override { return false; }
 
    /*
     * Retrieve the search result
     */
    const Object *GetElement() const { return m_element; }
 
    /*
     * Functor interface
     */
    FunctorCode VisitLayer(const Layer *layer) override;
    FunctorCode VisitScore(const Score *score) override;
 
protected:
    //
private:
    //
public:
    //
private:
    // The search result
    const Object *m_element;
    // ID of the element to be found
    std::string m_id;
};
 
//----------------------------------------------------------------------------
// AddToFlatListFunctor
//----------------------------------------------------------------------------
 
class AddToFlatListFunctor : public ConstFunctor {
public:
    AddToFlatListFunctor(ListOfConstObjects *flatList);
    virtual ~AddToFlatListFunctor() = default;
 
    /*
     * Abstract base implementation
     */
    bool ImplementsEndInterface() const override { return false; }
 
    /*
     * Functor interface
     */
    FunctorCode VisitObject(const Object *object) override;
 
protected:
    //
private:
    //
public:
    //
private:
    // The list of elements
    ListOfConstObjects *m_flatList;
};
 
} // namespace vrv
 
#endif // __VRV_FINDFUNCTOR_H__