wip

Author: 375gnu

src/celengine/config.cpp

@@ -0,0 +1,53 @@
+#include "config.h"
+#include "property.h"
+
+
+namespace celengine
+{
+
+void Config::setProperty(BaseProperty *p)
+{
+    auto pos = std::find(m_props.begin(), m_props.end(), p);
+    if (pos != m_props.end())
+        m_props.push_back(p);
+}
+
+void Config::removeProperty(BaseProperty *p)
+{
+    auto pos = std::find(m_props.begin(), m_props.end(), p);
+    if (pos != m_props.end())
+        m_props.erase(pos);
+}
+
+const Value Config::operator[](const std::string& name)
+{
+    auto pos = m_values.find(name);
+    if (pos != m_values.end())
+        return pos->second;
+
+    return Value();
+}
+
+void Config::beginUpdate()
+{
+    m_update = true;
+}
+
+void Config::set(const std::string& name, const Value& value)
+{
+    m_values[name] = value;
+}
+
+void Config::endUpdate()
+{
+    m_update = false;
+    onUpdate();
+}
+
+void Config::onUpdate()
+{
+    for (auto* p : m_props)
+        p->update();
+}
+
+} // namespace;

src/celengine/config.h

@@ -2,97 +2,33 @@
 
 #include <string>
 #include <memory>
+#include <vector>
+#include <map>
 #include "parser.h"
 
+
 namespace celengine
 {
 class BaseProperty;
+
 class Config
 {
  public:
     void setProperty(BaseProperty*);
+    void removeProperty(BaseProperty*);
     const Value operator[](const std::string& name);
-};
-
-class BaseProperty
-{
- public:
-    virtual void update() = 0;
-    friend class Config;
-};
-
-template<typename T>
-class Property : BaseProperty
-{
- public:
-    Property() = default;
-
-    Property(Config *config, std::string name) :
-        m_config(config),
-        m_name(std::move(name))
-    {
-        m_config->setProperty(this);
-    };
-
-    Property(Config *config, std::string name, T value) :
-        m_config(config),
-        m_name(std::move(name)),
-        m_value(std::move(value))
-    {
-    };
 
-    // Getters and setters
-    inline Property& set(T value)
-    {
-        m_value = value;
-    };
-
-    Property& operator() (T value)
-    {
-        return set(value);
-    };
-
-    Property& operator=(T value)
-    {
-        return set(value);
-    };
-
-    T get() const
-    {
-        return m_value;
-    };
-
-    T operator()() const
-    {
-        return get();
-    };
-
-    // Used by Config to propagate changes
-    void update() override;
+    void beginUpdate();
+    void set(const std::string& name, const Value& value);
+    void endUpdate();
 
  private:
-    Config         *m_config { nullptr };
-    std::string     m_name;
-    T               m_value  {};
-};
+    void onUpdate();
 
-template<>
-void Property<double>::update()
-{
-    m_value = (*m_config)[m_name].getNumber();
-}
-
-template<>
-void Property<std::string>::update()
-{
-    m_value = (*m_config)[m_name].getString();
-}
+    std::vector<BaseProperty*>      m_props;
+    std::map<std::string, Value>    m_values;
 
-template<>
-void Property<bool>::update()
-{
-    m_value = (*m_config)[m_name].getBoolean();
-}
+    bool m_update { false };
+};
 
-Property<bool> p;
 } // namespace;

src/celengine/parser.h

@@ -72,39 +72,45 @@ typedef AssociativeArray Hash;
 
 class Value
 {
-public:
-    enum ValueType {
-        NumberType     = 0,
-        StringType     = 1,
-        ArrayType      = 2,
-        HashType       = 3,
-        BooleanType    = 4
+ public:
+    enum ValueType
+    {
+        NullType       = 0,
+        NumberType     = 1,
+        StringType     = 2,
+        ArrayType      = 3,
+        HashType       = 4,
+        BooleanType    = 5
     };
 
     Value(double);
     Value(const string&);
     Value(ValueArray*);
     Value(Hash*);
     Value(bool);
+    Value() = default;
     ~Value();
 
     ValueType getType() const;
 
+    bool isNull() const;
     double getNumber() const;
     string getString() const;
     ValueArray* getArray() const;
     Hash* getHash() const;
     bool getBoolean() const;
 
-private:
-    ValueType type;
-
-    union {
+ private:
+    union Data
+    {
         string* s;
         double d;
         ValueArray* a;
         Hash* h;
-    } data;
+    };
+
+    ValueType type{ NullType };
+    Data data;
 };
 
 

src/celengine/property.h

@@ -0,0 +1,98 @@
+#pragma once
+
+#include <memory>
+#include "config.h"
+#include "parser.h"
+
+
+namespace celengine
+{
+class BaseProperty
+{
+ public:
+    virtual void update() = 0;
+    friend class Config;
+};
+
+template<typename T>
+class Property : BaseProperty
+{
+ public:
+    Property() = default;
+
+    Property(std::shared_ptr<Config> config, std::string name) :
+        m_config(std::move(config)),
+        m_name(std::move(name))
+    {
+        m_config->setProperty(this);
+    };
+
+    Property(std::shared_ptr<Config> config, std::string name, T value) :
+        m_config(std::move(config)),
+        m_name(std::move(name)),
+        m_value(std::move(value))
+    {
+    };
+
+    ~Property();
+
+    // Getters and setters
+    inline Property& set(T value)
+    {
+        m_value = value;
+    };
+
+    Property& operator() (T value)
+    {
+        return set(value);
+    };
+
+    Property& operator=(T value)
+    {
+        return set(value);
+    };
+
+    T get() const
+    {
+        return m_value;
+    };
+
+    T operator()() const
+    {
+        return get();
+    };
+
+    // Used by Config to propagate changes
+    void update() override;
+
+ private:
+    std::shared_ptr<Config> m_config { nullptr };
+    std::string             m_name;
+    T                       m_value  {};
+};
+
+template<>
+void Property<double>::update()
+{
+    m_value = (*m_config)[m_name].getNumber();
+}
+
+template<>
+void Property<std::string>::update()
+{
+    m_value = (*m_config)[m_name].getString();
+}
+
+template<>
+void Property<bool>::update()
+{
+    m_value = (*m_config)[m_name].getBoolean();
+}
+
+template<typename T>
+Property<T>::~Property()
+{
+    m_config->removeProperty(*this);
+}
+
+} // namespace;