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