GEEKING

App/include/v8datamodel/GlobalSettings.h

@@ -0,0 +1,200 @@
+#pragma once
+
+#include "V8Tree/Instance.h"
+#include "V8Tree/Service.h"
+#include "Script/ThreadRef.h"
+
+namespace RBX {
+
+	// A generic mechanism for displaying stats (like 3D FPS, network traffic, etc.)
+	extern const char *const sSettings;
+	extern const char *const sSettingsItem;
+
+	class Settings
+		: public DescribedNonCreatable<Settings, ServiceProvider, sSettings>
+	{
+	private:
+		typedef DescribedNonCreatable<Settings, ServiceProvider, sSettings> Super;
+		struct InvalidDescendentDetector {
+			bool anyInvalid;
+			InvalidDescendentDetector();
+			static bool invalid(const Instance* instance);
+			void operator()(shared_ptr<Instance> descendant);
+		};
+		struct InvalidDescendentCollector {
+			std::vector< shared_ptr<Instance> > invalidInstances;
+			InvalidDescendentCollector();
+			void operator()(shared_ptr<Instance> descendant);
+		};
+	protected:
+		std::string settingsFile;
+		bool settingsErased;
+
+		///////////////////////////////
+		// overrides
+		virtual void verifyAddDescendant(const Instance* newParent,
+			const Instance* instanceGettingNewParent) const override;
+
+	public:
+		Settings(const std::string& settingsFile);
+		void setSaveTarget(const std::string& optGlobalSettingsFile) {
+			settingsFile = optGlobalSettingsFile;
+		}
+
+		void loadState(const std::string& optGlobalSettingsFile);
+		void saveState();
+		void eraseSettingsStore();
+
+		void removeInvalidChildren();
+		bool useSubmitTaskForLuaListeners() const override { return true; }
+	};
+	
+	extern const char *const sGlobalBasicSettings;
+	class GlobalBasicSettings
+		: public DescribedNonCreatable<GlobalBasicSettings, Settings, sGlobalBasicSettings>
+	{
+		typedef DescribedNonCreatable<GlobalBasicSettings, Settings, sGlobalBasicSettings> Super;
+	public:
+		GlobalBasicSettings();
+
+		class Item : public NonFactoryProduct< Instance, sSettingsItem>
+		{
+		public:
+			virtual void reset() {}
+			bool useSubmitTaskForLuaListeners() const override { return true; }
+		protected:
+			bool askAddChild(const Instance* instance) const override
+			{
+				return dynamic_cast<const Item*>(instance)!=NULL;
+			}
+		};
+
+		boost::mutex mutex;
+		static shared_ptr<GlobalBasicSettings> singleton();
+		void reset();
+		bool isUserFeatureEnabled(std::string name);
+		void verifySetParent(const Instance* instance) const override;
+	};
+
+	extern const char *const sGlobalAdvancedSettings;
+
+	class GlobalAdvancedSettings
+		: public DescribedNonCreatable<GlobalAdvancedSettings, Settings, sGlobalAdvancedSettings>
+	{
+		typedef DescribedNonCreatable<GlobalAdvancedSettings, Settings, sGlobalAdvancedSettings> Super;
+	public:
+		GlobalAdvancedSettings();
+		 ~GlobalAdvancedSettings();
+
+		class Item : public NonFactoryProduct< Instance, sSettingsItem>
+		{
+		public:
+			bool useSubmitTaskForLuaListeners() const override { return true; }
+		protected:
+			bool askAddChild(const Instance* instance) const override
+			{
+				return dynamic_cast<const Item*>(instance)!=NULL;
+			}
+		};
+
+		shared_ptr<const RBX::Reflection::ValueTable> getFVariables();
+		std::string getFVariable(std::string flag);
+		bool getFFlag(std::string name);
+
+		boost::mutex mutex;
+		static shared_ptr<GlobalAdvancedSettings> singleton();
+		static GlobalAdvancedSettings* raw_singleton();
+		void verifySetParent(const Instance* instance) const override;
+	};
+
+	template<class Class, const char* const & sClassName>
+	class GlobalAdvancedSettingsItem
+		 : public RBX::DescribedCreatable<Class, RBX::GlobalAdvancedSettings::Item, sClassName>
+		 , public Service
+	{
+		typedef RBX::DescribedCreatable<Class, RBX::GlobalAdvancedSettings::Item, sClassName> Super;
+		static GlobalAdvancedSettingsItem* sing;
+	protected:
+		GlobalAdvancedSettingsItem()
+		{
+			Super::setName(sClassName);
+			if (sing)
+				throw RBX::runtime_error("singleton %s already exists", sClassName);
+			sing = this;
+		}
+		~GlobalAdvancedSettingsItem()
+		{
+			sing = NULL;
+		}
+
+	public:
+		static Class& singleton()
+		{
+			// shortcut
+			if (sing)
+				return *boost::polymorphic_downcast<Class*>(sing);
+
+			RBX::GlobalAdvancedSettings* gs = RBX::GlobalAdvancedSettings::singleton().get();
+			boost::mutex::scoped_lock lock(gs->mutex);
+			if (!sing)
+			{
+				// "s" won't get collected when we leave scope because the parent will hold a ref to it 
+				shared_ptr<Class> s = Class::createInstance();
+				s->setParent(gs);
+				RBXASSERT(s.get()==sing);
+			}
+			return *boost::polymorphic_downcast<Class*>(sing);
+		}
+	};
+		
+	template<class Class, const char* const & sClassName>
+	GlobalAdvancedSettingsItem<Class, sClassName>* GlobalAdvancedSettingsItem<Class, sClassName>::sing = NULL;
+
+	template<class Class, const char* const & sClassName>
+	class GlobalBasicSettingsItem
+		 : public RBX::DescribedCreatable<Class, RBX::GlobalBasicSettings::Item, sClassName>
+		 , public Service
+	{
+		typedef RBX::DescribedCreatable<Class, RBX::GlobalBasicSettings::Item, sClassName> Super;
+		static GlobalBasicSettingsItem* sing;
+	protected:
+		GlobalBasicSettingsItem()
+		{
+			Super::setName(sClassName);
+			if (sing)
+				throw RBX::runtime_error("singleton %s already exists", sClassName);
+			sing = this;
+		}
+		~GlobalBasicSettingsItem()
+		{
+			sing = NULL;
+		}
+
+
+	public:
+		static Class& singleton()
+		{
+			// shortcut
+			if (sing)
+				return *boost::polymorphic_downcast<Class*>(sing);
+
+			RBX::GlobalBasicSettings* gs = RBX::GlobalBasicSettings::singleton().get();
+			boost::mutex::scoped_lock lock(gs->mutex);
+			if (!sing)
+			{
+				// "s" won't get collected when we leave scope because the parent will hold a ref to it 
+				shared_ptr<Class> s = Class::createInstance();
+				s->setParent(gs);
+				RBXASSERT(s.get()==sing);
+			}
+			return *boost::polymorphic_downcast<Class*>(sing);
+		}
+
+		virtual void resetSettings()
+		{}
+	};
+		
+	template<class Class, const char* const & sClassName>
+	GlobalBasicSettingsItem<Class, sClassName>* GlobalBasicSettingsItem<Class, sClassName>::sing = NULL;
+
+} // namespace