binarystring.hxx

#ifndef PQXX_H_BINARYSTRING
#define PQXX_H_BINARYSTRING

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

#include <memory>
#include <string>

#include "pqxx/result.hxx"


namespace pqxx
{


class PQXX_LIBEXPORT binarystring
{
public:
  using char_type = unsigned char;
  using value_type = std::char_traits<char_type>::char_type;
  using size_type = size_t;
  using difference_type = long;
  using const_reference = const value_type &;
  using const_pointer = const value_type *;
  using const_iterator = const_pointer;
  using const_reverse_iterator = std::reverse_iterator<const_iterator>;

  binarystring(const binarystring &) =default;


  explicit binarystring(const field &);                                 //[t62]

  explicit binarystring(const std::string &);

  binarystring(const void *, size_t);

  size_type size() const noexcept { return m_size; }                    //[t62]
  size_type length() const noexcept { return size(); }                  //[t62]
  bool empty() const noexcept { return size()==0; }                     //[t62]

  const_iterator begin() const noexcept { return data(); }              //[t62]
  const_iterator cbegin() const noexcept { return begin(); }
  const_iterator end() const noexcept { return data()+m_size; }         //[t62]
  const_iterator cend() const noexcept { return end(); }

  const_reference front() const noexcept { return *begin(); }           //[t62]
  const_reference back() const noexcept                                 //[t62]
        { return *(data()+m_size-1); }

  const_reverse_iterator rbegin() const                                 //[t62]
        { return const_reverse_iterator(end()); }
  const_reverse_iterator crbegin() const { return rbegin(); }
  const_reverse_iterator rend() const                                   //[t62]
        { return const_reverse_iterator(begin()); }
  const_reverse_iterator crend() const { return rend(); }

  const value_type *data() const noexcept {return m_buf.get();}         //[t62]

  const_reference operator[](size_type i) const noexcept                //[t62]
        { return data()[i]; }

  PQXX_PURE bool operator==(const binarystring &) const noexcept;       //[t62]
  bool operator!=(const binarystring &rhs) const noexcept               //[t62]
        { return !operator==(rhs); }

  binarystring &operator=(const binarystring &);

  const_reference at(size_type) const;                                  //[t62]

  void swap(binarystring &);                                            //[t62]


  const char *get() const noexcept                                      //[t62]
        { return reinterpret_cast<const char *>(m_buf.get()); }


  std::string str() const;                                              //[t62]

private:
  using smart_pointer_type = std::shared_ptr<value_type>;

  static smart_pointer_type make_smart_pointer(unsigned char *buf=nullptr)
  {
    return smart_pointer_type(
        buf,
        internal::freemallocmem_templated<unsigned char>);
  }

  smart_pointer_type m_buf;
  size_type m_size;
};
}

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

#endif