ISettingsProvider.h

Go to the documentation of this file.

#pragma once

#include <fsdk/IObject.h>
#include <fsdk/Types.h>
#include "FSDKError.h"
#include <cstring>
#include <string>

namespace fsdk {
    
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    DECLARE_SMARTPTR(ISettingsProvider);
#endif

    struct 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 Result<Error> load(const char* path) noexcept = 0;

        virtual bool save(const char* path) const noexcept = 0;

        virtual void clear() noexcept = 0;
        
        virtual bool isEmpty() const noexcept = 0;


        struct 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 : m_type(Undefined) {}

            Value(int x) noexcept { setInt(x); }

            Value(int x, int y) noexcept { setInt(x, y); }

            Value(int x, int y, int z) noexcept { setInt(x, y, z); }

            Value(int x, int y, int z, int w) noexcept { setInt(x, y, z, w); }

            Value(float x) noexcept { setFloat(x); }

            Value(float x, float y) noexcept { setFloat(x, y); }

            Value(float x, float y, float z) noexcept { setFloat(x, y, z); }

            Value(float x, float y, float z, float w) noexcept { setFloat(x, y, z, w); }

            Value(const char* string) noexcept { setString(string); }

            Value(const Rect& rect) noexcept { setRect(rect); }

            Value(const Size& size) noexcept { setSize(size); }

            Value(const Point2f& point) noexcept { setPoint2f(point); }

            Value(bool x) noexcept { setBool(x); }
            
            operator bool() const noexcept { return !is(Undefined); }
            
            bool is(Type type) const noexcept { return m_type == type; }


            inline bool setString(const char* string) noexcept;

            inline bool getString(char* string) const noexcept;


            inline void setRect(const Rect& rect) noexcept;

            inline bool getRect(Rect* rect) const noexcept;


            inline void setSize(const Size& size) noexcept;

            inline bool getSize(Size* size) const noexcept;


            inline void setPoint2i(const Point2i& point) noexcept;

            inline bool getPoint2i(Point2i* point) const noexcept;


            inline void setPoint2f(const Point2f& point) noexcept;

            inline bool getPoint2f(Point2f* point) const noexcept;

            inline void setBool(bool x) noexcept;

            inline bool getBool(bool* x) const noexcept;


            inline void setInt(int x) noexcept;

            inline bool getInt(int* x) const noexcept;


            inline void setInt(int x, int y) noexcept;

            inline bool getInt(int* x, int* y) const noexcept;


            inline void setInt(int x, int y, int z) noexcept;

            inline bool getInt(int* x, int* y, int* z) const noexcept;


            inline void setInt(int x, int y, int z, int w) noexcept;

            inline bool getInt(int* x, int* y, int* z, int* w) const noexcept;


            inline void setFloat(float x) noexcept;

            inline bool getFloat(float* x) const noexcept;


            inline void setFloat(float x, float y) noexcept;
            
            inline bool getFloat(float* x, float* y) const noexcept;


            inline void setFloat(float x, float y, float z) noexcept;

            inline bool getFloat(float* x, float* y, float* z) const noexcept;


            inline void setFloat(float x, float y, float z, float w) noexcept;

            inline bool getFloat(float* x, float* y, float* z, float* w) const noexcept;


            inline float asFloat(float defaultValue = 0.f) const noexcept;


            inline Point2f asPoint2f(const Point2f& defaultValue = Point2f()) const noexcept;
            

            inline bool asBool(bool defaultValue = false) const noexcept;


            inline int asInt(int defaultValue = 0) const noexcept;


            inline Size asSize(const Size& defaultValue = Size()) const noexcept;


            inline Point2i asPoint2i(const Point2i& defaultValue = Point2i()) const noexcept;


            inline Rect asRect(const Rect& defaultValue = Rect()) const noexcept;


            inline const char* asString(const char* defaultValue = "") const noexcept;
            
            inline Value(const Value& other) = delete;
            inline Value(Value&& other);

            inline Value& operator=(const Value& other) = delete;
            inline Value& operator=(Value&& other);

            inline void swap(Value& first, Value& second);

            inline ~Value();

        };


        struct Key {

            inline Key() noexcept;

            inline Key(const char* section, const char* parameter) noexcept;

            const char* getSection() const noexcept {
                return m_section;
            }

            const char* getParameter() const noexcept {
                return m_parameter;
            }

            inline void setSection(const char* section) noexcept;

            inline void setParameter(const char* parameter) noexcept;

            inline 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 Desc {

            inline Desc() noexcept;

            inline Desc(const char* desc) noexcept;

            const char* getDesc() const noexcept {
                return m_desc;
            }

            inline void setDesc(const char* desc) noexcept;

        protected:
            static const unsigned int m_bufferLength = 256;
            char m_desc [m_bufferLength];           
        };


        struct Entry {

            Value m_value;      
            Desc m_desc;        

            Entry() noexcept = default;

            Entry(Entry&& right) : 
                m_value{std::move(right.m_value)},
                m_desc{right.m_desc}
            {}

            Entry& operator=(Entry&& right) {
                Entry tmp(std::move(right));
                swap(tmp, *this);
                return *this;
            }

            void swap(Entry& first, Entry& second) {
                std::swap(first.m_desc, second.m_desc);
                std::swap(first.m_value, second.m_value);
            }
            inline Entry(const Desc& desc, Value&& value) noexcept;

            inline void setDesc(const Desc& desc) noexcept;

            inline void setValue(Value&& value) noexcept;

            const Desc& getDesc() const noexcept {
                return m_desc;
            }

            const Value& getValue() const noexcept {
                return m_value;
            }
        };

        virtual void setDesc(const Key& key, const Desc& desc) noexcept = 0;

        void setDesc(
            const char* section,
            const char* parameter,
            const Desc& desc) noexcept {
            setDesc(Key(section, parameter), desc);
        }

        virtual void setValue(const Key& key, Value&& value) noexcept = 0;

        void setValue(
            const char* section,
            const char* parameter,
            Value&& value) noexcept {
            setValue(Key(section, parameter), std::move(value));
        }

        virtual void setEntry(const Key& key, Entry&& entry) noexcept = 0;

        void setEntry(
            const Key& key,
            const Desc& desc,
            Value&& value) noexcept {
            setEntry(key, Entry(desc, std::move(value)));
        }

        void setEntry(
            const char* section,
            const char* parameter,
            const Desc& desc,
            Value&& value) noexcept {
            setEntry(Key(section, parameter), Entry(desc, std::move(value)));
        }

        virtual const Entry& getEntry(const Key& key) const noexcept = 0;

        Desc getDesc(const Key& key) const noexcept {
            return getEntry(key).m_desc;
        }

        Desc getDesc(
            const char* section,
            const char* parameter) const noexcept {
            return getDesc(Key(section, parameter));
        }

        const Value& getValue(const Key& key) const noexcept {
            return getEntry(key).m_value;
        }

        const Value& getValue(
            const char* section,
            const char* parameter) const noexcept {
            return getValue(Key(section, parameter));
        }
    };
    
    FSDK_API fsdk::ResultValue<fsdk::FSDKError, fsdk::ISettingsProviderPtr>
        createSettingsProvider(const char* path) 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";
            }
        }
    };

#include "ISettingsProvider.inl"

}