Simplify namespace vec, define all tools except main class Vector in …

…amc::vec

src/include/amc_allocator.hpp

@@ -10,15 +10,16 @@
 #include "amc_type_traits.hpp"
 
 namespace amc {
+namespace alloc {
 
 /**
  * Adaptor that wraps a singleton class Alloc into a "basic" allocator.
  * Alloc is expected to model the "basic" allocator concept and to provide
  * a static instance() method to access singleton.
  *
  * A basic allocator is a class that provides methods:
- * void * allocate(size_t n)
- * void * reallocate(void *p, size_t oldSz, size_t newSz)
+ * void *allocate(size_t n)
+ * void *reallocate(void *p, size_t oldSz, size_t newSz)
  * void deallocate(void *p, size_t n)
  */
 template <typename Alloc>
@@ -161,6 +162,7 @@ struct SimpleAllocator {
 
   void deallocate(void *p, size_t) { free(p); }
 };
+}  // namespace alloc
 
 /**
  * Standard (STL conformant) allocator using std::allocator providing an extra 'reallocate' method.
@@ -169,5 +171,5 @@ struct SimpleAllocator {
  * otherwise it will simply allocate the new block and relocate all elements into it.
  */
 template <class T>
-using allocator = BasicAllocatorWrapper<T, SimpleAllocator>;
+using allocator = alloc::BasicAllocatorWrapper<T, alloc::SimpleAllocator>;
 }  // namespace amc

src/include/amc_smallvector.hpp

@@ -55,28 +55,27 @@ inline T *Reallocate(Alloc &alloc, T *p, SizeType oldCapa, SizeType newCapa, Siz
   alloc.deallocate(p, oldCapa);
   return newPtr;
 }
-}  // namespace vec
 
 template <class T, class Alloc, class SizeType>
 void SmallVectorBase<T, Alloc, SizeType>::grow(uintmax_t minSize, bool exact) {
   SizeType newCapa;
   if (isSmall()) {
     SizeType oldCapa = _size == std::numeric_limits<SizeType>::max() ? _capa : _size;
-    newCapa = vec::SafeNextCapacity(oldCapa, minSize, exact);
+    newCapa = SafeNextCapacity(oldCapa, minSize, exact);
     T *dynStorage = this->allocate(newCapa);
     (void)amc::uninitialized_relocate_n(_storage.ptr(), _capa, dynStorage);
     _storage.setDyn(dynStorage);
     _size = _capa;
   } else {
-    newCapa = vec::SafeNextCapacity(_capa, minSize, exact);
+    newCapa = SafeNextCapacity(_capa, minSize, exact);
     _storage.setDyn(vec::Reallocate(static_cast<Alloc &>(*this), _storage.dyn(), _capa, newCapa, _size));
   }
   _capa = newCapa;
 }
 
 template <class T, class Alloc, class SizeType>
 void StdVectorBase<T, Alloc, SizeType>::grow(uintmax_t minSize, bool exact) {
-  SizeType newCapa = vec::SafeNextCapacity(_capa, minSize, exact);
+  SizeType newCapa = SafeNextCapacity(_capa, minSize, exact);
   _storage = vec::Reallocate(static_cast<Alloc &>(*this), _storage, _capa, newCapa, _size);
   _capa = newCapa;
 }
@@ -116,6 +115,7 @@ template <class T, class Alloc, class SizeType>
 void SmallVectorBase<T, Alloc, SizeType>::freeStorage() {
   this->deallocate(_storage.dyn(), _capa);
 }
+}  // namespace vec
 
 /**
  * Vector optimized for *trivially relocatable types* and in 'Small' state (when its capacity is <= N).