ISettingsProvider.h

Go to the documentation of this file.

 
#pragma once
 
#include <cstring>
#include <fsdk/FSDKError.h>
#include <fsdk/IObject.h>
#include <fsdk/Types.h>
#include <string>
 
namespace fsdk {
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    DECLARE_SMARTPTR(ISettingsProvider);
#endif
 
    struct FSDK_API ISettingsProvider : IRefCounted {
 
        enum class Error : uint32_t {
            Ok,                
            IOError,           
            Memory,            
            Internal,          
            InvalidPi,         
            InvalidTag,        
            InvalidCdata,      
            FileNotFound,      
            InvalidPcdata,     
            InvalidDocType,    
            InvalidSettings,   
            InvalidComment,    
            InvalidAttribute,  
            InvalidEndElement, 
            AppendInvalidRoot, 
            NoDocumentElement, 
            EndElementMismatch,  
            InvalidStartElement, 
            MemoryAllocationFailed, 
        };
 
        virtual const char* getDefaultPath() const noexcept = 0;
 
        virtual void setDefaultPath(const char* path) noexcept = 0;
 
        virtual Result<Error> load(const char* path) noexcept = 0;
 
        virtual Result<Error> loadFromString(const char* content) noexcept = 0;
 
        virtual bool save(const char* path) const noexcept = 0;
 
        virtual void clear() noexcept = 0;
 
        virtual bool isEmpty() const noexcept = 0;
 
        struct FSDK_API Value {
 
            union Data {
                struct Int1 {
                    int m_value;
                } m_int1; 
 
                struct Int2 {
                    int m_value[2];
                } m_int2; 
 
                struct Int3 {
                    int m_value[3];
                } m_int3; 
 
                struct Int4 {
                    int m_value[4];
                } m_int4; 
 
                struct ULong {
                    std::uint64_t m_value;
                } m_uLong; 
 
                struct Float1 {
                    float m_value;
                } m_float1; 
 
                struct Float2 {
                    float m_value[2];
                } m_float2; 
 
                struct Float3 {
                    float m_value[3];
                } m_float3; 
 
                struct Float4 {
                    float m_value[4];
                } m_float4; 
 
                struct String {
                    char* m_value;
                } m_string; 
            } m_data;     
 
            enum Type {
                Undefined, 
                Int1,      
                Int2,      
                Int3,      
                Int4,      
                ULong,     
                Float1,    
                Float2,    
                Float3,    
                Float4,    
                String     
            } m_type;    
 
            Value() noexcept;
 
            Value(int x) noexcept;
 
            Value(std::uint64_t x) noexcept;
 
            Value(int x, int y) noexcept;
 
            Value(int x, int y, int z) noexcept;
 
            Value(int x, int y, int z, int w) noexcept;
 
            Value(float x) noexcept;
 
            Value(float x, float y) noexcept;
            Value(float x, float y, float z) noexcept;
 
            Value(float x, float y, float z, float w) noexcept;
 
            Value(const char* string) noexcept;
 
            Value(const Rect& rect) noexcept;
 
            Value(const Size& size) noexcept;
 
            Value(const Point2f& point) noexcept;
 
            Value(bool x) noexcept;
 
            operator bool() const noexcept;
 
            bool is(Type type) const noexcept;
 
 
            bool setString(const char* string) noexcept;
 
            bool getString(char* string) const noexcept;
 
 
            void setRect(const Rect& rect) noexcept;
 
            bool getRect(Rect* rect) const noexcept;
 
 
            void setSize(const Size& size) noexcept;
 
            bool getSize(Size* size) const noexcept;
 
 
            void setPoint2i(const Point2i& point) noexcept;
 
            bool getPoint2i(Point2i* point) const noexcept;
 
 
            void setPoint2f(const Point2f& point) noexcept;
 
            bool getPoint2f(Point2f* point) const noexcept;
 
            void setBool(bool x) noexcept;
 
            bool getBool(bool* x) const noexcept;
 
 
            void setInt(int x) noexcept;
 
            bool getInt(int* x) const noexcept;
 
            void setULong(std::uint64_t x) noexcept;
 
            bool getULong(std::uint64_t* x) const noexcept;
 
 
            void setInt(int x, int y) noexcept;
 
            bool getInt(int* x, int* y) const noexcept;
 
 
            void setInt(int x, int y, int z) noexcept;
 
            bool getInt(int* x, int* y, int* z) const noexcept;
 
 
            void setInt(int x, int y, int z, int w) noexcept;
 
            bool getInt(int* x, int* y, int* z, int* w) const noexcept;
 
 
            void setFloat(float x) noexcept;
 
            bool getFloat(float* x) const noexcept;
 
 
            void setFloat(float x, float y) noexcept;
 
            bool getFloat(float* x, float* y) const noexcept;
 
 
            void setFloat(float x, float y, float z) noexcept;
 
            bool getFloat(float* x, float* y, float* z) const noexcept;
 
 
            void setFloat(float x, float y, float z, float w) noexcept;
 
            bool getFloat(float* x, float* y, float* z, float* w) const noexcept;
 
 
            float asFloat(float defaultValue = 0.f) const noexcept;
 
 
            Point2f asPoint2f(const Point2f& defaultValue = Point2f()) const noexcept;
 
 
            bool asBool(bool defaultValue = false) const noexcept;
 
 
            int asInt(int defaultValue = 0) const noexcept;
 
            std::uint64_t asULong(std::uint64_t defaultValue = 0) const noexcept;
 
 
            Size asSize(const Size& defaultValue = Size()) const noexcept;
 
 
            Point2i asPoint2i(const Point2i& defaultValue = Point2i()) const noexcept;
 
 
            Rect asRect(const Rect& defaultValue = Rect()) const noexcept;
 
 
            const char* asString(const char* defaultValue = "") const noexcept;
 
            inline Value(const Value& other) = delete;
            Value(Value&& other);
 
            inline Value& operator=(const Value& other) = delete;
            Value& operator=(Value&& other);
 
            void swap(Value& first, Value& second);
 
            ~Value();
        };
 
        struct FSDK_API Key {
 
            Key() noexcept;
 
            Key(const char* section, const char* parameter) noexcept;
 
            const char* getSection() const noexcept;
 
            const char* getParameter() const noexcept;
 
            void setSection(const char* section) noexcept;
 
            void setParameter(const char* parameter) noexcept;
 
            bool operator<(const ISettingsProvider::Key& other) const noexcept;
 
        protected:
            static const unsigned int m_bufferLength = 128;
            char m_section[m_bufferLength];   
            char m_parameter[m_bufferLength]; 
        };
 
        struct FSDK_API Desc {
 
            Desc() noexcept;
 
            Desc(const char* desc) noexcept;
 
            const char* getDesc() const noexcept;
 
            void setDesc(const char* desc) noexcept;
 
        protected:
            static const unsigned int m_bufferLength = 256;
            char m_desc[m_bufferLength]; 
        };
 
        struct FSDK_API Entry {
 
            Value m_value; 
            Desc m_desc;   
 
            Entry() noexcept = default;
 
            Entry(Entry&& right);
 
            Entry& operator=(Entry&& right);
 
            void swap(Entry& first, Entry& second);
            Entry(const Desc& desc, Value&& value) noexcept;
 
            void setDesc(const Desc& desc) noexcept;
 
            void setValue(Value&& value) noexcept;
 
            const Desc& getDesc() const noexcept;
 
            const Value& getValue() const noexcept;
        };
 
        virtual void setDesc(const Key& key, const Desc& desc) noexcept = 0;
 
        void setDesc(const char* section, const char* parameter, const Desc& desc) noexcept;
 
        virtual void setValue(const Key& key, Value&& value) noexcept = 0;
 
        void setValue(const char* section, const char* parameter, Value&& value) noexcept;
 
        virtual void setEntry(const Key& key, Entry&& entry) noexcept = 0;
 
        void setEntry(const Key& key, const Desc& desc, Value&& value) noexcept;
 
        void setEntry(const char* section, const char* parameter, const Desc& desc, Value&& value) noexcept;
 
        virtual const Entry& getEntry(const Key& key) const noexcept = 0;
 
        Desc getDesc(const Key& key) const noexcept;
 
        Desc getDesc(const char* section, const char* parameter) const noexcept;
 
        const Value& getValue(const Key& key) const noexcept;
 
        const Value& getValue(const char* section, const char* parameter) const noexcept;
    };
 
    FSDK_API fsdk::ResultValue<fsdk::FSDKError, fsdk::ISettingsProviderPtr>
    createSettingsProvider(const char* path) noexcept;
 
    FSDK_API ResultValue<FSDKError, ISettingsProviderPtr>
    createSettingsProviderFromString(const char* content) noexcept;
 
    template <>
    struct ErrorTraits<ISettingsProvider::Error> {
 
        static bool isOk(ISettingsProvider::Error error) noexcept {
            return error == ISettingsProvider::Error::Ok;
        }
 
        static const char* toString(ISettingsProvider::Error error) noexcept {
            switch(error) {
            case ISettingsProvider::Error::Ok:
                return "Ok";
            case ISettingsProvider::Error::Memory:
                return "Could not allocate memory";
            case ISettingsProvider::Error::IOError:
                return "Error reading from file";
            case ISettingsProvider::Error::Internal:
                return "Internal error";
            case ISettingsProvider::Error::InvalidPi:
                return "Error during document declaration/processing instruction parsing";
            case ISettingsProvider::Error::InvalidTag:
                return "Parser could not determine tag type";
            case ISettingsProvider::Error::InvalidCdata:
                return "Error during CDATA section parsing";
            case ISettingsProvider::Error::FileNotFound:
                return "File was not found";
            case ISettingsProvider::Error::InvalidPcdata:
                return "Error during PCDATA section parsing";
            case ISettingsProvider::Error::InvalidComment:
                return "Error during comment parsing";
            case ISettingsProvider::Error::InvalidDocType:
                return "Error during document type declaration parsing";
            case ISettingsProvider::Error::InvalidSettings:
                return "Settings sections is invalid or absent";
            case ISettingsProvider::Error::InvalidAttribute:
                return "Error during element attribute parsing";
            case ISettingsProvider::Error::InvalidEndElement:
                return "Error during end element tag parsing";
            case ISettingsProvider::Error::AppendInvalidRoot:
                return "Root type is not node_element or node_document";
            case ISettingsProvider::Error::NoDocumentElement:
                return "Document without element nodes";
            case ISettingsProvider::Error::EndElementMismatch:
                return "Mismatch of start-end tags";
            case ISettingsProvider::Error::InvalidStartElement:
                return "Error during start element tag parsing";
            default:
                return "Unknown error";
            }
        }
    };
 
} // namespace fsdk