Changeset 10270 for trunk/FACT++

Timestamp:

03/30/11 15:41:11 (13 years ago)

Author:

tbretz

Message:

Change the interface. Now it first compiles the format string into a binary representation and any conversion can then be done later based on this.

Location:

trunk/FACT++/src

Files:

• Converter.cc (modified) (9 diffs)
• Converter.h (modified) (2 diffs)

trunk/FACT++/src/Converter.cc

@@ -2 +2 @@
 /** @class Converter
 
-@brief An interpreter to convert a command line into a command plus data memory
+@brief A compiler for the DIM data format string
 
 The Converter class interprets arguments in a string accoring to the
@@ -21 +21 @@
 
 \code
-  Converter c(cout, "I:1;F:2;I:2", "COMMAND 1 2.5 4.2 3 4");
+   Converter c(cout, "I:1;F:2;I:2", );
+   vector<char> v = c.GetVector("COMMAND 1 2.5 4.2 3 4");
 \endcode
 
@@ -30 +31 @@
 
 \code
-   Converter c(cout, "I:1;F:2;I:2", pointer, size);
+   Converter c(cout, "I:1;F:2;I:2");
+   cout << c.GetString(pointer, size) << endl;
  \endcode
 
+Other conversion functions also exist.
+
+A result of a conversion is valid if valid() returns true and either the
+result of the conversion is empty and the format string was valid empty
+or both contain contents.
+
+The format parameter \b W(ord) is dedicated to this kind of conversion and
+not understood by Dim. In addition there are \b O(ptions) which are like
+Words but can be omitted. They should only be used at the end of the string.
+\b B(ool) is also special. It evaluates true/false, yes/no, on/off, 1/0.
+
+The non-DIM like format options can be switched on and off by using the
+strict argument in the constructor.
+
+*/
+// **************************************************************************
+#include "Converter.h"
+
+#include <iostream>
+#include <iomanip>
+#include <sstream>
+
+#include <cctype>    // std::tolower
+#include <algorithm> // std::transform
+
+#include <boost/regex.hpp>
+
+#include "Readline.h"
+#include "WindowLog.h"
+
+using namespace std;
+/*
 In addition to converting the options from a string into binary format
 or back all found values are also put into a vector of boost::any objects.
@@ -46 +80 @@
    cout << c.Get<string>(4) << endl;  // prints 'is a test'
 \endcode
-
-The format parameter \b W(ord) is dedicated to this kind of conversion and
-not understood by Dim. In addition there are \b O(ptions) which are like
-Words but can be omitted. They should only be used at the end of the string.
-\b B(ool) is also special. It evaluates true/false, yes/no, on/off, 1/0.
-
-Access with Converter::Get() is exception safe. Access with Converter::At()
-would throw an exception if the index is out of bounds or the conversion
-fails. (This is the prefered method if the type is well known, to easily
-detect programing faults)
-
-@remark
-    Most probably we support more formats than dim does...
-
 */
-// **************************************************************************
-#include "Converter.h"
-
-#include <iomanip>
-#include <sstream>
-
-#include <cctype>    // std::tolower
-#include <algorithm> // std::transform
-
-#include <boost/regex.hpp>
-
-#include "Readline.h"
-#include "WindowLog.h"
-
-using namespace std;
-
+
+// --------------------------------------------------------------------------
+//
+//! This function is supposed to remove all whitespaces from the format
+//! string to allow easier regular expressions later.
+//!
+//! @param s
+//!     string to be cleaned
+//!
+//! @returns
+//!     string cleaned from whitespaces
+//
+std::string Converter::Clean(std::string s)
+{
+    while (1)
+    {
+        const size_t pos = s.find_last_of(' ');
+        if (pos==string::npos)
+            break;
+        s.erase(pos, pos+1);
+    }
+
+    return s;
+}
+
+// --------------------------------------------------------------------------
+//
+//! This is just a simplification. For the time being it is used to output
+//! the interpreted contents to the logging stream. Its main purpose
+//! is to add the contents of val in a binary representation to the
+//! vector v
+//!
+//! @tparam
+//!     data type of the variable which should be added
+//!
+//! @param val
+//!     reference to the data
+//!
+//! @param v
+//!     vector<char> to which the binary copy should be added
+//!
 template <class T>
-    void Converter::EvalImp(int i, std::stringstream &line, std::vector<char> &v, const T &val)
-{
-    if (!line)
-        wout << " arg[" << i << "]";
-    else
-        wout << " (" << val << ")";
-
-    vec.push_back(val);
+void Converter::GetBinImp(std::vector<char> &v, const T &val) const
+{
+    wout << " (" << val << ")";
 
     v.insert(v.end(),
@@ -92 +132 @@
 }
 
-
-// --------------------------------------------------------------------------
-//
-//! Gets a value of the template type T from the stringstream and adds the
-//! value as binary data to the end of the vector. If a value couldn't be
-//! obtained it is set to 0.
-//!
-//! Adds the value to Converter::vec.
-//!
-//! @param i
-//!     The number of the processed argument (currently used for some debug
-//!     output when an argument is not available and artificially set to 0)
+// --------------------------------------------------------------------------
+//
+//! This is just a simplification. For the time being it is used to output
+//! the interpreted contents to the logging stream. Its main purpose
+//! is to add the contents of val as a boost::any object to the
+//! vector v
+//!
+//! @tparam
+//!     data type of the variable which should be added
+//!
+//! @param val
+//!     reference to the data
+//!
+//! @param v
+//!     vector<boost::any> to which the value should be added
+//!
+template <class T>
+void Converter::GetBinImp(std::vector<boost::any> &v, const T &val) const
+{
+    wout << " (" << val << ")";
+
+    v.push_back(val);
+}
+
+// --------------------------------------------------------------------------
+//
+//! This is just a simplification. For the time being it is used to output
+//! the interpreted contents to the logging stream. Its main purpose
+//! is to add the contents of the provided string at the end of the vector v.
+//! vector v
+//!
+//! @param val
+//!     reference to the string
+//!
+//! @param v
+//!     vector<char> to which the value should be added
+//!
+void Converter::GetBinString(std::vector<char> &v, const string &val) const
+{
+    wout << " (" << val << ")";
+
+    v.insert(v.end(), val.begin(), val.end());
+}
+
+// --------------------------------------------------------------------------
+//
+//! This is just a simplification. For the time being it is used to output
+//! the interpreted contents to the logging stream. Its main purpose
+//! is to add the contents of the provided string at the end of the vector v.
+//! vector v
+//!
+//! @param val
+//!     reference to the string
+//!
+//! @param v
+//!     vector<boost::any> to which the value should be added
+//!
+void Converter::GetBinString(std::vector<boost::any> &v, const string &val) const
+{
+    wout << " (" << val << ")";
+
+    v.push_back(val);
+}
+
+// --------------------------------------------------------------------------
+//
+//! Converts from the stringstream into the provided type.
 //!
 //! @param line
-//!     The stringstream from which the data should be read
-//!
-//! @param vec
-//!     The vector of bytes at which end the data is added in binary format
+//!     reference to the stringstream from which the data should be
+//!     interpreted
+//!
+//! @tparam
+//!     Type of the data to be returned
+//!
+//! @returns
+//!     The interpreted data
 //!
 template <class T>
-    void Converter::Eval(int i, std::stringstream &line, std::vector<char> &v)
+T Converter::Get(std::stringstream &line) const
 {
     T val;
     line >> val;
-
-    EvalImp(i, line, v, val);
-}
-
-// --------------------------------------------------------------------------
-//
-//! This functions works similar the the template Eval but is dedicated to
-//! bools. It evaluates yes/no, on/off, true/false and 1/0.
-//!
-//! Sets the failbit of the stream if the "value" is not known.
-//!
-//! Adds the value to Converter::vec.
+    return val;
+}
+
+// --------------------------------------------------------------------------
+//
+//! Converts from the stringstream into bool. It allows to use lexical
+//! boolean representations like yes/no, on/off, true/false and of
+//! course 0/1. If the conversion fails the failbit is set.
 //!
 //! @param line
-//!     The stringstream from which the data should be read
-//!
-//! @param vec
-//!     The vector of bytes at which end the data is added in binary format
+//!     reference to the stringstream from which the data should be
+//!     interpreted
 //!
 //! @returns
-//!     The bool evaluated
-//!
-void Converter::EvalBool(int i, std::stringstream &line, std::vector<char> &v)
+//!     The boolean. 0 in case of failure
+//!
+bool Converter::GetBool(std::stringstream &line) const
 {
     string buf;
@@ -145 +238 @@
 
     if (buf=="yes" || buf=="true" || buf=="on" || buf=="1")
-    {
-        EvalImp(i, line, v, bool(true));
-        return;
-    }
+        return true;
 
     if (buf=="no" || buf=="false" || buf=="off" || buf=="0")
-    {
-        EvalImp(i, line, v, bool(false));
-        return;
-    }
+        return false;
 
     line.clear(ios::failbit);
-}
-
-void Converter::EvalString(int i, std::stringstream &line, std::vector<char> &v)
+
+    return false;
+}
+
+// --------------------------------------------------------------------------
+//
+//! Converts from the stringstream into a string. Leading whitespaces are
+//! skipped. Everything up to the next whitespace is returned.
+//! strings can be encapsulated into escape characters ("). Note, that
+//! they cannot be nested.
+//!
+//! @param line
+//!     reference to the stringstream from which the data should be
+//!     interpreted
+//!
+//! @returns
+//!     The string
+//!
+string Converter::GetString(std::stringstream &line) const
 {
     while (line.peek()==' ')
@@ -173 +276 @@
         line >> buf;
 
-    EvalImp(i, line, v, buf);
-}
-
-// --------------------------------------------------------------------------
-//
-//! Constructs a data block from the given string according to the given
-//! format. (See also the class reference for more details).
-//!
-//! The data block is stored in a vector<char>. It's content can be
-//! retrieved using the member functions Ptr() and Size(). Whether parsing
-//! was successfull or not can be checked with GetRc().
-//! If parsing was not successfull, either the format contained something
-//! odd, the conversion failed (e.g. 5.5 for an int) or the string contained
-//! a wrong number of arguments.
+    return buf;
+}
+
+// --------------------------------------------------------------------------
+//
+//! Converts from the stringstream into a string. Leading whitespaces are
+//! skipped. Everything until the end-of-line is returned. A trailing
+//! \0 is added.
+//!
+//! @param line
+//!     reference to the stringstream from which the data should be
+//!     interpreted
+//!
+//! @returns
+//!     The string
+//!
+string Converter::GetStringEol(stringstream &line) const
+{
+    // Remove leading whitespaces
+    while (line.peek()==' ')
+        line.get();
+
+    line >> noskipws;
+
+    const istream_iterator<char> eol; // end-of-line iterator
+    const string s(istream_iterator<char>(line), eol);
+    return s + '\0';
+}
+
+// --------------------------------------------------------------------------
+//
+//! Converts from a binary block into a string. The type of the expected
+//! value is defined by the template parameter.
+//!
+//! @param ptr
+//!     A refrenece to the pointer of the binary representation to be
+//!     interpreted. The pointer is incremented by the sizeof the type.
+//!
+//! @tparam T
+//!     Expected type
+//!
+//! @returns
+//!     The string
+//!
+template<class T>
+string Converter::GetString(const char* &ptr) const
+{
+    const T &t = *reinterpret_cast<const T*>(ptr);
+
+    ostringstream stream;
+    stream << t;
+    ptr += sizeof(T);
+
+    return stream.str();
+}
+
+// --------------------------------------------------------------------------
+//
+//! Converts from a binary block into a hex representation.
+//!
+//! @param ptr
+//!     Pointer to the data block
+//!
+//! @param size
+//!     Size of the data block
+//!
+//! @returns
+//!     The string
+//!
+string Converter::GetHex(const void *dat, int size)
+{
+    const char *ptr = reinterpret_cast<const char *>(dat);
+
+    ostringstream text;
+
+    text << hex;
+
+    for (int i=0; i<size; i++)
+        text << setw(2) << ptr[i] << " ";
+
+    return text.str();
+}
+
+// --------------------------------------------------------------------------
+//
+//! Convert the pointer using GetString into a string and add it (prefixed
+//! by a whaitespace) to the given string.
+//!
+//! @param str
+//!     Reference to the string to which the ptr should be added
+//!
+//! @param ptr
+//!     Pointer to the binary representation. It will be incremented
+//!     according to the sze of the template argument
+//!
+//! @tparam T
+//!     Type as which the binary data should be interpreted
+//!
+template<class T>
+void Converter::Add(string &str, const char* &ptr) const
+{
+    str += ' ' + GetString<T>(ptr);
+}
+
+// --------------------------------------------------------------------------
+//
+//! Convert the pointer into a boost::any object and add it to the
+//! provided vector
+//!
+//! @param vec
+//!     Vector to which the boost::any object should be added
+//!
+//! @param ptr
+//!     Pointer to the binary representation. It will be incremented
+//!     according to the sze of the template argument
+//!
+//! @tparam T
+//!     Type as which the binary data should be interpreted
+//!
+template<class T>
+void Converter::Add(vector<boost::any> &vec, const char* &ptr) const
+{
+    vec.push_back(*reinterpret_cast<const T*>(ptr));
+    ptr += sizeof(T);
+}
+
+// --------------------------------------------------------------------------
+//
+//! Add the string pointed to by ptr to the given string.
+//!
+//! @param str
+//!     Reference to the string to which the ptr should be added
+//!
+//! @param ptr
+//!     Pointer to the binary representation.
+//!
+void Converter::AddString(string &str, const string &ptr) const
+{
+    str += ' ' + ptr;
+}
+
+// --------------------------------------------------------------------------
+//
+//! Add the string pointed to by ptr as boost::any to the provided vector
+//!
+//! @param vec
+//!     Vector to which the boost::any object should be added
+//!
+//! @param ptr
+//!     Pointer to the binary representation of the string.
+//!
+void Converter::AddString(vector<boost::any> &vec, const string &ptr) const
+{
+    vec.push_back(ptr);
+}
+
+// --------------------------------------------------------------------------
+//
+//! Compiles the format string into fList. See Compile() for more details.
 //!
 //! @param out
-//!    The ostream to which errors and debug messages should be printed.
+//!     Output stream to which possible logging is redirected
 //!
 //! @param fmt
-//!    The format descriptor according to the dim definition
-//!
-//! @param str
-//!    The string which should be interpreted, e.g. "1 2 5.5 abcdef"
-//!
-Converter::Converter(std::ostream &out, const std::string &fmt, const std::string &str)
-: rc(false), wout(out)
-{
+//!     Format to be compiled. For details see class reference
+//!
+//! @param strict
+//!     Setting this to true allows non DIM options, whiel false
+//!     will restrict the possible format strings to the ones also
+//!     understood by DIM.
+//!
+Converter::Converter(std::ostream &out, const std::string &fmt, bool strict)
+: wout(out), fFormat(Clean(fmt)), fList(Compile(out, fmt, strict))
+{
+}
+
+// --------------------------------------------------------------------------
+//
+//! Compiles the format string into fList.
+//!
+//! Output by default is redirected to cout.
+//!
+//! @param fmt
+//!     Format to be compiled. For details see class reference
+//!
+//! @param strict
+//!     Setting this to true allows non DIM options, whiel false
+//!     will restrict the possible format strings to the ones also
+//!     understood by DIM.
+//!
+Converter::Converter(const std::string &fmt, bool strict)
+: wout(cout), fFormat(Clean(fmt)), fList(Compile(fmt, strict))
+{
+}
+
+// --------------------------------------------------------------------------
+//
+//! Converts the provided format string into a vector.
+//!
+//! @tparam T
+//!     Kind of data to be returned. This can either be boost::any objects
+//!     or a bnary data-block (char).
+//!
+//! @param fmt
+//!     Format to be compiled. For details see class reference
+//!
+//! @returns
+//!    A vector of the given template type containing the arguments. In
+//!    case of failure an empty vector is returned.
+//!
+template <class T>
+vector<T> Converter::Get(const std::string &str) const
+{
+    if (!valid())
+        return vector<T>();
+
     // If the format is empty we are already done
-    if (fmt.empty())
-    {
-        if (!str.empty())
+    if (empty())
+    {
+        if (str.empty())
         {
             wout << endl;
-            wout << kRed << "Data string not empty as it ought to be!" << endl;
-            return;
+            return vector<T>();
         }
 
         wout << endl;
-        rc = true;
-        return;
-    }
+        wout << kRed << "Data string not empty as it ought to be!" << endl;
+        return vector<T>();
+    }
+
+    int arg = 0;
+    stringstream line(str);
+
+    vector<T> data;
+
+    for (Converter::FormatList::const_iterator i=fList.begin(); i<fList.end(); i++)
+    {
+        if (*i->first.first == typeid(string))
+        {
+            GetBinString(data, GetStringEol(line));
+            line.clear(ios::eofbit);
+            continue;
+        }
+
+        // Get as many items from the input line as requested
+        for (int j=0; j<i->second.first; j++)
+        {
+            cout << j << ": " << i->first.first->name() << endl;
+            switch (i->first.first->name()[0])
+            {
+            case 'c': // Skip whitespaces when checking for characters
+                if (j>0)
+                    line >> noskipws;
+                GetBinImp(data, Get<char>(line));
+                line >> skipws;
+                break;
+            case 'b': GetBinImp(data, GetBool(line)); break;
+            case 's': GetBinImp(data, Get<short>    (line)); break;
+            case 'i': GetBinImp(data, Get<int>      (line)); break;
+            case 'l': GetBinImp(data, Get<long>     (line)); break;
+            case 'f': GetBinImp(data, Get<float>    (line)); break;
+            case 'd': GetBinImp(data, Get<double>   (line)); break;
+            case 'x': GetBinImp(data, Get<long long>(line)); break;
+            case 'N':
+                GetBinString(data, GetString(line));
+                if (*i->first.first == typeid(O))
+                    line.clear(ios::goodbit);
+                break;
+            default:
+                // This should never happen!
+                wout << endl << kRed << "Format '" << i->first.first->name() << " not supported!" << endl;
+                break;
+            }
+
+            arg++;
+        }
+
+        //wout << "{" << line.eof() << line.good() << line.fail() << "}";
+        if (!line)
+            break;
+    }
+
+    wout << endl;
+
+    // Something wrong with the conversion (e.g. 5.5 for an int)
+    if (line.fail() && !line.eof())
+    {
+        line.clear(); // This is necesasary to get a proper response from tellg()
+        wout << kRed << "Error converting argument at " << arg << " [fmt=" << fFormat << "]!" << endl;
+        wout << kRed << line.str() << endl;
+        wout << kRed << setw(int(line.tellg())) << " " << "^" << endl;
+        return vector<T>();
+    }
+
+    // Not enough arguments, we have not reached the end
+    if (line.fail() && line.eof())
+    {
+        line.clear();
+        wout << kRed << "Not enough arguments [fmt=" << fFormat << "]!" << endl;
+        wout << kRed << line.str() << endl;
+        wout << kRed << setw(int(line.tellg())+1) << " " << "^" << endl;
+        return vector<T>();
+    }
+
+    // Too many arguments, we have not reached the end
+    // Unfortunately, this can also mean that there is something
+    // wrong with the last argument
+    if (line.good() && !line.eof())
+    {
+        wout << kRed << "More arguments available than expected [" << fFormat << "]!" << endl;
+        wout << kRed << line.str() << endl;
+        wout << kRed << setw(int(line.tellg())+1) << " " << "^" << endl;
+        return vector<T>();
+    }
+
+    return data;
+
+}
+
+std::vector<boost::any> Converter::GetAny(const std::string &str) const
+{
+    return Get<boost::any>(str);
+}
+
+std::vector<char> Converter::GetVector(const std::string &str) const
+{
+    return Get<char>(str);
+}
+
+
+// --------------------------------------------------------------------------
+//
+//! Converts the provided data block into a vector of boost::any or
+//! a string.
+//!
+//! @tparam T
+//!     Kind of data to be returned. This can either be boost::any objects
+//!     or a string
+//!
+//! @returns
+//!    A vector of the given template type containing the arguments. In
+//!    case of failure an empty vector is returned.
+//!
+template<class T>
+T Converter::Get(const void *dat, int size) const
+{
+    if (!valid())
+        return T();
+
+    const char *ptr = reinterpret_cast<const char *>(dat);
+
+    T text;
+    for (Converter::FormatList::const_iterator i=fList.begin(); i<fList.end(); i++)
+    {
+        if (ptr-size>=dat)
+        {
+            wout << kRed << "Format description '" << fFormat << "' exceeds available data size (" << size << ")" << endl;
+            return T();
+        }
+
+        if (*i->first.first == typeid(string))
+        {
+            const string str(ptr);
+            AddString(text, str);
+            ptr += str.length()+1;
+            break;
+        }
+
+        // Get as many items from the input line as requested
+        for (int j=0; j<i->second.first; j++)
+        {
+            switch (i->first.first->name()[0])
+            {
+            case 'b': Add<bool>     (text, ptr); break;
+            case 'c': Add<char>     (text, ptr); break;
+            case 's': Add<short>    (text, ptr); break;
+            case 'i': Add<int>      (text, ptr); break;
+            case 'l': Add<long>     (text, ptr); break;
+            case 'f': Add<float>    (text, ptr); break;
+            case 'd': Add<double>   (text, ptr); break;
+            case 'x': Add<long long>(text, ptr); break;
+            case 'v':
+                // This should never happen!
+                wout << kRed << "Type 'void' not supported!" << endl;
+                return T();
+            default:
+                // This should never happen!
+                wout << kRed << "TypeId '" << i->first.first->name() << "' not known!" << endl;
+                return T();
+            }
+        }
+    }
+
+    if (ptr-size!=dat)
+    {
+        wout << kRed << "Data block size (" << size << ") doesn't fit format description '" << fFormat << "'" << endl;
+        return T();
+    }
+
+    return text;
+}
+
+std::vector<boost::any> Converter::GetAny(const void *dat, int size) const
+{
+    return Get<vector<boost::any>>(dat, size);
+}
+
+std::vector<char> Converter::GetVector(const void *dat, int size) const
+{
+    const string ref = GetString(dat, size);
+
+    vector<char> data;
+    data.insert(data.begin(), ref.begin()+1, ref.end());
+    data.push_back(0);
+
+    return data;
+}
+
+string Converter::GetString(const void *dat, int size) const
+{
+    return Get<string>(dat, size).substr(1);
+}
+
+template<class T>
+Converter::Type Converter::GetType()
+{
+    Type t;
+    t.first  = &typeid(T);
+    t.second = sizeof(T);
+    return t;
+}
+
+template<class T>
+Converter::Type Converter::GetVoid()
+{
+    Type t;
+    t.first  = &typeid(T);
+    t.second = 0;
+    return t;
+}
+
+// --------------------------------------------------------------------------
+//
+//! static function to compile a format string.
+//!
+//! @param out
+//!     Output stream to which possible logging is redirected
+//!
+//! @param fmt
+//!     Format to be compiled. For details see class reference
+//!
+//! @param strict
+//!     Setting this to true allows non DIM options, whiel false
+//!     will restrict the possible format strings to the ones also
+//!     understood by DIM.
+//!
+Converter::FormatList Converter::Compile(std::ostream &out, const std::string &fmt, bool strict)
+{
+    ostringstream text;
 
     // Access both, the data and the format through a stringstream
-    stringstream line(str);
     stringstream stream(fmt);
 
     // For better performance we could use sregex
-    static const boost::regex expr("^[ ]*([OBWCSILFDX])[ ]*(:[ ]*([1-9]+[0-9]*))?[ ]*$");
+    static const boost::regex expr1("^([CSILFDXBOW])(:([1-9]+[0-9]*))?$");
+    static const boost::regex expr2("^([CSILFDX])(:([1-9]+[0-9]*))?$");
+
+    FormatList list;
+    Format   format;
 
     // Tokenize the format
-    int arg = 0;
     string buffer;
     while (getline(stream, buffer, ';'))
     {
         boost::smatch what;
-        if (!boost::regex_match(buffer, what, expr))
+        if (!boost::regex_match(buffer, what, strict?expr2:expr1))
         {
-            wout << endl;
-            wout << kRed << "Wrong format string '" << buffer << "'!" << endl;
-            return;
+            out << kRed << "Wrong format string '" << buffer << "'!" << endl;
+            return FormatList();
         }
 
@@ -238 +760 @@
         const string n = what[3]; // counter
 
-        int cnt = atoi(n.c_str());
+        const int cnt = atoi(n.c_str());
+
+        // if the :N part was not given assume 1
+        format.second.first = cnt == 0 ? 1: cnt;
 
         // Check if the format is just C (without a number)
@@ -244 +769 @@
         if (t[0]=='C' && cnt==0)
         {
-            // Remove leading whitespaces
-            while (line.peek()==' ')
-                line.get();
-
-            line >> noskipws;
-
-            const istream_iterator<char> eol; // end-of-line iteartor
-            const string s(istream_iterator<char>(line), eol);
-
-            vec.push_back(s);
-
-            data.insert(data.end(), s.begin(), s.end());
-            data.push_back(0);
-
-            line.clear(ios::eofbit);
-
-            continue;
-        }
-
-        // if the :N part was not given assume 1
-        if (cnt==0)
-            cnt=1;
-
-        // Get as many items from the input line as requested
-        for (int j=0; j<cnt; j++)
-            switch (t[0])
-            {
-            case 'C': // Skip whitespaces when checking for characters
-                if (j>0)
-                    line >> noskipws;
-                Eval<char>(arg++, line, data);
-                line >> skipws;
-                break;
-            case 'B': EvalBool       (arg++, line, data); break;
-            case 'S': Eval<short>    (arg++, line, data); break;
-            case 'I': Eval<int>      (arg++, line, data); break;
-            case 'L': Eval<long>     (arg++, line, data); break;
-            case 'F': Eval<float>    (arg++, line, data); break;
-            case 'D': Eval<double>   (arg++, line, data); break;
-            case 'X': Eval<long long>(arg++, line, data); break;
-            case 'W': EvalString     (arg++, line, data); break;
-            case 'O': EvalString     (arg++, line, data); line.clear(ios::goodbit); break;
-            default:
-                // This should never happen!
-                wout << endl << kRed << "Format '" << t[0] << " not known!" << endl;
-                break;
-            }
-
-        //wout << "{" << line.eof() << line.good() << line.fail() << "}";
-        if (!line)
-            break;
-    }
-    //wout << "{" << line.eof() << line.good() << line.fail() << "}";
-
-    wout << " [" << fmt << "]=" << data.size() << endl;
-
-    // Something wrong with the conversion (e.g. 5.5 for an int)
-    if (line.fail() && !line.eof())
-    {
-        line.clear(); // This is necesasary to get a proper response from tellg()
-        wout << kRed << "Error converting argument at " << arg << " [fmt=" << fmt << "]!" << endl;
-        wout << kRed << str << endl;
-        wout << kRed << setw(int(line.tellg())) << " " << "^" << endl;
-        return;
-    }
-
-    // Not enough arguments, we have not reached the end
-    if (line.fail() && line.eof())
-    {
-        line.clear();
-        wout << kRed << "Not enough arguments [fmt=" << fmt << "]!" << endl;
-        wout << kRed << str << endl;
-        wout << kRed << setw(int(line.tellg())+1) << " " << "^" << endl;
-        return;
-    }
-
-    // Too many arguments, we have not reached the end
-    // Unfortunately, this can also mean that there is something
-    // wrong with the last argument
-    if (line.good() && !line.eof())
-    {
-        wout << kRed << "More arguments available than expected [" << fmt << "]!" << endl;
-        wout << kRed << str << endl;
-        wout << kRed << setw(int(line.tellg())+1) << " " << "^" << endl;
-        return;
-    }
-
-    // Set return code to true (successfull)
-    rc = true;
-}
-
-// --------------------------------------------------------------------------
-//
-//! Gets the value as a binary from the ptr and return it as a string.
-//! The pointer is increased accordingly.
-//!
-//! Adds the value to Converter::vec.
-//!
-//! @param ptr
-//!    A reference to a pointer to the data which should be converted.
-//!    The pointer is increased according to the size of the data.
-//!
-//! @returns
-//!    The data converted into a string
-//!
-template<class T>
-string Converter::Get(const char* &ptr)
-{
-    const T &t = *reinterpret_cast<const T*>(ptr);
-
-    vec.push_back(t);
-
-    ostringstream stream;
-    stream << t;
-    ptr += sizeof(T);
-
-    return stream.str();
-}
-
-// --------------------------------------------------------------------------
-//
-//! Constructs a string from the given data block according to the specified
-//! format. (See also the class reference for more details).
-//!
-//! The resulting string is stored in vector<char>  and 0-terminated.
-//! It can be accessed through Ptr().
-//!
-//! If the conversion faild GetRc will return false. In this case the data
-//! contents might not be well defined.
-//!
-//! If no format is given (size == 0) but the data size is finite (>0)
-//! then the data is converted into a hex representation.
-//!
-//! @remark
-//!    In cases of failures the stored data might be inexisting and
-//!    Ptr() might return NULL. If you output NULL to our streams
-//!    they might not show any further output anymore.
-//!
-//! @param fmt
-//!    The format descriptor according to the dim definition
-//!
-//! @param out
-//!    The ostream to which errors and debug messages should be printed.
-//!
-//! @param dat
-//!    Pointer to the start of the binary data
-//!
-//! @param size
-//!    Size of the binary data region
-//!
-Converter::Converter(ostream &out, const string &fmt, const void *dat, int size)
-: rc(false), wout(out)
-{
-    const char *ptr = reinterpret_cast<const char *>(dat);
-
-    ostringstream text;
-
-    // Structure: print hex representation
-    if (fmt.size()==0)
-    {
-        if (size==0)
-        {
-            data.push_back(0);
-            rc = true;
-            return;
-        }
-
-        text << hex;
-
-        for (int i=0; i<size; i++)
-            text << setw(2) << ptr[i] << " ";
-
-        const string &ref = text.str();
-        data.insert(data.begin(), ref.begin(), ref.end());
-        data.push_back(0);
-        return;
-    }
-
-    // Access both, the data and the format through a stringstream
-    stringstream stream(fmt);
-
-    // For better performance we could use sregex
-    static const boost::regex expr("^[ ]*([CSILFDX])[ ]*(:[ ]*([1-9]+[0-9]*))?[ ]*$");
-
-    // Tokenize the format
-    string buffer;
-    while (getline(stream, buffer, ';'))
-    {
-        if (ptr-size>=dat)
-        {
-            wout << kRed << "Format description '" << fmt << "' exceeds available data size (" << size << ")" << endl;
-            return;
-        }
-
-        boost::smatch what;
-        if (!boost::regex_match(buffer, what, expr))
-        {
-            wout << kRed << "Wrong format string '" << buffer << "'!" << endl;
-            return;
-        }
-
-        const string t = what[1]; // type id
-        const string n = what[3]; // counter
-
-        int cnt = atoi(n.c_str());
-
-        // Check if the format is just C (without a number)
-        // That would mean that it is a \0 terminated string
-        if (t[0]=='C' && cnt==0)
-        {
-            const string str(ptr);
-            text << ' ' << str;
-            ptr += str.length()+1;
-
-            vec.push_back(str);
-
+            format.first = GetType<string>();
+            list.push_back(format);
+            format.second.second = 0; // end position not known
             break;
         }
 
-        // if the :N part was not given assume 1
-        if (cnt==0)
-            cnt=1;
-
         // Get as many items from the input line as requested
-        for (int j=0; j<cnt; j++)
+        switch (t[0])
         {
-            text << ' ';
-
-            switch (t[0])
-            {
-            case 'C': text << Get<char>     (ptr); break;
-            case 'S': text << Get<short>    (ptr); break;
-            case 'I': text << Get<int>      (ptr); break;
-            case 'L': text << Get<long>     (ptr); break;
-            case 'F': text << Get<float>    (ptr); break;
-            case 'D': text << Get<double>   (ptr); break;
-            case 'X': text << Get<long long>(ptr); break;
-            default:
-                // This should never happen!
-                wout << kRed << "Format '" << t[0] << " not known!" << endl;
-                return;
-            }
+        case 'B':  format.first = GetType<bool>();      break;
+        case 'C':  format.first = GetType<char>();      break;
+        case 'S':  format.first = GetType<short>();     break;
+        case 'I':  format.first = GetType<int>();       break;
+        case 'L':  format.first = GetType<long>();      break;
+        case 'F':  format.first = GetType<float>();     break;
+        case 'D':  format.first = GetType<double>();    break;
+        case 'X':  format.first = GetType<long long>(); break;
+        case 'O':  format.first = GetVoid<O>();         break;
+        case 'W':  format.first = GetVoid<W>();         break;
+        default:
+            // This should never happen!
+            out << kRed << "Format '" << t[0] << " not known!" << endl;
+            return list;
         }
-    }
-
-    if (ptr-size!=dat)
-    {
-        wout << kRed << "Data block size (" << size << ") doesn't fit format description '" << fmt << "'" << endl;
-        return;
-    }
-
-    rc = true;
-
-    const string &ref = text.str();
-    data.insert(data.begin(), ref.begin()+1, ref.end());
-    data.push_back(0);
-}
-
-
+
+        list.push_back(format);
+        format.second.second += format.first.second * format.second.first;
+    }
+
+    format.first = GetVoid<void>();
+    format.second.first = 0;
+
+    list.push_back(format);
+
+    return list;
+}
+
+// --------------------------------------------------------------------------
+//
+//! Same as Compile(ostream&,string&,bool) but cout is used as the default
+//! output stream.
+//!
+//!
+Converter::FormatList Converter::Compile(const std::string &fmt, bool strict)
+{
+    return Compile(cout, fmt, strict);
+}
 
 vector<string> Converter::Regex(const string &expr, const string &line)

trunk/FACT++/src/Converter.h

@@ -9 +9 @@
 class Converter
 {
+public:
+    typedef std::pair<const std::type_info *, int> Type;
+    typedef std::pair<int, int>                    Offset;
+    typedef std::pair<Type, Offset>                Format;
+    typedef std::vector<Format>                    FormatList;
+
+    struct O { };
+    struct W { };
+
+    static std::string Clean(std::string s);
+
 private:
-    bool rc;                        /// Flag for the success of the conversion
-    std::ostream &wout;             /// ostream to which output is redirected
-    std::vector<char> data;         /// data storage
-    std::vector<boost::any> vec;    /// storage for typed data
+    std::ostream &wout;        /// ostream to which output is redirected
+
+    const std::string fFormat; /// Original format string
+    const FormatList  fList;   /// Compiled format description
+
+    template <class T>
+        T Get(std::stringstream &line) const;
+
+    bool        GetBool(std::stringstream &line) const;
+    std::string GetString(std::stringstream &line) const;
+    std::string GetStringEol(std::stringstream &line) const;
 
     template<class T>
-        void EvalImp(int i, std::stringstream &line, std::vector<char> &v, const T &val);
+        void GetBinImp(std::vector<char> &v, const T &val) const;
     template<class T>
-        void Eval(int i, std::stringstream &line, std::vector<char> &v);
-        void EvalBool(int i, std::stringstream &line, std::vector<char> &v);
-        void EvalString(int i, std::stringstream &line, std::vector<char> &v);
+        void GetBinImp(std::vector<boost::any> &v, const T &val) const;
+
+    void GetBinString(std::vector<char> &v, const std::string &val) const;
+    void GetBinString(std::vector<boost::any> &v, const std::string &val) const;
 
     template<class T>
-        std::string Get(const char *&data);
+        std::string GetString(const char *&data) const;
+
+    template<class T>
+        static Type GetType();
+    template<class T>
+        static Type GetVoid();
+
+    template <class T>
+        std::vector<T> Get(const std::string &str) const;
+    template <class T>
+        T Get(const void *d, int size) const;
+
+
+
+    template<class T>
+        void Add(std::string &str, const char* &ptr) const;
+    void AddString(std::string &str, const std::string &ptr) const;
+    template<class T>
+        void Add(std::vector<boost::any> &vec, const char* &ptr) const;
+    void AddString(std::vector<boost::any> &vec, const std::string &ptr) const;
+
 
 public:
-    Converter(std::ostream &out, const std::string &fmt, const std::string &str);
-    Converter(std::ostream &out, const std::string &fmt, const void *d, int size);
+    Converter(std::ostream &out, const std::string &fmt, bool strict=true);
+    Converter(const std::string &fmt, bool strict=true);
 
-    /// Returns whether the conversion was successfull
-    bool GetRc() const { return rc; }
+    /// @returns whether the interpreted format was valid but empty ("")
+    bool empty() const { return fList.size()==1 && fList.back().first.second==0; }
 
-    /// const Pointer to the data memory
-    const char *Ptr() const { return &*data.begin(); }
-    /// non-const Pointer to the data memory (for convinience using Dim)
-    char *Ptr() { return &*data.begin(); }
+    /// @returns whether the compilation was successfull
+    bool valid() const { return !fList.empty() && fList.back().first.second==0; }
 
-    /// Return the size of the data memory
-    int  Size() const { return data.size(); }
+    /// @returns true if the compilation failed
+    bool operator!() const { return !valid(); }
 
-    /// Return the data memory converted into a string (not necessarily \0-terminated)
-    const std::string Str() const { return std::string(&*data.begin(), data.size()); }
+    const FormatList &GetList() const { return fList; }
 
+    static FormatList Compile(std::ostream &out, const std::string &fmt, bool strict=false);
+    static FormatList Compile(const std::string &fmt, bool strict=false);
 
+    std::string             GetString(const void *d, int size) const;
+    std::vector<char>       GetVector(const void *d, int size) const;
+    std::vector<boost::any> GetAny(const void *d, int size) const;
+
+    std::vector<boost::any> GetAny(const std::string &str) const;
+    std::vector<char>       GetVector(const std::string &str) const;
+
+    static std::string GetHex(const void *d, int size);
+
+/*
     // Returns the number of entries in Converter:vec
     int N() const { return vec.size(); }
@@ -58 +106 @@
     template <class T>
         T At(int i) const { return boost::any_cast<T>(vec[i]); }
-
+*/
 
     static std::vector<std::string> Regex(const std::string &expr, const std::string &line);