string.hpp

Go to the documentation of this file.

 
/*
 * This file is part of Algorithms library toolkit.
 * Copyright (C) 2017 Jan Travnicek (jan.travnicek@fit.cvut.cz)
 
 * Algorithms library toolkit is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 
 * Algorithms library toolkit is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 
 * You should have received a copy of the GNU General Public License
 * along with Algorithms library toolkit.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include <stdexcept>
#include <algorithm>
 
#include <ext/sstream>
 
#include "vector.hpp"
 
namespace ext {
 
class string : public std::string {
public:
    using std::string::string; // NOLINT(modernize-use-equals-default)
 
    using std::string::operator =;
#ifndef __clang__
 
    string ( ) = default;
 
    string ( const string & other ) = default;
 
    string ( string && other ) = default;
 
    string & operator = ( string && other ) = default;
 
    string & operator = ( const string & other ) = default;
#endif
    explicit string ( const std::string & other ) noexcept : std::string ( other ) {
    }
 
    explicit string ( std::string && other ) noexcept : std::string ( std::move ( other ) ) {
    }
 
    string & operator = ( std::string && other ) noexcept {
        static_cast < std::string & > ( * this ) = std::move ( other );
        return * this;
    }
 
    string & operator = ( const std::string & other ) noexcept {
        static_cast < std::string & > ( * this ) = other;
        return * this;
    }
};
 
template < typename T >
std::string to_string ( const T & value ) {
    ext::ostringstream ss;
    ss << value;
    return ss.str ( );
}
 
template < typename T >
T from_string ( const std::string & );
 
template < >
std::string from_string ( const std::string & value );
 
template < >
int from_string ( const std::string & value );
 
template < >
bool from_string ( const std::string & value );
 
template < >
long from_string ( const std::string & value );
 
template < >
long long from_string ( const std::string & value );
 
template < >
unsigned from_string ( const std::string & value );
 
template < >
unsigned long from_string ( const std::string & value );
 
template < >
unsigned long long from_string ( const std::string & value );
 
template < >
double from_string ( const std::string & value );
 
ext::vector < std::string > explode ( const std::string & source, const std::string & delimiter );
 
std::string implode ( const std::vector < std::string > & source, const std::string & delimiter );
 
inline bool isspace ( int ch ) {
    return std::isspace ( ch ) != 0;
}
 
inline bool not_isspace ( int ch ) {
    return std::isspace ( ch ) == 0;
}
 
inline std::string_view ltrim ( std::string_view s ) {
    const auto * endPos = std::find_if ( s.begin ( ), s.end ( ), not_isspace );
    s.remove_prefix ( std::distance ( s.begin ( ), endPos ) );
    return s;
}
 
inline std::string_view rtrim ( std::string_view s ) {
    const auto * beginPos = std::find_if ( s.rbegin ( ), s.rend ( ), not_isspace ).base ( );
    s.remove_suffix ( std::distance ( beginPos, s.end ( ) ) );
    return s;
}
 
inline std::string_view trim ( std::string_view s ) {
    return rtrim(ltrim(s));
}
 
// Creates a string view from a pair of iterators
//  http://stackoverflow.com/q/33750600/882436
inline std::string_view make_string_view ( std::string::const_iterator begin, std::string::const_iterator end ) {
    return std::string_view { ( begin != end ) ? & * begin : nullptr, static_cast < std::string_view::size_type > ( std::max ( std::distance ( begin, end ), static_cast < typename std::string_view::difference_type > ( 0 ) ) ) };
} // make_string_view
 
} /* namespace ext */