functor.h

// Name:        functor.h
// Author:      David Bauer
// Created:     2022
// Copyright (c) Authors and others. All rights reserved.
 
#ifndef __VRV_FUNCTOR_H__
#define __VRV_FUNCTOR_H__
 
#include "comparison.h"
#include "functorinterface.h"
#include "vrvdef.h"
 
namespace vrv {
 
class Doc;
 
//----------------------------------------------------------------------------
// FunctorBase
//----------------------------------------------------------------------------
 
class FunctorBase {
public:
    FunctorBase() {}
    virtual ~FunctorBase() = default;
 
    FunctorCode GetCode() const { return m_code; }
    void ResetCode() { m_code = FUNCTOR_CONTINUE; }
    void SetCode(FunctorCode code) { m_code = code; }
 
    bool VisibleOnly() const { return m_visibleOnly; }
    void SetVisibleOnly(bool visibleOnly) { m_visibleOnly = visibleOnly; }
 
    Filters *GetFilters() const { return m_filters; }
    Filters *SetFilters(Filters *filters)
    {
        Filters *previous = m_filters;
        m_filters = filters;
        return previous;
    }
    bool GetDirection() const { return m_direction; }
    bool SetDirection(bool direction)
    {
        bool previous = m_direction;
        m_direction = direction;
        return previous;
    }
 
    virtual bool ImplementsEndInterface() const = 0;
 
private:
    //
public:
    //
private:
    // The functor code
    FunctorCode m_code = FUNCTOR_CONTINUE;
    // The filters
    Filters *m_filters = NULL;
    // Visible only flag
    bool m_visibleOnly = true;
    // Direction
    bool m_direction = FORWARD;
};
 
//----------------------------------------------------------------------------
// Functor
//----------------------------------------------------------------------------
 
class Functor : public FunctorBase, public FunctorInterface {
public:
    Functor() {}
    virtual ~Functor() = default;
 
private:
    //
public:
    //
private:
    //
};
 
//----------------------------------------------------------------------------
// ConstFunctor
//----------------------------------------------------------------------------
 
class ConstFunctor : public FunctorBase, public ConstFunctorInterface {
public:
    ConstFunctor() {}
    virtual ~ConstFunctor() = default;
 
private:
    //
public:
    //
private:
    //
};
 
//----------------------------------------------------------------------------
// DocFunctor
//----------------------------------------------------------------------------
 
class DocFunctor : public Functor {
public:
    DocFunctor(Doc *doc) { m_doc = doc; }
    virtual ~DocFunctor() = default;
 
    /*
     * Getter for the document
     */
    Doc *GetDoc() { return m_doc; }
 
private:
    //
public:
    //
protected:
    //
    Doc *m_doc;
 
private:
    //
};
 
//----------------------------------------------------------------------------
// DocConstFunctor
//----------------------------------------------------------------------------
 
class DocConstFunctor : public ConstFunctor {
public:
    DocConstFunctor(const Doc *doc) { m_doc = doc; }
    virtual ~DocConstFunctor() = default;
 
    /*
     * Getter for the document
     */
    const Doc *GetDoc() const { return m_doc; }
 
private:
    //
public:
    //
protected:
    //
    const Doc *m_doc;
 
private:
    //
};
 
//----------------------------------------------------------------------------
// CollectAndProcess
//----------------------------------------------------------------------------
 
class CollectAndProcess {
protected:
    CollectAndProcess() = default;
    ~CollectAndProcess() = default;
 
public:
    bool IsCollectingData() const { return !m_processingData; }
    bool IsProcessingData() const { return m_processingData; }
    void SetDataCollectionCompleted() { m_processingData = true; }
 
private:
    //
public:
    //
protected:
    //
private:
    // Indicates the current phase: collecting vs processing data
    bool m_processingData = false;
};
 
} // namespace vrv
 
#endif // __VRV_FUNCTOR_H__