Variable.h

/*
 * GDevelop Core
 * Copyright 2008-2016 Florian Rival ([email protected]). All rights
 * reserved. This project is released under the MIT License.
 */
 
#pragma once
 
#include <cmath>
#include <map>
#include <memory>
#include <vector>
 
#include "GDCore/String.h"
namespace gd {
class SerializerElement;
}
 
namespace gd {
 
class GD_CORE_API Variable {
 public:
  static gd::Variable badVariable;
  enum Type {
    Unknown,
    MixedTypes,
 
    // Primitive types
    String,
    Number,
    Boolean,
 
    // Collection types
    Structure,
    Array
  };
 
  static bool IsPrimitive(const Type type);
 
  Variable() : value(0), type(Type::Number), hasMixedValues(false) {};
  Variable(const Variable&);
  virtual ~Variable(){};
 
  Variable& operator=(const Variable& rhs);
 
  Type GetType() const { return type; }
 
  void CastTo(const Type newType);
 
  void CastTo(const gd::String& type) { return CastTo(StringAsType(type)); };
 
 
  const gd::String& GetString() const;
 
  void SetString(const gd::String& newStr) {
    str = newStr;
    type = Type::String;
    hasMixedValues = false;
  }
 
  double GetValue() const;
 
  void SetValue(double val) {
    value = val;
    // NaN values are not supported by GDevelop nor the serializer.
    if (std::isnan(value)) value = 0.0;
    type = Type::Number;
    hasMixedValues = false;
  }
 
  bool GetBool() const;
 
  void SetBool(bool val) {
    boolVal = val;
    type = Type::Boolean;
    hasMixedValues = false;
  }
 
  bool HasMixedValues() const {
    return hasMixedValues;
  }
 
  void MarkAsMixedValues();
 
  // Operators are overloaded to allow accessing to variable using a simple
  // int-like semantic.
  void operator=(double val) { SetValue(val); };
  void operator+=(double val) { SetValue(val + GetValue()); }
  void operator-=(double val) { SetValue(GetValue() - val); }
  void operator*=(double val) { SetValue(val * GetValue()); }
  void operator/=(double val) { SetValue(GetValue() / val); }
 
  bool operator<=(double val) const { return GetValue() <= val; };
  bool operator>=(double val) const { return GetValue() >= val; };
  bool operator<(double val) const { return GetValue() < val; };
  bool operator>(double val) const { return GetValue() > val; };
  bool operator==(double val) const { return GetValue() == val; };
  bool operator!=(double val) const { return GetValue() != val; };
 
  // Avoid ambiguous operators
  void operator=(int val) { SetValue(val); };
  void operator+=(int val) { SetValue(val + GetValue()); }
  void operator-=(int val) { SetValue(GetValue() - val); }
  void operator*=(int val) { SetValue(val * GetValue()); }
  void operator/=(int val) { SetValue(GetValue() / val); }
 
  bool operator<=(int val) const { return GetValue() <= val; };
  bool operator>=(int val) const { return GetValue() >= val; };
  bool operator<(int val) const { return GetValue() < val; };
  bool operator>(int val) const { return GetValue() > val; };
  bool operator==(int val) const { return GetValue() == val; };
  bool operator!=(int val) const { return GetValue() != val; };
 
  // Operators are overloaded to allow accessing to variable using a simple
  // string-like semantic.
  void operator=(const gd::String& val) { SetString(val); };
  void operator+=(const gd::String& val) { SetString(GetString() + val); }
 
  bool operator==(const gd::String& val) const { return GetString() == val; };
  bool operator!=(const gd::String& val) const { return GetString() != val; };
 
  // Avoid ambiguous operators
  void operator=(const char* val) { SetString(val); };
  void operator+=(const char* val) { SetString(GetString() + val); }
 
  bool operator==(const char* val) const { return GetString() == val; };
  bool operator!=(const char* val) const { return GetString() != val; };
 
  // Operators are overloaded to allow accessing to variable using a simple
  // bool-like semantic.
  void operator=(const bool val) { SetBool(val); };
 
  bool operator==(const bool val) const { return GetBool() == val; };
  bool operator!=(const bool val) const { return GetBool() != val; };
 
  bool operator==(const gd::Variable& variable) const;
  bool operator!=(const gd::Variable& variable) const;
 
 
 
  void ClearChildren() {
    children.clear();
    childrenArray.clear();
  };
 
  size_t GetChildrenCount() const {
    return type == Type::Structure ? children.size()
           : type == Type::Array   ? childrenArray.size()
                                   : 0;
  };
 
 
  bool HasChild(const gd::String& name) const;
 
  Variable& GetChild(const gd::String& name);
 
  const Variable& GetChild(const gd::String& name) const;
 
  void RemoveChild(const gd::String& name);
 
  bool RenameChild(const gd::String& oldName, const gd::String& newName);
 
  std::vector<gd::String> GetAllChildrenNames() const;
 
  const std::map<gd::String, std::shared_ptr<Variable>>& GetAllChildren()
      const {
    return children;
  }
 
  bool Contains(const gd::Variable& variableToSearch, bool recursive) const;
 
  void RemoveRecursively(const gd::Variable& variableToRemove);
 
 
  Variable& GetAtIndex(const size_t index);
 
  const Variable& GetAtIndex(const size_t index) const;
 
  Variable& PushNew();
 
  void RemoveAtIndex(const size_t index);
 
  void MoveChildInArray(const size_t oldIndex, const size_t newIndex);
 
  bool InsertAtIndex(const gd::Variable& variable, const size_t index);
 
  bool InsertChild(const gd::String& name, const gd::Variable& variable);
 
  const std::vector<std::shared_ptr<Variable>>& GetAllChildrenArray() const {
    return childrenArray;
  }
 
  void SetFolded(bool fold = true) { folded = fold; }
 
  bool IsFolded() const { return folded; }
 
 
 
  void SerializeTo(SerializerElement& element) const;
 
  void UnserializeFrom(const SerializerElement& element);
 
  Variable& ResetPersistentUuid();
 
  Variable& ClearPersistentUuid();
 
  const gd::String& GetPersistentUuid() const { return persistentUuid; };
 
 private:
  static gd::String TypeAsString(Type t);
 
  static Type StringAsType(const gd::String& str);
 
  bool folded = false;
  mutable Type type;
  mutable gd::String str;
  mutable double value;
  mutable bool boolVal = false;
  mutable bool hasMixedValues;
  mutable std::map<gd::String, std::shared_ptr<Variable>>
      children;  
  mutable std::vector<std::shared_ptr<Variable>>
      childrenArray;  
  mutable gd::String persistentUuid;  
 
  void CopyChildren(const Variable& other);
};
 
}  // namespace gd