SerializerElement.h

/*
 * GDevelop Core
 * Copyright 2008-2016 Florian Rival ([email protected]). All rights
 * reserved. This project is released under the MIT License.
 */
 
#ifndef GDCORE_SERIALIZERELEMENT_H
#define GDCORE_SERIALIZERELEMENT_H
#include <map>
#include <memory>
#include <string>
#include <vector>
 
#include "GDCore/Serialization/SerializerValue.h"
#include "GDCore/String.h"
 
namespace gd {
 
class GD_CORE_API SerializerElement {
 public:
  SerializerElement();
 
  SerializerElement(const SerializerValue &value);
 
  SerializerElement(const gd::SerializerElement &object) { Init(object); };
 
  SerializerElement &operator=(const gd::SerializerElement &object) {
    if ((this) != &object) Init(object);
    return *this;
  }
 
  virtual ~SerializerElement();
 
 
  void SetValue(const SerializerValue &value) {
    valueUndefined = false;
    elementValue = value;
  }
 
  void SetValue(bool val) {
    valueUndefined = false;
    elementValue.SetBool(val);
  }
 
  void SetBoolValue(bool val) { SetValue(val); }
 
  void SetValue(const gd::String &val) {
    valueUndefined = false;
    elementValue.SetString(val);
  }
 
  void SetStringValue(const gd::String &val) { SetValue(val); }
 
  void SetValue(int val) {
    valueUndefined = false;
    elementValue.SetInt(val);
  }
 
  void SetIntValue(int val) { SetValue(val); }
 
  void SetValue(unsigned int val) {
    valueUndefined = false;
    elementValue.SetInt((int)val);
  }
 
  void SetValue(double val) {
    valueUndefined = false;
    elementValue.SetDouble(val);
  }
 
  void SetDoubleValue(double val) { SetValue(val); }
 
  void SetValue(float val) { SetValue((double)val); }
 
  void SetFloatValue(float val) { SetValue(val); }
 
  const SerializerValue &GetValue() const;
 
  bool GetBoolValue() const { return GetValue().GetBool(); };
 
  gd::String GetStringValue() const { return GetValue().GetString(); };
 
  int GetIntValue() const { return GetValue().GetInt(); };
 
  double GetDoubleValue() const { return GetValue().GetDouble(); };
 
  bool IsValueUndefined() const { return valueUndefined; }
 
  void SetMultilineStringValue(const gd::String &value);
 
  gd::String GetMultilineStringValue();
 
 
  SerializerElement &SetAttribute(const gd::String &name, bool value);
 
  SerializerElement &SetBoolAttribute(const gd::String &name, bool value) {
    return SetAttribute(name, value);
  }
 
  SerializerElement &SetAttribute(const gd::String &name,
                                  const gd::String &value);
 
  SerializerElement &SetStringAttribute(const gd::String &name,
                                        const gd::String &value) {
    return SetAttribute(name, value);
  }
 
  SerializerElement &SetAttribute(const gd::String &name, const char *value) {
    if (value) SetAttribute(name, gd::String(value));
    return *this;
  };
 
  SerializerElement &SetAttribute(const gd::String &name, int value);
 
  SerializerElement &SetIntAttribute(const gd::String &name, int value) {
    return SetAttribute(name, value);
  }
 
  SerializerElement &SetAttribute(const gd::String &name, double value);
 
  SerializerElement &SetDoubleAttribute(const gd::String &name, double value) {
    return SetAttribute(name, value);
  }
 
  bool GetBoolAttribute(const gd::String &name,
                        bool defaultValue = false,
                        gd::String deprecatedName = "") const;
 
  gd::String GetStringAttribute(const gd::String &name,
                                gd::String defaultValue = "",
                                gd::String deprecatedName = "") const;
 
  int GetIntAttribute(const gd::String &name,
                      int defaultValue = 0,
                      gd::String deprecatedName = "") const;
 
  double GetDoubleAttribute(const gd::String &name,
                            double defaultValue = 0.0,
                            gd::String deprecatedName = "") const;
 
  bool HasAttribute(const gd::String &name) const;
 
  const std::map<gd::String, SerializerValue> &GetAllAttributes() const {
    return attributes;
  };
 
 
  void ConsiderAsArray() const { isArray = true; };
 
  bool ConsideredAsArray() const { return isArray; };
 
  void ConsiderAsArrayOf(const gd::String &name,
                         const gd::String &deprecatedName = "") const {
    ConsiderAsArray();
    arrayOf = name;
    deprecatedArrayOf = deprecatedName;
  };
 
  const gd::String &ConsideredAsArrayOf() const { return arrayOf; };
 
  SerializerElement &AddChild(gd::String name);
 
  SerializerElement &GetChild(gd::String name,
                              std::size_t index = 0,
                              gd::String deprecatedName = "") const;
 
  SerializerElement &GetChild(std::size_t index) const;
 
  std::size_t GetChildrenCount(gd::String name = "",
                               gd::String deprecatedName = "") const;
 
  bool HasChild(const gd::String &name, gd::String deprecatedName = "") const;
 
  void RemoveChild(const gd::String &name);
 
  const std::vector<std::pair<gd::String, std::shared_ptr<SerializerElement> > >
      &GetAllChildren() const {
    return children;
  };
 
  static SerializerElement nullElement;
 
 private:
  void Init(const gd::SerializerElement &other);
 
  bool valueUndefined;  
  SerializerValue elementValue;
 
  std::map<gd::String, SerializerValue> attributes;
  std::vector<std::pair<gd::String, std::shared_ptr<SerializerElement> > >
      children;
  mutable bool isArray;        
  mutable gd::String arrayOf;  
  mutable gd::String deprecatedArrayOf;  
};
 
}  // namespace gd
 
#endif