StringUtilities.hpp

Go to the documentation of this file.

/*
 * ------------------------------------------------------------------------------------------------------------
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (c) 2016-2024 Lawrence Livermore National Security LLC
 * Copyright (c) 2018-2024 TotalEnergies
 * Copyright (c) 2018-2024 The Board of Trustees of the Leland Stanford Junior University
 * Copyright (c) 2023-2024 Chevron
 * Copyright (c) 2019-     GEOS/GEOSX Contributors
 * All rights reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */
 
#ifndef GEOS_COMMON_FORMAT_STRINGUTILITIES_HPP_
#define GEOS_COMMON_FORMAT_STRINGUTILITIES_HPP_
 
#include "common/DataTypes.hpp"
 
#include <iomanip>
#include <sstream>
 
namespace geos
{
namespace stringutilities
{
 
string toLower( string const & input );
 
template< typename IT, typename S = char >
string join( IT first, IT last, S const & delim = S() )
{
  if( first == last )
  {
    return {};
  }
  std::ostringstream oss;
  oss << *first;
  while( ++first != last )
  {
    oss << delim << *first;
  }
  return oss.str();
}
 
template< typename CONTAINER, typename S = char >
string join( CONTAINER const & container, S const & delim = S() )
{
  return join( std::begin( container ), std::end( container ), delim );
}
 
template< typename IT, typename S, typename LAMBDA >
string joinLambda( IT first, IT last, S const & delim, LAMBDA formattingFunc )
{
  if( first == last )
  {
    return {};
  }
  std::ostringstream oss;
  oss << formattingFunc( first );
  while( ++first != last )
  {
    oss << delim << formattingFunc( first );
  }
  return oss.str();
}
 
template< typename CONTAINER, typename S, typename LAMBDA >
string joinLambda( CONTAINER const & container, S const & delim, LAMBDA formattingFunc )
{
  return joinLambda( std::begin( container ), std::end( container ), delim, formattingFunc );
}
 
template< typename S = char, typename T, typename ... Ts >
string concat( S const & delim, T const & v, Ts const & ... vs )
{
  std::ostringstream oss;
  oss << v;
  // Use array initializer and comma trick to get "fold expression" pre C++-17
  using expander = int[];
  (void) expander{ 0, ( void ( oss << delim << vs ), 0) ... };
  return oss.str();
}
 
template< template< class ... > class CONTAINER = std::vector >
CONTAINER< string > tokenize( string const & str,
                              string const & delimiters,
                              bool const treatConsecutiveDelimAsOne = true,
                              bool const preTrimStr = false )
{
  CONTAINER< string > tokens;
  string::size_type tokenBegin, tokenEnd, strEnd;
 
  if( preTrimStr )
  {
    tokenBegin = str.find_first_not_of( delimiters );
    strEnd = str.find_last_not_of( delimiters ) + 1;
  }
  else
  {
    tokenBegin = 0;
    strEnd = str.size();
  }
 
  while( ( ( tokenEnd = str.find_first_of( delimiters, tokenBegin ) ) < strEnd ) && tokenBegin < strEnd )
  {
    tokens.emplace_back( str.substr( tokenBegin, tokenEnd - tokenBegin ) );
    tokenBegin = !treatConsecutiveDelimAsOne ? tokenEnd + 1 : str.find_first_not_of( delimiters, tokenEnd );
  }
 
  if( tokenBegin < strEnd )
  {
    tokens.emplace_back( str.substr( tokenBegin, strEnd-tokenBegin ));
  }
  else if( !preTrimStr && str.find_first_of( delimiters, strEnd - 1 ) != string::npos )
  {
    tokens.emplace_back( "" );
  }
 
  return tokens;
}
 
template< template< class ... > class CONTAINER = std::vector >
CONTAINER< string > tokenizeBySpaces( string const & str )
{
  return tokenize< CONTAINER >( str, " \f\n\r\t\v", true, true );
}
 
string_view trim( string_view str,
                  string_view charsToRemove );
 
string_view ltrimSpaces( string_view s );
 
string_view trimSpaces( string_view str );
 
string removeStringAndFollowingContent( string_view str,
                                        string_view strToRemove );
 
template< typename T >
string addCommaSeparators( T const & num );
 
std::vector< std::string > wrapTextToMaxLength( std::vector< std::string > const & lines, size_t maxLength );
 
template< typename T >
array1d< T > fromStringToArray( string const & str )
{
  array1d< T > v;
  T sub;
 
  std::istringstream iss( str );
  while( iss >> sub )
  {
    v.emplace_back( sub );
  }
  return v;
}
 
template< typename T >
string toMetricPrefixString( T const & value );
 
constexpr size_t cstrlen( char const * const str )
{
  if( str )
  {
    char const * ptr = str;
    for(; *ptr != '\0'; ++ptr )
    {}
    return ptr - str;
  }
  else
  {
    return 0;
  }
}
 
constexpr bool startsWith( std::string_view str, std::string_view prefix )
{
  return str.size() >= prefix.size() &&
         str.compare( 0, prefix.size(), prefix ) == 0;
}
 
constexpr bool endsWith( std::string_view str, std::string_view suffix )
{
  return str.size() >= suffix.size() &&
         str.compare( str.size()-suffix.size(), suffix.size(), suffix ) == 0;
}
 
template< typename T >
std::ostream & operator<<( std::ostream & os, std::optional< T > const & optValue )
{
  if( optValue )
  {
    os << optValue.value();
  }
  return os;
}
 
} // namespace stringutilities
} // namespace geos
 
#endif /* GEOS_COMMON_FORMAT_STRINGUTILITIES_HPP_ */