openspades/Sources/Core/Settings.h

/*
 Copyright (c) 2013 yvt
 
 This file is part of OpenSpades.
 
 OpenSpades is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.
 
 OpenSpades is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with OpenSpades.  If not, see <http://www.gnu.org/licenses/>.
 
 */

#pragma once

#include <string>
#include <map>
#include <vector>
#include <type_traits>

namespace spades {
    enum class SettingItemFlags {
        None = 0
    };
    
    inline SettingItemFlags operator | (SettingItemFlags lhs, SettingItemFlags rhs)
    
    {
        using T = std::underlying_type<SettingItemFlags>::type;
        return (SettingItemFlags)(static_cast<T>(lhs) | static_cast<T>(rhs));
    }
    
    inline SettingItemFlags& operator |= (SettingItemFlags& lhs, SettingItemFlags rhs)
    {
        using T = std::underlying_type<SettingItemFlags>::type;
        lhs = (SettingItemFlags)(static_cast<T>(lhs) | static_cast<T>(rhs));
        return lhs;
    }
    
    struct SettingItemDescriptor {
        const std::string defaultValue;
        const SettingItemFlags flags;
        
        SettingItemDescriptor() = default;
        SettingItemDescriptor(const std::string &defaultValue = std::string(),
                              SettingItemFlags flags = SettingItemFlags::None) :
            defaultValue(defaultValue),
            flags(flags)
        {}
        
        bool operator == (const SettingItemDescriptor &o) const {
            return defaultValue == o.defaultValue &&
            flags == o.flags;
        }
        bool operator != (const SettingItemDescriptor &o) const {
            return !(*this == o);
        }
    };
    
    class ISettingItemListener {
    protected:
        ISettingItemListener() = default;
        virtual ~ISettingItemListener() {}
    public:
        virtual void SettingChanged(const std::string &name) = 0;
    };
    
	class Settings {
		struct Item {
			std::string name;
			std::string string;
			float value;
			int intValue;
			
            const SettingItemDescriptor *descriptor;
			bool defaults;
            
            std::vector<ISettingItemListener *> listeners;
			
			void Load();
			void Set(const std::string&);
			void Set(int);
			void Set(float);
            
            void NotifyChange();
		};
		std::map<std::string, Item *> items;
		bool loaded;
		Settings();
		
		Item *GetItem(const std::string& name,
					  const SettingItemDescriptor *descriptor);
		
		void Save();
		
	public:
		static Settings *GetInstance();
		
		
		class ItemHandle {
			Item *item;
		public:
            ItemHandle(const std::string& name,
                       const SettingItemDescriptor *descriptor);
			void operator =(const std::string&);
			void operator =(int);
			void operator =(float);
			operator std::string();
			operator float();
			operator int();
			operator bool();
			const char *CString();
			
			const SettingItemDescriptor &GetDescriptor();
            
            void AddListener(ISettingItemListener *);
            void RemoveListener(ISettingItemListener *);
		};
		
		void Load();
		void Flush();
		std::vector<std::string> GetAllItemNames();
		
	};
	/*
	template<const char *name, const char *def>
	class Setting: public Settings::ItemHandle {
	public:
		Setting(): Settings::ItemHandle(name, def, desc){
		}
	};*/
	
	static inline bool operator ==(const std::string& str, Settings::ItemHandle& handle) {
		return str == (std::string)handle;
	}
	
// Define SettingItemDescriptor with external linkage so duplicates are
// detected as linker errors.
#define DEFINE_SPADES_SETTING(name, ...) \
    spades::SettingItemDescriptor name ## _desc { __VA_ARGS__ }; \
    static spades::Settings::ItemHandle name ( # name , & name ## _desc )
    
#define SPADES_SETTING(name) \
extern spades::SettingItemDescriptor name ## _desc; \
static spades::Settings::ItemHandle name ( # name , & name ## _desc )
    
}