From 525fef708d9db5f6d0778f869405695243f87edf Mon Sep 17 00:00:00 2001
From: peter <peterghost86@gmail.com>
Date: Tue, 12 Mar 2019 01:53:42 -0700
Subject: [PATCH] Prevent VS2017 from emitting ambiguous symbol errors (second
 time)

Summary: Pull Request resolved: https://github.com/pytorch/pytorch/pull/17863

Differential Revision: D14404818

Pulled By: soumith

fbshipit-source-id: 9dac6b926e270e2a29ec2e4dba2e93984da0e5f5
---
 torch/csrc/api/include/torch/ordered_dict.h | 20 ++++++++++----------
 torch/csrc/jit/custom_operator.h            | 10 +++++-----
 2 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/torch/csrc/api/include/torch/ordered_dict.h b/torch/csrc/api/include/torch/ordered_dict.h
index 05bea8a..74d08d2 100644
--- a/torch/csrc/api/include/torch/ordered_dict.h
+++ b/torch/csrc/api/include/torch/ordered_dict.h
@@ -159,25 +159,25 @@ class OrderedDict {
 
   /// Returns a newly allocated vector and copies all keys from this
   /// `OrderedDict` into the vector.
-  std::vector<Key> keys() const;
+  ::std::vector<Key> keys() const;
 
   /// Returns a newly allocated vector and copies all values from this
   /// `OrderedDict` into the vector.
-  std::vector<Value> values() const;
+  ::std::vector<Value> values() const;
 
   /// Returns a newly allocated vector and copies all keys and values from this
   /// `OrderedDict` into a vector of `std::pair<Key, Value>`.
-  std::vector<std::pair<Key, Value>> pairs() const;
+  ::std::vector<std::pair<Key, Value>> pairs() const;
 
  private:
   /// A mapping from a key to an index into the `items_` vector.
-  std::unordered_map<Key, size_t> index_;
+  ::std::unordered_map<Key, size_t> index_;
 
   /// The items stored in the `OrderedDict`.
-  std::vector<Item> items_;
+  ::std::vector<Item> items_;
 
   /// A description of the keys stored in the `OrderedDict`.
-  std::string key_description_{"Key"};
+  ::std::string key_description_{"Key"};
 };
 
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ OrderedDict::Item ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -231,7 +231,7 @@ class OrderedDict<Key, Value>::Item {
  private:
   /// This is stored as an std::pair because it will make Python binding a lot,
   /// lot easier.
-  std::pair<const Key, Value> pair_;
+  ::std::pair<const Key, Value> pair_;
 };
 
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ OrderedDict ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -438,7 +438,7 @@ const std::vector<typename OrderedDict<Key, Value>::Item>& OrderedDict<
 }
 
 template <typename Key, typename Value>
-std::vector<Key> OrderedDict<Key, Value>::keys() const {
+::std::vector<Key> OrderedDict<Key, Value>::keys() const {
   std::vector<Key> keys;
   keys.reserve(size());
   for (const auto& item : items_) {
@@ -448,7 +448,7 @@ std::vector<Key> OrderedDict<Key, Value>::keys() const {
 }
 
 template <typename Key, typename Value>
-std::vector<Value> OrderedDict<Key, Value>::values() const {
+::std::vector<Value> OrderedDict<Key, Value>::values() const {
   std::vector<Value> values;
   values.reserve(size());
   for (const auto& item : items_) {
@@ -458,7 +458,7 @@ std::vector<Value> OrderedDict<Key, Value>::values() const {
 }
 
 template <typename Key, typename Value>
-std::vector<std::pair<Key, Value>> OrderedDict<Key, Value>::pairs() const {
+::std::vector<std::pair<Key, Value>> OrderedDict<Key, Value>::pairs() const {
   std::vector<std::pair<Key, Value>> values;
   values.reserve(size());
   for (const auto& item : items_) {
diff --git a/torch/csrc/jit/custom_operator.h b/torch/csrc/jit/custom_operator.h
index e787dc8..b7958b3 100644
--- a/torch/csrc/jit/custom_operator.h
+++ b/torch/csrc/jit/custom_operator.h
@@ -36,28 +36,28 @@ void checkStaticTypes() {
 }
 
 template <typename... Ts, size_t... Is>
-std::vector<Argument> createArgumentVectorFromTypes(Indices<Is...> indices) {
+::std::vector<Argument> createArgumentVectorFromTypes(Indices<Is...> indices) {
   checkStaticTypes<decay_t<Ts>...>();
   // Arguments are named "_<index>"
   return {Argument("_" + std::to_string(Is), getTypePtr<decay_t<Ts>>())...};
 }
 
 template <typename... Ts, size_t... Is>
-std::vector<Argument> createReturns(Indices<Is...> indices) {
+::std::vector<Argument> createReturns(Indices<Is...> indices) {
   return createArgumentVectorFromTypes<Ts..., Is...>();
 }
 
 /// Unpack a tuple return type into a vector of return types, one per tuple
 /// element.
 template <typename... Ts>
-std::vector<Argument> createReturns(std::tuple<Ts...>* tuple) {
+::std::vector<Argument> createReturns(std::tuple<Ts...>* tuple) {
   // Create an index pack so we can call `get<Indices>` on the tuple next.
   return createReturns<Ts...>(typename MakeIndices<sizeof...(Ts)>::indices{});
 }
 
 /// Create a single-element `vector` for simple (non-tuple) return types.
 template <typename ReturnType>
-std::vector<Argument> createReturns(ReturnType*) {
+::std::vector<Argument> createReturns(ReturnType*) {
   checkStaticTypes<decay_t<ReturnType>>();
   return {Argument("_1", getTypePtr<decay_t<ReturnType>>())};
 }
@@ -65,7 +65,7 @@ std::vector<Argument> createReturns(ReturnType*) {
 /// Creates a vector of `Argument` from `FunctionTraits` and a pack of indices
 /// into the argument list.
 template <typename FunctionTraits, size_t... Is>
-std::vector<Argument> createArgumentVectorFromTraits(Indices<Is...> indices) {
+::std::vector<Argument> createArgumentVectorFromTraits(Indices<Is...> indices) {
   using ArgumentTypes = typename FunctionTraits::parameter_types;
   return createArgumentVectorFromTypes<
       c10::guts::typelist::element_t<Is, ArgumentTypes>...>(indices);
-- 
2.7.4