Revert "Remove support for MSVC"

sky/engine/wtf/Vector.h

 /*
  *  Copyright (C) 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Library General Public
  *  License as published by the Free Software Foundation; either
  *  version 2 of the License, or (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 595 matching lines @@
         }
 
         Vector(const Vector&);
         template<size_t otherCapacity>
         explicit Vector(const Vector<T, otherCapacity, Allocator>&);
 
         Vector& operator=(const Vector&);
         template<size_t otherCapacity>
         Vector& operator=(const Vector<T, otherCapacity, Allocator>&);
 
+#if COMPILER_SUPPORTS(CXX_RVALUE_REFERENCES)
         Vector(Vector&&);
         Vector& operator=(Vector&&);
+#endif
 
         size_t size() const { return m_size; }
         size_t capacity() const { return Base::capacity(); }
         bool isEmpty() const { return !size(); }
 
         T& at(size_t i)
         {
             RELEASE_ASSERT(i < size());
             return Base::buffer()[i];
         }
@@ skipping 159 matching lines @@
             ASSERT(begin());
         }
 
         std::copy(other.begin(), other.begin() + size(), begin());
         TypeOperations::uninitializedCopy(other.begin() + size(), other.end(), end());
         m_size = other.size();
 
         return *this;
     }
 
+#if COMPILER_SUPPORTS(CXX_RVALUE_REFERENCES)
     template<typename T, size_t inlineCapacity, typename Allocator>
     Vector<T, inlineCapacity, Allocator>::Vector(Vector<T, inlineCapacity, Allocator>&& other)
     {
         m_size = 0;
         // It's a little weird to implement a move constructor using swap but this way we
         // don't have to add a move constructor to VectorBuffer.
         swap(other);
     }
 
     template<typename T, size_t inlineCapacity, typename Allocator>
     Vector<T, inlineCapacity, Allocator>& Vector<T, inlineCapacity, Allocator>::operator=(Vector<T, inlineCapacity, Allocator>&& other)
     {
         swap(other);
         return *this;
     }
+#endif
 
     template<typename T, size_t inlineCapacity, typename Allocator>
     template<typename U>
     bool Vector<T, inlineCapacity, Allocator>::contains(const U& value) const
     {
         return find(value) != kNotFound;
     }
 
     template<typename T, size_t inlineCapacity, typename Allocator>
     template<typename U>
@@ skipping 369 matching lines @@
     struct NeedsTracing<Vector<T, N> > {
         static const bool value = false;
     };
 #endif
 
 } // namespace WTF
 
 using WTF::Vector;
 
 #endif // WTF_Vector_h