JStringFacet.hh

Go to the documentation of this file.

#ifndef __JLANG__JSTRINGFACET__
#define __JLANG__JSTRINGFACET__
 
#include <istream>
#include <ostream>
#include <locale>
#include <string>
#include <iterator>
#include <limits>
 
 
/**
 * \author mdejong
 */
 
namespace JLANG {}
namespace JPP { using namespace JLANG; }
 
namespace JLANG {
 
 
  /**
   * Facet class to specify parsing of a JLANG::JString object.
   * This class extends the std::locale::facet class.
   */
  class JStringFacet : 
    public std::locale::facet
  {
  public:
 
    static std::locale::id  id;
 
 
    typedef std::istreambuf_iterator<char, std::char_traits<char> >    istreambuf_iterator;
    typedef std::ostreambuf_iterator<char, std::char_traits<char> >    ostreambuf_iterator;
 
 
  
    /**
     * Constructor.
     *
     * \param  refs      reference count
     */
    JStringFacet(std::size_t refs = 0) :
      std::locale::facet(refs)
    {}
 
 
    /**
     * Clone this facet.
     *
     * \return           pointer to newly created facet
     */
    virtual JStringFacet* clone() const
    {
      return new JStringFacet();
    }
 
 
    /**
     * Get string.
     *
     * \param  __begin   begin position of input stream
     * \param  __end     end   position of input stream
     * \param  format    format
     * \param  result    status after input operation
     * \param  buffer    output string
     * \return           position of input stream
     */
    istreambuf_iterator get(const istreambuf_iterator __begin,
                            const istreambuf_iterator __end,
                            const std::ios_base&      format,
                            std::ios_base::iostate&   result,
                            std::string&              buffer) const
    {
      return do_get(__begin, __end, format, result, buffer);
    }
 
 
    /**
     * Put string.
     *
     * \param  out       begin position of output stream
     * \param  format    format
     * \param  c         fill character
     * \param  buffer    input string
     * \return           position of output stream buffer
     */
    ostreambuf_iterator put(ostreambuf_iterator  out,
                            const std::ios_base& format,
                            const char           c,
                            const std::string&   buffer) const
    {
      return do_put(out, format, c, buffer);
    }
 
 
    /**
     * Ignore characters until next end of line.
     *
     * \param  in        input stream
     * \return           input stream
     */
    inline std::istream& ignore(std::istream& in) const
    {      
      if (do_ignore(in, istreambuf_iterator()) == istreambuf_iterator()) {
        in.setstate(std::ios_base::eofbit);
      }
 
      return in;
    }
 
 
    /**
     * Read characters until next end of line.
     *
     * \param  in        input stream
     * \param  buffer    output string
     * \return           input stream
     */
    inline std::istream& getline(std::istream& in, 
                                 std::string&  buffer) const
    {
      using namespace std;
 
      ios_base::iostate state = in.rdstate();
 
      if (do_getline(in, istreambuf_iterator(), state, buffer) == istreambuf_iterator()) {
        in.setstate(std::ios_base::eofbit);
      }
 
      if (state != ios_base::goodbit && state != ios_base::eofbit) {
        in.setstate(state);
      }
 
      return in;
    }
 
 
    /**
     * Get index for stream associated facet data.
     *
     * \return           index
     */
    static int getIndex() 
    {
      static int i = std::ios_base::xalloc();
 
      return i;
    }
 
 
  protected:
    /**
     * Get string.
     *
     * \param  __begin   begin position of input stream
     * \param  __end     end   position of input stream
     * \param  format    format
     * \param  result    status after input operation
     * \param  buffer    output string
     * \return           position of input stream
     */
    virtual istreambuf_iterator do_get(const istreambuf_iterator __begin,
                                       const istreambuf_iterator __end,
                                       const std::ios_base&      format,
                                       std::ios_base::iostate&   result,
                                       std::string&              buffer) const
    {
      using namespace std;
 
      result = (ios_base::iostate) 0;  // reset I/O status
 
      streamsize n = format.width();   // number of characters to read
 
      if (n == 0) {
        n = numeric_limits<streamsize>::max();
      }
 
      istreambuf_iterator i = __begin;
 
      if (i == __end) {
 
        result |= ios_base::failbit;    
        result |= ios_base::eofbit;
 
      } else {
 
        buffer.clear();
 
        buffer.push_back(*i);
          
        for (++i, --n; i != __end && n != 0; ++i, --n) {
          buffer.push_back(*i);
        }
 
        if (i == __end) {
          result |= ios_base::eofbit;
        }
      }
 
      return i;
    }
 
 
    /**
     * Put string.
     *
     * \param  out       begin position of output stream
     * \param  format    format
     * \param  c         fill character
     * \param  buffer    input string
     * \return           current position of output stream
     */
    virtual ostreambuf_iterator do_put(ostreambuf_iterator  out,
                                       const std::ios_base& format,
                                       const char           c,
                                       const std::string&   buffer) const
    {
      using namespace std;
 
      if (format.flags() & ios_base::right) {
        for (streamsize i = buffer.size(); i < format.width(); ++i, ++out) {
          *out = c;
        }
      }
 
      for (string::const_iterator i = buffer.begin(); i != buffer.end(); ++i, ++out) {
        *out = *i;
      }
        
      if (format.flags() & ios_base::left) {
        for (streamsize i = buffer.size(); i < format.width(); ++i, ++out) {
          *out = c;
        }
      }
 
      return out;
    }
 
 
    /**
     * Ignore characters until next end of line.
     *
     * \param  __begin   begin position of input stream
     * \param  __end     end   position of input stream
     * \return           position of input stream
     */
    virtual istreambuf_iterator do_ignore(const istreambuf_iterator __begin,
                                          const istreambuf_iterator __end) const
    {
      istreambuf_iterator i = __begin;
 
      while (i != __end && *i != '\n') {
        ++i;
      }
 
      while (i != __end && *i == '\n') {
        ++i;          // skip end of line(s)
      }
 
      return i;
    }
 
 
    /**
     * Read string.
     *
     * \param  __begin   begin position of input stream
     * \param  __end     end   position of input stream
     * \param  result    status after input operation
     * \param  buffer    output string
     * \return           position of input stream
     */
    virtual istreambuf_iterator do_getline(const istreambuf_iterator __begin,
                                           const istreambuf_iterator __end,
                                           std::ios_base::iostate&   result,
                                           std::string&              buffer) const
    {
      using namespace std;
 
      istreambuf_iterator i = __begin;
 
      if (i == __end) {
 
        result |= ios_base::failbit;    
        result |= ios_base::eofbit;
 
      } else {
 
        buffer.clear();
 
        for ( ; i != __end && *i != '\n'; ++i) {
          buffer.push_back(*i);
        }
 
        if (i != __end) {
          ++i;          // skip end of line
        }
      }
 
      return i;
    }
 
 
  private:
 
    JStringFacet(const JStringFacet&);        // not defined
    void operator=(const JStringFacet&);      // not defined
  };
}
 
#endif