ValueTypeMetadata.h

/*
 * GDevelop Core
 * Copyright 2008-2016 Florian Rival ([email protected]). All rights
 * reserved. This project is released under the MIT License.
 */
 
#ifndef VALUE_TYPE_METADATA_H
#define VALUE_TYPE_METADATA_H
#include <map>
#include <memory>
 
#include "GDCore/String.h"
namespace gd {
class SerializerElement;
}  // namespace gd
 
namespace gd {
 
class GD_CORE_API ValueTypeMetadata {
 public:
  ValueTypeMetadata();
  virtual ~ValueTypeMetadata(){};
 
  const gd::String &GetName() const { return name; }
 
  ValueTypeMetadata &SetName(const gd::String &name_) {
    name = name_;
    return *this;
  }
 
  const gd::String &GetExtraInfo() const { return supplementaryInformation; }
 
  ValueTypeMetadata &SetExtraInfo(const gd::String &supplementaryInformation_) {
    supplementaryInformation = supplementaryInformation_;
    return *this;
  }
 
  bool IsOptional() const { return optional; }
 
  ValueTypeMetadata &SetOptional(bool optional_ = true) {
    optional = optional_;
    return *this;
  }
 
  const gd::String &GetDefaultValue() const { return defaultValue; }
 
  ValueTypeMetadata &SetDefaultValue(const gd::String &defaultValue_) {
    defaultValue = defaultValue_;
    return *this;
  }
 
  bool IsDefined() const {
    return !name.empty();
  }
 
  bool IsObject() const {
    return gd::ValueTypeMetadata::IsTypeObject(name);
  }
 
  bool IsBehavior() const {
    return gd::ValueTypeMetadata::IsTypeBehavior(name);
  }
 
  bool IsNumber() const {
    return gd::ValueTypeMetadata::IsTypeValue("number", name);
  }
 
  bool IsString() const {
    return gd::ValueTypeMetadata::IsTypeValue("string", name);
  }
 
  bool IsBoolean() const {
    return gd::ValueTypeMetadata::IsTypeValue("boolean", name);
  }
 
  bool IsVariable() const {
    return gd::ValueTypeMetadata::IsVariable(name);
  }
 
  static bool IsVariable(const gd::String &type) {
    return gd::ValueTypeMetadata::GetPrimitiveValueType(type) == "variable";
  }
 
  bool IsVariableOnly() const {
      return
          // Any variable.
          name == "variable" ||
          // Old, "pre-scoped" variables:
          name == "objectvar" || name == "globalvar" ||
          name == "scenevar";
  }
 
  bool IsLegacyPreScopedVariable() const {
    return gd::ValueTypeMetadata::IsTypeLegacyPreScopedVariable(name);
  }
 
  static bool IsTypeLegacyPreScopedVariable(const gd::String &type) {
    return type == "scenevar" || type == "globalvar" || type == "objectvar";
  }
 
  static bool IsTypeObject(const gd::String &parameterType) {
    return parameterType == "object" || parameterType == "objectPtr" ||
           parameterType == "objectList" ||
           parameterType == "objectListOrEmptyIfJustDeclared" ||
           parameterType == "objectListOrEmptyWithoutPicking";
  }
 
  static bool IsTypeBehavior(const gd::String &parameterType) {
    return parameterType == "behavior";
  }
 
  bool IsResource() const {
    return gd::ValueTypeMetadata::IsTypeValue("resource", name);
  }
 
  static bool IsTypeExpression(const gd::String &type,
                           const gd::String &parameterType) {
    if (type == "number") {
      return parameterType == "number" || parameterType == "expression" ||
             parameterType == "camera" || parameterType == "forceMultiplier";
    } else if (type == "string") {
      // "key" and "mouse" are not mapped her, see GetPrimitiveValueType.
      return parameterType == "string" || parameterType == "layer" ||
             parameterType == "color" || parameterType == "file" ||
             parameterType == "stringWithSelector" ||
             parameterType == "sceneName" ||
             parameterType == "layerEffectName" ||
             parameterType == "layerEffectParameterName" ||
             parameterType == "objectEffectName" ||
             parameterType == "objectEffectParameterName" ||
             parameterType == "objectPointName" ||
             parameterType == "objectAnimationName" ||
             parameterType == "functionParameterName" ||
             parameterType == "externalLayoutName" ||
             parameterType == "leaderboardId" ||
             parameterType == "keyboardKey" ||
             parameterType == "mouseButton" ||
             parameterType == "identifier";
    } else if (type == "boolean") {
      return parameterType == "yesorno" || parameterType == "trueorfalse";
    } else if (type == "variable") {
      return
          // Any variable.
          parameterType == "variable" ||
          parameterType == "variableOrProperty" ||
          parameterType == "variableOrPropertyOrParameter" ||
          // Old, "pre-scoped" variables:
          parameterType == "objectvar" || parameterType == "globalvar" ||
          parameterType == "scenevar";
    } else if (type == "resource") {
      return parameterType == "fontResource" ||
             parameterType == "audioResource" ||
             parameterType == "videoResource" ||
             parameterType == "bitmapFontResource" ||
             parameterType == "imageResource" ||
             parameterType == "jsonResource" ||
             parameterType == "tilemapResource" ||
             parameterType == "tilesetResource" ||
             parameterType == "model3DResource" ||
             parameterType == "atlasResource" ||
             parameterType == "spineResource" ||
             // Deprecated, old parameter types:
             parameterType == "soundfile" ||
             parameterType == "musicfile" ||
             parameterType == "password";
    }
    return false;
  }
 
  static bool IsTypeValue(const gd::String &type,
                           const gd::String &parameterType) {
    if (gd::ValueTypeMetadata::IsTypeExpression(type, parameterType)) {
      return true;
    }
    // These 2 parameter types are not strings from the outside of a function as
    // the generator add quote around a text, but from the events inside of the
    // function the parameter is a string.
    //
    // See EventsCodeGenerator::GenerateParameterCodes
    if (type == "string") {
      return parameterType == "key" || parameterType == "mouse";
    }
    return false;
  }
 
  static const gd::String &GetExpressionPrimitiveValueType(const gd::String &parameterType);
 
  static const gd::String &GetPrimitiveValueType(const gd::String &parameterType);
  static const gd::String numberType;
  static const gd::String stringType;
  static const gd::String variableType;
  static const gd::String booleanType;
 
  static const gd::String &ConvertPropertyTypeToValueType(const gd::String &propertyType);
 
  static const gd::String &GetResourceType(const gd::String &parameterType);
 
 
  void SerializeTo(gd::SerializerElement &element) const;
 
  void UnserializeFrom(const gd::SerializerElement &element);
 
 private:
  gd::String name;                      
  gd::String supplementaryInformation;  
  bool optional;                        
  gd::String defaultValue;     
 
  static const gd::String numberValueType;
  static const gd::String booleanValueType;
  static const gd::String stringValueType;
  static const gd::String colorValueType;
  static const gd::String choiceValueType;
  static const gd::String behaviorValueType;
  static const gd::String leaderboardIdValueType;
  static const gd::String objectAnimationNameValueType;
  static const gd::String keyboardKeyValueType;
};
 
}  // namespace gd
 
#endif  // VALUE_TYPE_METADATA_H