Merge commit 'efcea3a80da7c4479d5fe168435ecc9fd06bdc72' as 'subprojects/boost-sqlite'

1 files changed, 223 insertions, 0 deletions

diff --git a/subprojects/boost-sqlite/include/boost/sqlite/cstring_ref.hpp b/subprojects/boost-sqlite/include/boost/sqlite/cstring_ref.hpp
new file mode 100644
index 0000000..6747f45
--- /dev/null
+++ b/subprojects/boost-sqlite/include/boost/sqlite/cstring_ref.hpp
@@ -0,0 +1,223 @@
+// Copyright (c) 2022 Klemens D. Morgenstern
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+// based on boost.process
+#ifndef BOOST_SQLITE_CSTRING_REF_HPP
+#define BOOST_SQLITE_CSTRING_REF_HPP
+
+#include <boost/config.hpp>
+#include <boost/core/detail/string_view.hpp>
+
+#include <cstddef>
+#include <type_traits>
+#include <string>
+
+
+#if __cplusplus >= 201702L
+#include <string_view>
+#endif
+
+namespace boost
+{
+namespace sqlite
+{
+
+/// Small wrapper for a null-terminated string that can be directly passed to C APIS
+/** This ref can only be modified by moving the front pointer. It does not store the
+ * size, but can detect values that can directly be passed to system APIs.
+ *
+ * It can be constructed from a `char*` pointer or any class that has a `c_str()`
+ * member function, e.g. std::string or boost::static_string.
+ *
+ */
+struct cstring_ref
+{
+  using value_type             = char;
+  using traits_type            = std::char_traits<char>;
+  BOOST_CONSTEXPR cstring_ref() noexcept : view_("") {}
+  BOOST_CONSTEXPR cstring_ref(std::nullptr_t) = delete;
+
+  BOOST_CONSTEXPR cstring_ref( const value_type* s ) : view_(s) {}
+
+  template<typename Source,
+      typename =
+      typename std::enable_if<
+          std::is_same<const value_type,
+              typename std::remove_pointer<decltype(std::declval<Source>().c_str())>::type
+          >::value>::type>
+  BOOST_CONSTEXPR cstring_ref(Source && src) : view_(src.c_str()) {}
+
+  BOOST_CONSTEXPR const char * c_str() const BOOST_NOEXCEPT
+  {
+    return this->data();
+  }
+
+  using string_view_type = core::string_view;
+  constexpr operator string_view_type() const {return view_;}
+
+#if __cplusplus >= 201702L 
+  constexpr operator std::string_view() const {return view_;}
+#endif 
+
+  using pointer                =       char *;
+  using const_pointer          = const char *;
+  using reference              =       char &;
+  using const_reference        = const char &;
+  using const_iterator         = const_pointer;
+  using iterator               = const_iterator;
+  using const_reverse_iterator = typename std::reverse_iterator<const_iterator>;
+  using reverse_iterator       = typename std::reverse_iterator<iterator>;
+  using size_type              = std::size_t;
+  using difference_type        = std::ptrdiff_t;
+
+  static BOOST_CONSTEXPR size_type npos = -1;
+
+  BOOST_CONSTEXPR const_iterator begin()  const BOOST_NOEXCEPT {return view_;};
+  BOOST_CONSTEXPR const_iterator end()    const BOOST_NOEXCEPT {return view_ + length();};
+  BOOST_CONSTEXPR const_iterator cbegin() const BOOST_NOEXCEPT {return view_;};
+  BOOST_CONSTEXPR const_iterator cend()   const BOOST_NOEXCEPT {return view_ + length();};
+
+#if defined(BOOST_NO_CXX17)
+  const_reverse_iterator rbegin()  const BOOST_NOEXCEPT {return reverse_iterator(end());};
+  const_reverse_iterator rend()    const BOOST_NOEXCEPT {return reverse_iterator(begin());};
+  const_reverse_iterator crbegin() const BOOST_NOEXCEPT {return reverse_iterator(end());};
+  const_reverse_iterator crend()   const BOOST_NOEXCEPT {return reverse_iterator(begin());};
+#else
+  BOOST_CONSTEXPR const_reverse_iterator rbegin()  const BOOST_NOEXCEPT {return reverse_iterator(end());};
+  BOOST_CONSTEXPR const_reverse_iterator rend()    const BOOST_NOEXCEPT {return reverse_iterator(begin());};
+  BOOST_CONSTEXPR const_reverse_iterator crbegin() const BOOST_NOEXCEPT {return reverse_iterator(end());};
+  BOOST_CONSTEXPR const_reverse_iterator crend()   const BOOST_NOEXCEPT {return reverse_iterator(begin());};
+#endif
+
+  BOOST_CONSTEXPR size_type size() const BOOST_NOEXCEPT {return length(); }
+  BOOST_CONSTEXPR size_type length() const BOOST_NOEXCEPT {return length_impl_(); }
+  BOOST_CONSTEXPR size_type max_size() const BOOST_NOEXCEPT {return static_cast<std::size_t>(-1); }
+  BOOST_ATTRIBUTE_NODISCARD BOOST_CONSTEXPR bool empty() const BOOST_NOEXCEPT {return *view_ ==  '\0'; }
+
+  BOOST_CONSTEXPR const_reference operator[](size_type pos) const  {return view_[pos] ;}
+  BOOST_CXX14_CONSTEXPR const_reference at(size_type pos) const
+  {
+    if (pos >= size())
+      throw_exception(std::out_of_range("cstring-view out of range"));
+    return view_[pos];
+  }
+  BOOST_CONSTEXPR const_reference front() const  {return *view_;}
+  BOOST_CONSTEXPR const_reference back()  const  {return view_[length() - 1];}
+  BOOST_CONSTEXPR const_pointer data()    const BOOST_NOEXCEPT  {return view_;}
+  BOOST_CXX14_CONSTEXPR void remove_prefix(size_type n)  {view_ = view_ + n;}
+  void swap(cstring_ref& s) BOOST_NOEXCEPT {std::swap(view_, s.view_);}
+
+  size_type copy(value_type* s, size_type n, size_type pos = 0) const
+  {
+    return traits_type::copy(s, view_ + pos, n) - view_;
+  }
+  BOOST_CONSTEXPR cstring_ref substr(size_type pos = 0) const
+  {
+    return cstring_ref(view_ + pos);
+  }
+
+  BOOST_CXX14_CONSTEXPR string_view_type substr(size_type pos, size_type length) const
+  {
+    return string_view_type(view_).substr(pos, length);
+  }
+
+  BOOST_CXX14_CONSTEXPR int compare(cstring_ref x) const BOOST_NOEXCEPT
+  {
+    auto idx = 0u;
+    for (; view_[idx] != null_char_()[0] && x[idx] != null_char_()[0]; idx++)
+      if (!traits_type::eq(view_[idx], x[idx]))
+        return traits_type::lt(view_[idx], x[idx]) ? -1 : 1;
+
+    return traits_type::to_int_type(view_[idx]) -
+           traits_type::to_int_type(x[idx]); // will compare to null char of either.
+  }
+
+  BOOST_CXX14_CONSTEXPR bool starts_with(string_view_type x) const BOOST_NOEXCEPT
+  {
+    if (x.empty())
+      return true;
+
+    auto idx = 0u;
+    for (; view_[idx] != null_char_()[0] && idx < x.size(); idx++)
+      if (!traits_type::eq(view_[idx], x[idx]))
+        return false;
+
+    return idx == x.size() || view_[idx] != null_char_()[0];
+  }
+  BOOST_CONSTEXPR bool starts_with(value_type x)       const BOOST_NOEXCEPT
+  {
+    return traits_type::eq(view_[0], x);
+  }
+
+  BOOST_CXX14_CONSTEXPR size_type find( char ch, size_type pos = 0 ) const BOOST_NOEXCEPT
+  {
+    for (auto p = view_ + pos; *p != *null_char_(); p++)
+      if (traits_type::eq(*p, ch))
+        return p - view_;
+    return npos;
+  }
+
+
+  friend BOOST_CXX14_CONSTEXPR bool operator==(cstring_ref x, cstring_ref y) BOOST_NOEXCEPT
+  {
+    std::size_t idx = 0u;
+    for (idx = 0u; x[idx] != null_char_()[0] && y[idx] != null_char_()[0]; idx++)
+      if (!traits_type::eq(x[idx], y[idx]))
+        return false;
+    return x[idx] == y[idx];
+  }
+  friend BOOST_CXX14_CONSTEXPR bool operator!=(cstring_ref x, cstring_ref y) BOOST_NOEXCEPT
+  {
+    std::size_t idx = 0u;
+    for (idx = 0u; x[idx] != null_char_()[0] &&
+                   y[idx] != null_char_()[0]; idx++)
+      if (!traits_type::eq(x[idx], y[idx]))
+        return true;
+    return x[idx] != y[idx];
+  }
+  friend BOOST_CXX14_CONSTEXPR bool operator< (cstring_ref x, cstring_ref y) BOOST_NOEXCEPT {return x.compare(y) <  0;}
+  friend BOOST_CXX14_CONSTEXPR bool operator> (cstring_ref x, cstring_ref y) BOOST_NOEXCEPT {return x.compare(y) >  0;}
+  friend BOOST_CXX14_CONSTEXPR bool operator<=(cstring_ref x, cstring_ref y) BOOST_NOEXCEPT {return x.compare(y) <= 0;}
+  friend BOOST_CXX14_CONSTEXPR bool operator>=(cstring_ref x, cstring_ref y) BOOST_NOEXCEPT {return x.compare(y) >= 0;}
+
+  // modifiers
+  void clear() BOOST_NOEXCEPT { view_ =  null_char_(); }          // Boost extension
+
+  std::basic_string<value_type, traits_type> to_string() const
+  {
+    return std::basic_string<char, traits_type>(begin(), end());
+  }
+
+  template<typename Allocator>
+  std::basic_string<value_type, traits_type, Allocator> to_string(const Allocator& a) const
+  {
+    return std::basic_string<value_type, traits_type, Allocator>(begin(), end(), a);
+  }
+
+  template<class A> operator std::basic_string<char, std::char_traits<char>, A>() const
+  {
+    return std::basic_string<char, std::char_traits<char>, A>( view_ );
+  }
+
+ private:
+  BOOST_CONSTEXPR static const_pointer   null_char_()         {return "\0";}
+  constexpr std::size_t length_impl_(std::size_t n = 0) const BOOST_NOEXCEPT
+  {
+    return view_[n] == null_char_()[0] ? n : length_impl_(n+1);
+  }
+  const_pointer view_;
+};
+
+template<typename Char>
+inline std::basic_ostream<Char>& operator<<( std::basic_ostream<Char> & os, cstring_ref str )
+{
+  return os << core::string_view(str);
+}
+
+
+}
+}
+
+
+#endif //BOOST_SQLITE_CSTRING_REF_HPP