xsil/stream.hh

/* -*- mode: c++; c-basic-offset: 4; -*- */
#ifndef XSIL_STREAM_HH
#define XSIL_STREAM_HH

#include "xsil/xobj.hh"
#include <string>
#ifdef __GNU_STDC_OLD
#include <gnusstream.h>
#else
#include <sstream>
#endif

//  If USEILWDCHAR is set the MetaTables will generate columns with
//  type=ilwd:char instead of type=lstring. The stream will also escape
//  spaces in strings.
#define USEILWDCHAR

namespace xsil {

    struct UCVec {
        UCVec(void) {}

        UCVec(const int* pN, const unsigned char* pD);

        UCVec(const int* pN, const char* pD);

        const int* pNBytes;

        const unsigned char* pData;
    };

    inline
    UCVec::UCVec(const int* pN, const unsigned char* pD) 
        : pNBytes(pN), pData(pD) 
    {}

    inline
    UCVec::UCVec(const int* pN, const char* pD) 
        : pNBytes(pN), pData(reinterpret_cast<const unsigned char*>(pD)) 
    {}

class Stream : public xobj {
public:

  Stream(void);

  Stream(const char* Name, const char* Type=0, const char* Data=0);

  Stream(const Stream& x);

  ~Stream();

  Stream& operator=(const Stream& x);

  void Spew(Xwriter& xout) const;

  void append(const std::string& s);

  Stream* Clone(void) const;

  bool empty(void) const;

  const char* getDelimit(void) const;

  const char* getEncode(void) const;

  const char* getObjType(void) const;

  void delimit(char Delim);

  void Add(float x);

  void Add(const std::string& x, bool escsp=false);

  void Add(int x);

  void Add(double x);

  void Add(const UCVec& x);

  void Clear(void);

  void Fill(int N, const float* x, int perLine=0);

  void Fill(int N, const double* x, int perLine=0);

  void Fill(int N, const int* x, int perLine=0);

  void Fill(int N, const std::string x[], int perLine=0);

  bool decode64Data(void* data, int dLen, int N);

  void encode64Data(const char* data, int N);

  void open(void);

  void lineBreak(void);

  bool read(double      data[], int N);

  bool read(float       data[], int N);

  bool read(int         data[], int N);

  bool read(std::string data[], int N);


  void setRemote(const char* File);

  void setData(const char* Data);

  void setEncode(const char* Code);

  void setSize(int Size);

private:
  void estLength(std::string::size_type len);

  void estDone(double frac);

private:
  std::string mData;
  std::string mRemote;
  int    mLineSz;
  int    mMaxSz;
  std::string mDelimit;
  bool   mEndLine;
  std::string mEncoding;
  std::istream* mInput;
};   // xsil::Stream

}    //  namespace xsil

//----------------------------------------  Test if stream is empty
inline bool
xsil::Stream::empty(void) const {
    return mData.empty();
}

//----------------------------------------  Get the encoding technique
inline const char*
xsil::Stream::getEncode(void) const {
    return mEncoding.c_str();
}

//----------------------------------------  Get the delimiter character
inline const char*
xsil::Stream::getDelimit(void) const {
    return mDelimit.c_str();
}

#endif  // !defined(XSIL_STREAM_HH)

---