ddcString.h

Go to the documentation of this file.

//-*- Mode: C++ -*-
//
//  DDC originally by Alexey Sokirko
//  Changes and modifications 2011-2018 by Bryan Jurish
//
//  This file is part of DDC.
// 
//  DDC is free software: you can redistribute it and/or modify
//  it under the terms of the GNU Lesser General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
// 
//  DDC 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 Lesser General Public License for more details.
// 
//  You should have received a copy of the GNU Lesser General Public License
//  along with DDC.  If not, see <http://www.gnu.org/licenses/>.
//
#ifndef DDC_STRING_H
#define DDC_STRING_H

#include "ddcConfig.h"
#include "utf8xx.h"
#include <stdarg.h>
#include <stdio.h>
#include <string>

//----------------------------------------------------------------------
//\name C escapes

std::string escapeCString(const std::string &s);

std::string unescapeCString(const std::string &s);

//----------------------------------------------------------------------
//\name JSON escapes

std::string escapeJsonString(const std::string &s, bool assume_utf8=true, bool add_quotes=false);

std::string unescapeJsonString(const std::string &s);

inline std::string jsonStr(const std::string &s, bool assume_utf8=true, bool add_quotes=true)
{
    return escapeJsonString(s,assume_utf8,add_quotes);
}

inline std::string jsonStr(unsigned char b)
{
    char buf[4];
    sprintf(buf,"%u",b);
    return std::string(buf);
};

inline std::string jsonStr(char c)
{
    return jsonStr(std::string(&c,1));
};

template<class Container>
std::string jsonArray(const Container &values)
{
    std::string s("[");
    for (typename Container::const_iterator vi=values.begin(); vi != values.end(); vi++) {
        if (s.size() > 1) s.push_back(',');
        s += jsonStr(*vi);
    }
    s.push_back(']');
    return s;
};


//----------------------------------------------------------------------
//\name Percent escapes (URL-encoding) 

std::string escapeUrlString(const std::string &s);

std::string unescapeUrlString(const std::string &s);

//----------------------------------------------------------------------
//\name UTF-8 escapes

std::string unescapeUtf8String(const std::string &s);

//----------------------------------------------------------------------
//\name Generic backslash escapes

std::string escapeChars(const std::string &s, const std::string &chars);

std::string sqString(const std::string &s);

std::string reString(const std::string &re);

std::string escapeRegex(const std::string &re);

//----------------------------------------------------------------------
//\name printf-style formatting

std::string Format( const char* format, ... );

std::string vFormat( const char* format, va_list& args );


//----------------------------------------------------------------------
//\name system errors

char* StrError(int ErrorNo);


//----------------------------------------------------------------------
//\name string splitting

//--------------------------------------------------------------
class StringTokenizer {
protected:
    char *text_ptr;
    char *text;
    int i;

    //-------------------------------------------------------
    std::string delims;
    inline bool is_delim(char ch) const
    { return delims.find_first_of(ch) != std::string::npos; }
  
    char *_val;

public:
    //-------------------------------------------------------
    // constructors etc.
    StringTokenizer(const char *_text, const char *_delims=" \t\r\n");

    StringTokenizer(const std::string& _text, const std::string& _delims)
    { initialize(_text,_delims); };

    ~StringTokenizer();

    void initialize(const char *_text, const char *_delims=" \t\r\n");
    void reinitialize(const char *_text, const char *_delims=" \t\r\n");

    void initialize(const std::string& _text, const std::string &_delims)
    { initialize(_text.c_str(), _delims.c_str()); };

    //-------------------------------------------------------
    // API
    const char * operator ()();
    std::string next_token();

    inline const char * get_rest () const
    { return text; };
  
    inline const char *val() const
    { return _val; };
  
    inline int count() const
    { return i; };
 
    inline bool has_next() const
    { return (*text) != '\0'; };

    void get_tokens(std::vector<std::string> &tokens);

    const char* get_rest_trim();
};


//--------------------------------------------------------------
class StringSplitter {
public:
    const std::string *srcp;      
    const std::string *delimp;    
    size_t begi;                  
    size_t endi;                  

public:

    inline StringSplitter(const std::string& src, const std::string& delims)
        : srcp(&src), delimp(&delims)
    {
        begin();
    };

    inline void begin()
    {
        begi = 0;
        endi = srcp->find_first_of(*delimp, begi);
    };

    inline bool valid() const
    { return begi != std::string::npos; };

    inline operator bool() const
    { return valid(); };

    inline std::string current() const
    { return endi==std::string::npos ? srcp->substr(begi) : srcp->substr(begi,endi-begi); };

    inline std::string operator*() const
    { return current(); };
  
    inline void next()
    {
        begi = endi==std::string::npos ? endi : (endi+1);
        endi = begi==std::string::npos ? begi : srcp->find_first_of(*delimp,begi);
    };

    inline StringSplitter& operator++()
    {
        next();
        return *this;
    };
};

//----------------------------------------------------------------------
//\name string trimming

std::string TrimSafe(const std::string &str);

inline bool TrimTruncate(std::string &str, size_t max)
{
    if (str.size() > max) {
        str.erase(max);
        return true;
    }
    return false;
};

void TrimTruncateV(std::string &str, size_t max, const char *label=NULL);


//----------------------------------------------------------------------
//\name bool parsing

bool StringToBool(const std::string &s, bool onempty=true);

const char *BoolToString(bool b);



#endif /* DDC_STRING_H */

/*--- emacs style variables ---
 * Local Variables:
 *  mode: C++
 *  c-file-style: "ellemtel"
 *  c-basic-offset: 4
 *  tab-width: 8
 *  indent-tabs-mode: nil
 * End:
 */