From df1ef68cd8e8582724ce1192bfc202e0b9aeaf0c Mon Sep 17 00:00:00 2001
From: Karen Arutyunov <karen@codesynthesis.com>
Date: Tue, 28 Sep 2021 19:24:31 +0300
Subject: Get rid of C++ modules related code and rename *.mxx files to *.hxx

---
 libbutl/small-vector.mxx | 189 -----------------------------------------------
 1 file changed, 189 deletions(-)
 delete mode 100644 libbutl/small-vector.mxx

(limited to 'libbutl/small-vector.mxx')

diff --git a/libbutl/small-vector.mxx b/libbutl/small-vector.mxx
deleted file mode 100644
index 7f9bb1e..0000000
--- a/libbutl/small-vector.mxx
+++ /dev/null
@@ -1,189 +0,0 @@
-// file      : libbutl/small-vector.mxx -*- C++ -*-
-// license   : MIT; see accompanying LICENSE file
-
-#ifndef __cpp_modules_ts
-#pragma once
-#endif
-
-#ifndef __cpp_lib_modules_ts
-#include <vector>
-#include <cstddef>     // size_t
-#include <utility>     // move()
-#endif
-
-// Other includes.
-
-#ifdef __cpp_modules_ts
-export module butl.small_vector;
-#ifdef __cpp_lib_modules_ts
-import std.core;
-#endif
-import butl.small_allocator;
-#else
-#include <libbutl/small-allocator.mxx>
-#endif
-
-#include <libbutl/export.hxx>
-
-LIBBUTL_MODEXPORT namespace butl
-{
-  // Issues and limitations.
-  //
-  // - vector::reserve() may allocate more per the spec. But the three main
-  //   C++ runtimes (libstdc++, libc++, and msvc) all seem to do the right
-  //   thing.
-  //
-  // - What if in most cases the vector is empty? How can we avoid initial
-  //   reserve? Provide no_reserve flag or some such? Is it really worth it?
-  //
-  // - swap() is deleted (see notes below).
-  //
-  template <typename T, std::size_t N>
-  class small_vector: private small_allocator_buffer<T, N>,
-                      public std::vector<T, small_allocator<T, N>>
-  {
-  public:
-    static constexpr const std::size_t small_size = N;
-
-    using buffer_type = small_allocator_buffer<T, N>;
-    using allocator_type = small_allocator<T, N>;
-    using base_type = std::vector<T, allocator_type>;
-
-    small_vector ()
-      : base_type (allocator_type (this))
-    {
-      reserve ();
-    }
-
-    small_vector (std::initializer_list<T> v)
-      : base_type (allocator_type (this))
-    {
-      if (v.size () <= N)
-        reserve ();
-
-      static_cast<base_type&> (*this) = v;
-    }
-
-    template <typename I>
-    small_vector (I b, I e)
-      : base_type (allocator_type (this))
-    {
-      // While we could optimize this for random access iterators, N will
-      // usually be pretty small. Let's hope the compiler sees this and does
-      // some magic for us.
-      //
-      std::size_t n (0);
-      for (I i (b); i != e && n <= N; ++i) ++n;
-
-      if (n <= N)
-        reserve ();
-
-      this->assign (b, e);
-    }
-
-    explicit
-    small_vector (std::size_t n)
-      : base_type (allocator_type (this))
-    {
-      if (n <= N)
-        reserve ();
-
-      this->resize (n);
-    }
-
-    small_vector (std::size_t n, const T& x)
-      : base_type (allocator_type (this))
-    {
-      if (n <= N)
-        reserve ();
-
-      this->assign (n, x);
-    }
-
-    small_vector (const small_vector& v)
-      : buffer_type (), base_type (allocator_type (this))
-    {
-      if (v.size () <= N)
-        reserve ();
-
-      static_cast<base_type&> (*this) = v;
-    }
-
-    small_vector&
-    operator= (const small_vector& v)
-    {
-      // Note: propagate_on_container_copy_assignment = false
-      //
-      static_cast<base_type&> (*this) = v;
-      return *this;
-    }
-
-    small_vector (small_vector&& v)
-      : base_type (allocator_type (this))
-    {
-      if (v.size () <= N)
-        reserve ();
-
-      *this = std::move (v); // Delegate to operator=(&&).
-
-      // Note that in contrast to the move assignment operator, the
-      // constructor must clear the other vector.
-      //
-      v.clear ();
-    }
-
-    small_vector&
-    operator= (small_vector&& v)
-    {
-      // VC's implementation of operator=(&&) (both 14 and 15) frees the
-      // memory and then reallocated with capacity equal to v.size(). This is
-      // clearly sub-optimal (the existing buffer could be reused) so we hope
-      // this will be fixed eventually (VSO#367146; reportedly fixed for
-      // VC15U1).
-      //
-#if defined(_MSC_VER) && _MSC_VER <= 1910
-      if (v.size () <= N)
-      {
-        clear ();
-        for (T& x: v)
-          push_back (std::move (x));
-        v.clear ();
-      }
-      else
-#endif
-
-      // Note: propagate_on_container_move_assignment = false
-      //
-      static_cast<base_type&> (*this) = std::move (v);
-
-      return *this;
-    }
-
-    small_vector&
-    operator= (std::initializer_list<T> v)
-    {
-      static_cast<base_type&> (*this) = v;
-      return *this;
-    }
-
-    // Implementing swap() under small buffer optimization is not trivial, to
-    // say the least (think of swapping two such buffers of different sizes).
-    // One easy option would be to force both in to the heap.
-    //
-    void
-    swap (small_vector&) = delete;
-
-    void
-    reserve (std::size_t n = N)
-    {
-      base_type::reserve (n < N ? N : n);
-    }
-
-    void
-    shrink_to_fit ()
-    {
-      if (this->capacity () > N)
-        base_type::shrink_to_fit ();
-    }
-  };
-}
-- 
cgit v1.1