StringV.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_BASE_STRINGV_H
#define ZYPP_BASE_STRINGV_H
#include <string_view>
#ifdef __cpp_lib_string_view
 
#include <zypp/APIConfig.h>
#include <zypp-core/base/String.h>
#include <zypp-core/base/Regex.h>
#include <zypp-core/base/Flags.h>
 
namespace zypp
{
  namespace strv
  {
    using regex = str::regex;
    using smatch = str::smatch;
 
    enum class Trim {
      notrim = 0,
      left   = 1<<0,
      right  = 1<<1,
      trim   = (left|right),
    };
 
    ZYPP_DECLARE_FLAGS_AND_OPERATORS( TrimFlag, Trim );
 
    inline constexpr std::string_view blank = " \t";
 
    inline std::string_view ltrim( std::string_view str_r, std::string_view chars_r = blank )
    {
      if ( str_r.empty() )
        return str_r;
      auto pos = str_r.find_first_not_of( chars_r );
      if ( pos == str_r.npos )
        str_r.remove_prefix( str_r.size() );
      else if ( pos )
        str_r.remove_prefix( pos );
      return str_r;
    }
 
    inline std::string_view rtrim( std::string_view str_r, std::string_view chars_r = blank )
    {
      if ( str_r.empty() )
        return str_r;
      auto pos = str_r.find_last_not_of( chars_r );
      if ( pos == str_r.npos )
        str_r.remove_suffix( str_r.size() );
      else if ( (pos = str_r.size()-1-pos) )
        str_r.remove_suffix( pos );
      return str_r;
    }
 
    inline std::string_view trim( std::string_view str_r, std::string_view chars_r = blank )
    {
      if ( str_r.empty() )
        return str_r;
      str_r = ltrim( std::move(str_r), chars_r );
      str_r = rtrim( std::move(str_r), chars_r );
      return str_r;
    }
 
    inline std::string_view trim( std::string_view str_r, std::string_view chars_r, TrimFlag trim_r )
    {
      if ( str_r.empty() || trim_r == Trim::notrim )
        return str_r;
      if ( trim_r.testFlag( Trim::left ) )
        str_r = ltrim( std::move(str_r), chars_r );
      if ( trim_r.testFlag( Trim::right ) )
        str_r = rtrim( std::move(str_r), chars_r );
      return str_r;
    }
    inline std::string_view trim( std::string_view str_r, TrimFlag trim_r )
    { return trim( std::move(str_r), blank, std::move(trim_r) ); }
 
    inline bool hasPrefix( std::string_view str_r, std::string_view prefix_r )
    { return( ::strncmp( str_r.data(), prefix_r.data(), prefix_r.size() ) == 0 ); }
 
    inline bool hasPrefixCI( std::string_view str_r, std::string_view prefix_r  )
    { return( ::strncasecmp( str_r.data(), prefix_r.data(), prefix_r.size()  ) == 0 ); }
 
    namespace detail
    {
      using WordConsumer = std::function<bool(std::string_view,unsigned,bool)>;
 
      template <typename Callable, std::enable_if_t<
      std::is_invocable_r_v<bool,Callable,std::string_view,unsigned,bool>
      , bool> = true>
      WordConsumer wordConsumer( Callable && fnc_r )
      { return std::forward<Callable>(fnc_r); }
      template <typename Callable, std::enable_if_t<
      ! std::is_invocable_r_v<bool,Callable,std::string_view,unsigned,bool>
      && std::is_invocable_r_v<void,Callable,std::string_view,unsigned,bool>
      , bool> = true>
      WordConsumer wordConsumer( Callable && fnc_r )
      { return [&fnc_r](std::string_view a1,unsigned a2,bool a3)->bool { fnc_r(a1,a2,a3); return true; }; }
 
      template <typename Callable, std::enable_if_t<
      std::is_invocable_r_v<bool,Callable,std::string_view,unsigned>
      , bool> = true>
      WordConsumer wordConsumer( Callable && fnc_r )
      { return [&fnc_r](std::string_view a1,unsigned a2,bool)->bool { return fnc_r(a1,a2); }; }
      template <typename Callable, std::enable_if_t<
      ! std::is_invocable_r_v<bool,Callable,std::string_view,unsigned>
      && std::is_invocable_r_v<void,Callable,std::string_view,unsigned>
      , bool> = true>
      WordConsumer wordConsumer( Callable && fnc_r )
      { return [&fnc_r](std::string_view a1,unsigned a2,bool)->bool { fnc_r(a1,a2); return true; }; }
 
      template <typename Callable, std::enable_if_t<
      std::is_invocable_r_v<bool,Callable,std::string_view>
      , bool> = true>
      WordConsumer wordConsumer( Callable && fnc_r )
      { return [&fnc_r](std::string_view a1,unsigned,bool)->bool { return fnc_r(a1); }; }
      template <typename Callable, std::enable_if_t<
      ! std::is_invocable_r_v<bool,Callable,std::string_view>
      && std::is_invocable_r_v<void,Callable,std::string_view>
      , bool> = true>
      WordConsumer wordConsumer( Callable && fnc_r )
      { return [&fnc_r](std::string_view a1,unsigned,bool)->bool { fnc_r(a1); return true; }; }
 
      template <typename Callable, std::enable_if_t<
      std::is_invocable_r_v<bool,Callable>
      , bool> = true>
      WordConsumer wordConsumer( Callable && fnc_r )
      { return [&fnc_r](std::string_view,unsigned,bool)->bool { return fnc_r(); }; }
      template <typename Callable, std::enable_if_t<
      ! std::is_invocable_r_v<bool,Callable>
      && std::is_invocable_r_v<void,Callable>
      , bool> = true>
      WordConsumer wordConsumer( Callable && fnc_r )
      { return [&fnc_r](std::string_view,unsigned,bool)->bool { fnc_r(); return true; }; }
 
      unsigned _split( std::string_view line_r, std::string_view sep_r, Trim trim_r, WordConsumer && fnc_r );
 
      unsigned _splitRx( std::string_view line_r, const regex & rx_r, WordConsumer && fnc_r );
#if LEGACY(1722)
      unsigned _splitRx( const std::string & line_r, const regex & rx_r, WordConsumer && fnc_r );
#endif
    }  // namespace detail
 
    template <typename Callable = detail::WordConsumer>
    unsigned splitRx( std::string_view line_r, const regex & rx_r, Callable && fnc_r = Callable() )
    { return detail::_splitRx( line_r, rx_r, detail::wordConsumer( std::forward<Callable>(fnc_r) ) ); }
 
 
    template <typename Callable = detail::WordConsumer>
    unsigned split( std::string_view line_r, std::string_view sep_r, Trim trim_r, Callable && fnc_r = Callable() )
    { return detail::_split( line_r, sep_r, trim_r, detail::wordConsumer( std::forward<Callable>(fnc_r) ) ); }
 
    template <typename Callable = detail::WordConsumer>
    inline unsigned split( std::string_view line_r, std::string_view sep_r, Callable && fnc_r = Callable() )
    { return detail::_split( line_r, sep_r, Trim::notrim, detail::wordConsumer( std::forward<Callable>(fnc_r) ) ); }
 
    template <typename Callable = detail::WordConsumer>
    inline unsigned split( std::string_view line_r, Callable && fnc_r = Callable() )
    { return detail::_split( line_r, std::string_view(), Trim::notrim, detail::wordConsumer( std::forward<Callable>(fnc_r) ) ); }
 
    inline std::string_view asStringView( const char * t )
    { return t == nullptr ? std::string_view() : t; }
 
  } // namespace strv
} // namespace zypp
#endif // __cpp_lib_string_view
#endif // ZYPP_BASE_STRINGV_H