binarystring.hxx

Go to the documentation of this file.

/*-------------------------------------------------------------------------
 *
 *   FILE
 *      pqxx/binarystring.hxx
 *
 *   DESCRIPTION
 *      declarations for bytea (binary string) conversions
 *   DO NOT INCLUDE THIS FILE DIRECTLY; include pqxx/binarystring 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"

#include <string>

#include "pqxx/result"


namespace pqxx
{


class PQXX_LIBEXPORT binarystring : internal::PQAlloc<unsigned char>
{
  // TODO: Templatize on character type?
public:
  typedef content_type char_type;
  typedef PGSTD::char_traits<char_type>::char_type value_type;
  typedef size_t size_type;
  typedef long difference_type;
  typedef const value_type &const_reference;
  typedef const value_type *const_pointer;
  typedef const_pointer const_iterator;

#ifdef PQXX_HAVE_REVERSE_ITERATOR
  typedef PGSTD::reverse_iterator<const_iterator> const_reverse_iterator;
#endif

private:
  typedef internal::PQAlloc<value_type> super;

public:

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

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

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

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

#ifdef PQXX_HAVE_REVERSE_ITERATOR
  const_reverse_iterator rbegin() const                                 //[t62]
        { return const_reverse_iterator(end()); }
  const_reverse_iterator rend() const                                   //[t62]
        { return const_reverse_iterator(begin()); }
#endif

  const value_type *data() const throw () {return super::c_ptr();}      //[t62]

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

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

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

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


  const char *c_ptr() const throw ()                                    //[t62]
  {
    return reinterpret_cast<char *>(super::c_ptr());
  }


  const PGSTD::string &str() const;                                     //[t62]

private:
  size_type m_size;
  mutable PGSTD::string m_str;
};


PGSTD::string PQXX_LIBEXPORT escape_binary(const PGSTD::string &bin);
PGSTD::string PQXX_LIBEXPORT escape_binary(const char bin[]);
PGSTD::string PQXX_LIBEXPORT escape_binary(const char bin[], size_t len);
PGSTD::string PQXX_LIBEXPORT escape_binary(const unsigned char bin[]);
PGSTD::string PQXX_LIBEXPORT escape_binary(const unsigned char bin[], size_t len);


}

---