Program Listing for File abstract.h

↰ Return to documentation for file (include/converter/include/mindapi/ir/abstract.h)

#ifndef MINDSPORE_CORE_MINDAPI_IR_ABSTRACT_H_
#define MINDSPORE_CORE_MINDAPI_IR_ABSTRACT_H_

#include <cstdint>
#include <string>
#include "mindapi/base/base.h"
#include "mindapi/ir/common.h"
#include "mindapi/ir/shape.h"
#include "mindapi/ir/type.h"
#include "mindapi/ir/value.h"

namespace mindspore::api {
class MIND_API AbstractBase : public Base {
 public:
  MIND_API_BASE_MEMBER(AbstractBase);

  AbstractBasePtr Clone() const;

  TypePtr type() const;

  ValuePtr value() const;

  ShapePtr shape() const;

  void set_type(const TypePtr &type);

  void set_value(const ValuePtr &value);

  void set_shape(const ShapePtr &shape);
};

class MIND_API AbstractScalar : public AbstractBase {
 public:
  MIND_API_BASE_MEMBER(AbstractScalar);

  AbstractScalar(const ValuePtr &value, const TypePtr &type);

  explicit AbstractScalar(const TypePtr &type);

  explicit AbstractScalar(const ValuePtr &value);

  explicit AbstractScalar(int64_t value);

  explicit AbstractScalar(float value);

  explicit AbstractScalar(bool value);

  explicit AbstractScalar(const std::string &value);
};

using AbstractScalarPtr = SharedPtr<AbstractScalar>;

class MIND_API AbstractTensor : public AbstractBase {
 public:
  MIND_API_BASE_MEMBER(AbstractTensor);

  AbstractTensor(TypeId type, const ShapeVector &shape);

  AbstractBasePtr element() const;
};

using AbstractTensorPtr = SharedPtr<AbstractTensor>;

class MIND_API AbstractSequence : public AbstractBase {
 public:
  MIND_API_BASE_MEMBER(AbstractSequence);

  AbstractBasePtrList elements() const;
};

using AbstractSequencePtr = SharedPtr<AbstractSequence>;

class MIND_API AbstractTuple : public AbstractSequence {
 public:
  MIND_API_BASE_MEMBER(AbstractTuple);

  explicit AbstractTuple(const AbstractBasePtrList &elements);
};

using AbstractTuplePtr = SharedPtr<AbstractTuple>;
}  // namespace mindspore::api
#endif  // MINDSPORE_CORE_MINDAPI_IR_ABSTRACT_H_