---

dsStrstream.h

Go to the documentation of this file.

/*
 * $Id: dsStrstream.h,v 1.7 2003/09/02 11:31:22 dsamersoff Exp $
 */
#ifndef dsStrstream_h
#define dsStrstream_h

#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <limits.h>

/*
 * Stream config 
 */

// #define _DS_ENABLE_AUTOFREEZE     
// #define _DS_USE_SGI_SEEK_ROUTINE 
#define _DS_AUTOTERMINATE 

#define _DS_ADAPTIVE_INCREMENT  
#define _DS_SEGMENT_SIZE        64



#define _DS_IO_FROZEN    0x1
#define _DS_IO_STATIC    0x2
#define _DS_IO_CONSTANT  0x4

#define _DS_IO_EOF    -1
#define _DS_IO_NOT_EOF 0

#define _DS_IO_NOTMOVABLE (_DS_IO_FROZEN | _DS_IO_STATIC | _DS_IO_CONSTANT)

/*
typedef streamoff streamoff;
typedef streampos streampos;
typedef streamsize streamsize;
*/

typedef void *(*p_alloc)(size_t);
typedef void (*p_free)(void *);

class dsStrstreambuf : public std::streambuf 
{
    long  _flags;
    p_alloc _palloc;
    p_free  _pfree;

    size_t _seg_size;
    int _overflow_cnt;
    
    char *_pbeg, *_gnext;
    std::streampos _pos_n;


    std::streampos _seekoff_p(std::streamoff off, std::ios::seekdir dir);
    std::streampos _seekoff_g(std::streamoff off, std::ios::seekdir dir);

public:

    explicit  dsStrstreambuf(size_t initial_size = _DS_SEGMENT_SIZE);
              dsStrstreambuf( const dsStrstreambuf* src );
              dsStrstreambuf( p_alloc cust_alloc, p_free cust_free );
              dsStrstreambuf(char *gnext, std::streampos n, char *pbeg );
              dsStrstreambuf(const char *gnext, std::streampos n );


    virtual ~dsStrstreambuf();

    int frozen();
    void freeze(bool n = true);

    size_t pcount();
    char *str();

    int overflow(int ch);
    int underflow();
    int pbackfail(int c);

    std::streampos seekoff(std::streamoff off, std::ios::seekdir dir, std::ios::openmode mode);
    std::streampos seekpos(std::streamoff off, std::ios::openmode mode){ return seekoff(off, std::ios::beg, mode); }

   /* Extensions */
    void setseg(size_t new_size = _DS_SEGMENT_SIZE);
    void clear();

};

class dsStrstream :  public std::iostream
{  
   dsStrstreambuf* _sb;
   
  public:
    dsStrstream();
    dsStrstream(const dsStrstream& s );
    dsStrstream(char *s, int n, std::ios::openmode mode = std::ios::out | std::ios::in);
    virtual ~dsStrstream();

    dsStrstreambuf *rdbuf() const;

    size_t pcount(); 
    char *str(); 
         
    void freeze(bool n = true);

    void clear();
};  


#ifdef USE_DMS_IOSTREAMS

class dsiStrstream : public std::istream
{
   dsStrstreambuf* _sb;

  public:
    explicit dsiStrstream(char* s);
    explicit dsiStrstream(const char* s);
             dsiStrstream(const dsiStrstream& s );
             dsiStrstream(char* s, std::streampos n);
             dsiStrstream(const char* s, std::streampos n);
    virtual ~dsiStrstream();

    dsStrstreambuf* rdbuf() const;
    char* str();            

    void clear();
};

  // Class ostrstream
class dsoStrstream : public std::ostream
{
   dsStrstreambuf* _sb;

  public:
    dsoStrstream();
    dsoStrstream(const dsoStrstream& s );
    dsoStrstream(char * s, int n, std::ios::openmode = std::ios::out);
    virtual ~dsoStrstream();

    dsStrstreambuf* rdbuf() const;

    void freeze(bool n = true);

    char* str();
    size_t pcount();      

    void clear();
};
#endif


#endif

---