Instruction.h

/*
 * GDevelop Core
 * Copyright 2008-2016 Florian Rival ([email protected]). All rights
 * reserved. This project is released under the MIT License.
 */
#ifndef INSTRUCTION_H
#define INSTRUCTION_H
#include <memory>
#include <vector>
 
#include "GDCore/Events/Expression.h"
#include "GDCore/Events/InstructionsList.h"
#include "GDCore/String.h"
 
namespace gd {
 
class GD_CORE_API Instruction {
 public:
  Instruction(gd::String type_ = "");
 
  Instruction(gd::String type_,
              const std::vector<gd::Expression>& parameters_,
              bool inverted = false);
 
  virtual ~Instruction(){};
 
  const gd::String& GetType() const { return type; }
 
  void SetType(const gd::String& newType) { type = newType; }
 
  bool IsInverted() const { return inverted; }
 
  void SetInverted(bool inverted_) { inverted = inverted_; }
 
  bool IsAwaited() const { return awaitAsync; }
 
  void SetAwaited(bool awaited) { awaitAsync = awaited; }
 
  std::size_t GetParametersCount() const { return parameters.size(); }
 
  void SetParametersCount(std::size_t size);
 
  const gd::Expression& GetParameter(std::size_t index) const;
 
  gd::Expression& GetParameter(std::size_t index);
 
  void SetParameter(std::size_t nb, const gd::Expression& val);
 
  void AddParameter(const gd::Expression& val);
 
  inline const std::vector<gd::Expression>& GetParameters() const {
    return parameters;
  }
 
  inline void SetParameters(const std::vector<gd::Expression>& val) {
    parameters = val;
  }
 
  inline const gd::InstructionsList& GetSubInstructions() const {
    return subInstructions;
  };
 
  inline gd::InstructionsList& GetSubInstructions() { return subInstructions; };
 
  std::weak_ptr<Instruction> GetOriginalInstruction() {
    return originalInstruction;
  };
 
  friend std::shared_ptr<Instruction> CloneRememberingOriginalElement(
      std::shared_ptr<Instruction> instruction);
 
 private:
  gd::String type;  
  bool inverted;  
  bool awaitAsync =
      false;  
  mutable std::vector<gd::Expression>
      parameters;                        
  gd::InstructionsList subInstructions;  
 
  std::weak_ptr<Instruction>
      originalInstruction;  
 
  static gd::Expression badExpression;
};
 
std::shared_ptr<Instruction> GD_CORE_API
CloneRememberingOriginalElement(std::shared_ptr<Instruction> instruction);
 
}  // namespace gd
 
#endif  // INSTRUCTION_H