largeobject.hxx

Go to the documentation of this file.

/*-------------------------------------------------------------------------
 *
 *   FILE
 *      pqxx/largeobject.hxx
 *
 *   DESCRIPTION
 *      libpqxx's Large Objects interface
 *   Allows access to large objects directly, or through I/O streams
 *   DO NOT INCLUDE THIS FILE DIRECTLY; include pqxx/largeobject instead.
 *
 * Copyright (c) 2003-2004, Jeroen T. Vermeulen <jtv@xs4all.nl>
 *
 * See COPYING for copyright license.  If you did not receive a file called
 * COPYING with this source code, please notify the distributor of this mistake,
 * or contact the author.
 *
 *-------------------------------------------------------------------------
 */
#include "pqxx/libcompiler.h"

#ifdef PQXX_HAVE_STREAMBUF
#include <streambuf>
#else
#include <streambuf.h>
#endif

#include "pqxx/dbtransaction"


namespace pqxx
{

class largeobjectaccess;


class PQXX_LIBEXPORT largeobject
{
public:
  typedef long size_type;

  largeobject() throw ();                                               //[t48]


  explicit largeobject(dbtransaction &T);                               //[t48]


  explicit largeobject(oid O) throw () : m_ID(O) {}                     //[t48]


  largeobject(dbtransaction &T, const PGSTD::string &File);             //[t53]


  largeobject(const largeobjectaccess &O) throw ();                     //[t50]


  oid id() const throw () { return m_ID; }                              //[t48]


  bool operator==(const largeobject &other) const                       //[t51]
          { return m_ID == other.m_ID; }

  bool operator!=(const largeobject &other) const                       //[t51]
          { return m_ID != other.m_ID; }

  bool operator<=(const largeobject &other) const                       //[t51]
          { return m_ID <= other.m_ID; }

  bool operator>=(const largeobject &other) const                       //[t51]
          { return m_ID >= other.m_ID; }

  bool operator<(const largeobject &other) const                        //[t51]
          { return m_ID < other.m_ID; }

  bool operator>(const largeobject &other) const                        //[t51]
          { return m_ID > other.m_ID; }


  void to_file(dbtransaction &T, const PGSTD::string &File) const;      //[t52]


  void remove(dbtransaction &T) const;                                  //[t48]

protected:
  static internal::pq::PGconn *RawConnection(const dbtransaction &T)
  {
    return T.conn().RawConnection();
  }

  PGSTD::string Reason() const;

private:
  oid m_ID;
};


// TODO: New hierarchy with separate read / write / mixed-mode access

class PQXX_LIBEXPORT largeobjectaccess : private largeobject
{
public:
  using largeobject::size_type;
  typedef long off_type;
  typedef size_type pos_type;


  typedef PGSTD::ios::openmode openmode;


  typedef PGSTD::ios::seekdir seekdir;


  explicit largeobjectaccess(dbtransaction &T, 
                             openmode mode = 
                                PGSTD::ios::in | 
                                PGSTD::ios::out);                       //[t51]


  largeobjectaccess(dbtransaction &T, 
                    oid O,
                    openmode mode = 
                        PGSTD::ios::in | 
                        PGSTD::ios::out);                               //[t52]


  largeobjectaccess(dbtransaction &T, 
                    largeobject O,
                    openmode mode = PGSTD::ios::in | PGSTD::ios::out);  //[t50]


  largeobjectaccess(dbtransaction &T, 
                    const PGSTD::string &File,
                    openmode mode = 
                        PGSTD::ios::in | PGSTD::ios::out);              //[t55]

  ~largeobjectaccess() throw () { close(); }


  using largeobject::id;


  void to_file(const PGSTD::string &File) const                         //[t54]
        { largeobject::to_file(m_Trans, File); }

#ifdef PQXX_BROKEN_USING_DECL


  void to_file(dbtransaction &T, const PGSTD::string &F) const
        { largeobject::to_file(T, F); }
#else
  using largeobject::to_file;
#endif



  void write(const char Buf[], size_type Len);                          //[t51]


  void write(const PGSTD::string &Buf)                                  //[t50]
        { write(Buf.c_str(), Buf.size()); }


  size_type read(char Buf[], size_type Len);                            //[t50]


  size_type seek(size_type dest, seekdir dir);                          //[t51]


  pos_type cseek(off_type dest, seekdir dir) throw ();                  //[t50]
    

  off_type cwrite(const char Buf[], size_type Len) throw ();            //[t50]


  off_type cread(char Buf[], size_type Len) throw ();                   //[t50]


  void process_notice(const PGSTD::string &) throw ();                  //[t50]

  using largeobject::remove;

  using largeobject::operator==;
  using largeobject::operator!=;
  using largeobject::operator<;
  using largeobject::operator<=;
  using largeobject::operator>;
  using largeobject::operator>=;

private:
  PGSTD::string Reason() const;
  internal::pq::PGconn *RawConnection()
        { return largeobject::RawConnection(m_Trans); }

  void open(openmode mode);
  void close() throw ();

  dbtransaction &m_Trans;
  int m_fd;

  // Not allowed:
  largeobjectaccess();
  largeobjectaccess(const largeobjectaccess &);
  largeobjectaccess operator=(const largeobjectaccess &);
};



template<typename CHAR=char, typename TRAITS=PGSTD::char_traits<CHAR> >
  class largeobject_streambuf :
#ifdef PQXX_HAVE_STREAMBUF
    public PGSTD::basic_streambuf<CHAR, TRAITS>
#else
    public PGSTD::streambuf
#endif
{
  typedef long size_type;
public:
  typedef CHAR   char_type;
  typedef TRAITS traits_type;
  typedef typename traits_type::int_type int_type;
#ifdef PQXX_HAVE_STREAMBUF
  typedef typename traits_type::pos_type pos_type;
  typedef typename traits_type::off_type off_type;
#else
  typedef streamoff off_type;
  typedef streampos pos_type;
#endif
  typedef largeobjectaccess::openmode openmode;
  typedef largeobjectaccess::seekdir seekdir;

  largeobject_streambuf(dbtransaction &T,
                        largeobject O,
                        openmode mode = PGSTD::ios::in | PGSTD::ios::out,
                        size_type BufSize=512) :                        //[t48]
    m_BufSize(BufSize),
    m_Obj(T, O),
    m_G(0),
    m_P(0)
        { initialize(mode); }

  largeobject_streambuf(dbtransaction &T,
                        oid O,
                        openmode mode = PGSTD::ios::in | PGSTD::ios::out,
                        size_type BufSize=512) :                        //[t48]
    m_BufSize(BufSize),
    m_Obj(T, O),
    m_G(0),
    m_P(0)
        { initialize(mode); }

  virtual ~largeobject_streambuf() throw () { delete [] m_P; delete [] m_G; }


  void process_notice(const PGSTD::string &s) { m_Obj.process_notice(s); }

#ifdef PQXX_HAVE_STREAMBUF
protected:
#endif
  virtual int sync()
  {
    // setg() sets eback, gptr, egptr
    setg(this->eback(), this->eback(), this->egptr());
    return overflow(EoF());
  }

protected:
  virtual pos_type seekoff(off_type offset, 
                           seekdir dir,
                           openmode mode)
  {
    if (mode != SEEK_CUR)
      throw PGSTD::logic_error("Offset "+to_string(int(mode))+" in seekoff()");
    return AdjustEOF(m_Obj.cseek(offset, dir));
  }

  virtual pos_type seekpos(pos_type pos, openmode mode)
  {
    if (mode != SEEK_SET)
      throw PGSTD::logic_error("Offset "+to_string(int(mode))+" in seekpos()");
    return AdjustEOF(m_Obj.cseek(pos, PGSTD::ios::beg));
  }

  virtual int_type overflow(int_type ch = EoF())
  {
    char *const pp = this->pptr();
    if (!pp) return EoF();
    char *const pb = this->pbase();
    int_type res = 0;

    if (pp > pb) res = AdjustEOF(m_Obj.cwrite(pb, pp-pb));
    setp(m_P, m_P + m_BufSize);

    // Write that one more character, if it's there.
    if (ch != EoF())
    {
      *this->pptr() = char(ch);
      this->pbump(1);
    }
    return res;
  }

  virtual int_type underflow()
  {
    if (!this->gptr()) return EoF();
    char *const eb = this->eback();
    const int res = AdjustEOF(m_Obj.cread(this->eback(), m_BufSize));
    setg(eb, eb, eb + ((res==EoF()) ? 0 : res));
    return (!res || (res == EoF())) ? EoF() : *eb;
  }

private:
  static int_type EoF() { return traits_type::eof(); }

  static PGSTD::streampos AdjustEOF(int pos)
  {
    return (pos == -1) ? EoF() : pos;
  }

  void initialize(openmode mode)
  {
    if (mode & PGSTD::ios::in) 
    {
      m_G = new char_type[m_BufSize];
      setg(m_G, m_G, m_G);
    }
    if (mode & PGSTD::ios::out)
    {
      m_P = new char_type[m_BufSize];
      setp(m_P, m_P + m_BufSize);
    }
  }

  const size_type m_BufSize;
  largeobjectaccess m_Obj;

  // Get & put buffers
  char_type *m_G, *m_P;
};



template<typename CHAR=char, typename TRAITS=PGSTD::char_traits<CHAR> > 
  class basic_ilostream :
#ifdef PQXX_HAVE_STREAMBUF
    public PGSTD::basic_istream<CHAR, TRAITS>
#else
    public PGSTD::istream
#endif
{
#ifdef PQXX_HAVE_STREAMBUF
  typedef PGSTD::basic_istream<CHAR, TRAITS> super;
#else
  typedef PGSTD::istream super;
#endif

public:
  typedef CHAR char_type;
  typedef TRAITS traits_type;
  typedef typename traits_type::int_type int_type;
  typedef typename traits_type::pos_type pos_type;
  typedef typename traits_type::off_type off_type;


  basic_ilostream(dbtransaction &T, 
                  largeobject O, 
                  largeobject::size_type BufSize=512) :                 //[t57]
    super(&m_Buf),
    m_Buf(T, O, PGSTD::ios::in, BufSize) 
        { }


  basic_ilostream(dbtransaction &T, 
                  oid O, 
                  largeobject::size_type BufSize=512) :                 //[t48]
    super(&m_Buf),
    m_Buf(T, O, PGSTD::ios::in, BufSize) 
        { }

private:
  largeobject_streambuf<CHAR,TRAITS> m_Buf;
};

typedef basic_ilostream<char> ilostream;



template<typename CHAR=char, typename TRAITS=PGSTD::char_traits<CHAR> > 
  class basic_olostream : 
#ifdef PQXX_HAVE_STREAMBUF
    public PGSTD::basic_ostream<CHAR, TRAITS>
#else
    public PGSTD::ostream
#endif
{
#ifdef PQXX_HAVE_STREAMBUF
  typedef PGSTD::basic_ostream<CHAR, TRAITS> super;
#else
  typedef PGSTD::ostream super;
#endif
public:
  typedef CHAR char_type;
  typedef TRAITS traits_type;
  typedef typename traits_type::int_type int_type;
  typedef typename traits_type::pos_type pos_type;
  typedef typename traits_type::off_type off_type;


  basic_olostream(dbtransaction &T, 
                  largeobject O,
                  largeobject::size_type BufSize=512) :                 //[t48]
    super(&m_Buf),
    m_Buf(T, O, PGSTD::ios::out, BufSize) 
        { }


  basic_olostream(dbtransaction &T, 
                  oid O,
                  largeobject::size_type BufSize=512) :                 //[t57]
    super(&m_Buf),
    m_Buf(T, O, PGSTD::ios::out, BufSize) 
        { }

  ~basic_olostream() 
  { 
    try
    {
#ifdef PQXX_HAVE_STREAMBUF
      m_Buf.pubsync(); m_Buf.pubsync(); 
#else
      m_Buf.sync(); m_Buf.sync();
#endif
    }
    catch (const PGSTD::exception &e)
    {
      m_Buf.process_notice(e.what());
    }
  }

private:
  largeobject_streambuf<CHAR,TRAITS> m_Buf;
};

typedef basic_olostream<char> olostream;



template<typename CHAR=char, typename TRAITS=PGSTD::char_traits<CHAR> > 
  class basic_lostream :
#ifdef PQXX_HAVE_STREAMBUF
    public PGSTD::basic_iostream<CHAR, TRAITS>
#else
    public PGSTD::iostream
#endif
{
#ifdef PQXX_HAVE_STREAMBUF
  typedef PGSTD::basic_iostream<CHAR, TRAITS> super;
#else
  typedef PGSTD::iostream super;
#endif

public:
  typedef CHAR char_type;
  typedef TRAITS traits_type;
  typedef typename traits_type::int_type int_type;
  typedef typename traits_type::pos_type pos_type;
  typedef typename traits_type::off_type off_type;


  basic_lostream(dbtransaction &T, 
                 largeobject O,
                 largeobject::size_type BufSize=512) :                  //[t59]
    super(&m_Buf),
    m_Buf(T, O, PGSTD::ios::in | PGSTD::ios::out, BufSize) 
        { }


  basic_lostream(dbtransaction &T, 
                 oid O,
                 largeobject::size_type BufSize=512) :                  //[t59]
    super(&m_Buf),
    m_Buf(T, O, PGSTD::ios::in | PGSTD::ios::out, BufSize) 
        { }

  ~basic_lostream() 
  {
    try
    {
#ifdef PQXX_HAVE_STREAMBUF
      m_Buf.pubsync(); m_Buf.pubsync(); 
#else
      m_Buf.sync(); m_Buf.sync();
#endif
    }
    catch (const PGSTD::exception &e)
    {
      m_Buf.process_notice(e.what());
    }
  }

private:
  largeobject_streambuf<CHAR,TRAITS> m_Buf;
};

typedef basic_lostream<char> lostream;

}

---