PropertyDescriptor.h

/*
 * GDevelop Core
 * Copyright 2008-present Florian Rival ([email protected]). All rights
 * reserved. This project is released under the MIT License.
 */
#ifndef GDCORE_PROPERTYDESCRIPTOR
#define GDCORE_PROPERTYDESCRIPTOR
#include <vector>
 
#include "GDCore/String.h"
#include "GDCore/Project/MeasurementUnit.h"
 
namespace gd {
class SerializerElement;
}
 
namespace gd {
 
class GD_CORE_API PropertyDescriptor {
 public:
  PropertyDescriptor(gd::String propertyValue)
      : currentValue(propertyValue), type("string"), label(""), hidden(false),
        deprecated(false), advanced(false),
        measurementUnit(gd::MeasurementUnit::GetUndefined()) {}
 
  PropertyDescriptor()
      : hidden(false), deprecated(false), advanced(false),
        measurementUnit(gd::MeasurementUnit::GetUndefined()){};
 
  virtual ~PropertyDescriptor();
 
  PropertyDescriptor& SetValue(gd::String value) {
    currentValue = value;
    return *this;
  }
 
  PropertyDescriptor& SetType(gd::String type_) {
    type = type_;
    return *this;
  }
 
  PropertyDescriptor& SetLabel(gd::String label_) {
    label = label_;
    return *this;
  }
 
  PropertyDescriptor& SetDescription(gd::String description_) {
    description = description_;
    return *this;
  }
 
  PropertyDescriptor& SetGroup(gd::String group_) {
    group = group_;
    return *this;
  }
 
  PropertyDescriptor& SetExtraInfo(const std::vector<gd::String>& info) {
    extraInformation = info;
    return *this;
  }
 
  PropertyDescriptor& AddExtraInfo(const gd::String& info) {
    extraInformation.push_back(info);
    return *this;
  }
  
  PropertyDescriptor& SetMeasurementUnit(const gd::MeasurementUnit &measurementUnit_) {
    measurementUnit = measurementUnit_;
    return *this;
  }
 
  const gd::String& GetValue() const { return currentValue; }
  const gd::String& GetType() const { return type; }
  const gd::String& GetLabel() const { return label; }
  const gd::String& GetDescription() const { return description; }
  const gd::String& GetGroup() const { return group; }
  const gd::MeasurementUnit& GetMeasurementUnit() const { return measurementUnit; }
 
  const std::vector<gd::String>& GetExtraInfo() const {
    return extraInformation;
  }
  
  std::vector<gd::String>& GetExtraInfo() {
    return extraInformation;
  }
 
  PropertyDescriptor& SetHidden(bool enable = true) {
    hidden = enable;
    return *this;
  }
 
  bool IsHidden() const { return hidden; }
 
  PropertyDescriptor& SetDeprecated(bool enable = true) {
    deprecated = enable;
    return *this;
  }
 
  bool IsDeprecated() const { return deprecated; }
 
  PropertyDescriptor& SetAdvanced(bool enable = true) {
    advanced = enable;
    return *this;
  }
 
  bool IsAdvanced() const { return advanced; }
 
 
  virtual void SerializeTo(SerializerElement& element) const;
 
  virtual void UnserializeFrom(const SerializerElement& element);
 
  virtual void SerializeValuesTo(SerializerElement& element) const;
 
  virtual void UnserializeValuesFrom(const SerializerElement& element);
 
 private:
  gd::String currentValue;  
  gd::String
      type;  
  gd::String label;        //< The user-friendly property name
  gd::String description;  //< The user-friendly property description
  gd::String group;        //< The user-friendly property group
  std::vector<gd::String>
      extraInformation;  
  bool hidden;
  bool deprecated;
  bool advanced;
  gd::MeasurementUnit measurementUnit; //< The unit of measurement of the property vale.
};
 
}  // namespace gd
 
#endif