---

mstream.cc

Go to the documentation of this file.

#include "magic/mobject.h"
#include "magic/mstream.h"
#include "magic/mpararr.h"

BEGIN_NAMESPACE (MagiC);

#ifdef SunOS
#include <sys/varargs.h>
#else
#include <stdarg.h>
#endif


class IStreamRef : private IODevice {
  protected:
    inline void         addStream           () {IODevice::addStream();}
    inline void         removeStream        () {IODevice::removeStream();}
    inline int          streamCount         () const {return IODevice::streamCount();}

    friend class Stream;
};

//                                                                           //
//                       ----                                                //
//                      (      |       ___   ___                             //
//                       ---  -+- |/\ /   )  ___| |/|/|                      //
//                          )  |  |   |---  (   | | | |                      //
//                      ___/    \ |    \__   \__| | | |                      //
//                                                                           //

Stream::Stream ()
{
    mpDevice    = NULL;
    mOwnDevice  = false;
    mFormatMode = 0;
}

/*****************************************************************************/
Stream::Stream (IODevice& dev) {
    mpDevice    = &dev;
    mOwnDevice  = false;
    mFormatMode = 0;
}

Stream::Stream (IODevice* dev)
{
    mpDevice    = dev;
    mOwnDevice  = true;
    mFormatMode = 0;
}

Stream::Stream (String& buffer)
{
    mpDevice    = new Buffer (buffer);
    mOwnDevice  = true;
    mFormatMode = 0;
}

Stream::Stream (FILE* strm)
{
    mpDevice    = new File (strm);
    mOwnDevice  = true;
    mFormatMode = 0;
}

Stream::Stream (Stream& orig)
{
    mpDevice    = orig.mpDevice;
    if (mpDevice)
        static_cast <IStreamRef*> (mpDevice)->addStream ();

    mOwnDevice  = orig.mOwnDevice;
    mFormatMode = orig.mFormatMode;
    mEncoding   = orig.mEncoding;
    mFlags      = orig.mFlags;
}

Stream::~Stream ()
{
    if (mOwnDevice)
        if (mpDevice) {
            static_cast <IStreamRef*> (mpDevice)->removeStream ();
            if (static_cast <IStreamRef*> (mpDevice)->streamCount() <= 0)
                delete mpDevice;
        }
}

void Stream::setDevice (IODevice* dev )
{
    mpDevice = dev;
    mOwnDevice = true;
}

/*******************************************************************************
** Returns true if the stream is at end.
**/
bool Stream::atEnd () const
{
    if (mpDevice)
        return mpDevice->atEnd ();
    else
        return true;
}

void Stream::copy (const Stream& other)
{
    TRACELINE;
    if (mpDevice && mOwnDevice)
        delete mpDevice;
    
    mpDevice    = other.mpDevice;
    mOwnDevice  = false; // WARNING
    mFormatMode = other.mFormatMode;
    mEncoding   = other.mEncoding;
    mFlags      = other.mFlags;
}


//                                                                           //
//                    ___   ----                                             //
//                   |   | (      |       ___   ___                          //
//                   |   |  ---  -+- |/\ /   )  ___| |/|/|                   //
//                   |   |     )  |  |   |---  (   | | | |                   //
//                   `___´ ___/    \ |    \__   \__| | | |                   //
//                                                                           //

/*****************************************************************************^
* Construction from a FILE output stream.
*
*  Example:
*  @code
*       FILE* myfile = fopen ("myfile.ext", "w");
*      OStream mystream (out);      // Attach to opened stream.
*      OStream outstd (stdout); // Attach to standard output stream.
*  @endcode
*
*  @note It is assumed that the FILE stream really is open.
**/
OStream::OStream (FILE* strm )
        : Stream (strm)
{
    mAutoFlush = false;
}

OStream::OStream (OStream& orig) : Stream (orig)
{
    mAutoFlush = orig.mAutoFlush;
}

OStream::OStream (String& buffer,   
                  int mode          )
        : Stream (new Buffer (buffer, mode | IO_Writable))
{
}

void OStream::flush ()
{
    if (mpDevice)
        mpDevice->flush ();
}

void OStream::copy (const OStream& other)
{
    Stream::copy (other);

    mAutoFlush = other.mAutoFlush;
}

OStream& OStream::printf (const char* sformat, ...)
{
    va_list args;
    va_start (args, sformat);

    *this << vstrformat (sformat, args);
    
    va_end (args);

    return *this;
}



//                                                                           //
//                    ---  ----                                              //
//                     |  (      |       ___   ___                           //
//                     |   ---  -+- |/\ /   )  ___| |/|/|                    //
//                     |      )  |  |   |---  (   | | | |                    //
//                    _|_ ___/    \ |    \__   \__| | | |                    //
//                                                                           //

IStream::IStream (IODevice* dev)
        : Stream (dev)
{
    /* Open the file if it wasn't opened already. */
    if (!mpDevice->isOpen())
        mpDevice->open (IO_Readable);
}

/*****************************************************************************/
//bool IStream::openload (const char* filename /**< Filename to open. */)
//{
//  NOT_IMPLEMENTED;
//  return false;
//}

END_NAMESPACE;

---