str.h

// @file str.h

/*    Copyright 2010 10gen Inc.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */

#pragma once

#include <string>
#include <sstream>

#include "mongo/bson/util/builder.h"

namespace mongoutils {

    namespace str {

        class stream {
        public:
            mongo::StringBuilder ss;
            template<class T>
            stream& operator<<(const T& v) {
                ss << v;
                return *this;
            }
            operator std::string () const { return ss.str(); }
        };

        inline bool startsWith(const char *str, const char *prefix) {
            const char *s = str;
            const char *p = prefix;
            while( *p ) {
                if( *p != *s ) return false;
                p++; s++;
            }
            return true;
        }
        inline bool startsWith(const std::string& s, const std::string& p) {
            return startsWith(s.c_str(), p.c_str());
        }

        // while these are trivial today use in case we do different wide char things later
        inline bool startsWith(const char *p, char ch) { return *p == ch; }
        inline bool startsWith(const std::string& s, char ch) { return startsWith(s.c_str(), ch); }

        inline bool endsWith(const std::string& s, const std::string& p) {
            int l = p.size();
            int x = s.size();
            if( x < l ) return false;
            return strncmp(s.c_str()+x-l, p.c_str(), l) == 0;
        }
        inline bool endsWith(const char *s, char p) {
            size_t len = strlen(s);
            return len && s[len-1] == p;
        }
        inline bool endsWith(const char *p, const char *suffix) {
            size_t a = strlen(p);
            size_t b = strlen(suffix);
            if ( b > a ) return false;
            return strcmp(p + a - b, suffix) == 0;
        }

        inline bool equals( const char * a , const char * b ) { return strcmp( a , b ) == 0; }

        inline const char * after(const char *s, char x) {
            const char *p = strchr(s, x);
            return (p != 0) ? p+1 : "";
        }
        inline std::string after(const std::string& s, char x) {
            const char *p = strchr(s.c_str(), x);
            return (p != 0) ? std::string(p+1) : "";
        }

        inline const char * after(const char *s, const char *x) {
            const char *p = strstr(s, x);
            return (p != 0) ? p+strlen(x) : "";
        }
        inline std::string after(const std::string& s, const std::string& x) {
            const char *p = strstr(s.c_str(), x.c_str());
            return (p != 0) ? std::string(p+x.size()) : "";
        }

        inline bool contains(const std::string& s, const std::string& x) {
            return strstr(s.c_str(), x.c_str()) != 0;
        }
        inline bool contains(const std::string& s, char x) {
            verify(x != '\0'); // this expects c-strings so don't use when looking for NUL bytes
            return strchr(s.c_str(), x) != 0;
        }

        inline std::string before(const std::string& s, char x) {
            const char *p = strchr(s.c_str(), x);
            return (p != 0) ? s.substr(0, p-s.c_str()) : s;
        }

        inline std::string before(const std::string& s, const std::string& x) {
            const char *p = strstr(s.c_str(), x.c_str());
            return (p != 0) ? s.substr(0, p-s.c_str()) : s;
        }

        inline int shareCommonPrefix(const char *p, const char *q) {
            int ofs = 0;
            while( 1 ) {
                if( *p == 0 || *q == 0 )
                    break;
                if( *p != *q )
                    break;
                p++; q++; ofs++;
            }
            return ofs;
        }
        inline int shareCommonPrefix(const std::string &a, const std::string &b)
        { return shareCommonPrefix(a.c_str(), b.c_str()); }

        inline unsigned toUnsigned(const std::string& a) {
            unsigned x = 0;
            const char *p = a.c_str();
            while( 1 ) {
                if( !isdigit(*p) )
                    break;
                x = x * 10 + (*p - '0');
                p++;
            }
            return x;
        }

        inline bool splitOn(const std::string &s, char c, std::string& L, std::string& R) {
            const char *start = s.c_str();
            const char *p = strchr(start, c);
            if( p == 0 ) {
                L = s; R.clear();
                return false;
            }
            L = std::string(start, p-start);
            R = std::string(p+1);
            return true;
        }
        inline bool rSplitOn(const std::string &s, char c, std::string& L, std::string& R) {
            const char *start = s.c_str();
            const char *p = strrchr(start, c);
            if( p == 0 ) {
                L = s; R.clear();
                return false;
            }
            L = std::string(start, p-start);
            R = std::string(p+1);
            return true;
        }

        inline unsigned count( const std::string& s , char c ) {
            unsigned n=0;
            for ( unsigned i=0; i<s.size(); i++ )
                if ( s[i] == c )
                    n++;
            return n;
        }

        inline std::string ltrim(const std::string& s) {
            const char *p = s.c_str();
            while( *p == ' ' ) p++;
            return p;
        }

        inline void stripTrailing(std::string& s, const char *chars) {
            std::string::iterator to = s.begin();
            for ( std::string::iterator i = s.begin(); i != s.end(); i++ ) {
                // During each iteration if i finds a non-"chars" character it writes it to the
                // position of t. So the part of the string left from the "to" iterator is already
                // "cleared" string.
                if ( !contains(chars, *i) ) {
                    if ( i != to )
                        s.replace(to, to + 1, 1, *i);
                    to++;
                }
            }
            s.erase(to, s.end());
        }

    }  // namespace str

}  // namespace mongoutils

namespace mongo {
    using namespace mongoutils;

#if defined(_WIN32)
    inline int strcasecmp(const char* s1, const char* s2) {return _stricmp(s1, s2);}
#endif

}  // namespace mongo