modify code style

src/framework/operator.cpp

@@ -21,22 +21,22 @@ SOFTWARE.
 
 namespace paddle_mobile {
     namespace framework {
-      
-template <typename Dtype>
-OperatorBase<Dtype>::OperatorBase(const std::string &type,
-                                  const VariableNameMap &inputs,
-                                  const VariableNameMap &outputs,
-                                  const AttributeMap &attrs,
-                                  std::shared_ptr<Scope> scope)
-    : type_(type), inputs_(inputs), outputs_(outputs), attrs_(attrs),
-      scope_(scope) {
-  CheckAllInputOutputSet();
-}
-template <typename Dtype>
-void OperatorBase<Dtype>::CheckAllInputOutputSet() const {}
 
-template class OperatorBase<CPU>;
-template class OperatorWithKernel<CPU>;
+        template <typename Dtype>
+        OperatorBase<Dtype>::OperatorBase(const std::string &type,
+                                          const VariableNameMap &inputs,
+                                          const VariableNameMap &outputs,
+                                          const AttributeMap &attrs,
+                                          std::shared_ptr<Scope> scope)
+            : type_(type), inputs_(inputs), outputs_(outputs), attrs_(attrs),
+              scope_(scope) {
+            CheckAllInputOutputSet();
+        }
+        template <typename Dtype>
+        void OperatorBase<Dtype>::CheckAllInputOutputSet() const {}
+
+        template class OperatorBase<CPU>;
+        template class OperatorWithKernel<CPU>;
 
     } // namespace framework
 } // namespace paddle_mobile

src/framework/operator.h

@@ -22,32 +22,33 @@ SOFTWARE.
 #include "operators/kernel/pool_kernel.h"
 
 namespace paddle_mobile {
-namespace operators {
-
-using namespace framework;
-
-template <typename DeviceType, typename T>
-class ConvOp : public framework::OperatorWithKernel<DeviceType> {
-public:
-  ConvOp(const std::string &type, const VariableNameMap &inputs,
-         const VariableNameMap &outputs, const framework::AttributeMap &attrs,
-         std::shared_ptr<framework::Scope> scope)
-          : framework::OperatorWithKernel<DeviceType>(type, inputs, outputs, attrs,
-                                                      scope),
-            param_(inputs, outputs, attrs, *scope) {}
-
-  using framework::OperatorWithKernel<DeviceType>::OperatorWithKernel;
-  void InferShape() const override;
-
-  void Run() const {
-    operators::ConvKernel<DeviceType, T, ConvParam> kernel;
-    kernel.Compute(param_);
-    this->ClearVariables();
-  }
-
-private:
-  ConvParam param_;
-};
-
-} // operators
+    namespace operators {
+
+        using namespace framework;
+
+        template <typename DeviceType, typename T>
+        class ConvOp : public framework::OperatorWithKernel<DeviceType> {
+          public:
+            ConvOp(const std::string &type, const VariableNameMap &inputs,
+                   const VariableNameMap &outputs,
+                   const framework::AttributeMap &attrs,
+                   std::shared_ptr<framework::Scope> scope)
+                : framework::OperatorWithKernel<DeviceType>(
+                      type, inputs, outputs, attrs, scope),
+                  param_(inputs, outputs, attrs, *scope) {}
+
+            using framework::OperatorWithKernel<DeviceType>::OperatorWithKernel;
+            void InferShape() const override;
+
+            void Run() const {
+                operators::ConvKernel<DeviceType, T, ConvParam> kernel;
+                kernel.Compute(param_);
+                this->ClearVariables();
+            }
+
+          private:
+            ConvParam param_;
+        };
+
+    } // operators
 } // paddle_mobile

src/framework/variable.h

@@ -26,69 +26,71 @@ SOFTWARE.
 #include <typeinfo>
 
 namespace paddle_mobile {
-namespace framework {
-class Variable : public PaddleMobileObject {
-public:
-  template <typename T> const T *Get() const {
-    return static_cast<const T *>(holder_->Ptr());
-  }
-
-  bool IsInitialized() const { return holder_ != nullptr; }
-
-  const std::string *Name() { return name_; }
-
-  template <typename T> T *GetMutable() {
-    if (!IsType<T>()) {
-      if (*Name() == "pixel") {
-        //        std::cout << " reset " << *Name() << std::endl;
-      }
-      holder_.reset(new PlaceholderImp<T>(new T()));
-    }
-    return static_cast<T *>(holder_->Ptr());
-  }
-
-  template <typename T> bool IsType() const {
-    if (holder_) {
-      //                printf("not null \n");
-      printf(" holder type : %s, this type %s \n", holder_->Type().name(),
-             typeid(T).name());
-    }
-
-    //              std::cout << " " << holder_->Type() << " " <<  typeid(T) <<
-    //              std::endl;
-    return holder_ != nullptr && holder_->Type() == typeid(T);
-  }
-
-  void Clear() { holder_.reset(); }
-
-  std::type_index Type() const { return holder_->Type(); }
-
-  void SetName(const std::string *name) { name_ = name; }
-
-private:
-  struct Placeholder {
-    Placeholder() = default;
-    virtual ~Placeholder() = default;
-
-    virtual const std::type_info &Type() const = 0;
-    virtual void *Ptr() const = 0;
-  };
-
-  template <typename T> struct PlaceholderImp : public Placeholder {
-    explicit PlaceholderImp(T *ptr) : ptr_(ptr), type_(typeid(T)) {}
-
-    virtual const std::type_info &Type() const { return type_; }
-    virtual void *Ptr() const override {
-      return static_cast<void *>(ptr_.get());
-    }
-
-    std::unique_ptr<T> ptr_;
-    const std::type_info &type_;
-  };
-
-  std::unique_ptr<Placeholder> holder_;
-  friend class Scope;
-  const std::string *name_;
-};
-} // namespace framework
+    namespace framework {
+        class Variable : public PaddleMobileObject {
+          public:
+            template <typename T> const T *Get() const {
+                return static_cast<const T *>(holder_->Ptr());
+            }
+
+            bool IsInitialized() const { return holder_ != nullptr; }
+
+            const std::string *Name() { return name_; }
+
+            template <typename T> T *GetMutable() {
+                if (!IsType<T>()) {
+                    if (*Name() == "pixel") {
+                        //        std::cout << " reset " << *Name() <<
+                        //        std::endl;
+                    }
+                    holder_.reset(new PlaceholderImp<T>(new T()));
+                }
+                return static_cast<T *>(holder_->Ptr());
+            }
+
+            template <typename T> bool IsType() const {
+                if (holder_) {
+                    //                printf("not null \n");
+                    printf(" holder type : %s, this type %s \n",
+                           holder_->Type().name(), typeid(T).name());
+                }
+
+                //              std::cout << " " << holder_->Type() << " " <<
+                //              typeid(T) <<
+                //              std::endl;
+                return holder_ != nullptr && holder_->Type() == typeid(T);
+            }
+
+            void Clear() { holder_.reset(); }
+
+            std::type_index Type() const { return holder_->Type(); }
+
+            void SetName(const std::string *name) { name_ = name; }
+
+          private:
+            struct Placeholder {
+                Placeholder() = default;
+                virtual ~Placeholder() = default;
+
+                virtual const std::type_info &Type() const = 0;
+                virtual void *Ptr() const = 0;
+            };
+
+            template <typename T> struct PlaceholderImp : public Placeholder {
+                explicit PlaceholderImp(T *ptr) : ptr_(ptr), type_(typeid(T)) {}
+
+                virtual const std::type_info &Type() const { return type_; }
+                virtual void *Ptr() const override {
+                    return static_cast<void *>(ptr_.get());
+                }
+
+                std::unique_ptr<T> ptr_;
+                const std::type_info &type_;
+            };
+
+            std::unique_ptr<Placeholder> holder_;
+            friend class Scope;
+            const std::string *name_;
+        };
+    } // namespace framework
 } // namespace paddle_mobile

src/operators/conv_op.h

@@ -22,32 +22,33 @@ SOFTWARE.
 #include "operators/kernel/conv_kernel.h"
 
 namespace paddle_mobile {
-namespace operators {
-
-using namespace framework;
-
-template <typename DeviceType, typename T>
-class ConvOp : public framework::OperatorWithKernel<DeviceType> {
-public:
-  ConvOp(const std::string &type, const VariableNameMap &inputs,
-         const VariableNameMap &outputs, const framework::AttributeMap &attrs,
-         std::shared_ptr<framework::Scope> scope)
-      : framework::OperatorWithKernel<DeviceType>(type, inputs, outputs, attrs,
-                                                  scope),
-        param_(inputs, outputs, attrs, *scope) {}
-
-  using framework::OperatorWithKernel<DeviceType>::OperatorWithKernel;
-  void InferShape() const override;
-
-  void Run() const {
-    operators::ConvKernel<DeviceType, T, ConvParam> kernel;
-    kernel.Compute(param_);
-    this->ClearVariables();
-  }
-
-private:
-  ConvParam param_;
-};
-
-} // operators
+    namespace operators {
+
+        using namespace framework;
+
+        template <typename DeviceType, typename T>
+        class ConvOp : public framework::OperatorWithKernel<DeviceType> {
+          public:
+            ConvOp(const std::string &type, const VariableNameMap &inputs,
+                   const VariableNameMap &outputs,
+                   const framework::AttributeMap &attrs,
+                   std::shared_ptr<framework::Scope> scope)
+                : framework::OperatorWithKernel<DeviceType>(
+                      type, inputs, outputs, attrs, scope),
+                  param_(inputs, outputs, attrs, *scope) {}
+
+            using framework::OperatorWithKernel<DeviceType>::OperatorWithKernel;
+            void InferShape() const override;
+
+            void Run() const {
+                operators::ConvKernel<DeviceType, T, ConvParam> kernel;
+                kernel.Compute(param_);
+                this->ClearVariables();
+            }
+
+          private:
+            ConvParam param_;
+        };
+
+    } // operators
 } // paddle_mobile