streamable.h

Go to the documentation of this file.

#ifndef streamable_h_included
#define streamable_h_included
//
// Copyright 2002, Lowell Boggs Jr.
//
// This file or directory, containing source code for a computer program,
// is Copyrighted by Lowell Boggs, Jr.  987 Regency Drive, Lewisville
// TX (USA), 75067.  You may use, copy, modify, and distribute this
// source file without charge or obligation so long as you agree to
// the following:
//
//  1.  You must indemnify Lowell Boggs against any and all financial
//      obligations caused by its use, misuse, function, or malfunction.
//      Further, you acknowledge that there is no warranty of any kind,
//      whatsoever.
//
//  2.  You agree not to attempt to patent any portion of this original
//      work -- though you may attempt to patent your own extensions to
//      it if you so choose.
//
//  3.  You keep this copyright notice with the file and all copies
//      of the file and do not change it anyway except language translation.
//
// You are responsible for enforcing your own compliance with these
// conditions and may not use this source file if you cannot agree to the
// above terms and conditions.


#include <fstream>
#include <cxxtls/classTraits.h>

namespace cxxtls
{

template <class Owner, class charT=char, class traits = std::char_traits<charT> >
class OstreamableBuffer: public std::basic_streambuf<charT, traits>
{
    Owner *owner;
public:
    typedef charT                          char_type;      
    typedef traits                         traits_type;
    typedef typename traits_type::int_type int_type;
    typedef typename traits_type::off_type off_type;
    typedef typename traits_type::pos_type pos_type;
        
        OstreamableBuffer(): owner(0) {}
        
        void setOwner(Owner *o) { owner = o; }

 protected:
    int_type overflow (int_type c = traits_type::eof ()); // calls Owner::ostreamable_helper() 
};

template <class Owner, class charT, class traits>
typename OstreamableBuffer<Owner, charT, traits>::int_type
OstreamableBuffer<Owner, charT, traits>::
overflow (typename OstreamableBuffer<Owner, charT, traits>::int_type c)
{
    // note that this is not a proper implemenation of overflow() for 
    // streams where you want to actually use the data in stream pointers.
    // This one should be copied with extreme caution.
    // See  http://stdcxx.apache.org/doc/stdlibug/39-2.html for a better
    // example, but still a wierd example...

    owner->ostreamable_helper(c);
    return c;
}

template <class Derived, class charT=char, class traits = std::char_traits<charT> >
class Ostreamable: public std::basic_iostream<charT, traits>
{
public:
    typedef charT                          char_type;    //2
    typedef traits                         traits_type;
    typedef typename traits_type::int_type int_type;
    typedef typename traits_type::off_type off_type;
    typedef typename traits_type::pos_type pos_type;

    typedef OstreamableBuffer<Derived, charT, traits> buf_type;
        
        Ostreamable();
        
        
private:

    buf_type buf;

public: 
        
};

template <class Derived, class charT, class traits>
Ostreamable<Derived, charT, traits>::
Ostreamable ()
: std::basic_iostream<charT, traits>(&buf)
{
    this->init (&buf); 

    Derived *owner=0;

    derivedFromBase(this, owner);

    buf.setOwner(owner);
}




class StreamableString
  //
  //
: public Ostreamable<StreamableString>,
  public std::string
{
public:

    void ostreamable_helper(char c)
    {
      std::string &p = *this;

      p += c;
    }

    StreamableString() 
         
    {
    } 

    StreamableString(StreamableString const &r)  
    {

      std::string &me = *this;  // SPOS MSVC 6.0
      me = r;
    }

    StreamableString( std::string const &r ) 
    {

      std::string &me = *this;
      me = r;
    }

    StreamableString( char const * r) 
    {
      std::string &me = *this;
      me = r;
    }

    StreamableString &operator=(std::string const &rhs)
    {
       std::string &me = *this;
       me = rhs;
       return *this;

    }

    StreamableString &operator=(char const *rhs)
    {
       std::string &me = *this;
       me = rhs;
       return *this;
    }


};

} // namespace cxxtls

#endif