sstream.hpp

Go to the documentation of this file.

// +-------------------------------------------------------------------------+
// |               I__n__t__e__L__i__b           0.6.10 development          |
// | Copyright (c) Andrey Vikt. Stolyarov <crocodil_AT_croco.net> 2000-2007. |
// |                                                                         |
// | This is free software. The library part is available under              |
// |                               GNU LESSER GENERAL PUBLIC LICENSE v.2.1.  |
// | GNU LGPL v2.1 is found in docs/gnu_gpl2.txt,  or at  http://www.gnu.org |
// |     Please see also docs/readme.txt and visit http://www.intelib.org    |
// |                                                                         |
// | !!! THERE IS NO WARRANTY OF ANY KIND, NEITHER EXPRESSED NOR IMPLIED !!! |
// +-------------------------------------------------------------------------+




#ifndef INTELIB_LSTREAM_HPP_SENTRY
#define INTELIB_LSTREAM_HPP_SENTRY

#include <stdio.h>
#include "../sexpress/refcount.hpp"
#include "../sexpress/iexcept.hpp"
#include "../sexpress/sstring.hpp"
#include "../sexpress/gensref.hpp"


class SExpressionStream : public SExpression {
public:
    static IntelibTypeId TypeId;

    SExpressionStream() : SExpression(TypeId) {}
protected:
    SExpressionStream(const IntelibTypeId &id) : SExpression(id) {}
    ~SExpressionStream() {}

public:
#if INTELIB_TEXT_REPRESENTATIONS == 1
    virtual SString TextRepresentation() const;
#endif

    virtual int Getc() = 0;
    virtual int Ungetc(int c) = 0;
    virtual int Putc(int c) = 0;
    virtual int Puts(const char *s) = 0;
    virtual char* Gets(char *buf, int bufsize) = 0;
    virtual int Seek(long pos) = 0;
    virtual long Tell() const = 0;
    virtual int Close() = 0;
    virtual int Flush() = 0;
    virtual int Fileno() const = 0;
};

class IntelibX_not_a_stream : public IntelibX {
public:
    IntelibX_not_a_stream(SReference a_param);
};

typedef GenericSReference<SExpressionStream,IntelibX_not_a_stream>
SStreamRef;


class SExpressionStreamFile : public SExpressionStream {
    FILE *f;
public:
    static IntelibTypeId TypeId;

    SExpressionStreamFile(FILE *); 

protected:
    SExpressionStreamFile(const IntelibTypeId &id, FILE *); 
    virtual ~SExpressionStreamFile(); 
public:

    virtual int Getc();
    virtual int Ungetc(int c);
    virtual int Putc(int c);
    virtual int Puts(const char *s);
    virtual char* Gets(char *buf, int bufsize);
    virtual int Seek(long pos);
    virtual long Tell() const;
    virtual int Close();
    virtual int Flush();
    virtual int Fileno() const; 
    
    FILE* GetFile() const { return f; }
};

class SStreamFile : public SStreamRef {
public:
    SStreamFile(FILE *f) : SStreamRef(new SExpressionStreamFile(f)) {}
};

class SStreamStdin : public SStreamFile {
public:
    SStreamStdin() : SStreamFile(stdin) {}
};

class SStreamStdout : public SStreamFile {
public:
    SStreamStdout() : SStreamFile(stdout) {}
};

class SStreamStderr : public SStreamFile {
public:
    SStreamStderr() : SStreamFile(stderr) {}
};

class SExpressionStreamCharbuf : public SExpressionStream {
    SString buf;
    unsigned long pos;
    bool multipass;
public:
    SExpressionStreamCharbuf(const char *initbuf = NULL, bool mpass = false);
protected:
    ~SExpressionStreamCharbuf();
public:
    void AddChar(char);
    void AddString(const char*);
    void Cleanup(); /* removes the processed part of the buffer */
    virtual int Getc();
    virtual int Ungetc(int c);
    virtual int Putc(int c);
    virtual int Puts(const char *s);
    virtual char* Gets(char *buf, int bufsize);
    virtual int Seek(long pos);
    virtual long Tell() const;
    virtual int Close();
    virtual int Flush();
    virtual int Fileno() const;
};

class SStreamCharbuf : public SStreamRef {
public:
    SStreamCharbuf(const char *str, int mpass = 1)
        : SStreamRef(new SExpressionStreamCharbuf(str, mpass)) {}
    SExpressionStreamCharbuf* operator->() const
        { return static_cast<SExpressionStreamCharbuf*>(GetPtr()); }
};


class SExpressionStreamTextInput : public SExpressionStreamFile {
    int line;
public:
    static IntelibTypeId TypeId;

    SExpressionStreamTextInput(FILE *f) 
        : SExpressionStreamFile(TypeId, f), line(1) {}
    virtual int Getc();
    virtual int Ungetc(int c);
    virtual char* Gets(char *buf, int bufsize);

    int TellLine() const { return line; } 
protected:
    ~SExpressionStreamTextInput() {}
};

class SStreamTextInput : public SStreamFile {
public:
    SStreamTextInput(FILE *f) : SStreamFile(f) {}
    SExpressionStreamTextInput* operator->() const
        { return static_cast<SExpressionStreamTextInput*>(GetPtr()); }
};


#endif

---