Dev ivalue for cpp api

oneflow/api/cpp/framework.h

@@ -21,5 +21,6 @@ limitations under the License.
 #include "framework/shape.h"
 #include "framework/dtype.h"
 #include "framework/tensor.h"
+#include "framework/ivalue.h"
 
-#endif  // !ONEFLOW_API_CPP_FRAMEWORK_H_
+#endif  // ONEFLOW_API_CPP_FRAMEWORK_H_

oneflow/api/cpp/framework/dtype.h

@@ -40,4 +40,4 @@ enum class DType {
 
 }  // namespace oneflow_api
 
-#endif  // !ONEFLOW_API_CPP_FRAMEWORK_DTYPE_H_
+#endif  // ONEFLOW_API_CPP_FRAMEWORK_DTYPE_H_

oneflow/api/cpp/framework/ivalue.cpp

@@ -0,0 +1,65 @@
+/*
+Copyright 2020 The OneFlow Authors. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+#include "oneflow/api/cpp/framework/ivalue.h"
+#include <glog/logging.h>
+
+namespace oneflow_api {
+
+namespace of = oneflow;
+
+std::ostream& operator<<(std::ostream& os, const IValue::Tag& tag) {
+  os << static_cast<int>(tag);
+  return os;
+}
+
+bool IValue::IsNone() { return tag_ == Tag::kNone; }
+
+bool IValue::IsInt() { return tag_ == Tag::kInt; }
+
+bool IValue::IsDouble() { return tag_ == Tag::kDouble; }
+
+bool IValue::IsBool() { return tag_ == Tag::kBool; }
+
+bool IValue::IsTensor() { return tag_ == Tag::kTensor; }
+
+bool IValue::IsTensorVector() { return tag_ == Tag::kTensorVector; }
+
+const int64_t IValue::ToInt() const {
+  CHECK_EQ(tag_, Tag::kInt) << "Current value is not int.";
+  return payload_.i.v_int;
+}
+
+const double IValue::ToDouble() const {
+  CHECK_EQ(tag_, Tag::kDouble) << "Current value is not double.";
+  return payload_.i.v_double;
+}
+
+const bool IValue::ToBool() const {
+  CHECK_EQ(tag_, Tag::kBool) << "Current value is not bool.";
+  return payload_.i.v_bool;
+}
+
+const Tensor& IValue::ToTensor() const {
+  CHECK_EQ(tag_, Tag::kTensor) << "Current value is not tensor.";
+  return payload_.v_tensor;
+}
+
+const std::vector<Tensor>& IValue::ToTensorVector() const {
+  CHECK_EQ(tag_, Tag::kTensorVector) << "Current value is not vector of tensor.";
+  return payload_.v_tensor_vector;
+}
+
+}  // namespace oneflow_api

oneflow/api/cpp/framework/ivalue.h

@@ -0,0 +1,144 @@
+/*
+Copyright 2020 The OneFlow Authors. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+#ifndef ONEFLOW_API_CPP_FRAMEWORK_IVALUE_H_
+#define ONEFLOW_API_CPP_FRAMEWORK_IVALUE_H_
+
+#include <cstdint>
+#include <memory>
+#include <vector>
+#include "tensor.h"
+
+namespace oneflow_api {
+
+class IValue {
+ public:
+  IValue() : tag_(IValue::Tag::kNone) {}
+  explicit IValue(int value) : tag_(IValue::Tag::kInt) { payload_.i.v_int = value; }
+
+  explicit IValue(int64_t value) : tag_(IValue::Tag::kInt) { payload_.i.v_int = value; }
+
+  explicit IValue(double value) : tag_(IValue::Tag::kDouble) { payload_.i.v_double = value; }
+
+  explicit IValue(bool value) : tag_(IValue::Tag::kBool) { payload_.i.v_bool = value; }
+
+  explicit IValue(const Tensor& value) : tag_(IValue::Tag::kTensor) {
+    new (&payload_.v_tensor) Tensor(value);
+  }
+
+  explicit IValue(Tensor&& value) : tag_(IValue::Tag::kTensor) {
+    new (&payload_.v_tensor) Tensor(std::move(value));
+  }
+
+  explicit IValue(const std::vector<Tensor>& value) : tag_(IValue::Tag::kTensorVector) {
+    new (&payload_.v_tensor_vector) std::vector<Tensor>(value);
+  }
+
+  explicit IValue(std::vector<Tensor>&& value) : tag_(IValue::Tag::kTensorVector) {
+    new (&payload_.v_tensor_vector) std::vector<Tensor>(std::move(value));
+  }
+
+  IValue(const IValue& value) : tag_(value.tag_) {
+    if (IsTensor()) {
+      new (&payload_.v_tensor) Tensor(value.payload_.v_tensor);
+    } else if (IsTensorVector()) {
+      new (&payload_.v_tensor_vector) std::vector<Tensor>(value.payload_.v_tensor_vector);
+    } else {
+      payload_.i = value.payload_.i;
+    }
+  }
+
+  IValue(IValue&& value) noexcept : tag_(value.tag_) { MoveFrom(std::move(value)); }
+
+  IValue& operator=(const IValue& value) {
+    if (&value == this) { return *this; }
+    this->tag_ = value.tag_;
+    *this = IValue(value);
+    return *this;
+  }
+
+  IValue& operator=(IValue&& value) noexcept {
+    if (&value == this) { return *this; }
+    Destory();
+    this->tag_ = value.tag_;
+    MoveFrom(std::move(value));
+    return *this;
+  }
+
+  ~IValue() { Destory(); }
+
+  bool IsNone();
+  bool IsInt();
+  bool IsDouble();
+  bool IsBool();
+  bool IsTensor();
+  bool IsTensorVector();
+
+  const int64_t ToInt() const;
+  const double ToDouble() const;
+  const bool ToBool() const;
+  const Tensor& ToTensor() const;
+  const std::vector<Tensor>& ToTensorVector() const;
+
+ private:
+  enum class Tag { kNone = 0, kInt = 1, kDouble = 2, kBool = 3, kTensor = 4, kTensorVector = 5 };
+  friend std::ostream& operator<<(std::ostream&, const Tag&);
+
+  union Payload {  // NOLINT
+    union InternalPayload {
+      InternalPayload() : v_int(0) {}
+
+      int64_t v_int;
+      double v_double;
+      bool v_bool;
+    } i;
+
+    Tensor v_tensor;
+    std::vector<Tensor> v_tensor_vector;
+
+    Payload() : i() {}
+    ~Payload() {}
+  };
+
+  Payload payload_;
+  Tag tag_;
+
+  inline void Destory() {
+    if (IsTensor()) { payload_.v_tensor.~Tensor(); }
+    if (IsTensorVector()) { payload_.v_tensor_vector.~vector(); }
+  }
+
+  inline void MoveFrom(IValue&& value) {
+    if (IsTensor()) {
+      new (&payload_.v_tensor) Tensor(std::move(value.payload_.v_tensor));
+    } else if (IsTensorVector()) {
+      new (&payload_.v_tensor_vector)
+          std::vector<Tensor>(std::move(value.payload_.v_tensor_vector));
+    } else {
+      payload_.i = value.payload_.i;
+    }
+    value.ClearToNone();
+  }
+
+  inline void ClearToNone() {
+    Destory();
+    payload_.i.v_int = 0;
+    tag_ = Tag::kNone;
+  }
+};
+
+}  // namespace oneflow_api
+
+#endif  // ONEFLOW_API_CPP_FRAMEWORK_IVALUE_H_

oneflow/api/cpp/framework/shape.cpp

@@ -60,4 +60,9 @@ int64_t Shape::Count(int64_t begin_axis, int64_t end_axis) const {
 
 int64_t Shape::Count(int64_t begin_axis) const { return shape_->Count(begin_axis); }
 
+std::ostream& operator<<(std::ostream& os, const Shape& shape) {
+  os << shape.shape_->DebugStr();
+  return os;
+}
+
 }  // namespace oneflow_api

oneflow/api/cpp/framework/shape.h

@@ -50,7 +50,9 @@ class Shape final {
 
  private:
   std::shared_ptr<oneflow::Shape> shape_ = nullptr;
+
+  friend std::ostream& operator<<(std::ostream&, const Shape&);
 };
 }  // namespace oneflow_api
 
-#endif  // !ONEFLOW_API_CPP_FRAMEWORK_SHAPE_H_
+#endif  // ONEFLOW_API_CPP_FRAMEWORK_SHAPE_H_

oneflow/api/cpp/framework/tensor.cpp

@@ -14,7 +14,6 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 #include "oneflow/api/cpp/framework/tensor.h"
-#include <memory>
 #include "oneflow/api/cpp/framework/device.h"
 #include "oneflow/api/cpp/framework/dtype.h"
 #include "oneflow/api/cpp/framework/shape.h"
@@ -42,6 +41,22 @@ Tensor::Tensor(const Shape& shape, const Device& device, const DType& dtype) {
 }
 Tensor::Tensor(const std::shared_ptr<oneflow::one::Tensor>& tensor) : tensor_(tensor) {}
 
+Tensor::Tensor(const Tensor& tensor) : tensor_(tensor.tensor_) {}
+Tensor::Tensor(Tensor&& tensor) noexcept : tensor_(std::move(tensor.tensor_)) {}
+
+Tensor::~Tensor() {}
+
+Tensor& Tensor::operator=(const Tensor& tensor) {
+  tensor_.reset();
+  tensor_ = tensor.tensor_;
+  return *this;
+}
+Tensor& Tensor::operator=(Tensor&& tensor) noexcept {
+  tensor_.reset();
+  tensor_ = std::move(tensor.tensor_);
+  return *this;
+}
+
 const Shape Tensor::shape() const {
   const auto shape_ = tensor_->shape();
   return Shape(std::vector<int64_t>(shape_->dim_vec().begin(), shape_->dim_vec().end()));

oneflow/api/cpp/framework/tensor.h

@@ -37,6 +37,15 @@ class Tensor final {
   explicit Tensor(const Shape& shape = Shape(), const Device& device = Device("cpu"),
                   const DType& dtype = DType::kFloat);
   explicit Tensor(const std::shared_ptr<oneflow::one::Tensor>& tensor);
+
+  Tensor(const Tensor& tensor);
+  Tensor(Tensor&& tensor) noexcept;
+
+  ~Tensor();
+
+  Tensor& operator=(const Tensor& tensor);
+  Tensor& operator=(Tensor&& tensor) noexcept;
+
   [[nodiscard]] const Shape shape() const;
   [[nodiscard]] const Device device() const;
   [[nodiscard]] const DType dtype() const;
@@ -58,4 +67,4 @@ class Tensor final {
 
 }  // namespace oneflow_api
 
-#endif  // !ONEFLOW_API_CPP_FRAMEWORK_TENSOR_H_
+#endif  // ONEFLOW_API_CPP_FRAMEWORK_TENSOR_H_

oneflow/api/cpp/nn.h

@@ -19,4 +19,4 @@ limitations under the License.
 
 #include "nn/functional/activation.h"
 
-#endif  // !ONEFLOW_API_CPP_NN_H_
+#endif  // ONEFLOW_API_CPP_NN_H_

oneflow/api/cpp/nn/functional/activation.h

@@ -27,4 +27,4 @@ Tensor relu(const Tensor& tensor);
 
 }  // namespace oneflow_api
 
-#endif  // !ONEFLOW_API_CPP_NN_FUNCTIONAL_ACTIVATION_H_
+#endif  // ONEFLOW_API_CPP_NN_FUNCTIONAL_ACTIVATION_H_

oneflow/api/cpp/tests/api_test.cpp

@@ -15,7 +15,6 @@ limitations under the License.
 */
 
 #include "oneflow/api/cpp/tests/api_test.h"
-#include <cstdint>
 #include <random>
 
 namespace oneflow_api {