field.hxx

#ifndef PQXX_H_FIELD
#define PQXX_H_FIELD

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

#if defined(PQXX_HAVE_OPTIONAL)
#include <optional>

/* Use std::experimental::optional as a fallback for std::optional, if
 * present.
 *
 * This may break compilation for some software, if using a libpqxx that was
 * configured for a different language version.  To stop libpqxx headers from
 * using or supporting std::experimental::optional, define a macro
 * PQXX_HIDE_EXP_OPTIONAL when building your software.
 */
#elif defined(PQXX_HAVE_EXP_OPTIONAL) && !defined(PQXX_HIDE_EXP_OPTIONAL)
#include <experimental/optional>
#endif

#include "pqxx/array.hxx"
#include "pqxx/result.hxx"
#include "pqxx/strconv.hxx"
#include "pqxx/types.hxx"


// Methods tested in eg. test module test01 are marked with "//[t01]".

namespace pqxx
{

class PQXX_LIBEXPORT field
{
public:
  using size_type = field_size_type;


  field(const row &R, row_size_type C) noexcept;                        //[t01]


  bool operator==(const field &) const;                         //[t75]


  bool operator!=(const field &rhs) const                               //[t82]
                                                   {return not operator==(rhs);}

  const char *name() const;                                             //[t11]

  oid type() const;                                                     //[t07]

  oid table() const;                                                    //[t02]

  row_size_type num() const { return col(); }                           //[t82]

  row_size_type table_column() const;                                   //[t93]


  const char *c_str() const;                                            //[t02]

  bool is_null() const noexcept;                                        //[t12]


  size_type size() const noexcept;                                      //[t11]


  template<typename T> auto to(T &Obj) const                            //[t03]
    -> typename std::enable_if<(
      not std::is_pointer<T>::value
      or std::is_same<T, const char*>::value
    ), bool>::type
  {
    const char *const bytes = c_str();
    if (bytes[0] == '\0' and is_null()) return false;
    from_string(bytes, Obj);
    return true;
  }

  template<typename T> bool operator>>(T &Obj) const                    //[t07]
      { return to(Obj); }


  template<typename T> auto to(T &Obj, const T &Default) const  //[t12]
    -> typename std::enable_if<(
      not std::is_pointer<T>::value
      or std::is_same<T, const char*>::value
    ), bool>::type
  {
    const bool NotNull = to(Obj);
    if (not NotNull) Obj = Default;
    return NotNull;
  }


  template<typename T> T as(const T &Default) const                     //[t01]
  {
    T Obj;
    to(Obj, Default);
    return Obj;
  }


  template<typename T> T as() const                                     //[t45]
  {
    T Obj;
    if (not to(Obj)) Obj = string_traits<T>::null();
    return Obj;
  }


  template<typename T, template<typename> class O
#if defined(PQXX_HAVE_OPTIONAL)
    = std::optional
#elif defined(PQXX_HAVE_EXP_OPTIONAL) && !defined(PQXX_HIDE_EXP_OPTIONAL)
    = std::experimental::optional
#endif
  > constexpr O<T> get() const { return as<O<T>>(); }


  array_parser as_array() const
        { return array_parser{c_str(), m_home.m_encoding}; }


protected:
  const result &home() const noexcept { return m_home; }
  size_t idx() const noexcept { return m_row; }
  row_size_type col() const noexcept { return row_size_type(m_col); }

  long m_col;

private:
  result m_home;
  size_t m_row;
};


template<>
inline bool field::to<std::string>(std::string &Obj) const
{
  const char *const bytes = c_str();
  if (bytes[0] == '\0' and is_null()) return false;
  Obj = std::string{bytes, size()};
  return true;
}


template<>
inline bool field::to<const char *>(const char *&Obj) const
{
  if (is_null()) return false;
  Obj = c_str();
  return true;
}


template<typename CHAR=char, typename TRAITS=std::char_traits<CHAR>>
  class field_streambuf :
  public std::basic_streambuf<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;
  using openmode = std::ios::openmode;
  using seekdir = std::ios::seekdir;

  explicit field_streambuf(const field &F) :                    //[t74]
    m_field{F}
  {
    initialize();
  }

protected:
  virtual int sync() override { return traits_type::eof(); }

protected:
  virtual pos_type seekoff(off_type, seekdir, openmode) override
        { return traits_type::eof(); }
  virtual pos_type seekpos(pos_type, openmode) override
        {return traits_type::eof();}
  virtual int_type overflow(int_type) override
        { return traits_type::eof(); }
  virtual int_type underflow() override
        { return traits_type::eof(); }

private:
  const field &m_field;

  int_type initialize()
  {
    char_type *G =
      reinterpret_cast<char_type *>(const_cast<char *>(m_field.c_str()));
    this->setg(G, G, G + m_field.size());
    return int_type(m_field.size());
  }
};



template<typename CHAR=char, typename TRAITS=std::char_traits<CHAR>>
  class basic_fieldstream :
    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_fieldstream(const field &F) : super{nullptr}, m_buf{F}
        { super::init(&m_buf); }

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

using fieldstream = basic_fieldstream<char>;


template<typename CHAR>
inline std::basic_ostream<CHAR> &operator<<(
        std::basic_ostream<CHAR> &S, const field &F)                    //[t46]
{
  S.write(F.c_str(), std::streamsize(F.size()));
  return S;
}


template<typename T>
inline void from_string(const field &F, T &Obj)                         //[t46]
        { from_string(F.c_str(), Obj, F.size()); }

template<> PQXX_LIBEXPORT std::string to_string(const field &Obj);      //[t74]

} // namespace pqxx
#include "pqxx/compiler-internal-post.hxx"
#endif