Add variable.h and test

paddle/framework/CMakeLists.txt

@@ -2,3 +2,5 @@ cc_library(ddim SRCS ddim.cc)
 cc_test(ddim_test SRCS ddim_test.cc DEPS ddim)
 
 nv_test(dim_test SRCS dim_test.cu DEPS ddim)
+
+cc_test(variable_test SRCS variable_test.cc)

paddle/framework/ddim_test.cc

@@ -1,5 +1,3 @@
-//#include <stdexcept>
-//#include <unittest/unittest.h>
 #include <sstream>
 #include <vector>
 

paddle/framework/variable.h

@@ -0,0 +1,88 @@
+/*
+  Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve.
+  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.
+*/
+#pragma once
+
+#include <typeinfo>
+
+namespace paddle {
+namespace framework {
+
+class Variable {
+ public:
+  template <typename T>
+  const T& Get() const {
+    return *static_cast<const T*>(holder_->Ptr());
+  }
+
+  template <typename T>
+  T* GetMutable() {
+    if (holder_ != nullptr && typeid(T) == holder_->Type()) {
+      return static_cast<T*>(holder_->Ptr());
+    } else {
+      return Reset<T>(new T(), DefaultDeleter<T>());
+    }
+  }
+
+  ~Variable() {
+    if (holder_ != nullptr) delete holder_;
+  }
+
+ private:
+  // DefaultDeleter is functor which uses C++'s delete(T*).
+  template <typename T>
+  struct DefaultDeleter {
+    void operator()(T* ptr) { delete ptr; }
+  };
+
+  struct Placeholder {
+    virtual ~Placeholder() {}
+    virtual const std::type_info& Type() const = 0;
+    virtual void* Ptr() const = 0;
+  };
+
+  // Placeholder hides type T, so it doesn't appear as a template
+  // parameter of Variable.
+  template <typename T>
+  struct PlaceholderImpl : public Placeholder {
+    typedef std::function<void(T*)> Deleter;
+
+    PlaceholderImpl(T* ptr) : ptr_(ptr), type_(typeid(T)) {}
+    PlaceholderImpl(T* ptr, Deleter d)
+        : ptr_(ptr), type_(typeid(T)), deleter_(d) {}
+
+    virtual ~PlaceholderImpl() {
+      deleter_(ptr_);
+      ptr_ = nullptr;
+    }
+    virtual const std::type_info& Type() const { return type_; }
+    virtual void* Ptr() const { return ptr_; }
+
+    T* ptr_ = nullptr;
+    const std::type_info& type_;
+    std::function<void(T*)> deleter_ = DefaultDeleter<T>();
+  };
+
+  template <typename T>
+  T* Reset(T* allocated, typename PlaceholderImpl<T>::Deleter deleter) {
+    if (holder_ != nullptr) {
+      delete holder_;
+    }
+    holder_ = new PlaceholderImpl<T>(allocated, deleter);
+    return allocated;
+  }
+
+  Placeholder* holder_;  // pointers to a PlaceholderImpl object indeed.
+};
+
+}  // namespace framework
+}  // namespace paddle

paddle/framework/variable_test.cc

@@ -0,0 +1,40 @@
+/*
+  Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve.
+  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 <memory>
+#include <string>
+
+#include "gtest/gtest.h"
+#include "paddle/framework/variable.h"
+
+TEST(Variable, GetMutable) {
+  using paddle::framework::Variable;
+
+  struct Tensor {
+    int content_;
+  };
+
+  std::unique_ptr<Variable> v(new Variable());
+
+  Tensor* t = v->GetMutable<Tensor>();
+  t->content_ = 1234;
+
+  const Tensor& tt = v->Get<Tensor>();
+  EXPECT_EQ(1234, tt.content_);
+
+  std::string* s = v->GetMutable<std::string>();
+  *s = "hello";
+
+  const std::string& ss = v->Get<std::string>();
+  EXPECT_EQ("hello", ss);
+}