ISettingsProvider.h

Go to the documentation of this file.

 
#pragma once
 
#include <fsdk/IObject.h>
#include <fsdk/Types.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, right);
                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::ISettingsProvider* 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"
 
}