ResultData.h

Go to the documentation of this file.

#pragma once
#include <gii/gen/FileMappedStorage.h>
#include <gii/gen/ResultDataHandler.h>
#include <gii/gen/ResultDataReference.h>
#include <gii/gen/ResultDataTypes.h>
#include <misc/gen/RangeManager.h>
#include <misc/gen/pointer.h>
 
namespace sf
{
 
class _GII_CLASS ResultData
  : public InformationBase
  , public ResultDataTypes
{
  public:
    static void initialize();
 
    static void uninitialize();
 
    ResultData();
 
    ResultData(const ResultData& rd);
 
    explicit inline ResultData(id_type id, bool set_desired = false);
 
    explicit inline ResultData(const std::string& definition, id_type id_ofs = 0);
 
    explicit inline ResultData(const Definition& definition, id_type id_ofs = 0);
 
    ~ResultData() override;
 
    inline bool setup(const std::string& definition, id_type id_ofs = 0);
 
    bool setup(const Definition& definition, id_type id_ofs);
 
    inline bool setup(const ResultData& rd);
 
    inline bool setup(id_type id, bool set_did = false);
 
    [[nodiscard]] std::string getSetupString() const;
 
    bool setAccessRange(const Range& rng, bool skip_self = false);
 
    inline bool setAccessRange(Range::size_type stop, bool skip_self = false);
 
    void setHandler(ResultDataHandler* handler);
 
    [[nodiscard]] const ResultDataHandler* getHandler() const
    {
      return _handler;
    }
 
    void makeOwner();
 
    ResultData& getOwner() const;
 
    [[nodiscard]] bool isOwner() const;
 
    inline void setUserData(void* data);
 
    [[nodiscard]] inline void* getUserData() const;
 
    [[nodiscard]] bool isValid() const;
 
    [[nodiscard]] data_type getValueOffset() const;
 
    [[nodiscard]] data_type getValueRange() const;
 
    sdata_type getValue(const void* data) const;
 
    data_type getValueU(const void* data) const;
 
    sdata_type getValue(size_type idx, const void* data) const;
 
    data_type getValueU(size_type idx, const void* data) const;
 
    [[nodiscard]] id_type getId() const;
 
    [[nodiscard]] inline id_type getDesiredId() const;
 
    [[nodiscard]] id_type getSequenceId() const;
 
    [[nodiscard]] std::string getName(int levels = 0) const;
 
    [[nodiscard]] int getNameLevelCount() const;
 
    [[nodiscard]] std::string getDescription() const;
 
    void setDesiredId();
 
    void setDesiredId(id_type id);
 
    template<typename T>
    void setData(T data);
 
    template<typename T = uint64_t>
    [[nodiscard]] T getData() const;
 
    [[nodiscard]] size_type getUsageCount() const;
 
    [[nodiscard]] const FileMappedStorage& getDataStore() const;
 
    [[nodiscard]] size_type getBufferSize(size_type blocks) const;
 
    [[nodiscard]] inline size_type getBufferSize(const Range& rng) const;
 
    [[nodiscard]] size_type getBlockSize() const;
 
    [[nodiscard]] Range::size_type getBlockCount() const;
 
    [[nodiscard]] FileMappedStorage::size_type getSegmentSize() const;
 
    [[nodiscard]] FileMappedStorage::size_type getSegmentCount() const;
 
    [[nodiscard]] FileMappedStorage::size_type getReservedBlockCount() const;
 
    [[nodiscard]] FileMappedStorage::size_type getReservedSize() const;
 
    bool blockRead(Range::size_type ofs, Range::size_type sz, void* dest, bool force = false) const;
 
    inline bool blockRead(const Range& rng, void* dest, bool force = false) const;
 
    bool readIndexRange(Range::size_type ofs, Range& range) const;
 
    bool readIndexRange(const Range& index, Range& range) const;
 
    [[nodiscard]] bool isRangeValid(Range::size_type ofs, Range::size_type sz) const;
 
    [[nodiscard]] bool isRangeValid(const Range& rng) const;
 
    [[nodiscard]] bool isIndexRangeValid(const Range& rng) const;
 
    [[nodiscard]] const Range& getAccessRange() const;
 
    bool getRequests(Range::Vector& requests) const;
 
    bool getSplitRequests(Range::Vector& req_list) const;
 
    std::ostream& reportStatus(std::ostream& os) const;
 
    [[nodiscard]] inline Range::id_type getTransId() const;
 
    bool blockWrite(Range::size_type ofs, Range::size_type sz, const void* src, bool auto_reserve = false);
 
    inline bool blockWrite(const Range& rng, const void* src, bool auto_reserve = false);
 
    size_type commitValidations(bool skip_self = false);
 
    bool setReservedBlockCount(Range::size_type sz, bool skip_self = false);
 
    bool clearValidations(bool skip_self = false) const;
 
    inline void validateRange(Range::size_type ofs, Range::size_type sz) const;
 
    void validateRange(Range rng) const;
 
    void validateRange(const Range::Vector& rl) const;
 
    inline bool requestRange(Range::size_type ofs, Range::size_type sz);
 
    bool requestRange(const Range& rng);
 
    bool requestIndexRange(const Range& rng);
 
    void clearRequests() const;
 
    [[nodiscard]] bool isFlag(int flag) const;
 
    bool setFlag(int flag, bool skip_self);
 
    bool unsetFlag(int flag, bool skip_self);
 
    [[nodiscard]] std::string getCurFlagsString() const;
 
    [[nodiscard]] std::string getFlagsString() const;
 
    bool updateFlags(int flags, bool skip_self);
 
    [[nodiscard]] flags_type getFlags() const;
 
    [[nodiscard]] flags_type getCurFlags() const;
 
    static EType getType(std::string_view type);
 
    static std::string getType(EType type);
 
    [[nodiscard]] EType getType() const;
 
    static size_type getTypeSize(EType type);
 
    [[nodiscard]] inline size_type getTypeSize() const;
 
    [[nodiscard]] unsigned getSignificantBits() const;
 
    static size_type getCount();
 
    static size_type getInstanceCount();
 
    static PtrVector getList();
 
    static std::string getFieldName(int field);
 
    static const ResultData& getInstanceById(id_type id);
 
    static const ResultData& getInstanceById(id_type id, const PtrVector& list);
 
    static const ResultData& getInstanceBySequenceId(id_type seq_id, const PtrVector& list);
 
    static size_type getTotalReservedSize();
 
    static bool create(std::istream& is, PtrVector& list = null_ref<PtrVector>(), int& err_line = null_ref<int>());
 
    bool writeUpdate(std::ostream& os) const;
 
    static bool readUpdate(std::istream& is, bool skip_self, PtrVector& list = null_ref<PtrVector>());
 
    static Definition getDefinition(const std::string& str);
 
    static flags_type toFlags(const std::string& flags);
 
    static std::string getFlagsString(flags_type flags);
 
    inline ResultData& operator=(const ResultData& rd);
 
    inline bool operator==(const ResultData& rd) const;
 
    void operator delete(void*);// NOLINT(misc-new-delete-overloads)
 
  private:
    explicit ResultData(void*, void*);
 
    bool createDataStore(ResultDataReference* ref, size_type segment_size, size_type block_size);
 
    [[maybe_unused]] size_type emitLocalEvent(EEvent event, const Range& rng, bool skip_self = true) const;
 
    [[maybe_unused]] size_type emitGlobalEvent(EEvent event, const Range& rng, bool skip_self = true) const;
 
    bool emitEvent(EEvent event, const ResultData& caller, const Range& rng);
 
    static ResultDataReference* getReferenceById(id_type id);
 
    static void removeHandler(const ResultDataHandler* handler);
 
    bool attachRef(ResultDataReference* ref);
 
    size_type attachDesired() const;
 
    bool recycleEnable(bool recycle);
 
    ResultDataReference* _reference{nullptr};
    ResultDataHandler* _handler{nullptr};
    Range::id_type _transactionId{0};
    id_type _desiredId{0};
    void* _userData{nullptr};
    uint64_t _data{0};
 
  public:
    void setDebug(bool debug) const;
    [[nodiscard]] inline bool isDebug() const;
    static std::string_view getEventName(EEvent event);
 
    inline const ResultDataReference& getReference() const;
 
    [[nodiscard]] const Range::Vector& getCommitList() const;
 
    [[nodiscard]] const Range::Vector& getValidatedList() const;
 
    [[nodiscard]] size_type getSegmentLocks() const;
 
    size_type emitEvent(EEvent event, const Range& rng, bool skip_self = false);
 
    friend class ResultDataHandler;
 
    friend class ResultDataReference;
 
    friend class ResultDataStatic;
};
 
_GII_FUNC std::ostream& operator<<(std::ostream& os, const ResultData&);
 
_GII_FUNC std::istream& operator>>(std::istream& is, ResultData&);
 
}// namespace sf
 
// Include all inlined functions and template implementations.
#include <gii/gen/ResultData.hpp>