libpqxx  4.0.1
field.hxx
1 /*-------------------------------------------------------------------------
2  *
3  * FILE
4  * pqxx/field.hxx
5  *
6  * DESCRIPTION
7  * definitions for the pqxx::field class.
8  * pqxx::field refers to a field in a query result.
9  * DO NOT INCLUDE THIS FILE DIRECTLY; include pqxx/field instead.
10  *
11  * Copyright (c) 2001-2011, Jeroen T. Vermeulen <jtv@xs4all.nl>
12  *
13  * See COPYING for copyright license. If you did not receive a file called
14  * COPYING with this source code, please notify the distributor of this mistake,
15  * or contact the author.
16  *
17  *-------------------------------------------------------------------------
18  */
19 #ifndef PQXX_H_FIELD
20 #define PQXX_H_FIELD
21 
22 #include "pqxx/compiler-public.hxx"
23 #include "pqxx/compiler-internal-pre.hxx"
24 
25 #include "pqxx/strconv"
26 
27 
28 /* Methods tested in eg. self-test program test001 are marked with "//[t1]"
29  */
30 
31 namespace pqxx
32 {
33 class result;
34 class tuple;
35 
36 typedef unsigned int tuple_size_type;
37 typedef signed int tuple_difference_type;
38 
40 
43 class PQXX_LIBEXPORT field
44 {
45 public:
46  typedef size_t size_type;
47 
49 
53  field(const tuple &T, tuple_size_type C) throw (); //[t1]
54 
59 
60 
76  bool operator==(const field &) const; //[t75]
77 
79 
81  bool operator!=(const field &rhs) const //[t82]
82  {return !operator==(rhs);}
84 
89 
90  const char *name() const; //[t11]
91 
93  oid type() const; //[t7]
94 
96  oid table() const; //[t2]
97 
98  tuple_size_type num() const { return col(); } //[t82]
99 
101  tuple_size_type table_column() const; //[t93]
103 
108 
109 
114  const char *c_str() const; //[t2]
115 
117  template<typename T> bool to(T &Obj) const //[t3]
118  {
119  const char *const bytes = c_str();
120  if (!bytes[0] && is_null()) return false;
121  from_string(bytes, Obj);
122  return true;
123  }
124 
126  template<typename T> bool operator>>(T &Obj) const //[t7]
127  { return to(Obj); }
128 
129 #ifdef PQXX_NO_PARTIAL_CLASS_TEMPLATE_SPECIALISATION
130 
131  template<> bool to<PGSTD::string>(PGSTD::string &Obj) const;
132 
134 
137  template<> bool to<const char *>(const char *&Obj) const;
138 #endif
139 
141  template<typename T> bool to(T &Obj, const T &Default) const //[t12]
142  {
143  const bool NotNull = to(Obj);
144  if (!NotNull) Obj = Default;
145  return NotNull;
146  }
147 
149 
152  template<typename T> T as(const T &Default) const //[t1]
153  {
154  T Obj;
155  to(Obj, Default);
156  return Obj;
157  }
158 
160  template<typename T> T as() const //[t45]
161  {
162  T Obj;
163  const bool NotNull = to(Obj);
164  if (!NotNull) Obj = string_traits<T>::null();
165  return Obj;
166  }
167 
168  bool is_null() const throw (); //[t12]
169  size_type size() const throw (); //[t11]
171 
172 
173 protected:
174  const result *home() const throw () { return m_home; }
175  size_t idx() const throw () { return m_row; }
176  tuple_size_type col() const throw () { return m_col; }
177 
179 
180 private:
181  const result *m_home;
182  size_t m_row;
183 };
184 
185 
187 template<>
188 inline bool field::to<PGSTD::string>(PGSTD::string &Obj) const
189 {
190  const char *const bytes = c_str();
191  if (!bytes[0] && is_null()) return false;
192  Obj = PGSTD::string(bytes, size());
193  return true;
194 }
195 
197 
202 template<>
203 inline bool field::to<const char *>(const char *&Obj) const
204 {
205  if (is_null()) return false;
206  Obj = c_str();
207  return true;
208 }
209 
210 
211 template<typename CHAR=char, typename TRAITS=PGSTD::char_traits<CHAR> >
213 #ifdef PQXX_HAVE_STREAMBUF
214  public PGSTD::basic_streambuf<CHAR, TRAITS>
215 #else
216  public PGSTD::streambuf
217 #endif
218 {
219 public:
220  typedef CHAR char_type;
221  typedef TRAITS traits_type;
222  typedef typename traits_type::int_type int_type;
223 #ifdef PQXX_HAVE_STREAMBUF
224  typedef typename traits_type::pos_type pos_type;
225  typedef typename traits_type::off_type off_type;
226 #else
227  typedef streamoff off_type;
228  typedef streampos pos_type;
229 #endif
230  typedef PGSTD::ios::openmode openmode;
231  typedef PGSTD::ios::seekdir seekdir;
232 
233  explicit field_streambuf(const field &F) : //[t74]
234  m_Field(F)
235  {
236  initialize();
237  }
238 
239 #ifdef PQXX_HAVE_STREAMBUF
240 protected:
241 #endif
242  virtual int sync() { return traits_type::eof(); }
243 
244 protected:
246  { return traits_type::eof(); }
247  virtual pos_type seekpos(pos_type, openmode) {return traits_type::eof();}
248  virtual int_type overflow(int_type) { return traits_type::eof(); }
249  virtual int_type underflow() { return traits_type::eof(); }
250 
251 private:
252  const field &m_Field;
253 
254  int_type initialize()
255  {
256  char_type *G =
257  reinterpret_cast<char_type *>(const_cast<char *>(m_Field.c_str()));
258  this->setg(G, G, G + m_Field.size());
259  return int_type(m_Field.size());
260  }
261 };
262 
263 
265 
273 template<typename CHAR=char, typename TRAITS=PGSTD::char_traits<CHAR> >
275 #ifdef PQXX_HAVE_STREAMBUF
276  public PGSTD::basic_istream<CHAR, TRAITS>
277 #else
278  public PGSTD::istream
279 #endif
280 {
281 #ifdef PQXX_HAVE_STREAMBUF
282  typedef PGSTD::basic_istream<CHAR, TRAITS> super;
283 #else
284  typedef PGSTD::istream super;
285 #endif
286 
287 public:
288  typedef CHAR char_type;
289  typedef TRAITS traits_type;
290  typedef typename traits_type::int_type int_type;
291  typedef typename traits_type::pos_type pos_type;
292  typedef typename traits_type::off_type off_type;
293 
294  basic_fieldstream(const field &F) : super(0), m_Buf(F)
295  { super::init(&m_Buf); }
296 
297 private:
299 };
300 
302 
303 } // namespace pqxx
304 
305 
306 #include "pqxx/compiler-internal-post.hxx"
307 
308 #endif