iostring.hh
/* iostring.hh - Read and write strings in parts.
* Copyright 2007-2008 Bas Wijnen <wijnen@debian.org>
*
* This program 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.
*
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef SHEVEK_IOSTRING_HH
#define SHEVEK_IOSTRING_HH
#include <string>
#include <stack>
#include <sstream>
#include <glibmm.h>
namespace shevek
{
class istring
{
// The data to parse.
Glib::ustring data;
// Pointer to data still to be parsed.
std::stack <Glib::ustring::size_type> pos;
// Read a variable.
template <typename T>
bool read_var (Glib::ustring const &format, T &ret, Glib::ustring::size_type &inpos);
// Read away whitespace.
void del_whitespace ();
// Check for a constant.
bool read_const (Glib::ustring const &format, Glib::ustring::size_type &inpos);
public:
// Constructors: fill data and make one stack level.
istring () { pos.push (0); }
istring (Glib::ustring const &str) { init (str); }
void init (Glib::ustring const &str)
{ data = str; while (!pos.empty ()) pos.pop (); pos.push (0); }
// Stack functions.
void push () { pos.push (pos.top ()); }
int pop (bool keep = false);
void reset () { pos.top () = 0; }
Glib::ustring rest () const { return data.substr (pos.top ()); }
void skip (Glib::ustring::size_type p) { pos.top () += p; }
bool operator() (Glib::ustring const &format)
{
push ();
Glib::ustring::size_type inpos = 0;
bool ret = read_const (format, inpos)
&& inpos == format.size ();
pop (ret);
return ret;
}
template <typename T1>
bool operator() (Glib::ustring const &format, T1 &arg1)
{
push ();
Glib::ustring::size_type inpos = 0;
bool ret = read_const (format, inpos)
&& read_var (format, arg1, inpos)
&& read_const (format, inpos)
&& inpos == format.size ();
pop (ret);
return ret;
}
template <typename T1, typename T2>
bool operator() (Glib::ustring const &format, T1 &arg1,
T2 &arg2)
{
push ();
Glib::ustring::size_type inpos = 0;
bool ret = read_const (format, inpos)
&& read_var (format, arg1, inpos)
&& read_const (format, inpos)
&& read_var (format, arg2, inpos)
&& read_const (format, inpos)
&& inpos == format.size ();
pop (ret);
return ret;
}
template <typename T1, typename T2, typename T3>
bool operator() (Glib::ustring const &format, T1 &arg1,
T2 &arg2, T3 &arg3)
{
push ();
Glib::ustring::size_type inpos = 0;
bool ret = read_const (format, inpos)
&& read_var (format, arg1, inpos)
&& read_const (format, inpos)
&& read_var (format, arg2, inpos)
&& read_const (format, inpos)
&& read_var (format, arg3, inpos)
&& read_const (format, inpos)
&& inpos == format.size ();
pop (ret);
return ret;
}
template <typename T1, typename T2, typename T3, typename T4>
bool operator() (Glib::ustring const &format, T1 &arg1,
T2 &arg2, T3 &arg3, T4 &arg4)
{
push ();
Glib::ustring::size_type inpos = 0;
bool ret = read_const (format, inpos)
&& read_var (format, arg1, inpos)
&& read_const (format, inpos)
&& read_var (format, arg2, inpos)
&& read_const (format, inpos)
&& read_var (format, arg3, inpos)
&& read_const (format, inpos)
&& read_var (format, arg4, inpos)
&& read_const (format, inpos)
&& inpos == format.size ();
pop (ret);
return ret;
}
template <typename T1, typename T2, typename T3, typename T4,
typename T5>
bool operator() (Glib::ustring const &format, T1 &arg1,
T2 &arg2, T3 &arg3, T4 &arg4, T5 &arg5)
{
push ();
Glib::ustring::size_type inpos = 0;
bool ret = read_const (format, inpos)
&& read_var (format, arg1, inpos)
&& read_const (format, inpos)
&& read_var (format, arg2, inpos)
&& read_const (format, inpos)
&& read_var (format, arg3, inpos)
&& read_const (format, inpos)
&& read_var (format, arg4, inpos)
&& read_const (format, inpos)
&& read_var (format, arg5, inpos)
&& read_const (format, inpos)
&& inpos == format.size ();
pop (ret);
return ret;
}
template <typename T1, typename T2, typename T3, typename T4,
typename T5, typename T6>
bool operator() (Glib::ustring const &format, T1 &arg1,
T2 &arg2, T3 &arg3, T4 &arg4, T5 &arg5,
T6 &arg6)
{
push ();
Glib::ustring::size_type inpos = 0;
bool ret = read_const (format, inpos)
&& read_var (format, arg1, inpos)
&& read_const (format, inpos)
&& read_var (format, arg2, inpos)
&& read_const (format, inpos)
&& read_var (format, arg3, inpos)
&& read_const (format, inpos)
&& read_var (format, arg4, inpos)
&& read_const (format, inpos)
&& read_var (format, arg5, inpos)
&& read_const (format, inpos)
&& read_var (format, arg6, inpos)
&& read_const (format, inpos)
&& inpos == format.size ();
pop (ret);
return ret;
}
template <typename T1, typename T2, typename T3, typename T4,
typename T5, typename T6, typename T7>
bool operator() (Glib::ustring const &format, T1 &arg1,
T2 &arg2, T3 &arg3, T4 &arg4, T5 &arg5,
T6 &arg6, T7 &arg7)
{
push ();
Glib::ustring::size_type inpos = 0;
bool ret = read_const (format, inpos)
&& read_var (format, arg1, inpos)
&& read_const (format, inpos)
&& read_var (format, arg2, inpos)
&& read_const (format, inpos)
&& read_var (format, arg3, inpos)
&& read_const (format, inpos)
&& read_var (format, arg4, inpos)
&& read_const (format, inpos)
&& read_var (format, arg5, inpos)
&& read_const (format, inpos)
&& read_var (format, arg6, inpos)
&& read_const (format, inpos)
&& read_var (format, arg7, inpos)
&& read_const (format, inpos)
&& inpos == format.size ();
pop (ret);
return ret;
}
template <typename T1, typename T2, typename T3, typename T4,
typename T5, typename T6, typename T7, typename T8>
bool operator() (Glib::ustring const &format, T1 &arg1,
T2 &arg2, T3 &arg3, T4 &arg4, T5 &arg5,
T6 &arg6, T7 &arg7, T8 &arg8)
{
push ();
Glib::ustring::size_type inpos = 0;
bool ret = read_const (format, inpos)
&& read_var (format, arg1, inpos)
&& read_const (format, inpos)
&& read_var (format, arg2, inpos)
&& read_const (format, inpos)
&& read_var (format, arg3, inpos)
&& read_const (format, inpos)
&& read_var (format, arg4, inpos)
&& read_const (format, inpos)
&& read_var (format, arg5, inpos)
&& read_const (format, inpos)
&& read_var (format, arg6, inpos)
&& read_const (format, inpos)
&& read_var (format, arg7, inpos)
&& read_const (format, inpos)
&& read_var (format, arg8, inpos)
&& read_const (format, inpos)
&& inpos == format.size ();
pop (ret);
return ret;
}
template <typename T>
static T direct (Glib::ustring const &data,
Glib::ustring const &format,
T def = T ())
{
T ret;
istring tmp (data);
if (!tmp (format, ret))
ret = def;
return ret;
}
};
template <typename T>
bool istring::read_var (Glib::ustring const &format, T &ret,
Glib::ustring::size_type &inpos)
{
++inpos;
std::istringstream s (data.substr (pos.top ()));
s >> ret;
std::streampos p = s.tellg ();
if (!s || p < 0)
return false;
pos.top () += p;
return true;
}
template <> bool istring::read_var <double> (Glib::ustring const &format, double &ret, Glib::ustring::size_type &inpos);
template <> bool istring::read_var <float> (Glib::ustring const &format, float &ret, Glib::ustring::size_type &inpos);
template <> bool istring::read_var <Glib::ustring> (Glib::ustring const &format, Glib::ustring &ret, Glib::ustring::size_type &inpos);
template <> bool istring::read_var <int> (Glib::ustring const &format, int &ret, Glib::ustring::size_type &inpos);
template <> bool istring::read_var <unsigned> (Glib::ustring const &format, unsigned &ret, Glib::ustring::size_type &inpos);
class ostring
{
Glib::ustring data;
Glib::ustring format;
Glib::ustring::size_type pos;
void write_const ();
template <typename T> void write_var (T const &a,
Glib::ustring const &flags,
unsigned width, unsigned precision);
template <typename T> void write_var_raw (T const &a);
ostring &init (Glib::ustring const &f);
// If you get a linker error to this line, you have tried to insert a std::string into a shevek::ostring.
// Fix the program by turning it into a Glib::ustring first, or by using a shevek::rostring instead.
template <typename T> ostring &operator ()(T const &a) { write_const (); write_var_raw (a); return *this; }
ostring &operator ()();
public:
operator Glib::ustring () const { return data; }
Glib::ustring operator+ (Glib::ustring const &that) const { return data + that; }
friend std::ostream &operator<< (std::ostream &s, ostring const &o) { return s << o.data; }
ostring (Glib::ustring const &fmt) { init (fmt)(); }
template <typename T1>
ostring (Glib::ustring const &fmt, T1 const &a1)
{ init (fmt)(a1)(); }
template <typename T1, typename T2>
ostring (Glib::ustring const &fmt, T1 const &a1, T2 const &a2)
{ init (fmt)(a1)(a2)(); }
template <typename T1, typename T2, typename T3>
ostring (Glib::ustring const &fmt, T1 const &a1, T2 const &a2,
T3 const &a3)
{ init (fmt)(a1)(a2)(a3)(); }
template <typename T1, typename T2, typename T3, typename T4>
ostring (Glib::ustring const &fmt, T1 const &a1, T2 const &a2,
T3 const &a3, T4 const &a4)
{ init (fmt)(a1)(a2)(a3)(a4)(); }
template <typename T1, typename T2, typename T3, typename T4,
typename T5>
ostring (Glib::ustring const &fmt, T1 const &a1, T2 const &a2,
T3 const &a3, T4 const &a4, T5 const &a5)
{ init (fmt)(a1)(a2)(a3)(a4)(a5)(); }
template <typename T1, typename T2, typename T3, typename T4,
typename T5, typename T6>
ostring (Glib::ustring const &fmt, T1 const &a1, T2 const &a2,
T3 const &a3, T4 const &a4, T5 const &a5,
T6 const &a6)
{ init (fmt)(a1)(a2)(a3)(a4)(a5)(a6)(); }
template <typename T1, typename T2, typename T3, typename T4,
typename T5, typename T6, typename T7>
ostring (Glib::ustring const &fmt, T1 const &a1, T2 const &a2,
T3 const &a3, T4 const &a4, T5 const &a5,
T6 const &a6, T7 const &a7)
{ init (fmt)(a1)(a2)(a3)(a4)(a5)(a6)(a7)(); }
template <typename T1, typename T2, typename T3, typename T4,
typename T5, typename T6, typename T7 ,typename T8>
ostring (Glib::ustring const &fmt, T1 const &a1, T2 const &a2,
T3 const &a3, T4 const &a4, T5 const &a5,
T6 const &a6, T7 const &a7, T8 const &a8)
{ init (fmt)(a1)(a2)(a3)(a4)(a5)(a6)(a7)(a8)(); }
template <typename T1, typename T2, typename T3, typename T4,
typename T5, typename T6, typename T7 ,typename T8,
typename T9>
ostring (Glib::ustring const &fmt, T1 const &a1, T2 const &a2,
T3 const &a3, T4 const &a4, T5 const &a5,
T6 const &a6, T7 const &a7, T8 const &a8,
T9 const &a9)
{ init (fmt)(a1)(a2)(a3)(a4)(a5)(a6)(a7)(a8)(a9)(); }
};
template <typename T> void ostring::write_var_raw (T const &a)
{
unsigned width = 0, precision = 0;
Glib::ustring flags;
while (pos < format.size ()
&& (format[pos] < 'a' || format[pos] > 'z')
&& (format[pos] < 'A' || format[pos] > 'Z')
&& (format[pos] < '1' || format[pos] > '9'))
flags += format[pos++];
while (pos < format.size () && format[pos] >= '0'
&& format[pos] <= '9')
{
width *= 10;
width += format[pos++] - '0';
}
if (pos < format.size () && format[pos] == '.')
{
++pos;
while (pos < format.size () && format[pos] >= '0'
&& format[pos] <= '9')
{
precision *= 10;
precision += format[pos++] - '0';
}
}
return write_var (a, flags, width, precision);
}
template <typename T> void ostring::write_var (T const &a,
Glib::ustring const &flags,
unsigned width, unsigned precision)
{
(void)flags;
(void)width;
(void)precision;
if (pos < format.size ())
++pos;
std::ostringstream s;
s << a;
data += s.str ();
}
template <> void ostring::write_var <unsigned short> (unsigned short const &a, Glib::ustring const &flags, unsigned width, unsigned precision);
template <> void ostring::write_var <short> (short const &a, Glib::ustring const &flags, unsigned width, unsigned precision);
template <> void ostring::write_var <unsigned> (unsigned const &a, Glib::ustring const &flags, unsigned width, unsigned precision);
template <> void ostring::write_var <int> (int const &a, Glib::ustring const &flags, unsigned width, unsigned precision);
template <> void ostring::write_var <Glib::ustring> (Glib::ustring const &a, Glib::ustring const &flags, unsigned width, unsigned precision);
template <> void ostring::write_var_raw <std::string> (std::string const &a);
template <> bool istring::read_var <std::string> (Glib::ustring const &format, std::string &ret, Glib::ustring::size_type &inpos);
class ristring
{
// The data to parse.
std::string data;
// Pointer to data still to be parsed.
std::stack <std::string::size_type> pos;
// Read a variable.
template <typename T>
bool read_var (std::string const &format, T &ret, std::string::size_type &inpos);
// Read away whitespace.
void del_whitespace ();
// Check for a constant.
bool read_const (std::string const &format, std::string::size_type &inpos);
public:
// Constructors: fill data and make one stack level.
ristring () { pos.push (0); }
ristring (std::string const &str) { init (str); }
void init (std::string const &str) { data = str; while (!pos.empty ()) pos.pop (); pos.push (0); }
// Stack functions.
void push () { pos.push (pos.top ()); }
int pop (bool keep = false);
void reset () { pos.top () = 0; }
std::string rest () const { return data.substr (pos.top ()); }
void skip (std::string::size_type p) { pos.top () += p; }
bool operator() (std::string const &format)
{
push ();
std::string::size_type inpos = 0;
bool ret = read_const (format, inpos)
&& inpos == format.size ();
pop (ret);
return ret;
}
template <typename T1>
bool operator() (std::string const &format, T1 &arg1)
{
push ();
std::string::size_type inpos = 0;
bool ret = read_const (format, inpos)
&& read_var (format, arg1, inpos)
&& read_const (format, inpos)
&& inpos == format.size ();
pop (ret);
return ret;
}
template <typename T1, typename T2>
bool operator() (std::string const &format, T1 &arg1,
T2 &arg2)
{
push ();
std::string::size_type inpos = 0;
bool ret = read_const (format, inpos)
&& read_var (format, arg1, inpos)
&& read_const (format, inpos)
&& read_var (format, arg2, inpos)
&& read_const (format, inpos)
&& inpos == format.size ();
pop (ret);
return ret;
}
template <typename T1, typename T2, typename T3>
bool operator() (std::string const &format, T1 &arg1,
T2 &arg2, T3 &arg3)
{
push ();
std::string::size_type inpos = 0;
bool ret = read_const (format, inpos)
&& read_var (format, arg1, inpos)
&& read_const (format, inpos)
&& read_var (format, arg2, inpos)
&& read_const (format, inpos)
&& read_var (format, arg3, inpos)
&& read_const (format, inpos)
&& inpos == format.size ();
pop (ret);
return ret;
}
template <typename T1, typename T2, typename T3, typename T4>
bool operator() (std::string const &format, T1 &arg1,
T2 &arg2, T3 &arg3, T4 &arg4)
{
push ();
std::string::size_type inpos = 0;
bool ret = read_const (format, inpos)
&& read_var (format, arg1, inpos)
&& read_const (format, inpos)
&& read_var (format, arg2, inpos)
&& read_const (format, inpos)
&& read_var (format, arg3, inpos)
&& read_const (format, inpos)
&& read_var (format, arg4, inpos)
&& read_const (format, inpos)
&& inpos == format.size ();
pop (ret);
return ret;
}
template <typename T1, typename T2, typename T3, typename T4,
typename T5>
bool operator() (std::string const &format, T1 &arg1,
T2 &arg2, T3 &arg3, T4 &arg4, T5 &arg5)
{
push ();
std::string::size_type inpos = 0;
bool ret = read_const (format, inpos)
&& read_var (format, arg1, inpos)
&& read_const (format, inpos)
&& read_var (format, arg2, inpos)
&& read_const (format, inpos)
&& read_var (format, arg3, inpos)
&& read_const (format, inpos)
&& read_var (format, arg4, inpos)
&& read_const (format, inpos)
&& read_var (format, arg5, inpos)
&& read_const (format, inpos)
&& inpos == format.size ();
pop (ret);
return ret;
}
template <typename T1, typename T2, typename T3, typename T4,
typename T5, typename T6>
bool operator() (std::string const &format, T1 &arg1,
T2 &arg2, T3 &arg3, T4 &arg4, T5 &arg5,
T6 &arg6)
{
push ();
std::string::size_type inpos = 0;
bool ret = read_const (format, inpos)
&& read_var (format, arg1, inpos)
&& read_const (format, inpos)
&& read_var (format, arg2, inpos)
&& read_const (format, inpos)
&& read_var (format, arg3, inpos)
&& read_const (format, inpos)
&& read_var (format, arg4, inpos)
&& read_const (format, inpos)
&& read_var (format, arg5, inpos)
&& read_const (format, inpos)
&& read_var (format, arg6, inpos)
&& read_const (format, inpos)
&& inpos == format.size ();
pop (ret);
return ret;
}
template <typename T1, typename T2, typename T3, typename T4,
typename T5, typename T6, typename T7>
bool operator() (std::string const &format, T1 &arg1,
T2 &arg2, T3 &arg3, T4 &arg4, T5 &arg5,
T6 &arg6, T7 &arg7)
{
push ();
std::string::size_type inpos = 0;
bool ret = read_const (format, inpos)
&& read_var (format, arg1, inpos)
&& read_const (format, inpos)
&& read_var (format, arg2, inpos)
&& read_const (format, inpos)
&& read_var (format, arg3, inpos)
&& read_const (format, inpos)
&& read_var (format, arg4, inpos)
&& read_const (format, inpos)
&& read_var (format, arg5, inpos)
&& read_const (format, inpos)
&& read_var (format, arg6, inpos)
&& read_const (format, inpos)
&& read_var (format, arg7, inpos)
&& read_const (format, inpos)
&& inpos == format.size ();
pop (ret);
return ret;
}
template <typename T1, typename T2, typename T3, typename T4,
typename T5, typename T6, typename T7, typename T8>
bool operator() (std::string const &format, T1 &arg1,
T2 &arg2, T3 &arg3, T4 &arg4, T5 &arg5,
T6 &arg6, T7 &arg7, T8 &arg8)
{
push ();
std::string::size_type inpos = 0;
bool ret = read_const (format, inpos)
&& read_var (format, arg1, inpos)
&& read_const (format, inpos)
&& read_var (format, arg2, inpos)
&& read_const (format, inpos)
&& read_var (format, arg3, inpos)
&& read_const (format, inpos)
&& read_var (format, arg4, inpos)
&& read_const (format, inpos)
&& read_var (format, arg5, inpos)
&& read_const (format, inpos)
&& read_var (format, arg6, inpos)
&& read_const (format, inpos)
&& read_var (format, arg7, inpos)
&& read_const (format, inpos)
&& read_var (format, arg8, inpos)
&& read_const (format, inpos)
&& inpos == format.size ();
pop (ret);
return ret;
}
template <typename T>
static T direct (std::string const &data,
std::string const &format,
T def = T ())
{
T ret;
istring tmp (data);
if (!tmp (format, ret))
ret = def;
return ret;
}
};
template <typename T>
bool ristring::read_var (std::string const &format, T &ret, std::string::size_type &inpos)
{
(void *)&format;
++inpos;
std::istringstream s (data.substr (pos.top ()));
s >> ret;
std::streampos p = s.tellg ();
if (!s || p < 0)
return false;
pos.top () += p;
return true;
}
template <>
bool ristring::read_var <double> (std::string const &format,
double &ret, std::string::size_type &inpos);
template <>
bool ristring::read_var <float> (std::string const &format,
float &ret, std::string::size_type &inpos);
template <>
bool ristring::read_var <std::string> (std::string const &format,
std::string &ret, std::string::size_type &inpos);
template <>
bool ristring::read_var <int> (std::string const &format,
int &ret, std::string::size_type &inpos);
template <>
bool ristring::read_var <unsigned> (std::string const &format,
unsigned &ret, std::string::size_type &inpos);
class rostring
{
std::string data;
std::string format;
std::string::size_type pos;
void write_const ();
template <typename T> void write_var (T const &a,
std::string const &flags,
unsigned width, unsigned precision);
template <typename T> void write_var_raw (T const &a);
rostring &init (std::string const &f);
template <typename T> rostring &operator ()(T const &a)
{ write_const (); write_var_raw (a); return *this; }
rostring &operator ()();
public:
operator std::string () const { return data; }
std::string operator+ (std::string const &that) const { return data + that; }
friend std::ostream &operator<< (std::ostream &s, rostring const &o) { return s << o.data; }
rostring (std::string const &fmt)
{ init (fmt)(); }
template <typename T1>
rostring (std::string const &fmt, T1 const &a1)
{ init (fmt)(a1)(); }
template <typename T1, typename T2>
rostring (std::string const &fmt, T1 const &a1, T2 const &a2)
{ init (fmt)(a1)(a2)(); }
template <typename T1, typename T2, typename T3>
rostring (std::string const &fmt, T1 const &a1, T2 const &a2, T3 const &a3)
{ init (fmt)(a1)(a2)(a3)(); }
template <typename T1, typename T2, typename T3, typename T4>
rostring (std::string const &fmt, T1 const &a1, T2 const &a2, T3 const &a3, T4 const &a4)
{ init (fmt)(a1)(a2)(a3)(a4)(); }
template <typename T1, typename T2, typename T3, typename T4, typename T5>
rostring (std::string const &fmt, T1 const &a1, T2 const &a2, T3 const &a3, T4 const &a4, T5 const &a5)
{ init (fmt)(a1)(a2)(a3)(a4)(a5)(); }
template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
rostring (std::string const &fmt, T1 const &a1, T2 const &a2, T3 const &a3, T4 const &a4, T5 const &a5, T6 const &a6)
{ init (fmt)(a1)(a2)(a3)(a4)(a5)(a6)(); }
template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
rostring (std::string const &fmt, T1 const &a1, T2 const &a2, T3 const &a3, T4 const &a4, T5 const &a5, T6 const &a6, T7 const &a7)
{ init (fmt)(a1)(a2)(a3)(a4)(a5)(a6)(a7)(); }
template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7 ,typename T8>
rostring (std::string const &fmt, T1 const &a1, T2 const &a2, T3 const &a3, T4 const &a4, T5 const &a5, T6 const &a6, T7 const &a7, T8 const &a8)
{ init (fmt)(a1)(a2)(a3)(a4)(a5)(a6)(a7)(a8)(); }
template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7 ,typename T8, typename T9>
rostring (std::string const &fmt, T1 const &a1, T2 const &a2, T3 const &a3, T4 const &a4, T5 const &a5, T6 const &a6, T7 const &a7, T8 const &a8, T9 const &a9)
{ init (fmt)(a1)(a2)(a3)(a4)(a5)(a6)(a7)(a8)(a9)(); }
};
template <typename T> void rostring::write_var_raw (T const &a)
{
unsigned width = 0, precision = 0;
std::string flags;
while (pos < format.size ()
&& (format[pos] < 'a' || format[pos] > 'z')
&& (format[pos] < 'A' || format[pos] > 'Z')
&& (format[pos] < '1' || format[pos] > '9'))
flags += format[pos++];
while (pos < format.size () && format[pos] >= '0'
&& format[pos] <= '9')
{
width *= 10;
width += format[pos++] - '0';
}
if (pos < format.size () && format[pos] == '.')
{
++pos;
while (pos < format.size () && format[pos] >= '0'
&& format[pos] <= '9')
{
precision *= 10;
precision += format[pos++] - '0';
}
}
return write_var (a, flags, width, precision);
}
template <typename T> void rostring::write_var (T const &a, std::string const &flags, unsigned width, unsigned precision)
{
(void)flags;
(void)width;
(void)precision;
if (pos < format.size ())
++pos;
std::ostringstream s;
s << a;
data += s.str ();
}
template <> void rostring::write_var <unsigned> (unsigned const &a, std::string const &flags, unsigned width, unsigned precision);
template <> void rostring::write_var <int> (int const &a, std::string const &flags, unsigned width, unsigned precision);
template <> void rostring::write_var_raw <Glib::ustring> (Glib::ustring const &a);
template <> bool ristring::read_var <Glib::ustring> (std::string const &format, Glib::ustring &ret, std::string::size_type &inpos);
}
#endif
shevek::ostring
shevek::ostring is a C++ version of printf.
Definition: iostring.hh:322
shevek::ristring::push
void push()
Push the current position to the stack so it can be restored later.
Definition: iostring.hh:496
shevek::istring::rest
Glib::ustring rest() const
Get remaining string.
Definition: iostring.hh:70
shevek::ostring::ostring
ostring(Glib::ustring const &fmt)
Create a string with a constant format.
Definition: iostring.hh:345
shevek::ostring::ostring
ostring(Glib::ustring const &fmt, T1 const &a1, T2 const &a2)
Create a string with two arguments.
Definition: iostring.hh:352
shevek::ristring::init
void init(std::string const &str)
Set new data to an existing istring.
Definition: iostring.hh:492
shevek::ostring::ostring
ostring(Glib::ustring const &fmt, T1 const &a1, T2 const &a2, T3 const &a3, T4 const &a4)
Create a string with four arguments.
Definition: iostring.hh:361
shevek::rostring::rostring
rostring(std::string const &fmt, T1 const &a1, T2 const &a2, T3 const &a3, T4 const &a4)
Create a string with four arguments.
Definition: iostring.hh:803
shevek::rostring
shevek::rostring is identical to shevek::ostring, but it uses std::string instead of Glib::ustring...
Definition: iostring.hh:765
shevek::ostring::ostring
ostring(Glib::ustring const &fmt, T1 const &a1, T2 const &a2, T3 const &a3, T4 const &a4, T5 const &a5, T6 const &a6, T7 const &a7)
Create a string with seven arguments.
Definition: iostring.hh:380
shevek::ostring::operator+
Glib::ustring operator+(Glib::ustring const &that) const
Use the result as a string.
Definition: iostring.hh:341
shevek::ostring::operator<<
friend std::ostream & operator<<(std::ostream &s, ostring const &o)
Send the result to an ostream.
Definition: iostring.hh:343
shevek::rostring::rostring
rostring(std::string const &fmt, T1 const &a1, T2 const &a2, T3 const &a3)
Create a string with three arguments.
Definition: iostring.hh:799
shevek::ristring::direct
static T direct(std::string const &data, std::string const &format, T def=T())
Read a variable from given data and return it.
Definition: iostring.hh:709
shevek::ostring::ostring
ostring(Glib::ustring const &fmt, T1 const &a1, T2 const &a2, T3 const &a3, T4 const &a4, T5 const &a5, T6 const &a6, T7 const &a7, T8 const &a8, T9 const &a9)
Create a string with nine arguments.
Definition: iostring.hh:395
shevek::ristring::rest
std::string rest() const
Get remaining string.
Definition: iostring.hh:506
shevek
Definition: args.hh:52
shevek::istring::istring
istring(Glib::ustring const &str)
Create a new istring with data.
Definition: iostring.hh:53
shevek::rostring::rostring
rostring(std::string const &fmt, T1 const &a1, T2 const &a2, T3 const &a3, T4 const &a4, T5 const &a5, T6 const &a6, T7 const &a7)
Create a string with seven arguments.
Definition: iostring.hh:815
shevek::istring::reset
void reset()
Set the current position to 0, but don't change the stack.
Definition: iostring.hh:67
shevek::rostring::rostring
rostring(std::string const &fmt, T1 const &a1)
Create a string with one argument.
Definition: iostring.hh:791
shevek::rostring::rostring
rostring(std::string const &fmt, T1 const &a1, T2 const &a2)
Create a string with two arguments.
Definition: iostring.hh:795
shevek::ristring::ristring
ristring()
Create a new istring with no data.
Definition: iostring.hh:488
shevek::ristring::skip
void skip(std::string::size_type p)
Skip some characters.
Definition: iostring.hh:509
shevek::rostring::rostring
rostring(std::string const &fmt, T1 const &a1, T2 const &a2, T3 const &a3, T4 const &a4, T5 const &a5, T6 const &a6, T7 const &a7, T8 const &a8, T9 const &a9)
Create a string with nine arguments.
Definition: iostring.hh:823
shevek::istring::push
void push()
Push the current position to the stack so it can be restored later.
Definition: iostring.hh:60
shevek::rostring::rostring
rostring(std::string const &fmt, T1 const &a1, T2 const &a2, T3 const &a3, T4 const &a4, T5 const &a5)
Create a string with five arguments.
Definition: iostring.hh:807
shevek::rostring::operator<<
friend std::ostream & operator<<(std::ostream &s, rostring const &o)
Send the result to an ostream.
Definition: iostring.hh:785
shevek::ostring::ostring
ostring(Glib::ustring const &fmt, T1 const &a1)
Create a string with one argument.
Definition: iostring.hh:348
shevek::ostring::ostring
ostring(Glib::ustring const &fmt, T1 const &a1, T2 const &a2, T3 const &a3, T4 const &a4, T5 const &a5, T6 const &a6, T7 const &a7, T8 const &a8)
Create a string with eight arguments.
Definition: iostring.hh:387
shevek::ristring::reset
void reset()
Set the current position to 0, but don't change the stack.
Definition: iostring.hh:503
shevek::istring
shevek::istring is a C++ version of scanf.
Definition: iostring.hh:32
shevek::ostring::ostring
ostring(Glib::ustring const &fmt, T1 const &a1, T2 const &a2, T3 const &a3)
Create a string with three arguments.
Definition: iostring.hh:356
shevek::istring::istring
istring()
Create a new istring with no data.
Definition: iostring.hh:51
shevek::ristring::operator()
bool operator()(std::string const &format)
Read a constant string from the input.
Definition: iostring.hh:512
shevek::rostring::rostring
rostring(std::string const &fmt, T1 const &a1, T2 const &a2, T3 const &a3, T4 const &a4, T5 const &a5, T6 const &a6, T7 const &a7, T8 const &a8)
Create a string with eight arguments.
Definition: iostring.hh:819
shevek::rostring::operator+
std::string operator+(std::string const &that) const
Use the result as a string.
Definition: iostring.hh:783
shevek::istring::direct
static T direct(Glib::ustring const &data, Glib::ustring const &format, T def=T())
Read a variable from given data and return it.
Definition: iostring.hh:273
shevek::ristring
shevek::ristring is identical to shevek::istring, but it uses std::string instead of Glib::ustring...
Definition: iostring.hh:469
shevek::ristring::ristring
ristring(std::string const &str)
Create a new istring with data.
Definition: iostring.hh:490
shevek::rostring::rostring
rostring(std::string const &fmt, T1 const &a1, T2 const &a2, T3 const &a3, T4 const &a4, T5 const &a5, T6 const &a6)
Create a string with six arguments.
Definition: iostring.hh:811
shevek::ostring::ostring
ostring(Glib::ustring const &fmt, T1 const &a1, T2 const &a2, T3 const &a3, T4 const &a4, T5 const &a5)
Create a string with five arguments.
Definition: iostring.hh:367
shevek::ostring::ostring
ostring(Glib::ustring const &fmt, T1 const &a1, T2 const &a2, T3 const &a3, T4 const &a4, T5 const &a5, T6 const &a6)
Create a string with six arguments.
Definition: iostring.hh:373
shevek::istring::init
void init(Glib::ustring const &str)
Set new data to an existing istring.
Definition: iostring.hh:55
shevek::ristring::pop
int pop(bool keep=false)
Pop the last pushed position from the stack.
shevek::istring::pop
int pop(bool keep=false)
Pop the last pushed position from the stack.
shevek::istring::operator()
bool operator()(Glib::ustring const &format)
Read a constant string from the input.
Definition: iostring.hh:76
shevek::istring::skip
void skip(Glib::ustring::size_type p)
Skip some characters.
Definition: iostring.hh:73
shevek::rostring::rostring
rostring(std::string const &fmt)
Create a string with a constant format.
Definition: iostring.hh:787