---

mstream.h

/***************************************************************************
 *   This file is part of the MagiC++ library.                             *
 *                                                                         *
 *   Copyright (C) 1998-2001 Marko Grönroos <magi@iki.fi>                  *
 *                                                                         *
 ***************************************************************************
 *                                                                         *
 *  This library is free software; you can redistribute it and/or          *
 *  modify it under the terms of the GNU Library General Public            *
 *  License as published by the Free Software Foundation; either           *
 *  version 2 of the License, or (at your option) any later version.       *
 *                                                                         *
 *  This library 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      *
 *  Library General Public License for more details.                       *
 *                                                                         *
 *  You should have received a copy of the GNU Library General Public      *
 *  License along with this library; see the file COPYING.LIB.  If         *
 *  not, write to the Free Software Foundation, Inc., 59 Temple Place      *
 *  - Suite 330, Boston, MA 02111-1307, USA.                               *
 *                                                                         *
 ***************************************************************************/

#ifndef __MAGISTREAM_H__
#define __MAGISTREAM_H__

#include "magic/mobject.h"
#include "magic/mstring.h"

class File;
class DumpContext;
class Stream;
class OStream;

class IODevice : public Object {
  public:
};

class File : public IODevice {
  protected:
    FILE*   mpFile;
    String  mName;
  public:
                        File        (FILE* str=stdout) : mpFile (str) {;}
                        File        (const String& n) : mpFile(NULL), mName(n) {;}
    FILE*               getfp       () {return mpFile;}
    bool                isopen      () const {return mpFile;}
    //  bool                open        (bool mode=FMRead);
};

class Stream : public Object {
  protected:
    int     mode;       // Tallennusmoodi
    FILE*   stream;
  public:
                        Stream      (FILE* strm) {stream=strm; mode=0;}
    void                operator=   (FILE* strm) {stream=strm; mode=0;}

    void                close       ();
    
    friend DumpContext;
};



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

class OStream : public Stream {
  protected:
    bool            aflush;
    unsigned long   mUserFlags;
  public:
                        OStream     (FILE* strm=stdout);
                        OStream     (OStream& o);

    OStream&            print       (const char c);
    OStream&            print       (const char* str);
    void                flush       () {fflush (stream);}
    void                autoflush   (bool afl=true) {aflush=afl;}
    void                operator=   (const OStream& other);

    void                setFlag     (int flag, bool=true);

    bool                flag        (int flag) const;

    bool                operator[]  (int f) const {return flag(f);}
    
    // Virtual methods
    
    virtual OStream&        printf      (const char* format, ...);
    virtual OStream&        operator<<  (const char* str);
    virtual OStream&        operator<<  (int i);
    virtual OStream&        operator<<  (long i);

};

// Standard output and atandard error output
extern OStream sout;
extern OStream serr;

//                                                                           //
//         ___                     ___                                       //
//         |  \               --  /   \        _    |   ___       |          //
//         |   | |   | |/|/| |  ) |      __  |/ \  -+- /   ) \ / -+-         //
//         |   | |   | | | | |--  |     /  \ |   |  |  |---   X   |          //
//         |__/   \__! | | | |    \___/ \__/ |   |   \  \__  / \   \         //
//                                                                           //

class DumpContext : public OStream {
  protected:
    String          nextname;   // Seuraavan objektin nimi
    int             depth;      // Sisennystaso
    int             prevdepth;  // Sisennystaso viime tulostuksessa
    Array<String>*  attribs;    // Muistiinpannut attribuutit
    int             errst;
    
    int                 open        (const char* filename, int flag);
  public:
    bool    names;
    bool    classnames;
    
                        DumpContext     (FILE* strm=stdout);
                        DumpContext     (OStream& o);
                        ~DumpContext    ();

    DumpContext&        printf      (const char* format, ...);

    // Implementations

    DumpContext&        operator<<  (int i);
    DumpContext&        operator<<  (long i);
    DumpContext&        operator<<  (char i);
    DumpContext&        operator<<  (float i);
    DumpContext&        operator<<  (double i);
    DumpContext&        operator<<  (const char* str);
    DumpContext&        write       (const char* p, int n);

    // Asettaa seuraavan objektin nimen
    DumpContext&        name        (const char* nam) {nextname=nam; return *this;}

    const Array<String>&    getattribs  () const {return *attribs;}

  protected:
    // Tulostaa nimen (tekstimoodissa)
    DumpContext&        printName   ();

    // Tulostaa sisennyksen, jos haluttu
    void                printIndent ();

    // Tulostaa pilkun jos syvyystaso on sama kuin viime kutsulla
    void                printComma  ();
    
    friend DumpContext& operator<< (DumpContext& out, const Object& obj);
    friend DumpContext& operator>> (DumpContext& in, Object& obj);
};

// DumpContext& operator<< (DumpContext& dc, int i) {;}

// Sokerointioperaatio name()-liitteen tekemiseksi luokan attribuutteihin
// DumpContext& operator<< (DumpContext& out, const char* str);

enum {  DUMP_LOAD=0, DUMP_SAVE=1, DUMP_RECORD=2,
        DUMP_BINARY=0, DUMP_TEXT=16, DUMP_FORMATTED=32,
        DUMP_VERINFO=64,
        DUMP_ADDRESSES=128, DUMP_CLASSNAMES};



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

class IStream : public Stream {

  public:

                IStream     (FILE* strm=stdin) : Stream (strm) {;}
    
    // Avaa streamin tiedostoon lukua varten, palauttaa FALSE, jos
    // virhetilanne
    bool        openload    (const char* filename = NULL);

    // Lukee kokonaisluvun (todellisuudessa pitkän)
    IStream&    operator>>  (int& i);

    // Lukee pitkän kokonaisluvun
    IStream&    operator>>  (long& i);

    // Lukee yksittäisen merkin
    IStream&    operator>>  (char& i);
    IStream&    operator>>  (uchar& i) {return operator>> ((char&)i);}

    // Lukee liukuluvun (todellisuudessa pitkän)
    IStream&    operator>>  (float& i);

    // Lukee pitkän liukuluvun
    IStream&    operator>>  (double& i);
    //  IStream&    operator>>  (char* p)       {if (in) in->read (p, n); return *this;}

    // Lukee muistipuskurin
    IStream&    read        (char* p, int n);

    // const Array<String>& getattribs  () const {return *attribs;}
};

class TextStream {
  public:
    TextStream  (String& str, int mode);
    
  protected:
  private:
};

#endif

---