FBase.h

Go to the documentation of this file.

#pragma once
#include "Platform.h"
#include "TimeStamp.h"
 
#include <typeinfo>
#include <string>
#include <functional>
#include <cfloat>
 
namespace dyno {
    class OBase;
    class FCallBackFunc;
 
    enum FieldTypeEnum
    {
        In,
        Out,
        IO,
        Param,
        State,
        Next
    };

class FBase
{
public:
    FBase() : m_name("default"), m_description("") {};
    FBase(std::string name, std::string description, FieldTypeEnum type = FieldTypeEnum::Param, OBase* parent = nullptr);
    virtual ~FBase();

    enum FInputPolicy
    {
        One,
        Many
    };
 
    virtual uint size() = 0;
    virtual const std::string getTemplateName() { return std::string(""); }
    virtual const std::string getClassName() { return std::string("Field"); }
 
    std::string getObjectName() { return m_name; }
    std::string getDescription() { return m_description; }
    virtual DeviceType getDeviceType() { return DeviceType::UNDEFINED; }
 
    void setObjectName(std::string name) { m_name = name; }
    void setDescription(std::string description) { m_description = description; }
 
    void setParent(OBase* owner);
    OBase* parent();
 
    bool isDerived();
    bool isAutoDestroyable();
 
    void setAutoDestroy(bool autoDestroy);
    void setDerived(bool derived);
 
    uint sizeOfSinks();
    uint sizeOfValidSources();
    
    void requestValidSources(std::vector<FBase*>& src);
 
    //Used for fields with FInputPolicy::One
    FBase* getSource();
    FBase* getTopField();
 
    //Used for fields with FInputPolicy::Many
    std::vector<FBase*>& getSources() { return mMultipleSources; }
    std::vector<FBase*>& getSinks() { return mSinks; }
 
 
 
    bool isModified();

    bool isActive();
    void setActive(bool b);
 
    void tick();
    void tack();
 
    bool isOptional();
    void tagOptional(bool optional);
 
    inline float getMin() { return m_min; }
    inline void setMin(float min_val) { m_min = min_val; }
 
    inline float getMax() { return m_max; }
    inline void setMax(float max_val) { m_max = max_val; }
 
    inline void setRange(float min_val, float max_val) { m_min = min_val; m_max = max_val; }
 
    FieldTypeEnum getFieldType();
 
    virtual bool connect(FBase* dst) = 0;
    virtual bool disconnect(FBase* dst);
 
 
    virtual FInputPolicy inputPolicy() { return FInputPolicy::One; }
 
    virtual inline std::string serialize() { return ""; }
    virtual inline bool deserialize(const std::string& str) { return false; }

    FBase* promoteOuput();

    FBase* promoteInput();
 

    FBase* demoteOuput();

    FBase* demoteInput();
 
    virtual bool isEmpty() = 0;
    virtual void update();
 
    void attach(std::shared_ptr<FCallBackFunc> func);
    void detach(std::shared_ptr<FCallBackFunc> func);
 
protected:
    void setSource(FBase* source);
 
    bool addSink(FBase* f);
    bool removeSink(FBase* f);
 
    bool addSource(FBase* f);
    bool removeSource(FBase* f);
 
    bool connectField(FBase* dst);
    bool disconnectField(FBase* dst);
 
    FieldTypeEnum m_fType = FieldTypeEnum::Param;
 
private:
    std::string m_name;
    std::string m_description;
 
    bool m_optional = false;
 
    bool m_autoDestroyable = true;
    bool m_derived = false;
 
    bool mActive = true;
 
    float m_min = -FLT_MAX;
    float m_max = FLT_MAX;
 
    OBase* mOwner = nullptr;

    FBase* mSingleSource = nullptr;
    std::vector<FBase*> mMultipleSources;
 
    std::vector<FBase*> mSinks;
 
    TimeStamp mTickTime;
    TimeStamp mTackTime;
 
    std::vector<std::shared_ptr<FCallBackFunc>> mCallbackFunc;
};
 
#define DEFINE_FIELD_FUNC(DerivedField, Data, FieldName)                        \
FieldName() : FBase("", ""){}                               \
\
FieldName(std::string name, std::string description, FieldTypeEnum fieldType, OBase* parent)        \
    : FBase(name, description, fieldType, parent){}             \
\
const std::string getTemplateName() override { return std::string(typeid(VarType).name()); }            \
const std::string getClassName() override { return std::string(#FieldName); }                   \
\
std::shared_ptr<Data>& getDataPtr()                                 \
{                                                                   \
    FBase* topField = this->getTopField();                      \
    DerivedField* derived = dynamic_cast<DerivedField*>(topField);  \
    derived->tick();                                                \
    return derived->m_data;                                         \
}                                                                   \
\
std::shared_ptr<Data>& constDataPtr()                               \
{                                                                   \
    FBase* topField = this->getTopField();                      \
    DerivedField* derived = dynamic_cast<DerivedField*>(topField);  \
    return derived->m_data;                                         \
}                                                                   \
\
std::shared_ptr<Data> allocate()                                    \
{                                                                   \
    auto& data = this->getDataPtr();                                \
    if (data == nullptr) {                                          \
        data = std::make_shared<Data>();                            \
    }                                                               \
    return data;                                                    \
}                                                                   \
\
bool connect(DerivedField* dst)                                     \
{                                                                   \
    this->connectField(dst);                                        \
    return true;                                                    \
}                                                                   \
bool connect(FBase* dst) override {                                 \
    DerivedField* derived = dynamic_cast<DerivedField*>(dst);       \
    if (derived == nullptr) return false;                           \
    return this->connect(derived);                                  \
}                                                                   \
Data& getData() {                                                   \
    auto dataPtr = this->getDataPtr();                              \
    assert(dataPtr != nullptr);                                     \
    return *dataPtr;                                                \
}                                                                   \
const Data& constData() {                                           \
    auto dataPtr = this->constDataPtr();                            \
    assert(dataPtr != nullptr);                                     \
    return *dataPtr;                                                \
}                                                                   \
private:                                                            \
    std::shared_ptr<Data> m_data = nullptr;                         \
public:
 
}