Variable.h

Go to the documentation of this file.

#pragma once
#include <gii/gen/VariableHandler.h>
#include <misc/gen/pointer.h>
 
namespace sf
{
 
class _GII_CLASS Variable
  : public InformationBase
  , public VariableTypes
{
  public:
    static void initialize();
 
    static void uninitialize();
 
    Variable();
 
    Variable(const Variable& v);
 
    Variable(id_type id, bool set_desired);
 
    explicit Variable(const std::string& definition, id_type id_ofs = 0);
 
    bool isZero() const;
 
    explicit Variable(const Definition& def, id_type id_ofs = 0);
 
    ~Variable() override;
 
    bool setup(const std::string& definition, id_type id_ofs = 0);
 
    bool setup(const Definition& definition, id_type id_ofs = 0);
 
    inline bool setup(const Variable& v);
 
    inline bool setup(id_type id, bool set_did = false);
 
    bool setId(id_type id, bool skip_self = false) const;
 
    [[nodiscard]] bool isValid() const;
 
    [[nodiscard]] bool isConverted() const;
 
    bool setConvert(bool enable);
 
    [[nodiscard]] bool isNumber() const;
 
    void makeOwner();
 
    Variable& getOwner() const;
 
    [[nodiscard]] bool isOwner() const;
 
    [[nodiscard]] inline bool isGlobal() const;
 
    bool setGlobal(bool global);
 
    bool setExport(bool global);
 
    [[nodiscard]] bool isExported() const;
 
    bool isTemporary() const;
 
    void setTemporary(bool on_off);
 
    bool applyTemporary(bool skip_self = true) const;
 
    bool updateTemporary(bool skip_self = false);
 
    [[nodiscard]] bool isTemporaryDifferent() const;
 
    void setHandler(VariableHandler* handler);
 
    [[nodiscard]] VariableHandler* getHandler() const;
 
    static void setConvertHandler(VariableHandler* handler);
 
    [[nodiscard]] static VariableHandler* getConvertHandler();
 
    size_type emitEvent(EEvent event, bool skip_self = false);
 
    void setDesiredId();
 
    void setDesiredId(id_type id);
 
    template<typename T>
    void setData(T data);
 
    template<typename T = uint64_t>
    [[nodiscard]] T getData() const;
 
    bool setCur(const Value& value, bool skip_self = false);
 
    [[nodiscard]] bool setCur(const Value& value, bool skip_self = false) const;
 
    [[nodiscard]] bool loadCur(const Value& value) const;
 
    static std::string filterString(const std::string& str, EStringType type, size_t max_len);
 
    bool increase(int steps, bool skip_self = false);
 
    bool unsetFlag(flags_type flag, bool skip_self = false) const;
 
    bool setFlag(flags_type flag, bool skip_self = false) const;
 
    bool updateFlags(flags_type flags, bool skip_self = false) const;
 
    [[nodiscard]] flags_type getFlags() const;
 
    [[nodiscard]] flags_type getCurFlags() const;
 
    bool setConvertValues(const std::string& unit, const Value& multiplier, const Value& offset, int digits = std::numeric_limits<int>::max()) const;
 
    bool setConvertValues(bool convert = true) const;
 
    [[nodiscard]] id_type getId() const;
 
    [[nodiscard]] id_type getDesiredId() const;
 
    [[nodiscard]] std::string getName(int levels = 0) const;
 
    [[nodiscard]] int getNameLevelCount() const;
 
    [[nodiscard]] std::string getUnit() const;
 
    [[nodiscard]] std::string getUnit(bool converted) const;
 
    [[nodiscard]] std::string getConvertOption() const;
 
    [[nodiscard]] EStringType getStringType() const;
 
    static std::string_view getStringType(EStringType type);
 
    static EStringType getStringType(const std::string& flags);
 
    [[nodiscard]] std::string getDescription() const;
 
    [[nodiscard]] bool isFlag(int flag) const;
 
    [[nodiscard]] std::string getCurFlagsString() const;
 
    [[nodiscard]] std::string getFlagsString() const;
 
    [[nodiscard]] bool isReadOnly() const;
 
    [[nodiscard]] int getSigDigits() const;
 
    [[nodiscard]] int getSigDigits(bool converted) const;
 
    [[nodiscard]] int getRequiredDigits() const;
 
    [[nodiscard]] const Value& getDef() const;
 
    [[nodiscard]] const Value& getMin() const;
 
    [[nodiscard]] const Value& getMax() const;
 
    [[nodiscard]] const Value& getRnd() const;
 
    [[nodiscard]] const Value& getCur() const;
 
    [[nodiscard]] const Value& getDef(bool converted) const;
 
    [[nodiscard]] const Value& getMin(bool converted) const;
 
    [[nodiscard]] const Value& getMax(bool converted) const;
 
    [[nodiscard]] const Value& getRnd(bool converted) const;
 
    //
    [[nodiscard]] const Value& getCur(bool converted) const;
 
    [[nodiscard]] const State::Vector& getStates() const;
 
    [[nodiscard]] size_type getUsageCount() const;
 
    [[nodiscard]] size_type getStateCount() const;
 
    [[nodiscard]] size_type getState(const Value& v) const;
 
    [[nodiscard]] std::string getStateName(size_type state) const;
 
    [[nodiscard]] const Value& getStateValue(size_type state) const;
 
    static Value::EType getType(std::string_view type);
 
    static std::string getType(Value::EType type);
 
    [[nodiscard]] Value::EType getType() const;
 
    static size_type getCount();
 
    static size_type getInstanceCount(bool global_only = true);
 
    static PtrVector getList();
 
    static std::string getFieldName(int field);
 
    static const Variable& getInstanceById(id_type id);
 
    static Variable& getInstanceById(id_type id, PtrVector& list);
 
    static const Variable& getInstanceById(id_type id, const PtrVector& list);
 
    Variable& operator=(const Variable& v);
 
    int operator==(const Variable& v) const;
 
    [[nodiscard]] std::string getCurString(bool use_states = true) const;
 
    [[nodiscard]] std::string getSetupString() const;
 
    void clipRound(Value& value) const;
 
    [[nodiscard]] Value convert(const Value& value, bool to_org = false) const;
 
    bool writeUpdate(std::ostream& os) const;
 
    static bool readUpdate(std::istream& is, bool skip_self = false, PtrVector& list = null_ref<PtrVector>());
 
    bool write(std::ostream& os) const;
 
    static Definition getDefinition(const std::string& str);
 
    static bool read(std::istream& is, bool skip_self = false, PtrVector& list = null_ref<PtrVector>());
 
    static bool create(std::istream& is, PtrVector& list = null_ref<PtrVector>(), bool global = true, int& err_line = null_ref<int>());
 
    static flags_type toFlags(const std::string& flags);
 
    static std::string getFlagsString(flags_type flags);
 
    static std::string_view getEventName(EEvent event);
 
    void operator delete(void*);
 
  protected:
    explicit Variable(bool global);
 
  private:
    explicit Variable(void*, void*);
 
    bool updateValue(const Value& value, bool skip_self) const;
 
    bool updateTempValue(const Value& value, bool skip_self);
 
    [[maybe_unused]] size_type emitLocalEvent(EEvent event, bool skip_self = true) const;
 
    [[maybe_unused]] size_type emitGlobalEvent(EEvent event, bool skip_self = true) const;
 
    void emitEvent(EEvent ev, const Variable& caller);
 
    static VariableReference* getReferenceById(id_type id);
 
    static void removeHandler(const VariableHandler* handler);
 
    bool attachRef(VariableReference* ref);
 
    size_type attachDesired() const;
 
    VariableReference* _reference{nullptr};
    uint64_t _data{0};
    bool _converted{false};
    Value* _temporary{nullptr};
    VariableHandler* _handler{nullptr};
    id_type _desiredId{0};
    bool _global{false};
 
    friend class VariableHandler;
 
    friend class VariableReference;
 
    friend class VariableStatic;
};
 
_GII_FUNC std::ostream& operator<<(std::ostream& os, const Variable& v);
 
_GII_FUNC std::istream& operator>>(std::istream& is, Variable& v);
 
_GII_FUNC std::ostream& operator<<(std::ostream& os, const Variable::State::Vector& v);
 
class LocalVariable final : public Variable
{
  public:
    LocalVariable();
};
 
}// namespace sf
 
// Include all inlined functions and template implementations.
#include <gii/gen/Variable.hpp>