StringView.h

Go to the documentation of this file.

/*

             *
            ***
           *****
   *********************       Mercenaries Engineering SARL
     *****************              Copyright (C) 2020
       *************
         *********        http://www.mercenaries-engineering.com
        ***********
       ****     ****
      **           **

*/
#pragma once

#include <assert.h>
#include <string>
#include <vector>
#include <stdexcept>
#include <cstring>

namespace maquina
{
  // * This string view holds a 0 terminated string.
  template<class C, class STDS>
  class StringViewBase {
  public:
    typedef std::char_traits<C>                   traits_type;
    typedef C                                     value_type;
    typedef const C*                              pointer;
    typedef const C*                              const_pointer;
    typedef const C&                              reference;
    typedef const C&                              const_reference;
    typedef const_pointer                         const_iterator;
    typedef const_iterator                        iterator;
    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
    typedef const_reverse_iterator                reverse_iterator;
    typedef size_t                                size_type;
    typedef ptrdiff_t                             difference_type;
    static const size_type npos = size_type(-1);

    StringViewBase() noexcept
      : _str{""}, _size{0}
    {}

    StringViewBase( const StringViewBase& other ) noexcept = default;

    StringViewBase( StringViewBase&& other ) noexcept
      : _str{ other._str }, _size{other._size}
    {}

    StringViewBase& operator=( const StringViewBase& other ) noexcept = default;

    StringViewBase& operator=( StringViewBase&& other ) noexcept
    {
      _str = other._str;
      _size = other._size;
      return *this;
    }

    StringViewBase( const C* str ) noexcept
      : _str{ str }, _size{strlen(str)}
    {}

    StringViewBase( const std::basic_string<C>& string ) noexcept
      : _str{ string.data() }, _size{ string.size() }
    {}

    StringViewBase( const C* str, size_t size_ ) noexcept
      : _str{str}, _size{size_}
    {
      assert(_size == strlen(_str));
    }

    StringViewBase& operator=( const std::basic_string<C>& string ) noexcept
    {
      _str = string.data();
      _size = string.size();
      return *this;
    }

    iterator begin() const noexcept
    {
      return cbegin();
    }

    iterator end() const noexcept
    {
      return cend();
    }

    const_iterator cbegin() const noexcept
    {
      return _str;
    }

    const_iterator cend() const noexcept
    {
      return _str + _size;
    }

    size_type size() const noexcept
    {
      return _size;
    }

    size_type length() const noexcept
    {
      return size_type(strlen(_str));
    }

    const_pointer data() const noexcept
    {
      return _str;
    }

    pointer data() noexcept
    {
      return _str;
    }

    const_pointer c_str() const noexcept
    {
      return _str;
    }

    pointer c_str() noexcept
    {
      return _str;
    }

    bool empty() const noexcept
    {
      return _size == size_type(0);
    }

    bool operator==( const StringViewBase& other ) const noexcept
    {
      return other._size == _size
        && traits_type::compare( _str, other._str, _size ) == 0;
    }

    bool operator!=( const StringViewBase& other ) const noexcept
    {
      return other._size != _size
        || traits_type::compare( _str, other._str, _size ) != 0;
    }

    size_type find( value_type c, size_type pos = 0 ) const noexcept
    {
      size_type result = npos;
      if( pos < _size )
        {
          const value_type* p = traits_type::find( _str + pos, _size - pos, c );
          if( p )
            result = p - _str;
        }
      return result;
    }

    size_type find( const StringViewBase& pattern, size_type pos = 0 ) const noexcept
    {
      const auto pattern_size = pattern.size();
      if( pattern_size == 0 )
        return pos <= _size ? pos : npos;

      if( pattern_size <= _size )
        {
          for( ; pos <= _size - pattern_size; ++ pos )
            {
              if( traits_type::eq( _str[ pos ], pattern._str[0] )
                && traits_type::compare( _str + pos + 1,
                    pattern._str + 1, pattern_size -1 ) == 0 )
                return pos;
            }
        }
      return npos;
    }

    size_type
    rfind( value_type c, size_type pos = npos ) const noexcept
    {
      size_type __size = _size;
      if( __size )
        {
          if( --__size > pos )
            __size = pos;
          for( ++__size; __size-- > 0; )
            if( traits_type::eq( _str[ __size ], c ) )
              return __size;
        }
      return npos;
    }

    size_type
    rfind( const StringViewBase& pattern, size_type pos = npos ) const noexcept
    {
      const size_type __size = _size;
      const size_type __n = pattern.size();
      const value_type* __s = pattern.data();
      if( __n <= __size )
        {
          pos = std::min( size_type(__size - __n), pos);
          const value_type* __data = _str;
          do
            {
             if( traits_type::compare( __data + pos, __s, __n ) == 0 )
               return pos;
            }
          while( pos -- > 0 );
        }
      return npos;
    }

    STDS substr( size_type pos = 0, size_type n = npos) const
    {
      if( pos > _size )
        throw std::out_of_range("StringViewBase::substr");
      size_type len = std::min( n, _size - pos );
      return STDS( _str + pos, len );
    }

    // FIXME: this implementation skips empty sub-parts
    std::vector< STDS > split( StringViewBase separator ) const
    {
      std::vector< STDS > splitted;
      size_type prev_pos = 0, pos = 0;
      const auto separator_size = separator.size();
      while( (pos = find( separator, pos ) ) != npos )
        {
          if( prev_pos != pos )
            splitted.emplace_back( substr( prev_pos, pos - prev_pos ) );
          pos += separator_size;
          prev_pos = pos;
        }
      if( prev_pos != _size )
        splitted.emplace_back( substr( prev_pos ) );
      return splitted;
    }

    value_type operator[]( size_type position ) const
    {
      return _str[ position ];
    }

    operator STDS() const
    {
      return STDS( _str );
    }

  protected:
    const value_type* _str;
    size_type         _size;
  };

  template<class C, class STDS>
  struct StringViewHasherBase {

    size_t operator()( const StringViewBase<C, STDS>& str ) const noexcept
    {
      size_t result = static_cast<size_t>(0xc70f6907UL);
      for( const auto& c : str )
        {
          hash_combine( result, c );
        }
      return result;
    }
  };

  template<class C, class STDS>
  inline bool
  operator==( const C* str, const StringViewBase<C, STDS>& sv ) noexcept
  {
    return sv.size() == StringViewBase<C, STDS>::traits_type::length( str )
        && StringViewBase<C, STDS>::traits_type::compare( sv.data(), str, sv.size() ) == 0;
  }

  template<class C, class STDS>
  inline bool
  operator==( const StringViewBase<C, STDS>& sv, const C* str ) noexcept
  {
    return sv.size() == StringViewBase<C, STDS>::traits_type::length( str )
        && StringViewBase<C, STDS>::traits_type::compare( sv.data(), str, sv.size() ) == 0;
  }

  template<class C, class STDS>
  inline bool
  operator==( const StringViewBase<C, STDS>& sv, const STDS& s ) noexcept
  {
    return sv.size() == s.size()
        && StringViewBase<C, STDS>::traits_type::compare( sv.data(), s.data(), sv.size() ) == 0;
  }

  template<class C, class STDS>
  inline bool
  operator==( const STDS& s, const StringViewBase<C, STDS>& sv ) noexcept
  {
    return sv.size() == s.size()
        && StringViewBase<C, STDS>::traits_type::compare( sv.data(), s.data(), sv.size() ) == 0;
  }

  template<class C, class STDS>
  inline bool
  operator!=( const C* str, const StringViewBase<C, STDS>& sv ) noexcept
  {
    return sv.size() != StringViewBase<C, STDS>::traits_type::length( str )
        || StringViewBase<C, STDS>::traits_type::compare( sv.data(), str, sv.size() ) != 0;
  }

  template<class C, class STDS>
  inline bool
  operator!=( const StringViewBase<C, STDS>& sv, const C* str ) noexcept
  {
    return sv.size() != StringViewBase<C, STDS>::traits_type::length( str )
        || StringViewBase<C, STDS>::traits_type::compare( sv.data(), str, sv.size() ) != 0;
  }

  template<class C, class STDS>
  inline bool
  operator!=( const StringViewBase<C, STDS>& sv, const STDS& s ) noexcept
  {
    return sv.size() != s.size()
        || StringViewBase<C, STDS>::traits_type::compare( sv.data(), s.data(), sv.size() ) != 0;
  }

  template<class C, class STDS>
  inline bool
  operator!=( const STDS& s, const StringViewBase<C, STDS>& sv ) noexcept
  {
    return sv.size() != s.size()
        || StringViewBase<C, STDS>::traits_type::compare( sv.data(), s.data(), sv.size() ) != 0;
  }

  template<class C, class STDS>
  inline bool
  operator<( const StringViewBase<C, STDS> &a, const StringViewBase<C, STDS>& b ) noexcept
  {
    int result = StringViewBase<C, STDS>::traits_type::compare(
      a.data(), b.data(), std::min( a.size(), b.size() ) );
    if( result == 0 )
      return a.size() < b.size();
    return result < 0;
  }

  template<class _CharT, class _Traits, class C, class STDS>
  std::basic_ostream<_CharT, _Traits>&
  operator<<(std::basic_ostream<_CharT, _Traits>& os, const StringViewBase<C, STDS>& sv )
  {
    for( const auto& c : sv )
      os << c;
    return os;
  }

  template<class C, class STDS>
  struct string_view_less
  {
    using is_transparent = void;

    bool
    operator()( const StringViewBase<C, STDS>& a, const StringViewBase<C, STDS>& b ) const
    {
      int result = StringViewBase<C, STDS>::traits_type::compare(
          a.data(), b.data(), std::min( a.size(), b.size() ) );

      if( result == 0 )
        {
          const typename StringViewBase<C, STDS>::difference_type diff = a.size() - b.size();
          return diff < 0;
        }
      return result < 0;
    }
  };

  typedef StringViewBase<char, std::string> StringView;
  typedef StringViewHasherBase<char, std::string> StringViewHasher;

  typedef StringViewBase<wchar_t, std::wstring> WStringView;
  typedef StringViewHasherBase<wchar_t, std::wstring> WStringViewHasher;
}