largeobject.hxx

#ifndef PQXX_H_LARGEOBJECT
#define PQXX_H_LARGEOBJECT

#include "pqxx/compiler-public.hxx"
#include "pqxx/compiler-internal-pre.hxx"

#include <streambuf>

#include "pqxx/dbtransaction.hxx"


namespace pqxx
{

class PQXX_LIBEXPORT largeobject
{
public:
  using size_type = large_object_size_type;

  largeobject() noexcept =default;                                      //[t48]


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


  explicit largeobject(oid O) noexcept : m_id{O} {}                     //[t48]


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


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


  oid id() const noexcept { 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 std::string &File) const;        //[t52]


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

protected:
  PQXX_PURE static internal::pq::PGconn *raw_connection(
        const dbtransaction &T);

  PQXX_PRIVATE std::string reason(const connection_base &, int err) const;

private:
  oid m_id = oid_none;
};


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

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


  using openmode = std::ios::openmode;


  using seekdir = std::ios::seekdir;


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


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


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


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

  ~largeobjectaccess() noexcept { close(); }


  using largeobject::id;


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

  using largeobject::to_file;


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


  void write(const std::string &Buf)                                    //[t50]
        { write(Buf.c_str(), static_cast<size_type>(Buf.size())); }


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


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


  size_type tell() const;                                               //[t50]


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


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


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


  pos_type ctell() const noexcept;                                      //[t50]

  void process_notice(const std::string &) noexcept;                    //[t50]

  using largeobject::remove;

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

private:
  PQXX_PRIVATE std::string reason(int err) const;
  internal::pq::PGconn *raw_connection() const
        { return largeobject::raw_connection(m_trans); }

  PQXX_PRIVATE void open(openmode mode);
  void close() noexcept;

  dbtransaction &m_trans;
  int m_fd = -1;

  largeobjectaccess() =delete;
  largeobjectaccess(const largeobjectaccess &) =delete;
  largeobjectaccess operator=(const largeobjectaccess &) =delete;
};



template<typename CHAR=char, typename TRAITS=std::char_traits<CHAR>>
  class largeobject_streambuf :
    public std::basic_streambuf<CHAR, TRAITS>
{
  using size_type = long;
public:
  using char_type = CHAR;
  using traits_type = TRAITS;
  using int_type = typename traits_type::int_type;
  using pos_type = typename traits_type::pos_type;
  using off_type = typename traits_type::off_type;
  using openmode = largeobjectaccess::openmode;
  using seekdir = largeobjectaccess::seekdir;

  largeobject_streambuf(                                                //[t48]
        dbtransaction &T,
        largeobject O,
        openmode mode=std::ios::in|std::ios::out,
        size_type BufSize=512) :
    m_bufsize{BufSize},
    m_obj{T, O, mode},
    m_g{nullptr},
    m_p{nullptr}
        { initialize(mode); }

  largeobject_streambuf(                                                //[t48]
        dbtransaction &T,
        oid O,
        openmode mode=std::ios::in|std::ios::out,
        size_type BufSize=512) :
    m_bufsize{BufSize},
    m_obj{T, O, mode},
    m_g{nullptr},
    m_p{nullptr}
        { initialize(mode); }

  virtual ~largeobject_streambuf() noexcept
        { delete [] m_p; delete [] m_g; }


  void process_notice(const std::string &s) { m_obj.process_notice(s); }

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

  virtual pos_type seekoff(
        off_type offset,
        seekdir dir,
        openmode)
        override
  {
    return AdjustEOF(m_obj.cseek(largeobjectaccess::off_type(offset), dir));
  }

  virtual pos_type seekpos(pos_type pos, openmode) override
  {
    const largeobjectaccess::pos_type newpos = m_obj.cseek(
        largeobjectaccess::off_type(pos),
        std::ios::beg);
    return AdjustEOF(newpos);
  }

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

    if (pp > pb) res = int_type(AdjustEOF(m_obj.cwrite(pb, pp-pb)));
    this->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() override
  {
    if (this->gptr() == nullptr) return EoF();
    char *const eb = this->eback();
    const int_type res(static_cast<int_type>(
        AdjustEOF(m_obj.cread(this->eback(), m_bufsize))));
    this->setg(eb, eb, eb + ((res==EoF()) ? 0 : res));
    return ((res == 0) or (res == EoF())) ? EoF() : *eb;
  }

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

  template<typename INTYPE>
  static std::streampos AdjustEOF(INTYPE pos)
        { return (pos==-1) ? std::streampos(EoF()) : std::streampos(pos); }

  void initialize(openmode mode)
  {
    if (mode & std::ios::in)
    {
      m_g = new char_type[unsigned(m_bufsize)];
      this->setg(m_g, m_g, m_g);
    }
    if (mode & std::ios::out)
    {
      m_p = new char_type[unsigned(m_bufsize)];
      this->setp(m_p, m_p + m_bufsize);
    }
  }

  const size_type m_bufsize;
  largeobjectaccess m_obj;

  char_type *m_g, *m_p;
};



template<typename CHAR=char, typename TRAITS=std::char_traits<CHAR>>
  class basic_ilostream :
    public std::basic_istream<CHAR, TRAITS>
{
  using super = std::basic_istream<CHAR, TRAITS>;

public:
  using char_type = CHAR;
  using traits_type = TRAITS;
  using int_type = typename traits_type::int_type;
  using pos_type = typename traits_type::pos_type;
  using off_type = typename traits_type::off_type;


  basic_ilostream(                                                      //[t57]
        dbtransaction &T,
        largeobject O,
        largeobject::size_type BufSize=512) :
    super{nullptr},
    m_buf{T, O, std::ios::in, BufSize}
        { super::init(&m_buf); }


  basic_ilostream(                                                      //[t48]
        dbtransaction &T,
        oid O,
        largeobject::size_type BufSize=512) :
    super{nullptr},
    m_buf{T, O, std::ios::in, BufSize}
        { super::init(&m_buf); }

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

using ilostream = basic_ilostream<char>;



template<typename CHAR=char, typename TRAITS=std::char_traits<CHAR>>
  class basic_olostream :
    public std::basic_ostream<CHAR, TRAITS>
{
  using super = std::basic_ostream<CHAR, TRAITS>;
public:
  using char_type = CHAR;
  using traits_type = TRAITS;
  using int_type = typename traits_type::int_type;
  using pos_type = typename traits_type::pos_type;
  using off_type = typename traits_type::off_type;


  basic_olostream(                                                      //[t48]
        dbtransaction &T,
        largeobject O,
        largeobject::size_type BufSize=512) :
    super{nullptr},
    m_buf{T, O, std::ios::out, BufSize}
        { super::init(&m_buf); }


  basic_olostream(                                                      //[t57]
        dbtransaction &T,
        oid O,
        largeobject::size_type BufSize=512) :
    super{nullptr},
    m_buf{T, O, std::ios::out, BufSize}
        { super::init(&m_buf); }

  ~basic_olostream()
  {
    try
    {
      m_buf.pubsync(); m_buf.pubsync();
    }
    catch (const std::exception &e)
    {
      m_buf.process_notice(e.what());
    }
  }

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

using olostream = basic_olostream<char>;



template<typename CHAR=char, typename TRAITS=std::char_traits<CHAR>>
  class basic_lostream :
    public std::basic_iostream<CHAR, TRAITS>
{
  using super = std::basic_iostream<CHAR, TRAITS>;

public:
  using char_type = CHAR;
  using traits_type = TRAITS;
  using int_type = typename traits_type::int_type;
  using pos_type = typename traits_type::pos_type;
  using off_type = typename traits_type::off_type;


  basic_lostream(                                                       //[t59]
        dbtransaction &T,
        largeobject O,
        largeobject::size_type BufSize=512) :
    super{nullptr},
    m_buf{T, O, std::ios::in | std::ios::out, BufSize}
        { super::init(&m_buf); }


  basic_lostream(                                                       //[t59]
        dbtransaction &T,
        oid O,
        largeobject::size_type BufSize=512) :
    super{nullptr},
    m_buf{T, O, std::ios::in | std::ios::out, BufSize}
        { super::init(&m_buf); }

  ~basic_lostream()
  {
    try
    {
      m_buf.pubsync(); m_buf.pubsync();
    }
    catch (const std::exception &e)
    {
      m_buf.process_notice(e.what());
    }
  }

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

using lostream = basic_lostream<char>;

} // namespace pqxx

#include "pqxx/compiler-internal-post.hxx"

#endif