ISettingsProvider.h

Go to the documentation of this file.

#pragma once

#include <fsdk/IObject.h>
#include <fsdk/Types.h>
#include <fsdk/FSDKError.h>
#include <cstring>
#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 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,       
                Float1,     
                Float2,     
                Float3,     
                Float4,     
                String      
            } m_type;   

            Value() noexcept;

            Value(int 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 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;


            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";
            }
        }
    };
}