rdbxx  1.0.7_02
RDBColumnTmplt.cc
1 // --8<--8<--8<--8<--
2 //
3 // Copyright (C) 2006 Smithsonian Astrophysical Observatory
4 //
5 // This file is part of RDB
6 //
7 // RDB is free software; you can redistribute it and/or
8 // modify it under the terms of the GNU General Public License
9 // as published by the Free Software Foundation; either version 2
10 // of the License, or (at your option) any later version.
11 //
12 // RDB is distributed in the hope that it will be useful,
13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 // GNU General Public License for more details.
16 //
17 // You should have received a copy of the GNU General Public License
18 // along with this program; if not, write to the
19 // Free Software Foundation, Inc.
20 // 51 Franklin Street, Fifth Floor
21 // Boston, MA 02110-1301, USA
22 //
23 // -->8-->8-->8-->8--
24 
25 #define RDBColumnTmplt_cc
26 
27 #include <rdbxx/RDBColumnTmplt.h>
28 
36 template<class Tmplt0,class Tmplt1,class Tmplt2>
38  const string& name,
39  const string& def
40  )
41  : RDBColumn(name,def) {
42 
43  _nelems = 2;
44  _data = new Tmplt0[_nelems];
45  _idx = 0;
46  _mine = true;
47 
48 }
49 
57 template<class Tmplt0,class Tmplt1,class Tmplt2>
59  const RDBColumnTmplt& col
60  )
61  : RDBColumn(col) {
62 
63  _nelems = col._nelems;
64  _data = new Tmplt0[_nelems];
65  _idx = col._idx;
66  _mine = true;
67 
68 }
69 
75 template<class Tmplt0,class Tmplt1,class Tmplt2>
77  void
78  ) {
79 
80  cleanup( );
81 
82 }
83 
91 template<class Tmplt0,class Tmplt1,class Tmplt2>
92 RDBColumn&
95  ) {
96 
97  if ( this != &col ) {
98  RDBColumn::operator=( col );
99 
100  cleanup( );
101 
102  _nelems = col._nelems;
103  _data = col._data;
104  _idx = col._idx;
105  _mine = false;
106 
107  if ( _group && 2 > _nelems )
108  throw( RDBErr( "RDBColumnTmplt::operator=(RDBColumnTmplt&): user supplied column must provide >= 2 data elements" ) );
109 
110  }
111 
112  return *this;
113 
114 }
115 
122 template<class Tmplt0,class Tmplt1,class Tmplt2>
123 RDBColumn&
125  const Tmplt0& data
126  ) {
127 
128  try {
129  convert( data, _data[_idx] );
130 
131  } catch ( RDBErr& rdberr ) {
132  rdberr.set_message( "RDBColumnTmplt::operator=(Tmplt0&): " );
133  throw( rdberr );
134 
135  } catch ( ... ) {
136  throw( RDBErr( "RDBColumnTmplt::operator=(Tmplt0&): unexpected exception caught" ) );
137 
138  }
139 
140  return *this;
141 
142 }
143 
153 template<class Tmplt0,class Tmplt1,class Tmplt2>
154 RDBColumn&
156  const Tmplt1& data
157  ) {
158 
159  try {
160  convert( data, _data[_idx] );
161 
162  } catch ( RDBErr& rdberr ) {
163  rdberr.set_message( "RDBColumnTmplt::operator=(Tmplt1&): " );
164  throw( rdberr );
165 
166  } catch ( ... ) {
167  throw( RDBErr( "RDBColumnTmplt::operator=(Tmplt1&): unexpected exception caught" ) );
168 
169  }
170 
171  return *this;
172 
173 }
174 
184 template<class Tmplt0,class Tmplt1,class Tmplt2>
185 RDBColumn&
187  const Tmplt2& data
188  ) {
189 
190  try {
191  convert( data, _data[_idx] );
192 
193  } catch ( RDBErr& rdberr ) {
194  rdberr.set_message( "RDBColumnTmplt::operator=(Tmplt2&): " );
195  throw( rdberr );
196 
197  } catch ( ... ) {
198  throw( RDBErr( "RDBColumnTmplt::operator=(Tmplt2&): unexpected exception caught" ) );
199 
200  }
201 
202  return *this;
203 
204 }
205 
210 template<class Tmplt0,class Tmplt1,class Tmplt2>
211 void
213  void
214  ) {
215 
216  if ( _nelems == ++_idx ) {
217  _idx = 0;
218 
219  }
220 }
221 
226 template<class Tmplt0,class Tmplt1,class Tmplt2>
227 void
229  void
230  ) {
231 
232  _idx = 0;
233 
234 }
235 
240 template<class Tmplt0,class Tmplt1,class Tmplt2>
241 void
243  bool group
244  ) {
245 
246  RDBColumn::setGroup( group );
247  if ( _mine ) {
248  if ( 2 > _nelems ) {
249  Tmplt0* tmp = _data;
250  _nelems = 2;
251  _data = new Tmplt0[_nelems];
252  _data[0] = tmp[_idx];
253  _data[1] = tmp[_idx];
254  delete [] tmp;
255  }
256  } else if ( 2 > _nelems ) {
257  throw( RDBErr( "RDBColumnTmplt::setGroup(bool): user supplied column must provide >= 2 data elements" ) );
258 
259  }
260 }
261 
266 template<class Tmplt0,class Tmplt1,class Tmplt2>
267 void
269  void
270  ) {
271 
272  if ( _group ) {
273  _data[(_idx+1)%_nelems] = _groupvalue;
274  _groupvalue = _data[_idx];
275  }
276 
277 }
278 
283 template<class Tmplt0,class Tmplt1,class Tmplt2>
284 int
286  void
287  ) {
288 
289  if ( _group ) {
290  if ( _initgroup ) {
291  _initgroup = false;
292  _data[_idx] = _groupvalue;
293  _groupvalue = _data[(_idx+1)%_nelems];
294  return RDBColumn::CBOG;
295 
296  } else {
297  int status = RDBColumn::CMOG;
298 
299  if ( _data[_idx] != _groupvalue )
300  status |= RDBColumn::CBOG;
301 
302  if ( _data[_idx] != _data[(_idx+1)%_nelems] )
303  status |= RDBColumn::CEOG;
304 
305  _groupvalue = _data[_idx];
306 
307  return status;
308  }
309  }
310 
311  return RDBColumn::CMOG;
312 
313  /*
314  if ( _group ) {
315  if ( _initgroup ) {
316  _initgroup = false;
317  _data[(_idx+1)%_nelems] = _groupvalue;
318  _groupvalue = _data[_idx];
319  return RDBColumn::CBOG;
320 
321  } else if ( _data[_idx] != _groupvalue ) {
322  _data[(_idx+1)%_nelems] = _groupvalue;
323  _groupvalue = _data[_idx];
324  return RDBColumn::CBOG;
325 
326  }
327  }
328 
329  return RDBColumn::CMOG;
330  */
331 }
332 
341 template<class Tmplt0,class Tmplt1,class Tmplt2>
342 bool
344  const Tmplt0& data
345  ) {
346 
347  try {
348  convert( data, _data[_idx] );
349 
350  } catch ( RDBErr& rdberr ) {
351  rdberr.set_message( "RDBColumnTmplt::setData(Tmplt0&): " );
352  throw( rdberr );
353 
354  } catch ( ... ) {
355  throw( RDBErr( "RDBColumnTmplt::setData(Tmplt0&): unexpected exception caught" ) );
356 
357  }
358 
359  return 0 == _errno;
360 
361 }
362 
374 template<class Tmplt0,class Tmplt1,class Tmplt2>
375 bool
377  const Tmplt1& data
378  ) {
379 
380  try {
381  convert( data, _data[_idx] );
382 
383  } catch ( RDBErr& rdberr ) {
384  rdberr.set_message( "RDBColumnTmplt::setData(Tmplt1&): " );
385  throw( rdberr );
386 
387  } catch ( ... ) {
388  throw( RDBErr( "RDBColumnTmplt::setData(Tmplt1&): unexpected exception caught" ) );
389 
390  }
391 
392  return 0 == _errno;
393 
394 }
395 
407 template<class Tmplt0,class Tmplt1,class Tmplt2>
408 bool
410  const Tmplt2& data
411  ) {
412 
413  try {
414  convert( data, _data[_idx] );
415 
416  } catch ( RDBErr& rdberr ) {
417  rdberr.set_message( "RDBColumnTmplt::setData(Tmplt2&): " );
418  throw( rdberr );
419 
420  } catch ( ... ) {
421  throw( RDBErr( "RDBColumnTmplt::setData(Tmplt2&): unexpected exception caught" ) );
422 
423  }
424 
425  return 0 == _errno;
426 
427 }
428 
438 template<class Tmplt0,class Tmplt1,class Tmplt2>
439 void
441  Tmplt0 data[],
442  const size_t nelems
443  ) {
444 
445  cleanup( );
446 
447  _nelems = nelems;
448  _data = data;
449  _idx = _idx % _nelems;
450  _mine = false;
451 
452  if ( _group && 2 > _nelems )
453  throw( RDBErr( "RDBColumnTmplt::mapData: user supplied data must provide >= 2 data elements" ) );
454 
455 }
456 
464 template<class Tmplt0,class Tmplt1,class Tmplt2>
465 void*
467  void
468  ) {
469 
470  return ((void *) &_data[_idx]);
471 
472 }
473 
482 template<class Tmplt0,class Tmplt1,class Tmplt2>
483 bool
485  Tmplt0& data
486  ) {
487 
488  try {
489  convert( _data[_idx], data );
490 
491  } catch ( RDBErr& rdberr ) {
492  rdberr.set_message( "RDBColumnTmplt::getData(Tmplt0&): " );
493  throw( rdberr );
494 
495  } catch ( ... ) {
496  throw( RDBErr( "RDBColumnTmplt::getData(Tmplt0&): unexpected exception caught" ) );
497 
498  }
499 
500  return 0 == _errno;
501 
502 }
503 
515 template<class Tmplt0,class Tmplt1,class Tmplt2>
516 bool
518  Tmplt1& data
519  ) {
520 
521  try {
522  convert( _data[_idx], data );
523 
524  } catch ( RDBErr& rdberr ) {
525  rdberr.set_message( "RDBColumnTmplt::getData(Tmplt1&): " );
526  throw( rdberr );
527 
528  } catch ( ... ) {
529  throw( RDBErr( "RDBColumnTmplt::getData(Tmplt1&): unexpected exception caught" ) );
530 
531  }
532 
533  return 0 == _errno;
534 
535 }
536 
548 template<class Tmplt0,class Tmplt1,class Tmplt2>
549 bool
551  Tmplt2& data
552  ) {
553 
554  try {
555  convert( _data[_idx], data );
556 
557  } catch ( RDBErr& rdberr ) {
558  rdberr.set_message( "RDBColumnTmplt::getData(Tmplt2&): " );
559  throw( rdberr );
560 
561  } catch ( ... ) {
562  throw( RDBErr( "RDBColumnTmplt::getData(Tmplt2&): unexpected exception caught" ) );
563 
564  }
565 
566  return 0 == _errno;
567 
568 }
569 
576 template<class Tmplt0,class Tmplt1,class Tmplt2>
577 double
579  void
580  ) {
581 
582  double odata;
583  try {
584  convert( _data[_idx], odata );
585 
586  } catch ( RDBErr& rdberr ) {
587  rdberr.set_message( "RDBColumnTmplt::getDataDouble(void): " );
588  throw( rdberr );
589 
590  } catch ( ... ) {
591  throw( RDBErr( "RDBColumnTmplt::getDataDouble(void): unexpected exception caught" ) );
592 
593  }
594 
595  return odata;
596 
597 }
598 
606 template<class Tmplt0,class Tmplt1,class Tmplt2>
607 long
609  void
610  ) {
611 
612  long odata;
613  try {
614  convert( _data[_idx], odata );
615 
616  } catch ( RDBErr& rdberr ) {
617  rdberr.set_message( "RDBColumnTmplt::getDataLong(void): " );
618  throw( rdberr );
619 
620  } catch ( ... ) {
621  throw( RDBErr( "RDBColumnTmplt::getDataLong(void): unexpected exception caught" ) );
622 
623  }
624 
625  return odata;
626 
627 }
628 
633 template<class Tmplt0,class Tmplt1,class Tmplt2>
634 string
636  void
637  ) {
638 
639  string odata;
640  try {
641  convert( _data[_idx], odata );
642 
643  } catch ( RDBErr& rdberr ) {
644  rdberr.set_message( "RDBColumnTmplt::getDataString(void): " );
645  throw( rdberr );
646 
647  } catch ( ... ) {
648  throw( RDBErr( "RDBColumnTmplt::getDataString(void): unexpected exception caught" ) );
649 
650  }
651 
652  return odata;
653 
654 }
655 
664 template<class Tmplt0,class Tmplt1,class Tmplt2>
665 istream&
667  istream& is
668  ) {
669 
670  try {
671  extract( is, _data[_idx] );
672 
673  } catch ( RDBErr& rdberr ) {
674  rdberr.set_message( "RDBColumnTmplt::read(istream&): " );
675  throw( rdberr );
676 
677  } catch ( ... ) {
678  throw( RDBErr( "RDBColumnTmplt::read(istream&): unexpected exception caught" ) );
679 
680  }
681 
682  return is;
683 
684 }
685 
694 template<class Tmplt0,class Tmplt1,class Tmplt2>
695 ostream&
697  ostream& os
698  ) const {
699 
700  return insert( os, _data[_idx] );
701 
702 }
703 
708 template<class Tmplt0,class Tmplt1,class Tmplt2>
709 void
711  void
712  ) {
713 
714  if ( _mine && _data ) {
715  delete [] _data;
716 
717  }
718 }
virtual istream & read(istream &is)
Called by the stream insertion operator.
virtual string getDataString(void)
Returns the value of the current data element, converting if necessary.
RDBColumn & operator=(const RDBColumn &col)
Copies RDBColumn object.
Definition: RDBColumn.cc:191
Tmplt0 * _data
Pointer to the data managed by object.
virtual void mapData(Tmplt0 data[], const size_t nelems)
Maps data to user-supplied memory.
virtual void rewind(void)
Rewinds index to the RDBColumn's data elements.
The parent class for all RDB related exceptions.
Definition: RDBErr.h:33
virtual bool setData(const Tmplt0 &data)
Sets the data value, converting as necessary.
void cleanup(void)
Deletes resources allocated by RDBColumnTmplt object.
virtual void setGroup(bool group)
Turn on/off group tracking for this column object.
Definition: RDBColumn.cc:219
bool _mine
Indicates that RDBColumnTmplt is responsible for deallocating the data.
void * getData(void)
Returns a pointer to the current data element.
size_t _idx
Index into the data.
~RDBColumnTmplt(void)
Deletes resources allocated by RDBColumnTmplt object.
RDBColumnTmplt(const string &name="", const string &def="")
Assigns name and definition.
virtual long getDataLong(void)
Returns the value of the current data element, converting if necessary.
virtual double getDataDouble(void)
Returns the value of the current data element, converting if necessary.
RDBColumn & operator=(const RDBColumnTmplt< Tmplt0, Tmplt1, Tmplt2 > &rdbcolumntmplt)
Copies RDBColumnTmplt object.
virtual void setGroup(bool group)
size_t _nelems
Number of elements of data.
virtual void advanceIdx(void)
Increments index to the RDBColumn's data elements.
virtual int newGroup(void)
Returns the group status of this column object.
virtual void setGroupValue(void)
Sets the group value to the current data value.
virtual ostream & write(ostream &os) const
Called by the stream extraction operator.
Parameterizes RDBColumn interface for many data types.
Provides interface for general column related methods.
Definition: RDBColumn.h:43