Olga Sergijenko / gammalib

Commit 56d87b7ad30800c7d8df486c910dfb0592139f33

Authored by knodlseder
1 parent d111479a

enhance column table handling and testing suite

Inline Side-by-side
Showing 16 changed files with 1671 additions and 760 deletions
include/GFitsData.hpp
  View file @56d87b7
@@ -46,7 +46,7 @@ public: @@ -46,7 +46,7 @@ public:
46 protected: 46 protected:
47 // Protected methods 47 // Protected methods
48 virtual void connect(__fitsfile* fptr); 48 virtual void connect(__fitsfile* fptr);
49 - 49 +
50 // Protected data area 50 // Protected data area
51 __fitsfile m_fitsfile; //!< FITS file 51 __fitsfile m_fitsfile; //!< FITS file
52 }; 52 };
include/GFitsImage.hpp
  View file @56d87b7
@@ -66,7 +66,8 @@ protected: @@ -66,7 +66,8 @@ protected:
66 void copy_members(const GFitsImage& image); 66 void copy_members(const GFitsImage& image);
67 void free_members(void); 67 void free_members(void);
68 void open_image(__fitsfile* fptr); 68 void open_image(__fitsfile* fptr);
69 - void load_image(int datatype, const void* pixels, const void* nulval, int* anynul); 69 + void load_image(int datatype, const void* pixels, const void* nulval,
  70 + int* anynul);
70 void save_image(int datatype, const void* pixels); 71 void save_image(int datatype, const void* pixels);
71 72
72 // Private data area 73 // Private data area
include/GFitsTableCol.hpp
  View file @56d87b7
@@ -37,9 +37,6 @@ class GFitsTableCol { @@ -37,9 +37,6 @@ class GFitsTableCol {
37 // Friend classes 37 // Friend classes
38 friend class GFitsTable; 38 friend class GFitsTable;
39 39
40 - // I/O friends  
41 -// friend ostream& operator<< (ostream& os, const GFitsTableCol& column);  
42 -  
43 public: 40 public:
44 // Constructors and destructors 41 // Constructors and destructors
45 GFitsTableCol(); 42 GFitsTableCol();
@@ -70,24 +67,36 @@ public: @@ -70,24 +67,36 @@ public:
70 67
71 protected: 68 protected:
72 // Protected data area 69 // Protected data area
73 - std::string m_name; //!< Column name  
74 - std::string m_unit; //!< Column unit  
75 - int m_colnum; //!< @brief Column number (starting from 1).  
76 - //!< This parameter is used to signal if a  
77 - //!< table column corresponds to a FITS file  
78 - //!< column. If it is set to 0 there is no  
79 - //!< correspondance.  
80 - int m_type; //!< Column type  
81 - int m_repeat; //!< Repeat value of column  
82 - int m_width; //!< Width of single column element  
83 - int m_number; //!< Number of elements in column  
84 - //!< m_number = m_repeat / m_width  
85 - int m_length; //!< Length of column  
86 - __fitsfile m_fitsfile; //!< FITS file associated with column 70 + std::string m_name; //!< Column name
  71 + std::string m_unit; //!< Column unit
  72 + int m_colnum; //!< @brief Column number (starting from 1).
  73 + //!< This parameter is used to signal if a
  74 + //!< table column corresponds to a FITS file
  75 + //!< column. If it is set to 0 there is no
  76 + //!< correspondance.
  77 + int m_type; //!< Column type
  78 + int m_repeat; //!< Repeat value of column
  79 + int m_width; //!< Width of single column element
  80 + int m_number; //!< @brief Number of elements in column.
  81 + //!< m_number = m_repeat / m_width
  82 + int m_length; //!< Length of column
  83 + int m_size; //!< Size of allocated data area (0 if not loaded)
  84 + int m_anynul; //!< Number of NULLs encountered
  85 + __fitsfile m_fitsfile; //!< FITS file associated with column
87 86
88 - // Protected methods 87 + // Protected virtual methods
89 virtual std::string ascii_format(void) const = 0; 88 virtual std::string ascii_format(void) const = 0;
90 virtual std::string binary_format(void) const = 0; 89 virtual std::string binary_format(void) const = 0;
  90 + virtual void alloc_data(void) = 0;
  91 + virtual void init_data(void) = 0;
  92 + virtual void fetch_data(void) = 0;
  93 + virtual void* ptr_data(void) = 0;
  94 + virtual void* ptr_nulval(void) = 0;
  95 +
  96 + // Protected methods
  97 + void load_column(void);
  98 + void save_column(void);
  99 + void dump_column(ostream& os, void* data) const;
91 100
92 private: 101 private:
93 // Private methods 102 // Private methods
include/GFitsTableDblCol.hpp
  View file @56d87b7
@@ -68,15 +68,17 @@ private: @@ -68,15 +68,17 @@ private:
68 void init_members(void); 68 void init_members(void);
69 void copy_members(const GFitsTableDblCol& column); 69 void copy_members(const GFitsTableDblCol& column);
70 void free_members(void); 70 void free_members(void);
71 - void fetch_data(void);  
72 std::string ascii_format(void) const; 71 std::string ascii_format(void) const;
73 std::string binary_format(void) const; 72 std::string binary_format(void) const;
  73 + void alloc_data(void);
  74 + void init_data(void);
  75 + void fetch_data(void);
  76 + void* ptr_data(void) { return m_data; }
  77 + void* ptr_nulval(void) { return m_nulval; }
74 78
75 // Private data area 79 // Private data area
76 - int m_size; //!< Size of allocated data area (0 if not loaded)  
77 double* m_data; //!< Data area 80 double* m_data; //!< Data area
78 double* m_nulval; //!< NULL value 81 double* m_nulval; //!< NULL value
79 - int m_anynul; //!< Number of NULLs encountered  
80 }; 82 };
81 83
82 #endif /* GFITSTABLEDBLCOL_HPP */ 84 #endif /* GFITSTABLEDBLCOL_HPP */
include/GFitsTableFltCol.hpp
  View file @56d87b7
@@ -68,15 +68,17 @@ private: @@ -68,15 +68,17 @@ private:
68 void init_members(void); 68 void init_members(void);
69 void copy_members(const GFitsTableFltCol& column); 69 void copy_members(const GFitsTableFltCol& column);
70 void free_members(void); 70 void free_members(void);
71 - void fetch_data(void);  
72 std::string ascii_format(void) const; 71 std::string ascii_format(void) const;
73 std::string binary_format(void) const; 72 std::string binary_format(void) const;
  73 + void alloc_data(void);
  74 + void init_data(void);
  75 + void fetch_data(void);
  76 + void* ptr_data(void) { return m_data; }
  77 + void* ptr_nulval(void) { return m_nulval; }
74 78
75 // Private data area 79 // Private data area
76 - int m_size; //!< Size of allocated data area (0 if not loaded)  
77 float* m_data; //!< Data area 80 float* m_data; //!< Data area
78 float* m_nulval; //!< NULL value 81 float* m_nulval; //!< NULL value
79 - int m_anynul; //!< Number of NULLs encountered  
80 }; 82 };
81 83
82 #endif /* GFITSTABLEFLTCOL_HPP */ 84 #endif /* GFITSTABLEFLTCOL_HPP */
include/GFitsTableLngCol.hpp
  View file @56d87b7
@@ -38,6 +38,9 @@ @@ -38,6 +38,9 @@
38 ***************************************************************************/ 38 ***************************************************************************/
39 class GFitsTableLngCol : public GFitsTableCol { 39 class GFitsTableLngCol : public GFitsTableCol {
40 40
  41 + // I/O friends
  42 + friend ostream& operator<< (ostream& os, const GFitsTableLngCol& column);
  43 +
41 public: 44 public:
42 // Constructors and destructors 45 // Constructors and destructors
43 GFitsTableLngCol(); 46 GFitsTableLngCol();
@@ -65,15 +68,17 @@ private: @@ -65,15 +68,17 @@ private:
65 void init_members(void); 68 void init_members(void);
66 void copy_members(const GFitsTableLngCol& column); 69 void copy_members(const GFitsTableLngCol& column);
67 void free_members(void); 70 void free_members(void);
68 - void fetch_data(void);  
69 std::string ascii_format(void) const; 71 std::string ascii_format(void) const;
70 std::string binary_format(void) const; 72 std::string binary_format(void) const;
  73 + void alloc_data(void);
  74 + void init_data(void);
  75 + void fetch_data(void);
  76 + void* ptr_data(void) { return m_data; }
  77 + void* ptr_nulval(void) { return m_nulval; }
71 78
72 // Private data area 79 // Private data area
73 - int m_size; //!< Size of data area  
74 long* m_data; //!< Data area 80 long* m_data; //!< Data area
75 long* m_nulval; //!< NULL value 81 long* m_nulval; //!< NULL value
76 - int m_anynul; //!< Number of NULLs encountered  
77 }; 82 };
78 83
79 #endif /* GFITSTABLELNGCOL_HPP */ 84 #endif /* GFITSTABLELNGCOL_HPP */
include/GFitsTableShtCol.hpp
  View file @56d87b7
@@ -10,6 +10,11 @@ @@ -10,6 +10,11 @@
10 * (at your option) any later version. * 10 * (at your option) any later version. *
11 * * 11 * *
12 ***************************************************************************/ 12 ***************************************************************************/
  13 +/**
  14 + * @file GFitsTableShtCol.hpp
  15 + * @brief GFitsTableShtCol class definition.
  16 + * @author J. Knodlseder
  17 + */
13 18
14 #ifndef GFITSTABLESHTCOL_HPP 19 #ifndef GFITSTABLESHTCOL_HPP
15 #define GFITSTABLESHTCOL_HPP 20 #define GFITSTABLESHTCOL_HPP
@@ -24,21 +29,30 @@ @@ -24,21 +29,30 @@
24 /* __ Structures _________________________________________________________ */ 29 /* __ Structures _________________________________________________________ */
25 30
26 31
27 -/***************************************************************************  
28 - * GFitsTableShtCol class definition * 32 +/***********************************************************************//**
  33 + * @class GFitsTableShtCol
  34 + *
  35 + * @brief Interface for FITS table short integer column
  36 + *
  37 + * This class implements a FITS table short integer column.
29 ***************************************************************************/ 38 ***************************************************************************/
30 class GFitsTableShtCol : public GFitsTableCol { 39 class GFitsTableShtCol : public GFitsTableCol {
31 40
  41 + // I/O friends
  42 + friend ostream& operator<< (ostream& os, const GFitsTableShtCol& column);
  43 +
32 public: 44 public:
33 // Constructors and destructors 45 // Constructors and destructors
34 GFitsTableShtCol(); 46 GFitsTableShtCol();
35 GFitsTableShtCol(const std::string& name, const int& length, 47 GFitsTableShtCol(const std::string& name, const int& length,
36 - const int& size = 1); 48 + const int& size = 1);
37 GFitsTableShtCol(const GFitsTableShtCol& column); 49 GFitsTableShtCol(const GFitsTableShtCol& column);
38 virtual ~GFitsTableShtCol(); 50 virtual ~GFitsTableShtCol();
39 51
40 // Operators 52 // Operators
41 GFitsTableShtCol& operator= (const GFitsTableShtCol& column); 53 GFitsTableShtCol& operator= (const GFitsTableShtCol& column);
  54 + short& operator() (const int& row, const int& inx = 0);
  55 + const short& operator() (const int& row, const int& inx = 0) const;
42 56
43 // Methods 57 // Methods
44 void save(void); 58 void save(void);
@@ -46,11 +60,7 @@ public: @@ -46,11 +60,7 @@ public:
46 double real(const int& row, const int& col = 0); 60 double real(const int& row, const int& col = 0);
47 int integer(const int& row, const int& col = 0); 61 int integer(const int& row, const int& col = 0);
48 GFitsTableShtCol* clone(void) const; 62 GFitsTableShtCol* clone(void) const;
49 - double* ptr_double(void);  
50 - float* ptr_float(void);  
51 - short* ptr_short(void);  
52 - long* ptr_long(void);  
53 - int* ptr_int(void); 63 + short* data(void);
54 void set_nullval(const short* value); 64 void set_nullval(const short* value);
55 65
56 private: 66 private:
@@ -58,26 +68,17 @@ private: @@ -58,26 +68,17 @@ private:
58 void init_members(void); 68 void init_members(void);
59 void copy_members(const GFitsTableShtCol& column); 69 void copy_members(const GFitsTableShtCol& column);
60 void free_members(void); 70 void free_members(void);
61 - void load(void);  
62 std::string ascii_format(void) const; 71 std::string ascii_format(void) const;
63 std::string binary_format(void) const; 72 std::string binary_format(void) const;
  73 + void alloc_data(void);
  74 + void init_data(void);
  75 + void fetch_data(void);
  76 + void* ptr_data(void) { return m_data; }
  77 + void* ptr_nulval(void) { return m_nulval; }
64 78
65 // Private data area 79 // Private data area
66 - int m_size; // Size of data area  
67 - short* m_data; // Data area  
68 - short* m_nulval; // NULL value  
69 - int m_anynul; // Number of NULLs encountered 80 + short* m_data; //!< Data area
  81 + short* m_nulval; //!< NULL value
70 }; 82 };
71 83
72 -  
73 -/***************************************************************************  
74 - * Inline methods *  
75 - ***************************************************************************/  
76 -inline short* GFitsTableShtCol::ptr_short(void) { return m_data; }  
77 -inline  
78 -GFitsTableShtCol* GFitsTableShtCol::clone(void) const  
79 -{  
80 - return new GFitsTableShtCol(*this);  
81 -}  
82 -  
83 #endif /* GFITSTABLESHTCOL_HPP */ 84 #endif /* GFITSTABLESHTCOL_HPP */
include/GFitsTableStrCol.hpp
  View file @56d87b7
@@ -10,6 +10,11 @@ @@ -10,6 +10,11 @@
10 * (at your option) any later version. * 10 * (at your option) any later version. *
11 * * 11 * *
12 ***************************************************************************/ 12 ***************************************************************************/
  13 +/**
  14 + * @file GFitsTableStrCol.hpp
  15 + * @brief GFitsTableStrCol class definition.
  16 + * @author J. Knodlseder
  17 + */
13 18
14 #ifndef GFITSTABLESTRCOL_HPP 19 #ifndef GFITSTABLESTRCOL_HPP
15 #define GFITSTABLESTRCOL_HPP 20 #define GFITSTABLESTRCOL_HPP
@@ -24,21 +29,30 @@ @@ -24,21 +29,30 @@
24 /* __ Structures _________________________________________________________ */ 29 /* __ Structures _________________________________________________________ */
25 30
26 31
27 -/***************************************************************************  
28 - * GFitsTableStrCol class definition * 32 +/***********************************************************************//**
  33 + * @class GFitsTableStrCol
  34 + *
  35 + * @brief Interface for FITS table string column
  36 + *
  37 + * This class implements a FITS table string column.
29 ***************************************************************************/ 38 ***************************************************************************/
30 class GFitsTableStrCol : public GFitsTableCol { 39 class GFitsTableStrCol : public GFitsTableCol {
31 40
  41 + // I/O friends
  42 + friend ostream& operator<< (ostream& os, const GFitsTableStrCol& column);
  43 +
32 public: 44 public:
33 // Constructors and destructors 45 // Constructors and destructors
34 GFitsTableStrCol(); 46 GFitsTableStrCol();
35 GFitsTableStrCol(const std::string& name, const int& length, 47 GFitsTableStrCol(const std::string& name, const int& length,
36 - const int& size = 1); 48 + const int& width, const int& size = 1);
37 GFitsTableStrCol(const GFitsTableStrCol& column); 49 GFitsTableStrCol(const GFitsTableStrCol& column);
38 ~GFitsTableStrCol(); 50 ~GFitsTableStrCol();
39 51
40 // Operators 52 // Operators
41 - GFitsTableStrCol& operator= (const GFitsTableStrCol& column); 53 + GFitsTableStrCol& operator= (const GFitsTableStrCol& column);
  54 + std::string& operator() (const int& row, const int& inx = 0);
  55 + const std::string& operator() (const int& row, const int& inx = 0) const;
42 56
43 // Methods 57 // Methods
44 void save(void); 58 void save(void);
@@ -46,37 +60,28 @@ public: @@ -46,37 +60,28 @@ public:
46 double real(const int& row, const int& col = 0); 60 double real(const int& row, const int& col = 0);
47 int integer(const int& row, const int& col = 0); 61 int integer(const int& row, const int& col = 0);
48 GFitsTableStrCol* clone(void) const; 62 GFitsTableStrCol* clone(void) const;
49 - float* ptr_float(void);  
50 - double* ptr_double(void);  
51 - short* ptr_short(void);  
52 - long* ptr_long(void);  
53 - int* ptr_int(void);  
54 - void set_nullstr(const std::string string); 63 + std::string* data(void);
  64 + void set_nullval(const std::string string);
55 65
56 private: 66 private:
57 // Private methods 67 // Private methods
58 void init_members(void); 68 void init_members(void);
59 void copy_members(const GFitsTableStrCol& column); 69 void copy_members(const GFitsTableStrCol& column);
60 void free_members(void); 70 void free_members(void);
61 - void load(void);  
62 std::string ascii_format(void) const; 71 std::string ascii_format(void) const;
63 std::string binary_format(void) const; 72 std::string binary_format(void) const;
  73 + void alloc_data(void);
  74 + void init_data(void);
  75 + void fetch_data(void);
  76 + void* ptr_data(void) { return m_buffer; }
  77 + void* ptr_nulval(void) { return m_nulval; }
  78 + void alloc_buffer(void);
  79 + void free_buffer(void);
64 80
65 // Private data area 81 // Private data area
66 - int m_size; // Total number of strings  
67 - char** m_data; // Data area  
68 - char* m_nulstr; // NULL string  
69 - int m_anynul; // Number of NULLs encountered 82 + std::string* m_data; //!< Data area
  83 + char** m_buffer; //!< Data area for CFITSIO transfer
  84 + char* m_nulval; //!< NULL string
70 }; 85 };
71 86
72 -  
73 -/***************************************************************************  
74 - * Inline methods *  
75 - ***************************************************************************/  
76 -inline  
77 -GFitsTableStrCol* GFitsTableStrCol::clone(void) const  
78 -{  
79 - return new GFitsTableStrCol(*this);  
80 -}  
81 -  
82 #endif /* GFITSTABLESTRCOL_HPP */ 87 #endif /* GFITSTABLESTRCOL_HPP */
src/fits/GFitsTable.cpp
  View file @56d87b7
@@ -917,16 +917,20 @@ ostream&amp; operator&lt;&lt; (ostream&amp; os, const GFitsTable&amp; table) @@ -917,16 +917,20 @@ ostream&amp; operator&lt;&lt; (ostream&amp; os, const GFitsTable&amp; table)
917 if (table.m_columns[i] != NULL) { 917 if (table.m_columns[i] != NULL) {
918 switch (table.m_columns[i]->type()) { 918 switch (table.m_columns[i]->type()) {
919 case __TSTRING: 919 case __TSTRING:
920 - os << " column " << i << " no << operator" << endl; 920 + os << " " << *((GFitsTableStrCol*)table.m_columns[i])
  921 + << endl;
921 break; 922 break;
922 case __TSHORT: 923 case __TSHORT:
923 - os << " column " << i << " no << operator" << endl; 924 + os << " " << *((GFitsTableShtCol*)table.m_columns[i])
  925 + << endl;
924 break; 926 break;
925 case __TLONG: 927 case __TLONG:
926 - os << " column " << i << " no << operator" << endl; 928 + os << " " << *((GFitsTableLngCol*)table.m_columns[i])
  929 + << endl;
927 break; 930 break;
928 case __TFLOAT: 931 case __TFLOAT:
929 - os << " column " << i << " no << operator" << endl; 932 + os << " " << *((GFitsTableFltCol*)table.m_columns[i])
  933 + << endl;
930 break; 934 break;
931 case __TDOUBLE: 935 case __TDOUBLE:
932 os << " " << *((GFitsTableDblCol*)table.m_columns[i]) 936 os << " " << *((GFitsTableDblCol*)table.m_columns[i])
src/fits/GFitsTableCol.cpp
  View file @56d87b7
@@ -20,6 +20,8 @@ @@ -20,6 +20,8 @@
20 /* __ Namespaces _________________________________________________________ */ 20 /* __ Namespaces _________________________________________________________ */
21 21
22 /* __ Method name definitions ____________________________________________ */ 22 /* __ Method name definitions ____________________________________________ */
  23 +#define G_LOAD_COLUMN "GFitsTableCol::load_column(void*, void*)"
  24 +#define G_SAVE_COLUMN "GFitsTableCol::save_column(void*, void*)"
23 25
24 /* __ Macros _____________________________________________________________ */ 26 /* __ Macros _____________________________________________________________ */
25 27
@@ -268,6 +270,8 @@ void GFitsTableCol::init_members(void) @@ -268,6 +270,8 @@ void GFitsTableCol::init_members(void)
268 m_width = 0; 270 m_width = 0;
269 m_number = 0; 271 m_number = 0;
270 m_length = 0; 272 m_length = 0;
  273 + m_size = 0;
  274 + m_anynul = 0;
271 m_fitsfile.HDUposition = 0; 275 m_fitsfile.HDUposition = 0;
272 m_fitsfile.Fptr = NULL; 276 m_fitsfile.Fptr = NULL;
273 277
@@ -292,6 +296,8 @@ void GFitsTableCol::copy_members(const GFitsTableCol&amp; column) @@ -292,6 +296,8 @@ void GFitsTableCol::copy_members(const GFitsTableCol&amp; column)
292 m_width = column.m_width; 296 m_width = column.m_width;
293 m_number = column.m_number; 297 m_number = column.m_number;
294 m_length = column.m_length; 298 m_length = column.m_length;
  299 + m_size = column.m_size;
  300 + m_anynul = column.m_anynul;
295 m_fitsfile = column.m_fitsfile; 301 m_fitsfile = column.m_fitsfile;
296 302
297 // Return 303 // Return
@@ -329,6 +335,159 @@ void GFitsTableCol::connect(__fitsfile* fptr) @@ -329,6 +335,159 @@ void GFitsTableCol::connect(__fitsfile* fptr)
329 } 335 }
330 336
331 337
  338 +/***********************************************************************//**
  339 + * @brief Load table column from FITS file
  340 + *
  341 + * @exception GException::fits_hdu_not_found
  342 + * Specified HDU not found in FITS file.
  343 + * @exception GException::fits_error
  344 + * An error occured while loading column data from FITS file.
  345 + *
  346 + * If a FITS file is attached to the column the data are loaded into memory
  347 + * from the FITS file. If no FITS file is attached, memory is allocated
  348 + * to hold the column data and all cells are set to 0.
  349 + *
  350 + * The method make use of the virtual methods
  351 + * GFitsTableCol::alloc_data,
  352 + * GFitsTableCol::init_data,
  353 + * GFitsTableCol::ptr_data, and
  354 + * GFitsTableCol::ptr_nulval.
  355 + * These methods are implemented by the derived column classes which
  356 + * implement a specific storage class (i.e. float, double, short, ...).
  357 + ***************************************************************************/
  358 +void GFitsTableCol::load_column(void)
  359 +{
  360 + // Calculate size of memory
  361 + m_size = m_number * m_length;
  362 +
  363 + // Load only if the column has a positive size
  364 + if (m_size > 0) {
  365 +
  366 + // Allocate fresh memory
  367 + alloc_data();
  368 +
  369 + // If a FITS file is attached then load column data from the FITS
  370 + // file
  371 + if (m_fitsfile.Fptr != NULL) {
  372 +
  373 + // Move to the HDU
  374 + int status = 0;
  375 + status = __ffmahd(&m_fitsfile, (m_fitsfile.HDUposition)+1,
  376 + NULL, &status);
  377 + if (status != 0)
  378 + throw GException::fits_hdu_not_found(G_LOAD_COLUMN,
  379 + (m_fitsfile.HDUposition)+1,
  380 + status);
  381 +
  382 + // Load data
  383 + status = __ffgcv(&m_fitsfile, m_type, m_colnum, 1, 1, m_size,
  384 + ptr_nulval(), ptr_data(), &m_anynul, &status);
  385 + if (status != 0)
  386 + throw GException::fits_error(G_LOAD_COLUMN, status);
  387 + }
  388 +
  389 + // ... otherwise initialise all column values
  390 + else
  391 + init_data();
  392 +
  393 + } // endif: column has a positive size
  394 +
  395 + // Return
  396 + return;
  397 +}
  398 +
  399 +
  400 +/***********************************************************************//**
  401 + * @brief Save table column into FITS file
  402 + *
  403 + * @exception GException::fits_hdu_not_found
  404 + * Specified HDU not found in FITS file.
  405 + * @exception GException::fits_error
  406 + * Error occured during writing of the column data.
  407 + *
  408 + * The table column is only saved if it is linked to a FITS file and if the
  409 + * data are indeed present in the class instance. This avoids saving of data
  410 + * that have not been modified.
  411 + *
  412 + * The method make use of the virtual methods
  413 + * GFitsTableCol::ptr_data and
  414 + * GFitsTableCol::ptr_nulval.
  415 + * These methods are implemented by the derived column classes which
  416 + * implement a specific storage class (i.e. float, double, short, ...).
  417 + ***************************************************************************/
  418 +void GFitsTableCol::save_column(void)
  419 +{
  420 + // Continue only if a FITS file is connected and data have been loaded
  421 + if (m_fitsfile.Fptr != NULL && m_colnum > 0 && ptr_data() != NULL) {
  422 +
  423 + // Move to the HDU
  424 + int status = 0;
  425 + status = __ffmahd(&m_fitsfile, (m_fitsfile.HDUposition)+1, NULL,
  426 + &status);
  427 + if (status != 0)
  428 + throw GException::fits_hdu_not_found(G_SAVE_COLUMN,
  429 + (m_fitsfile.HDUposition)+1,
  430 + status);
  431 + // Save the column data
  432 + status = __ffpcn(&m_fitsfile, m_type, m_colnum, 1, 1,
  433 + (long)m_size, ptr_data(), ptr_nulval(), &status);
  434 + if (status != 0)
  435 + throw GException::fits_error(G_SAVE_COLUMN, status);
  436 +
  437 + } // endif: FITS file was connected
  438 +
  439 + // Return
  440 + return;
  441 +}
  442 +
  443 +
  444 +/***********************************************************************//**
  445 + * @brief Put column information in output stream
  446 + *
  447 + * @param[in] os Output stream
  448 + * @param[in] column Column to put in output stream
  449 + ***************************************************************************/
  450 +void GFitsTableCol::dump_column(ostream& os, void* data) const
  451 +{
  452 + // Put column name in stream
  453 + os << "'" << m_name << "'";
  454 +
  455 + // Put FITS column number in stream
  456 + if (m_colnum > 0)
  457 + os << " [fits_colnum=" << m_colnum << "]";
  458 + else
  459 + os << " [not linked to FITS file]";
  460 +
  461 + // Put column type in stream
  462 + os << " " << ascii_format();
  463 + os << " " << binary_format();
  464 +
  465 + // Put data loading in stream
  466 + if (data == NULL)
  467 + os << " (not loaded)";
  468 + else
  469 + os << " (loaded in memory)";
  470 +
  471 + // Set data area size
  472 + os << " size=" << m_size;
  473 +
  474 + // Set vector length
  475 + os << " repeat=" << m_repeat;
  476 +
  477 + // Set width
  478 + os << " width=" << m_width;
  479 +
  480 + // Set number
  481 + os << " number=" << m_number;
  482 +
  483 + // Set length
  484 + os << " length=" << m_length;
  485 +
  486 + // Return
  487 + return;
  488 +}
  489 +
  490 +
332 /*========================================================================== 491 /*==========================================================================
333 = = 492 = =
334 = GFitsTableCol friends = 493 = GFitsTableCol friends =
src/fits/GFitsTableDblCol.cpp
  View file @56d87b7
@@ -21,11 +21,9 @@ @@ -21,11 +21,9 @@
21 /* __ Namespaces _________________________________________________________ */ 21 /* __ Namespaces _________________________________________________________ */
22 22
23 /* __ Method name definitions ____________________________________________ */ 23 /* __ Method name definitions ____________________________________________ */
24 -#define G_SAVE "GFitsTableDblCol::save(void)"  
25 -#define G_STRING "GFitsTableDblCol::string(const int&, const int&)"  
26 -#define G_REAL "GFitsTableDblCol::real(const int&, const int&)"  
27 -#define G_INTEGER "GFitsTableDblCol::integer(const int&, const int&)"  
28 -#define G_FETCH_DATA "GFitsTableDblCol::fetch_data()" 24 +#define G_STRING "GFitsTableDblCol::string(const int&, const int&)"
  25 +#define G_REAL "GFitsTableDblCol::real(const int&, const int&)"
  26 +#define G_INTEGER "GFitsTableDblCol::integer(const int&, const int&)"
29 27
30 /* __ Macros _____________________________________________________________ */ 28 /* __ Macros _____________________________________________________________ */
31 29
@@ -161,7 +159,7 @@ double&amp; GFitsTableDblCol::operator() (const int&amp; row, const int&amp; inx) @@ -161,7 +159,7 @@ double&amp; GFitsTableDblCol::operator() (const int&amp; row, const int&amp; inx)
161 // Calculate pixel offset 159 // Calculate pixel offset
162 int offset = row * m_number + inx; 160 int offset = row * m_number + inx;
163 161
164 - // Return image pixel 162 + // Return data bin
165 return m_data[offset]; 163 return m_data[offset];
166 } 164 }
167 165
@@ -180,7 +178,7 @@ double&amp; GFitsTableDblCol::operator() (const int&amp; row, const int&amp; inx) @@ -180,7 +178,7 @@ double&amp; GFitsTableDblCol::operator() (const int&amp; row, const int&amp; inx)
180 * if range checking is required. 178 * if range checking is required.
181 ***************************************************************************/ 179 ***************************************************************************/
182 const double& GFitsTableDblCol::operator() (const int& row, const int& inx) 180 const double& GFitsTableDblCol::operator() (const int& row, const int& inx)
183 - const 181 + const
184 { 182 {
185 // If data are not available then load them now 183 // If data are not available then load them now
186 if (m_data == NULL) ((GFitsTableDblCol*)this)->fetch_data(); 184 if (m_data == NULL) ((GFitsTableDblCol*)this)->fetch_data();
@@ -188,7 +186,7 @@ const double&amp; GFitsTableDblCol::operator() (const int&amp; row, const int&amp; inx) @@ -188,7 +186,7 @@ const double&amp; GFitsTableDblCol::operator() (const int&amp; row, const int&amp; inx)
188 // Calculate pixel offset 186 // Calculate pixel offset
189 int offset = row * m_number + inx; 187 int offset = row * m_number + inx;
190 188
191 - // Return image pixel 189 + // Return data bin
192 return m_data[offset]; 190 return m_data[offset];
193 } 191 }
194 192
@@ -202,35 +200,16 @@ const double&amp; GFitsTableDblCol::operator() (const int&amp; row, const int&amp; inx) @@ -202,35 +200,16 @@ const double&amp; GFitsTableDblCol::operator() (const int&amp; row, const int&amp; inx)
202 /***********************************************************************//** 200 /***********************************************************************//**
203 * @brief Save table column into FITS file 201 * @brief Save table column into FITS file
204 * 202 *
205 - * @exception GException::fits_hdu_not_found  
206 - * Specified HDU not found in FITS file.  
207 - * @exception GException::fits_error  
208 - * Error occured during writing of the column data.  
209 - *  
210 * The table column is only saved if it is linked to a FITS file and if the 203 * The table column is only saved if it is linked to a FITS file and if the
211 * data are indeed present in the class instance. This avoids saving of data 204 * data are indeed present in the class instance. This avoids saving of data
212 * that have not been modified. 205 * that have not been modified.
  206 + *
  207 + * Refer to GFitsTableCol::save_column() for more information.
213 ***************************************************************************/ 208 ***************************************************************************/
214 void GFitsTableDblCol::save(void) 209 void GFitsTableDblCol::save(void)
215 { 210 {
216 - // Continue only if a FITS file is connected and data have been loaded  
217 - if (m_fitsfile.Fptr != NULL && m_colnum > 0 && m_data != NULL) {  
218 -  
219 - // Move to the HDU  
220 - int status = 0;  
221 - status = __ffmahd(&m_fitsfile, (m_fitsfile.HDUposition)+1, NULL,  
222 - &status);  
223 - if (status != 0)  
224 - throw GException::fits_hdu_not_found(G_SAVE,  
225 - (m_fitsfile.HDUposition)+1,  
226 - status);  
227 - // Save the column data  
228 - status = __ffpcn(&m_fitsfile, __TDOUBLE, m_colnum, 1, 1,  
229 - (long)m_size, m_data, m_nulval, &status);  
230 - if (status != 0)  
231 - throw GException::fits_error(G_SAVE, status);  
232 -  
233 - } // endif: FITS file was connected 211 + // Save column
  212 + save_column();
234 213
235 // Return 214 // Return
236 return; 215 return;
@@ -406,8 +385,6 @@ void GFitsTableDblCol::init_members(void) @@ -406,8 +385,6 @@ void GFitsTableDblCol::init_members(void)
406 { 385 {
407 // Initialise members 386 // Initialise members
408 m_type = __TDOUBLE; 387 m_type = __TDOUBLE;
409 - m_size = 0;  
410 - m_anynul = 0;  
411 m_data = NULL; 388 m_data = NULL;
412 m_nulval = NULL; 389 m_nulval = NULL;
413 390
@@ -424,8 +401,6 @@ void GFitsTableDblCol::init_members(void) @@ -424,8 +401,6 @@ void GFitsTableDblCol::init_members(void)
424 void GFitsTableDblCol::copy_members(const GFitsTableDblCol& column) 401 void GFitsTableDblCol::copy_members(const GFitsTableDblCol& column)
425 { 402 {
426 // Copy attributes 403 // Copy attributes
427 - m_size = column.m_size;  
428 - m_anynul = column.m_anynul;  
429 404
430 // Copy column data 405 // Copy column data
431 if (column.m_data != NULL && m_size > 0) { 406 if (column.m_data != NULL && m_size > 0) {
@@ -465,53 +440,6 @@ void GFitsTableDblCol::free_members(void) @@ -465,53 +440,6 @@ void GFitsTableDblCol::free_members(void)
465 440
466 441
467 /***********************************************************************//** 442 /***********************************************************************//**
468 - * @brief Fetch column data  
469 - *  
470 - * @exception GException::fits_error  
471 - * An error occured while loading column data from FITS file.  
472 - *  
473 - * If a FITS file is attached to the column the data are loaded into memory  
474 - * from the FITS file. If no FITS file is attached, memory is allocated  
475 - * to hold the column data and all cells are set to 0.  
476 - ***************************************************************************/  
477 -void GFitsTableDblCol::fetch_data(void)  
478 -{  
479 - // Calculate size of memory  
480 - m_size = m_number * m_length;  
481 -  
482 - // Load only if the column has a positive size  
483 - if (m_size > 0) {  
484 -  
485 - // Allocate fresh memory  
486 - if (m_data != NULL) delete [] m_data;  
487 - m_data = new double[m_size];  
488 -  
489 - // If a FITS file is attached then load column data from the FITS  
490 - // file  
491 - if (m_fitsfile.Fptr != NULL) {  
492 - int status = 0;  
493 - status = __ffmahd(&m_fitsfile, (m_fitsfile.HDUposition)+1, NULL,  
494 - &status);  
495 - status = __ffgcv(&m_fitsfile, __TDOUBLE, m_colnum, 1, 1, m_size,  
496 - m_nulval, m_data, &m_anynul, &status);  
497 - if (status != 0)  
498 - throw GException::fits_error(G_FETCH_DATA, status);  
499 - }  
500 -  
501 - // ... otherwise initialise all column values to 0  
502 - else {  
503 - for (int i = 0; i < m_size; ++i)  
504 - m_data[i] = 0.0;  
505 - }  
506 -  
507 - } // endif: column has a positive size  
508 -  
509 - // Return  
510 - return;  
511 -}  
512 -  
513 -  
514 -/***********************************************************************//**  
515 * @brief Returns format string of ASCII table 443 * @brief Returns format string of ASCII table
516 ***************************************************************************/ 444 ***************************************************************************/
517 std::string GFitsTableDblCol::ascii_format(void) const 445 std::string GFitsTableDblCol::ascii_format(void) const
@@ -549,6 +477,61 @@ std::string GFitsTableDblCol::binary_format(void) const @@ -549,6 +477,61 @@ std::string GFitsTableDblCol::binary_format(void) const
549 } 477 }
550 478
551 479
  480 +/***********************************************************************//**
  481 + * @brief Allocates column data
  482 + ***************************************************************************/
  483 +void GFitsTableDblCol::alloc_data(void)
  484 +{
  485 + // Free any existing memory
  486 + if (m_data != NULL) delete [] m_data;
  487 +
  488 + // Mark pointer as free
  489 + m_data = NULL;
  490 +
  491 + // Allocate new data
  492 + if (m_size > 0)
  493 + m_data = new double[m_size];
  494 +
  495 + // Return
  496 + return;
  497 +}
  498 +
  499 +
  500 +/***********************************************************************//**
  501 + * @brief Initialise column data
  502 + ***************************************************************************/
  503 +void GFitsTableDblCol::init_data(void)
  504 +{
  505 + // Initialise data if they exist
  506 + if (m_data != NULL) {
  507 + for (int i = 0; i < m_size; ++i)
  508 + m_data[i] = 0.0;
  509 + }
  510 +
  511 + // Return
  512 + return;
  513 +}
  514 +
  515 +
  516 +/***********************************************************************//**
  517 + * @brief Fetch column data
  518 + *
  519 + * If a FITS file is attached to the column the data are loaded into memory
  520 + * from the FITS file. If no FITS file is attached, memory is allocated
  521 + * to hold the column data and all cells are set to 0.
  522 + *
  523 + * Refer to GFitsTableCol::load_column for more information.
  524 + ***************************************************************************/
  525 +void GFitsTableDblCol::fetch_data(void)
  526 +{
  527 + // Save column
  528 + load_column();
  529 +
  530 + // Return
  531 + return;
  532 +}
  533 +
  534 +
552 /*========================================================================== 535 /*==========================================================================
553 = = 536 = =
554 = GFitsTableDblCol friends = 537 = GFitsTableDblCol friends =
@@ -563,39 +546,8 @@ std::string GFitsTableDblCol::binary_format(void) const @@ -563,39 +546,8 @@ std::string GFitsTableDblCol::binary_format(void) const
563 ***************************************************************************/ 546 ***************************************************************************/
564 ostream& operator<< (ostream& os, const GFitsTableDblCol& column) 547 ostream& operator<< (ostream& os, const GFitsTableDblCol& column)
565 { 548 {
566 - // Put column name in stream  
567 - os << "'" << column.m_name << "'";  
568 -  
569 - // Put FITS column number in stream  
570 - if (column.m_colnum > 0)  
571 - os << " [fits_colnum=" << column.m_colnum << "]";  
572 - else  
573 - os << " [not linked to FITS file]";  
574 -  
575 - // Put column type in stream  
576 - os << " " << column.ascii_format();  
577 - os << " " << column.binary_format();  
578 -  
579 - // Put data loading in stream  
580 - if (column.m_data == NULL)  
581 - os << " (not loaded)";  
582 - else  
583 - os << " (loaded in memory)";  
584 -  
585 - // Set data area size  
586 - os << " size=" << column.m_size;  
587 -  
588 - // Set vector length  
589 - os << " repeat=" << column.m_repeat;  
590 -  
591 - // Set width  
592 - os << " width=" << column.m_width;  
593 -  
594 - // Set number  
595 - os << " number=" << column.m_number;  
596 -  
597 - // Set length  
598 - os << " length=" << column.m_length; 549 + // Dump column in output stream
  550 + column.dump_column(os, column.m_data);
599 551
600 // Return output stream 552 // Return output stream
601 return os; 553 return os;
src/fits/GFitsTableFltCol.cpp
  View file @56d87b7
@@ -21,11 +21,9 @@ @@ -21,11 +21,9 @@
21 /* __ Namespaces _________________________________________________________ */ 21 /* __ Namespaces _________________________________________________________ */
22 22
23 /* __ Method name definitions ____________________________________________ */ 23 /* __ Method name definitions ____________________________________________ */
24 -#define G_SAVE "GFitsTableFltCol::save()"  
25 -#define G_STRING "GFitsTableFltCol::string(const int&, const int&)"  
26 -#define G_REAL "GFitsTableFltCol::real(const int&, const int&)"  
27 -#define G_INTEGER "GFitsTableFltCol::integer(const int&, const int&)"  
28 -#define G_FETCH_DATA "GFitsTableFltCol::fetch_data()" 24 +#define G_STRING "GFitsTableFltCol::string(const int&, const int&)"
  25 +#define G_REAL "GFitsTableFltCol::real(const int&, const int&)"
  26 +#define G_INTEGER "GFitsTableFltCol::integer(const int&, const int&)"
29 27
30 /* __ Macros _____________________________________________________________ */ 28 /* __ Macros _____________________________________________________________ */
31 29
@@ -202,35 +200,16 @@ const float&amp; GFitsTableFltCol::operator() (const int&amp; row, const int&amp; inx) @@ -202,35 +200,16 @@ const float&amp; GFitsTableFltCol::operator() (const int&amp; row, const int&amp; inx)
202 /***********************************************************************//** 200 /***********************************************************************//**
203 * @brief Save table column into FITS file 201 * @brief Save table column into FITS file
204 * 202 *
205 - * @exception GException::fits_hdu_not_found  
206 - * Specified HDU not found in FITS file.  
207 - * @exception GException::fits_error  
208 - * Error occured during writing of the column data.  
209 - *  
210 * The table column is only saved if it is linked to a FITS file and if the 203 * The table column is only saved if it is linked to a FITS file and if the
211 * data are indeed present in the class instance. This avoids saving of data 204 * data are indeed present in the class instance. This avoids saving of data
212 * that have not been modified. 205 * that have not been modified.
  206 + *
  207 + * Refer to GFitsTableCol::save_column() for more information.
213 ***************************************************************************/ 208 ***************************************************************************/
214 void GFitsTableFltCol::save(void) 209 void GFitsTableFltCol::save(void)
215 { 210 {
216 - // Continue only if a FITS file is connected and data have been loaded  
217 - if (m_fitsfile.Fptr != NULL && m_colnum > 0 && m_data != NULL) {  
218 -  
219 - // Move to the HDU  
220 - int status = 0;  
221 - status = __ffmahd(&m_fitsfile, (m_fitsfile.HDUposition)+1, NULL,  
222 - &status);  
223 - if (status != 0)  
224 - throw GException::fits_hdu_not_found(G_SAVE,  
225 - (m_fitsfile.HDUposition)+1,  
226 - status);  
227 - // Save the column data  
228 - status = __ffpcn(&m_fitsfile, __TFLOAT, m_colnum, 1, 1,  
229 - (long)m_size, m_data, m_nulval, &status);  
230 - if (status != 0)  
231 - throw GException::fits_error(G_SAVE, status);  
232 -  
233 - } // endif: FITS file was connected 211 + // Save column
  212 + save_column();
234 213
235 // Return 214 // Return
236 return; 215 return;
@@ -410,8 +389,6 @@ void GFitsTableFltCol::init_members(void) @@ -410,8 +389,6 @@ void GFitsTableFltCol::init_members(void)
410 { 389 {
411 // Initialise members 390 // Initialise members
412 m_type = __TFLOAT; 391 m_type = __TFLOAT;
413 - m_size = 0;  
414 - m_anynul = 0;  
415 m_data = NULL; 392 m_data = NULL;
416 m_nulval = NULL; 393 m_nulval = NULL;
417 394
@@ -428,8 +405,6 @@ void GFitsTableFltCol::init_members(void) @@ -428,8 +405,6 @@ void GFitsTableFltCol::init_members(void)
428 void GFitsTableFltCol::copy_members(const GFitsTableFltCol& column) 405 void GFitsTableFltCol::copy_members(const GFitsTableFltCol& column)
429 { 406 {
430 // Copy attributes 407 // Copy attributes
431 - m_size = column.m_size;  
432 - m_anynul = column.m_anynul;  
433 408
434 // Copy column data 409 // Copy column data
435 if (column.m_data != NULL && m_size > 0) { 410 if (column.m_data != NULL && m_size > 0) {
@@ -469,55 +444,6 @@ void GFitsTableFltCol::free_members(void) @@ -469,55 +444,6 @@ void GFitsTableFltCol::free_members(void)
469 444
470 445
471 /***********************************************************************//** 446 /***********************************************************************//**
472 - * @brief Fetch column data  
473 - *  
474 - * @exception GException::fits_error  
475 - * An error occured while loading column data from FITS file.  
476 - *  
477 - * If a FITS file is attached to the column the data are loaded into memory  
478 - * from the FITS file. If no FITS file is attached, memory is allocated  
479 - * to hold the column data and all cells are set to 0.  
480 - ***************************************************************************/  
481 -void GFitsTableFltCol::fetch_data(void)  
482 -{  
483 - // Calculate size of memory  
484 - m_size = m_number * m_length;  
485 -  
486 - // Load only if the column has a positive size  
487 - if (m_size > 0) {  
488 -  
489 - // Allocate fresh memory  
490 - if (m_data != NULL) delete [] m_data;  
491 - m_data = new float[m_size];  
492 -  
493 - // If a FITS file is attached then load column data from the FITS  
494 - // file  
495 - if (m_fitsfile.Fptr != NULL) {  
496 - int status = 0;  
497 - status = __ffmahd(&m_fitsfile, (m_fitsfile.HDUposition)+1, NULL,  
498 - &status);  
499 - status = __ffgcv(&m_fitsfile, __TFLOAT, m_colnum, 1, 1, m_size,  
500 - m_nulval, m_data, &m_anynul, &status);  
501 - if (status != 0)  
502 - throw GException::fits_error(G_FETCH_DATA, status);  
503 - }  
504 -  
505 - // ... otherwise initialise all column values to 0  
506 - else {  
507 - for (int i = 0; i < m_size; ++i)  
508 - m_data[i] = 0.0;  
509 - }  
510 -  
511 - } // endif: column has a positive size  
512 -  
513 - // Return  
514 - return;  
515 -}  
516 -  
517 -  
518 -  
519 -  
520 -/***********************************************************************//**  
521 * @brief Returns format string of ASCII table 447 * @brief Returns format string of ASCII table
522 ***************************************************************************/ 448 ***************************************************************************/
523 std::string GFitsTableFltCol::ascii_format(void) const 449 std::string GFitsTableFltCol::ascii_format(void) const
@@ -555,6 +481,61 @@ std::string GFitsTableFltCol::binary_format(void) const @@ -555,6 +481,61 @@ std::string GFitsTableFltCol::binary_format(void) const
555 } 481 }
556 482
557 483
  484 +/***********************************************************************//**
  485 + * @brief Allocates column data
  486 + ***************************************************************************/
  487 +void GFitsTableFltCol::alloc_data(void)
  488 +{
  489 + // Free any existing memory
  490 + if (m_data != NULL) delete [] m_data;
  491 +
  492 + // Mark pointer as free
  493 + m_data = NULL;
  494 +
  495 + // Allocate new data
  496 + if (m_size > 0)
  497 + m_data = new float[m_size];
  498 +
  499 + // Return
  500 + return;
  501 +}
  502 +
  503 +
  504 +/***********************************************************************//**
  505 + * @brief Initialise column data
  506 + ***************************************************************************/
  507 +void GFitsTableFltCol::init_data(void)
  508 +{
  509 + // Initialise data if they exist
  510 + if (m_data != NULL) {
  511 + for (int i = 0; i < m_size; ++i)
  512 + m_data[i] = 0.0;
  513 + }
  514 +
  515 + // Return
  516 + return;
  517 +}
  518 +
  519 +
  520 +/***********************************************************************//**
  521 + * @brief Fetch column data
  522 + *
  523 + * If a FITS file is attached to the column the data are loaded into memory
  524 + * from the FITS file. If no FITS file is attached, memory is allocated
  525 + * to hold the column data and all cells are set to 0.
  526 + *
  527 + * Refer to GFitsTableCol::load_column for more information.
  528 + ***************************************************************************/
  529 +void GFitsTableFltCol::fetch_data(void)
  530 +{
  531 + // Save column
  532 + load_column();
  533 +
  534 + // Return
  535 + return;
  536 +}
  537 +
  538 +
558 /*========================================================================== 539 /*==========================================================================
559 = = 540 = =
560 = GFitsTableFltCol friends = 541 = GFitsTableFltCol friends =
@@ -569,39 +550,8 @@ std::string GFitsTableFltCol::binary_format(void) const @@ -569,39 +550,8 @@ std::string GFitsTableFltCol::binary_format(void) const
569 ***************************************************************************/ 550 ***************************************************************************/
570 ostream& operator<< (ostream& os, const GFitsTableFltCol& column) 551 ostream& operator<< (ostream& os, const GFitsTableFltCol& column)
571 { 552 {
572 - // Put column name in stream  
573 - os << "'" << column.m_name << "'";  
574 -  
575 - // Put FITS column number in stream  
576 - if (column.m_colnum > 0)  
577 - os << " [fits_colnum=" << column.m_colnum << "]";  
578 - else  
579 - os << " [not linked to FITS file]";  
580 -  
581 - // Put column type in stream  
582 - os << " " << column.ascii_format();  
583 - os << " " << column.binary_format();  
584 -  
585 - // Put data loading in stream  
586 - if (column.m_data == NULL)  
587 - os << " (not loaded)";  
588 - else  
589 - os << " (loaded in memory)";  
590 -  
591 - // Set data area size  
592 - os << " size=" << column.m_size;  
593 -  
594 - // Set vector length  
595 - os << " repeat=" << column.m_repeat;  
596 -  
597 - // Set width  
598 - os << " width=" << column.m_width;  
599 -  
600 - // Set number  
601 - os << " number=" << column.m_number;  
602 -  
603 - // Set length  
604 - os << " length=" << column.m_length; 553 + // Dump column in output stream
  554 + column.dump_column(os, column.m_data);
605 555
606 // Return output stream 556 // Return output stream
607 return os; 557 return os;
src/fits/GFitsTableLngCol.cpp
  View file @56d87b7
@@ -21,11 +21,9 @@ @@ -21,11 +21,9 @@
21 /* __ Namespaces _________________________________________________________ */ 21 /* __ Namespaces _________________________________________________________ */
22 22
23 /* __ Method name definitions ____________________________________________ */ 23 /* __ Method name definitions ____________________________________________ */
24 -#define G_SAVE "GFitsTableLngCol::save()"  
25 -#define G_STRING "GFitsTableLngCol::string(const int&, const int&)"  
26 -#define G_REAL "GFitsTableLngCol::real(const int&, const int&)"  
27 -#define G_INTEGER "GFitsTableLngCol::integer(const int&, const int&)"  
28 -#define G_FETCH_DATA "GFitsTableLngCol::fetch_data()" 24 +#define G_STRING "GFitsTableLngCol::string(const int&, const int&)"
  25 +#define G_REAL "GFitsTableLngCol::real(const int&, const int&)"
  26 +#define G_INTEGER "GFitsTableLngCol::integer(const int&, const int&)"
29 27
30 /* __ Macros _____________________________________________________________ */ 28 /* __ Macros _____________________________________________________________ */
31 29
@@ -78,8 +76,8 @@ GFitsTableLngCol::GFitsTableLngCol(const std::string&amp; name, @@ -78,8 +76,8 @@ GFitsTableLngCol::GFitsTableLngCol(const std::string&amp; name,
78 * 76 *
79 * @param[in] column Column from which class instance should be built. 77 * @param[in] column Column from which class instance should be built.
80 ***************************************************************************/ 78 ***************************************************************************/
81 -GFitsTableLngCol::GFitsTableLngCol(const GFitsTableLngCol& column) :  
82 - GFitsTableCol(column) 79 +GFitsTableLngCol::GFitsTableLngCol(const GFitsTableLngCol& column)
  80 + : GFitsTableCol(column)
83 { 81 {
84 // Initialise class members for clean destruction 82 // Initialise class members for clean destruction
85 init_members(); 83 init_members();
@@ -159,7 +157,7 @@ long&amp; GFitsTableLngCol::operator() (const int&amp; row, const int&amp; inx) @@ -159,7 +157,7 @@ long&amp; GFitsTableLngCol::operator() (const int&amp; row, const int&amp; inx)
159 if (m_data == NULL) fetch_data(); 157 if (m_data == NULL) fetch_data();
160 158
161 // Calculate pixel offset 159 // Calculate pixel offset
162 - int offset = row * m_repeat + inx; 160 + int offset = row * m_number + inx;
163 161
164 // Return image pixel 162 // Return image pixel
165 return m_data[offset]; 163 return m_data[offset];
@@ -180,13 +178,13 @@ long&amp; GFitsTableLngCol::operator() (const int&amp; row, const int&amp; inx) @@ -180,13 +178,13 @@ long&amp; GFitsTableLngCol::operator() (const int&amp; row, const int&amp; inx)
180 * if range checking is required. 178 * if range checking is required.
181 ***************************************************************************/ 179 ***************************************************************************/
182 const long& GFitsTableLngCol::operator() (const int& row, const int& inx) 180 const long& GFitsTableLngCol::operator() (const int& row, const int& inx)
183 - const 181 + const
184 { 182 {
185 // If data are not available then load them now 183 // If data are not available then load them now
186 if (m_data == NULL) ((GFitsTableLngCol*)this)->fetch_data(); 184 if (m_data == NULL) ((GFitsTableLngCol*)this)->fetch_data();
187 185
188 // Calculate pixel offset 186 // Calculate pixel offset
189 - int offset = row * m_repeat + inx; 187 + int offset = row * m_number + inx;
190 188
191 // Return image pixel 189 // Return image pixel
192 return m_data[offset]; 190 return m_data[offset];
@@ -202,27 +200,16 @@ const long&amp; GFitsTableLngCol::operator() (const int&amp; row, const int&amp; inx) @@ -202,27 +200,16 @@ const long&amp; GFitsTableLngCol::operator() (const int&amp; row, const int&amp; inx)
202 /***********************************************************************//** 200 /***********************************************************************//**
203 * @brief Save table column into FITS file 201 * @brief Save table column into FITS file
204 * 202 *
205 - * @exception GException::fits_hdu_not_found  
206 - * Specified HDU not found in FITS file. 203 + * The table column is only saved if it is linked to a FITS file and if the
  204 + * data are indeed present in the class instance. This avoids saving of data
  205 + * that have not been modified.
  206 + *
  207 + * Refer to GFitsTableCol::save_column() for more information.
207 ***************************************************************************/ 208 ***************************************************************************/
208 void GFitsTableLngCol::save(void) 209 void GFitsTableLngCol::save(void)
209 { 210 {
210 - // Continue only if a FITS file is connected  
211 - if (m_fitsfile.Fptr != NULL) {  
212 -  
213 - // Move to the HDU  
214 - int status = 0;  
215 - status = __ffmahd(&m_fitsfile, (m_fitsfile.HDUposition)+1, NULL,  
216 - &status);  
217 - if (status != 0)  
218 - throw GException::fits_hdu_not_found(G_SAVE,  
219 - (m_fitsfile.HDUposition)+1,  
220 - status);  
221 -  
222 - // Save the column data  
223 - // TBD  
224 -  
225 - } // endif: FITS file was connected 211 + // Save column
  212 + save_column();
226 213
227 // Return 214 // Return
228 return; 215 return;
@@ -254,7 +241,7 @@ std::string GFitsTableLngCol::string(const int&amp; row, const int&amp; inx) @@ -254,7 +241,7 @@ std::string GFitsTableLngCol::string(const int&amp; row, const int&amp; inx)
254 throw GException::out_of_range(G_STRING, inx, 0, m_number-1); 241 throw GException::out_of_range(G_STRING, inx, 0, m_number-1);
255 242
256 // Get index 243 // Get index
257 - int offset = row * m_repeat + inx; 244 + int offset = row * m_number + inx;
258 245
259 // Convert long into string 246 // Convert long into string
260 ostringstream s_value; 247 ostringstream s_value;
@@ -290,7 +277,7 @@ double GFitsTableLngCol::real(const int&amp; row, const int&amp; inx) @@ -290,7 +277,7 @@ double GFitsTableLngCol::real(const int&amp; row, const int&amp; inx)
290 throw GException::out_of_range(G_REAL, inx, 0, m_number-1); 277 throw GException::out_of_range(G_REAL, inx, 0, m_number-1);
291 278
292 // Get index 279 // Get index
293 - int offset = row * m_repeat + inx; 280 + int offset = row * m_number + inx;
294 281
295 // Convert long into double 282 // Convert long into double
296 double value = (double)m_data[offset]; 283 double value = (double)m_data[offset];
@@ -325,7 +312,7 @@ int GFitsTableLngCol::integer(const int&amp; row, const int&amp; inx) @@ -325,7 +312,7 @@ int GFitsTableLngCol::integer(const int&amp; row, const int&amp; inx)
325 throw GException::out_of_range(G_INTEGER, inx, 0, m_number-1); 312 throw GException::out_of_range(G_INTEGER, inx, 0, m_number-1);
326 313
327 // Get index 314 // Get index
328 - int offset = row * m_repeat + inx; 315 + int offset = row * m_number + inx;
329 316
330 // Convert long into int 317 // Convert long into int
331 int value = (int)m_data[offset]; 318 int value = (int)m_data[offset];
@@ -402,8 +389,6 @@ void GFitsTableLngCol::init_members(void) @@ -402,8 +389,6 @@ void GFitsTableLngCol::init_members(void)
402 { 389 {
403 // Initialise members 390 // Initialise members
404 m_type = __TLONG; 391 m_type = __TLONG;
405 - m_size = 0;  
406 - m_anynul = 0;  
407 m_data = NULL; 392 m_data = NULL;
408 m_nulval = NULL; 393 m_nulval = NULL;
409 394
@@ -420,8 +405,6 @@ void GFitsTableLngCol::init_members(void) @@ -420,8 +405,6 @@ void GFitsTableLngCol::init_members(void)
420 void GFitsTableLngCol::copy_members(const GFitsTableLngCol& column) 405 void GFitsTableLngCol::copy_members(const GFitsTableLngCol& column)
421 { 406 {
422 // Copy attributes 407 // Copy attributes
423 - m_size = column.m_size;  
424 - m_anynul = column.m_anynul;  
425 408
426 // Copy column data 409 // Copy column data
427 if (column.m_data != NULL && m_size > 0) { 410 if (column.m_data != NULL && m_size > 0) {
@@ -461,53 +444,6 @@ void GFitsTableLngCol::free_members(void) @@ -461,53 +444,6 @@ void GFitsTableLngCol::free_members(void)
461 444
462 445
463 /***********************************************************************//** 446 /***********************************************************************//**
464 - * @brief Fetch column data  
465 - *  
466 - * @exception GException::fits_error  
467 - * An error occured while loading column data from FITS file.  
468 - *  
469 - * If a FITS file is attached to the column the data are loaded into memory  
470 - * from the FITS file. If no FITS file is attached, memory is allocated  
471 - * to hold the column data and all cells are set to 0.  
472 - ***************************************************************************/  
473 -void GFitsTableLngCol::fetch_data(void)  
474 -{  
475 - // Calculate size of memory  
476 - m_size = m_number * m_length;  
477 -  
478 - // Load only if the column has a positive size  
479 - if (m_size > 0) {  
480 -  
481 - // Allocate fresh memory  
482 - if (m_data != NULL) delete [] m_data;  
483 - m_data = new long[m_size];  
484 -  
485 - // If a FITS file is attached then load column data from the FITS  
486 - // file  
487 - if (m_fitsfile.Fptr != NULL) {  
488 - int status = 0;  
489 - status = __ffmahd(&m_fitsfile, (m_fitsfile.HDUposition)+1, NULL,  
490 - &status);  
491 - status = __ffgcv(&m_fitsfile, __TLONG, m_colnum, 1, 1, m_size,  
492 - m_nulval, m_data, &m_anynul, &status);  
493 - if (status != 0)  
494 - throw GException::fits_error(G_FETCH_DATA, status);  
495 - }  
496 -  
497 - // ... otherwise initialise all column values to 0  
498 - else {  
499 - for (int i = 0; i < m_size; ++i)  
500 - m_data[i] = 0;  
501 - }  
502 -  
503 - } // endif: column has a positive size  
504 -  
505 - // Return  
506 - return;  
507 -}  
508 -  
509 -  
510 -/***********************************************************************//**  
511 * @brief Returns format string of ASCII table 447 * @brief Returns format string of ASCII table
512 ***************************************************************************/ 448 ***************************************************************************/
513 std::string GFitsTableLngCol::ascii_format(void) const 449 std::string GFitsTableLngCol::ascii_format(void) const
@@ -545,12 +481,82 @@ std::string GFitsTableLngCol::binary_format(void) const @@ -545,12 +481,82 @@ std::string GFitsTableLngCol::binary_format(void) const
545 } 481 }
546 482
547 483
  484 +/***********************************************************************//**
  485 + * @brief Allocates column data
  486 + ***************************************************************************/
  487 +void GFitsTableLngCol::alloc_data(void)
  488 +{
  489 + // Free any existing memory
  490 + if (m_data != NULL) delete [] m_data;
  491 +
  492 + // Mark pointer as free
  493 + m_data = NULL;
  494 +
  495 + // Allocate new data
  496 + if (m_size > 0)
  497 + m_data = new long[m_size];
  498 +
  499 + // Return
  500 + return;
  501 +}
  502 +
  503 +
  504 +/***********************************************************************//**
  505 + * @brief Initialise column data
  506 + ***************************************************************************/
  507 +void GFitsTableLngCol::init_data(void)
  508 +{
  509 + // Initialise data if they exist
  510 + if (m_data != NULL) {
  511 + for (int i = 0; i < m_size; ++i)
  512 + m_data[i] = 0;
  513 + }
  514 +
  515 + // Return
  516 + return;
  517 +}
  518 +
  519 +
  520 +/***********************************************************************//**
  521 + * @brief Fetch column data
  522 + *
  523 + * If a FITS file is attached to the column the data are loaded into memory
  524 + * from the FITS file. If no FITS file is attached, memory is allocated
  525 + * to hold the column data and all cells are set to 0.
  526 + *
  527 + * Refer to GFitsTableCol::load_column for more information.
  528 + ***************************************************************************/
  529 +void GFitsTableLngCol::fetch_data(void)
  530 +{
  531 + // Save column
  532 + load_column();
  533 +
  534 + // Return
  535 + return;
  536 +}
  537 +
  538 +
548 /*========================================================================== 539 /*==========================================================================
549 = = 540 = =
550 = GFitsTableLngCol friends = 541 = GFitsTableLngCol friends =
551 = = 542 = =
552 ==========================================================================*/ 543 ==========================================================================*/
553 544
  545 +/***********************************************************************//**
  546 + * @brief Output operator
  547 + *
  548 + * @param[in] os Output stream
  549 + * @param[in] column Column to put in output stream
  550 + ***************************************************************************/
  551 +ostream& operator<< (ostream& os, const GFitsTableLngCol& column)
  552 +{
  553 + // Dump column in output stream
  554 + column.dump_column(os, column.m_data);
  555 +
  556 + // Return output stream
  557 + return os;
  558 +}
  559 +
554 560
555 /*========================================================================== 561 /*==========================================================================
556 = = 562 = =
src/fits/GFitsTableShtCol.cpp
  View file @56d87b7
@@ -21,16 +21,9 @@ @@ -21,16 +21,9 @@
21 /* __ Namespaces _________________________________________________________ */ 21 /* __ Namespaces _________________________________________________________ */
22 22
23 /* __ Method name definitions ____________________________________________ */ 23 /* __ Method name definitions ____________________________________________ */
24 -#define G_SAVE "GFitsTableShtCol::save()"  
25 -#define G_STRING "GFitsTableShtCol::string(const int&, const int&)"  
26 -#define G_REAL "GFitsTableShtCol::real(const int&, const int&)"  
27 -#define G_INTEGER "GFitsTableShtCol::integer(const int&, const int&)"  
28 -#define G_PTR_FLOAT "GFitsTableShtCol::ptr_float()"  
29 -#define G_PTR_DOUBLE "GFitsTableShtCol::ptr_double()"  
30 -#define G_PTR_SHORT "GFitsTableShtCol::ptr_short()"  
31 -#define G_PTR_LONG "GFitsTableShtCol::ptr_long()"  
32 -#define G_PTR_INT "GFitsTableShtCol::ptr_int()"  
33 -#define G_LOAD "GFitsTableShtCol::load()" 24 +#define G_STRING "GFitsTableShtCol::string(const int&, const int&)"
  25 +#define G_REAL "GFitsTableShtCol::real(const int&, const int&)"
  26 +#define G_INTEGER "GFitsTableShtCol::integer(const int&, const int&)"
34 27
35 /* __ Macros _____________________________________________________________ */ 28 /* __ Macros _____________________________________________________________ */
36 29
@@ -45,9 +38,8 @@ @@ -45,9 +38,8 @@
45 = = 38 = =
46 ==========================================================================*/ 39 ==========================================================================*/
47 40
48 -/***************************************************************************  
49 - * Constructor *  
50 - * ----------------------------------------------------------------------- * 41 +/***********************************************************************//**
  42 + * @brief Constructor
51 ***************************************************************************/ 43 ***************************************************************************/
52 GFitsTableShtCol::GFitsTableShtCol() : GFitsTableCol() 44 GFitsTableShtCol::GFitsTableShtCol() : GFitsTableCol()
53 { 45 {
@@ -79,9 +71,10 @@ GFitsTableShtCol::GFitsTableShtCol(const std::string&amp; name, @@ -79,9 +71,10 @@ GFitsTableShtCol::GFitsTableShtCol(const std::string&amp; name,
79 } 71 }
80 72
81 73
82 -/***************************************************************************  
83 - * Copy constructor *  
84 - * ----------------------------------------------------------------------- * 74 +/***********************************************************************//**
  75 + * @brief Copy constructor
  76 + *
  77 + * @param[in] column Column from which class instance should be built.
85 ***************************************************************************/ 78 ***************************************************************************/
86 GFitsTableShtCol::GFitsTableShtCol(const GFitsTableShtCol& column) : GFitsTableCol(column) 79 GFitsTableShtCol::GFitsTableShtCol(const GFitsTableShtCol& column) : GFitsTableCol(column)
87 { 80 {
@@ -96,9 +89,8 @@ GFitsTableShtCol::GFitsTableShtCol(const GFitsTableShtCol&amp; column) : GFitsTableC @@ -96,9 +89,8 @@ GFitsTableShtCol::GFitsTableShtCol(const GFitsTableShtCol&amp; column) : GFitsTableC
96 } 89 }
97 90
98 91
99 -/***************************************************************************  
100 - * Destructor *  
101 - * ----------------------------------------------------------------------- * 92 +/***********************************************************************//**
  93 + * @brief Destructor
102 ***************************************************************************/ 94 ***************************************************************************/
103 GFitsTableShtCol::~GFitsTableShtCol() 95 GFitsTableShtCol::~GFitsTableShtCol()
104 { 96 {
@@ -116,9 +108,10 @@ GFitsTableShtCol::~GFitsTableShtCol() @@ -116,9 +108,10 @@ GFitsTableShtCol::~GFitsTableShtCol()
116 = = 108 = =
117 ==========================================================================*/ 109 ==========================================================================*/
118 110
119 -/***************************************************************************  
120 - * Assignment operator *  
121 - * ----------------------------------------------------------------------- * 111 +/***********************************************************************//**
  112 + * @brief Assignment operator
  113 + *
  114 + * @param[in] column Column which should be assigned
122 ***************************************************************************/ 115 ***************************************************************************/
123 GFitsTableShtCol& GFitsTableShtCol::operator= (const GFitsTableShtCol& column) 116 GFitsTableShtCol& GFitsTableShtCol::operator= (const GFitsTableShtCol& column)
124 { 117 {
@@ -144,6 +137,59 @@ GFitsTableShtCol&amp; GFitsTableShtCol::operator= (const GFitsTableShtCol&amp; column) @@ -144,6 +137,59 @@ GFitsTableShtCol&amp; GFitsTableShtCol::operator= (const GFitsTableShtCol&amp; column)
144 } 137 }
145 138
146 139
  140 +/***********************************************************************//**
  141 + * @brief Column data access operator
  142 + *
  143 + * @param[in] row Row of column to access.
  144 + * @param[in] inx Vector index in column row to access
  145 + *
  146 + * Provides access to data in a column. No range checking is performed.
  147 + * Use one of
  148 + * GFitsTableShtCol::string(ix,iy),
  149 + * GFitsTableShtCol::real(ix;iy) or
  150 + * GFitsTableShtCol::integer(ix;iy)
  151 + * if range checking is required.
  152 + ***************************************************************************/
  153 +short& GFitsTableShtCol::operator() (const int& row, const int& inx)
  154 +{
  155 + // If data are not available then load them now
  156 + if (m_data == NULL) fetch_data();
  157 +
  158 + // Calculate pixel offset
  159 + int offset = row * m_number + inx;
  160 +
  161 + // Return data bin
  162 + return m_data[offset];
  163 +}
  164 +
  165 +
  166 +/***********************************************************************//**
  167 + * @brief Column data access operator (const variant)
  168 + *
  169 + * @param[in] row Row of column to access.
  170 + * @param[in] inx Vector index in column row to access
  171 + *
  172 + * Provides access to data in a column. No range checking is performed.
  173 + * Use one of
  174 + * GFitsTableDblCol::string(ix,iy),
  175 + * GFitsTableShtCol::real(ix;iy) or
  176 + * GFitsTableShtCol::integer(ix;iy)
  177 + * if range checking is required.
  178 + ***************************************************************************/
  179 +const short& GFitsTableShtCol::operator() (const int& row, const int& inx)
  180 + const
  181 +{
  182 + // If data are not available then load them now
  183 + if (m_data == NULL) ((GFitsTableShtCol*)this)->fetch_data();
  184 +
  185 + // Calculate pixel offset
  186 + int offset = row * m_number + inx;
  187 +
  188 + // Return data bin
  189 + return m_data[offset];
  190 +}
  191 +
  192 +
147 /*========================================================================== 193 /*==========================================================================
148 = = 194 = =
149 = GFitsTableShtCol public methods = 195 = GFitsTableShtCol public methods =
@@ -153,149 +199,153 @@ GFitsTableShtCol&amp; GFitsTableShtCol::operator= (const GFitsTableShtCol&amp; column) @@ -153,149 +199,153 @@ GFitsTableShtCol&amp; GFitsTableShtCol::operator= (const GFitsTableShtCol&amp; column)
153 /***********************************************************************//** 199 /***********************************************************************//**
154 * @brief Save table column into FITS file 200 * @brief Save table column into FITS file
155 * 201 *
156 - * @exception GException::fits_hdu_not_found  
157 - * Specified HDU not found in FITS file. 202 + * The table column is only saved if it is linked to a FITS file and if the
  203 + * data are indeed present in the class instance. This avoids saving of data
  204 + * that have not been modified.
  205 + *
  206 + * Refer to GFitsTableCol::save_column() for more information.
158 ***************************************************************************/ 207 ***************************************************************************/
159 void GFitsTableShtCol::save(void) 208 void GFitsTableShtCol::save(void)
160 { 209 {
161 - // Continue only if a FITS file is connected  
162 - if (m_fitsfile.Fptr != NULL) {  
163 -  
164 - // Move to the HDU  
165 - int status = 0;  
166 - status = __ffmahd(&m_fitsfile, (m_fitsfile.HDUposition)+1, NULL,  
167 - &status);  
168 - if (status != 0)  
169 - throw GException::fits_hdu_not_found(G_SAVE,  
170 - (m_fitsfile.HDUposition)+1,  
171 - status);  
172 -  
173 - // Save the column data  
174 - // TBD  
175 -  
176 - } // endif: FITS file was connected 210 + // Save column
  211 + save_column();
177 212
178 // Return 213 // Return
179 return; 214 return;
180 } 215 }
181 216
182 -/***************************************************************************  
183 - * Get string value *  
184 - * ----------------------------------------------------------------------- * 217 +
  218 +/***********************************************************************//**
  219 + * @brief Get string value
  220 + *
  221 + * @param[in] row Table row.
  222 + * @param[in] inx Table column vector index.
  223 + *
  224 + * @exception GException::out_of_range
  225 + * Table row or vector index are out of valid range.
  226 + *
  227 + * Returns value of specified row and vector index as string.
185 ***************************************************************************/ 228 ***************************************************************************/
186 -std::string GFitsTableShtCol::string(const int& row, const int& col) 229 +std::string GFitsTableShtCol::string(const int& row, const int& inx)
187 { 230 {
188 - // Make sure that data are loaded  
189 - if (m_data == NULL)  
190 - load(); 231 + // If data are not available then load them now
  232 + if (m_data == NULL) fetch_data();
191 233
192 // Check row value 234 // Check row value
193 if (row < 0 || row >= m_length) 235 if (row < 0 || row >= m_length)
194 throw GException::out_of_range(G_STRING, row, 0, m_length-1); 236 throw GException::out_of_range(G_STRING, row, 0, m_length-1);
195 237
196 - // Check col value  
197 - if (col < 0 || col >= m_number)  
198 - throw GException::out_of_range(G_STRING, col, 0, m_number-1); 238 + // Check inx value
  239 + if (inx < 0 || inx >= m_number)
  240 + throw GException::out_of_range(G_STRING, inx, 0, m_number-1);
199 241
200 // Get index 242 // Get index
201 - int inx = row * m_repeat + col; 243 + int offset = row * m_number + inx;
202 244
203 - // Convert short into string 245 + // Convert double into string
204 ostringstream s_value; 246 ostringstream s_value;
205 - s_value << m_data[inx]; 247 + s_value << m_data[offset];
206 248
207 // Return value 249 // Return value
208 return s_value.str(); 250 return s_value.str();
209 } 251 }
210 252
211 253
212 -/***************************************************************************  
213 - * Get real value *  
214 - * ----------------------------------------------------------------------- * 254 +/***********************************************************************//**
  255 + * @brief Get double precision value
  256 + *
  257 + * @param[in] row Table row.
  258 + * @param[in] inx Table column vector index.
  259 + *
  260 + * @exception GException::out_of_range
  261 + * Table row or vector index are out of valid range.
  262 + *
  263 + * Returns value of specified row and vector index as double precision.
215 ***************************************************************************/ 264 ***************************************************************************/
216 -double GFitsTableShtCol::real(const int& row, const int& col) 265 +double GFitsTableShtCol::real(const int& row, const int& inx)
217 { 266 {
218 - // Make sure that data are loaded  
219 - if (m_data == NULL)  
220 - load(); 267 + // If data are not available then load them now
  268 + if (m_data == NULL) fetch_data();
221 269
222 // Check row value 270 // Check row value
223 if (row < 0 || row >= m_length) 271 if (row < 0 || row >= m_length)
224 throw GException::out_of_range(G_REAL, row, 0, m_length-1); 272 throw GException::out_of_range(G_REAL, row, 0, m_length-1);
225 273
226 - // Check col value  
227 - if (col < 0 || col >= m_number)  
228 - throw GException::out_of_range(G_REAL, col, 0, m_number-1); 274 + // Check inx value
  275 + if (inx < 0 || inx >= m_number)
  276 + throw GException::out_of_range(G_REAL, inx, 0, m_number-1);
229 277
230 // Get index 278 // Get index
231 - int inx = row * m_repeat + col; 279 + int offset = row * m_number + inx;
232 280
233 // Convert short into double 281 // Convert short into double
234 - double value = (double)m_data[inx]; 282 + double value = (double)m_data[offset];
235 283
236 // Return value 284 // Return value
237 return value; 285 return value;
238 } 286 }
239 287
240 288
241 -/***************************************************************************  
242 - * Get int value *  
243 - * ----------------------------------------------------------------------- * 289 +/***********************************************************************//**
  290 + * @brief Get integer value
  291 + *
  292 + * @param[in] row Table row.
  293 + * @param[in] inx Table column vector index.
  294 + *
  295 + * @exception GException::out_of_range
  296 + * Table row or vector index are out of valid range.
  297 + *
  298 + * Returns value of specified row and vector index as integer.
244 ***************************************************************************/ 299 ***************************************************************************/
245 -int GFitsTableShtCol::integer(const int& row, const int& col) 300 +int GFitsTableShtCol::integer(const int& row, const int& inx)
246 { 301 {
247 - // Make sure that data are loaded  
248 - if (m_data == NULL)  
249 - load(); 302 + // If data are not available then load them now
  303 + if (m_data == NULL) fetch_data();
250 304
251 // Check row value 305 // Check row value
252 if (row < 0 || row >= m_length) 306 if (row < 0 || row >= m_length)
253 throw GException::out_of_range(G_INTEGER, row, 0, m_length-1); 307 throw GException::out_of_range(G_INTEGER, row, 0, m_length-1);
254 308
255 // Check col value 309 // Check col value
256 - if (col < 0 || col >= m_number)  
257 - throw GException::out_of_range(G_INTEGER, col, 0, m_number-1); 310 + if (inx < 0 || inx >= m_number)
  311 + throw GException::out_of_range(G_INTEGER, inx, 0, m_number-1);
258 312
259 // Get index 313 // Get index
260 - int inx = row * m_repeat + col; 314 + int offset = row * m_number + inx;
261 315
262 // Convert short into int 316 // Convert short into int
263 - int value = (int)m_data[inx]; 317 + int value = (int)m_data[offset];
264 318
265 // Return value 319 // Return value
266 return value; 320 return value;
267 } 321 }
268 322
269 323
270 -/***************************************************************************  
271 - * Access to invalid data pointers *  
272 - * ----------------------------------------------------------------------- * 324 +/***********************************************************************//**
  325 + * @brief Clone column
273 ***************************************************************************/ 326 ***************************************************************************/
274 -float* GFitsTableShtCol::ptr_float(void) 327 +GFitsTableShtCol* GFitsTableShtCol::clone(void) const
275 { 328 {
276 - throw GException::fits_invalid_type(G_PTR_FLOAT,  
277 - "No <float> pointer allowed to <short> array"); 329 + return new GFitsTableShtCol(*this);
278 } 330 }
279 -double* GFitsTableShtCol::ptr_double(void)  
280 -{  
281 - throw GException::fits_invalid_type(G_PTR_DOUBLE,  
282 - "No <double> pointer allowed to <short> array");  
283 -}  
284 -long* GFitsTableShtCol::ptr_long(void)  
285 -{  
286 - throw GException::fits_invalid_type(G_PTR_LONG,  
287 - "No <long> pointer allowed to <short> array");  
288 -}  
289 -int* GFitsTableShtCol::ptr_int(void) 331 +
  332 +
  333 +/***********************************************************************//**
  334 + * @brief Return pointer to short integer column
  335 + ***************************************************************************/
  336 +short* GFitsTableShtCol::data(void)
290 { 337 {
291 - throw GException::fits_invalid_type(G_PTR_INT,  
292 - "No <int> pointer allowed to <short> array"); 338 + return m_data;
293 } 339 }
294 340
295 341
296 -/***************************************************************************  
297 - * Set NULL string *  
298 - * ----------------------------------------------------------------------- * 342 +/***********************************************************************//**
  343 + * @brief Set NULL value
  344 + *
  345 + * @param[in] value Pointer on NULL value
  346 + *
  347 + * Allows the specification of the FITS table NULL value. If value=NULL the
  348 + * data will not be screened for NULL values.
299 ***************************************************************************/ 349 ***************************************************************************/
300 void GFitsTableShtCol::set_nullval(const short* value) 350 void GFitsTableShtCol::set_nullval(const short* value)
301 { 351 {
@@ -312,13 +362,13 @@ void GFitsTableShtCol::set_nullval(const short* value) @@ -312,13 +362,13 @@ void GFitsTableShtCol::set_nullval(const short* value)
312 *m_nulval = *value; 362 *m_nulval = *value;
313 } 363 }
314 364
315 - // Re-load column  
316 - // NOTE: THIS WILL LEAD TO A LOSS OF MODIFICATIONS; ISSUE SAVE BEFORE !!! 365 + // Re-load column
  366 +/*
317 if (m_data != NULL) { 367 if (m_data != NULL) {
318 - //save(); 368 + save();
319 load(); 369 load();
320 } 370 }
321 - 371 +*/
322 // Return 372 // Return
323 return; 373 return;
324 } 374 }
@@ -330,16 +380,13 @@ void GFitsTableShtCol::set_nullval(const short* value) @@ -330,16 +380,13 @@ void GFitsTableShtCol::set_nullval(const short* value)
330 = = 380 = =
331 ==========================================================================*/ 381 ==========================================================================*/
332 382
333 -/***************************************************************************  
334 - * Initialise class members *  
335 - * ----------------------------------------------------------------------- * 383 +/***********************************************************************//**
  384 + * @brief Initialise class members
336 ***************************************************************************/ 385 ***************************************************************************/
337 void GFitsTableShtCol::init_members(void) 386 void GFitsTableShtCol::init_members(void)
338 { 387 {
339 // Initialise members 388 // Initialise members
340 m_type = __TSHORT; 389 m_type = __TSHORT;
341 - m_size = 0;  
342 - m_anynul = 0;  
343 m_data = NULL; 390 m_data = NULL;
344 m_nulval = NULL; 391 m_nulval = NULL;
345 392
@@ -348,15 +395,14 @@ void GFitsTableShtCol::init_members(void) @@ -348,15 +395,14 @@ void GFitsTableShtCol::init_members(void)
348 } 395 }
349 396
350 397
351 -/***************************************************************************  
352 - * Copy class members *  
353 - * ----------------------------------------------------------------------- * 398 +/***********************************************************************//**
  399 + * @brief Copy class members
  400 + *
  401 + * @param[in] column Column for which members should be copied.
354 ***************************************************************************/ 402 ***************************************************************************/
355 void GFitsTableShtCol::copy_members(const GFitsTableShtCol& column) 403 void GFitsTableShtCol::copy_members(const GFitsTableShtCol& column)
356 { 404 {
357 // Copy attributes 405 // Copy attributes
358 - m_size = column.m_size;  
359 - m_anynul = column.m_anynul;  
360 406
361 // Copy column data 407 // Copy column data
362 if (column.m_data != NULL && m_size > 0) { 408 if (column.m_data != NULL && m_size > 0) {
@@ -377,9 +423,8 @@ void GFitsTableShtCol::copy_members(const GFitsTableShtCol&amp; column) @@ -377,9 +423,8 @@ void GFitsTableShtCol::copy_members(const GFitsTableShtCol&amp; column)
377 } 423 }
378 424
379 425
380 -/***************************************************************************  
381 - * Delete class members *  
382 - * ----------------------------------------------------------------------- * 426 +/***********************************************************************//**
  427 + * @brief Delete class members
383 ***************************************************************************/ 428 ***************************************************************************/
384 void GFitsTableShtCol::free_members(void) 429 void GFitsTableShtCol::free_members(void)
385 { 430 {
@@ -396,32 +441,6 @@ void GFitsTableShtCol::free_members(void) @@ -396,32 +441,6 @@ void GFitsTableShtCol::free_members(void)
396 } 441 }
397 442
398 443
399 -/***************************************************************************  
400 - * Load column data *  
401 - * ----------------------------------------------------------------------- *  
402 - ***************************************************************************/  
403 -void GFitsTableShtCol::load(void)  
404 -{  
405 - // Calculate size of memory  
406 - m_size = m_number * m_length;  
407 -  
408 - // Allocate memory  
409 - if (m_data != NULL) delete [] m_data;  
410 - m_data = new short[m_size];  
411 -  
412 - // Load column data  
413 - int status = 0;  
414 - status = __ffmahd(&m_fitsfile, (m_fitsfile.HDUposition)+1, NULL, &status);  
415 - status = __ffgcv(&m_fitsfile, __TSHORT, m_colnum, 1, 1, m_size,  
416 - m_nulval, m_data, &m_anynul, &status);  
417 - if (status != 0)  
418 - throw GException::fits_error(G_LOAD, status);  
419 -  
420 - // Return  
421 - return;  
422 -}  
423 -  
424 -  
425 /***********************************************************************//** 444 /***********************************************************************//**
426 * @brief Returns format string of ASCII table 445 * @brief Returns format string of ASCII table
427 ***************************************************************************/ 446 ***************************************************************************/
@@ -460,12 +479,82 @@ std::string GFitsTableShtCol::binary_format(void) const @@ -460,12 +479,82 @@ std::string GFitsTableShtCol::binary_format(void) const
460 } 479 }
461 480
462 481
  482 +/***********************************************************************//**
  483 + * @brief Allocates column data
  484 + ***************************************************************************/
  485 +void GFitsTableShtCol::alloc_data(void)
  486 +{
  487 + // Free any existing memory
  488 + if (m_data != NULL) delete [] m_data;
  489 +
  490 + // Mark pointer as free
  491 + m_data = NULL;
  492 +
  493 + // Allocate new data
  494 + if (m_size > 0)
  495 + m_data = new short[m_size];
  496 +
  497 + // Return
  498 + return;
  499 +}
  500 +
  501 +
  502 +/***********************************************************************//**
  503 + * @brief Initialise column data
  504 + ***************************************************************************/
  505 +void GFitsTableShtCol::init_data(void)
  506 +{
  507 + // Initialise data if they exist
  508 + if (m_data != NULL) {
  509 + for (int i = 0; i < m_size; ++i)
  510 + m_data[i] = 0;
  511 + }
  512 +
  513 + // Return
  514 + return;
  515 +}
  516 +
  517 +
  518 +/***********************************************************************//**
  519 + * @brief Fetch column data
  520 + *
  521 + * If a FITS file is attached to the column the data are loaded into memory
  522 + * from the FITS file. If no FITS file is attached, memory is allocated
  523 + * to hold the column data and all cells are set to 0.
  524 + *
  525 + * Refer to GFitsTableCol::load_column for more information.
  526 + ***************************************************************************/
  527 +void GFitsTableShtCol::fetch_data(void)
  528 +{
  529 + // Save column
  530 + load_column();
  531 +
  532 + // Return
  533 + return;
  534 +}
  535 +
  536 +
463 /*========================================================================== 537 /*==========================================================================
464 = = 538 = =
465 = GFitsTableShtCol friends = 539 = GFitsTableShtCol friends =
466 = = 540 = =
467 ==========================================================================*/ 541 ==========================================================================*/
468 542
  543 +/***********************************************************************//**
  544 + * @brief Output operator
  545 + *
  546 + * @param[in] os Output stream
  547 + * @param[in] column Column to put in output stream
  548 + ***************************************************************************/
  549 +ostream& operator<< (ostream& os, const GFitsTableShtCol& column)
  550 +{
  551 + // Dump column in output stream
  552 + column.dump_column(os, column.m_data);
  553 +
  554 + // Return output stream
  555 + return os;
  556 +}
  557 +
469 558
470 /*========================================================================== 559 /*==========================================================================
471 = = 560 = =
src/fits/GFitsTableStrCol.cpp
  View file @56d87b7
@@ -21,17 +21,9 @@ @@ -21,17 +21,9 @@
21 /* __ Namespaces _________________________________________________________ */ 21 /* __ Namespaces _________________________________________________________ */
22 22
23 /* __ Method name definitions ____________________________________________ */ 23 /* __ Method name definitions ____________________________________________ */
24 -#define G_SAVE "GFitsTableStrCol::save()"  
25 -#define G_STRING "GFitsTableStrCol::string(const int&, const int&)"  
26 -#define G_REAL "GFitsTableStrCol::real(const int&, const int&)"  
27 -#define G_INTEGER "GFitsTableStrCol::integer(const int&, const int&)"  
28 -#define G_PTR_STRING "GFitsTableStrCol::ptr_string()"  
29 -#define G_PTR_FLOAT "GFitsTableStrCol::ptr_float()"  
30 -#define G_PTR_DOUBLE "GFitsTableStrCol::ptr_double()"  
31 -#define G_PTR_SHORT "GFitsTableStrCol::ptr_short()"  
32 -#define G_PTR_LONG "GFitsTableStrCol::ptr_long()"  
33 -#define G_PTR_INT "GFitsTableStrCol::ptr_int()"  
34 -#define G_LOAD "GFitsTableStrCol::load()" 24 +#define G_STRING "GFitsTableStrCol::string(const int&, const int&)"
  25 +#define G_REAL "GFitsTableStrCol::real(const int&, const int&)"
  26 +#define G_INTEGER "GFitsTableStrCol::integer(const int&, const int&)"
35 27
36 /* __ Macros _____________________________________________________________ */ 28 /* __ Macros _____________________________________________________________ */
37 29
@@ -46,9 +38,8 @@ @@ -46,9 +38,8 @@
46 = = 38 = =
47 ==========================================================================*/ 39 ==========================================================================*/
48 40
49 -/***************************************************************************  
50 - * Constructor *  
51 - * ----------------------------------------------------------------------- * 41 +/***********************************************************************//**
  42 + * @brief Constructor
52 ***************************************************************************/ 43 ***************************************************************************/
53 GFitsTableStrCol::GFitsTableStrCol() : GFitsTableCol() 44 GFitsTableStrCol::GFitsTableStrCol() : GFitsTableCol()
54 { 45 {
@@ -60,11 +51,35 @@ GFitsTableStrCol::GFitsTableStrCol() : GFitsTableCol() @@ -60,11 +51,35 @@ GFitsTableStrCol::GFitsTableStrCol() : GFitsTableCol()
60 } 51 }
61 52
62 53
63 -/***************************************************************************  
64 - * Copy constructor *  
65 - * ----------------------------------------------------------------------- * 54 +/***********************************************************************//**
  55 + * @brief Constructor
  56 + *
  57 + * @param[in] name Name of column.
  58 + * @param[in] length Length of column.
  59 + * @param[in] width Length of individual string.
  60 + * @param[in] size Number of strings in each column.
66 ***************************************************************************/ 61 ***************************************************************************/
67 -GFitsTableStrCol::GFitsTableStrCol(const GFitsTableStrCol& column) : GFitsTableCol(column) 62 +GFitsTableStrCol::GFitsTableStrCol(const std::string& name,
  63 + const int& length,
  64 + const int& width,
  65 + const int& size)
  66 + : GFitsTableCol(name, length, size, width)
  67 +{
  68 + // Initialise class members for clean destruction
  69 + init_members();
  70 +
  71 + // Return
  72 + return;
  73 +}
  74 +
  75 +
  76 +/***********************************************************************//**
  77 + * @brief Copy constructor
  78 + *
  79 + * @param[in] column Column from which class instance should be built.
  80 + ***************************************************************************/
  81 +GFitsTableStrCol::GFitsTableStrCol(const GFitsTableStrCol& column)
  82 + : GFitsTableCol(column)
68 { 83 {
69 // Initialise class members for clean destruction 84 // Initialise class members for clean destruction
70 init_members(); 85 init_members();
@@ -77,9 +92,8 @@ GFitsTableStrCol::GFitsTableStrCol(const GFitsTableStrCol&amp; column) : GFitsTableC @@ -77,9 +92,8 @@ GFitsTableStrCol::GFitsTableStrCol(const GFitsTableStrCol&amp; column) : GFitsTableC
77 } 92 }
78 93
79 94
80 -/***************************************************************************  
81 - * Destructor *  
82 - * ----------------------------------------------------------------------- * 95 +/***********************************************************************//**
  96 + * @brief Destructor
83 ***************************************************************************/ 97 ***************************************************************************/
84 GFitsTableStrCol::~GFitsTableStrCol() 98 GFitsTableStrCol::~GFitsTableStrCol()
85 { 99 {
@@ -97,9 +111,10 @@ GFitsTableStrCol::~GFitsTableStrCol() @@ -97,9 +111,10 @@ GFitsTableStrCol::~GFitsTableStrCol()
97 = = 111 = =
98 ==========================================================================*/ 112 ==========================================================================*/
99 113
100 -/***************************************************************************  
101 - * Assignment operator *  
102 - * ----------------------------------------------------------------------- * 114 +/***********************************************************************//**
  115 + * @brief Assignment operator
  116 + *
  117 + * @param[in] column Column which should be assigned
103 ***************************************************************************/ 118 ***************************************************************************/
104 GFitsTableStrCol& GFitsTableStrCol::operator= (const GFitsTableStrCol& column) 119 GFitsTableStrCol& GFitsTableStrCol::operator= (const GFitsTableStrCol& column)
105 { 120 {
@@ -125,6 +140,59 @@ GFitsTableStrCol&amp; GFitsTableStrCol::operator= (const GFitsTableStrCol&amp; column) @@ -125,6 +140,59 @@ GFitsTableStrCol&amp; GFitsTableStrCol::operator= (const GFitsTableStrCol&amp; column)
125 } 140 }
126 141
127 142
  143 +/***********************************************************************//**
  144 + * @brief Column data access operator
  145 + *
  146 + * @param[in] row Row of column to access.
  147 + * @param[in] inx Vector index in column row to access
  148 + *
  149 + * Provides access to data in a column. No range checking is performed.
  150 + * Use one of
  151 + * GFitsTableStrCol::string(ix,iy),
  152 + * GFitsTableStrCol::real(ix;iy) or
  153 + * GFitsTableStrCol::integer(ix;iy)
  154 + * if range checking is required.
  155 + ***************************************************************************/
  156 +std::string& GFitsTableStrCol::operator() (const int& row, const int& inx)
  157 +{
  158 + // If data are not available then load them now
  159 + if (m_data == NULL) fetch_data();
  160 +
  161 + // Calculate pixel offset
  162 + int offset = row * m_number + inx;
  163 +
  164 + // Return data bin
  165 + return m_data[offset];
  166 +}
  167 +
  168 +
  169 +/***********************************************************************//**
  170 + * @brief Column data access operator (const variant)
  171 + *
  172 + * @param[in] row Row of column to access.
  173 + * @param[in] inx Vector index in column row to access
  174 + *
  175 + * Provides access to data in a column. No range checking is performed.
  176 + * Use one of
  177 + * GFitsTableStrCol::string(ix,iy),
  178 + * GFitsTableStrCol::real(ix;iy) or
  179 + * GFitsTableStrCol::integer(ix;iy)
  180 + * if range checking is required.
  181 + ***************************************************************************/
  182 +const std::string& GFitsTableStrCol::operator() (const int& row, const int& inx)
  183 + const
  184 +{
  185 + // If data are not available then load them now
  186 + if (m_data == NULL) ((GFitsTableStrCol*)this)->fetch_data();
  187 +
  188 + // Calculate pixel offset
  189 + int offset = row * m_number + inx;
  190 +
  191 + // Return data bin
  192 + return m_data[offset];
  193 +}
  194 +
  195 +
128 /*========================================================================== 196 /*==========================================================================
129 = = 197 = =
130 = GFitsTableStrCol public methods = 198 = GFitsTableStrCol public methods =
@@ -134,171 +202,186 @@ GFitsTableStrCol&amp; GFitsTableStrCol::operator= (const GFitsTableStrCol&amp; column) @@ -134,171 +202,186 @@ GFitsTableStrCol&amp; GFitsTableStrCol::operator= (const GFitsTableStrCol&amp; column)
134 /***********************************************************************//** 202 /***********************************************************************//**
135 * @brief Save table column into FITS file 203 * @brief Save table column into FITS file
136 * 204 *
137 - * @exception GException::fits_hdu_not_found  
138 - * Specified HDU not found in FITS file. 205 + * The table column is only saved if it is linked to a FITS file and if the
  206 + * data are indeed present in the class instance. This avoids saving of data
  207 + * that have not been modified.
  208 + *
  209 + * Refer to GFitsTableCol::save_column() for more information.
139 ***************************************************************************/ 210 ***************************************************************************/
140 void GFitsTableStrCol::save(void) 211 void GFitsTableStrCol::save(void)
141 { 212 {
142 - // Continue only if a FITS file is connected  
143 - if (m_fitsfile.Fptr != NULL) { 213 + // Free buffer
  214 + free_buffer();
144 215
145 - // Move to the HDU  
146 - int status = 0;  
147 - status = __ffmahd(&m_fitsfile, (m_fitsfile.HDUposition)+1, NULL,  
148 - &status);  
149 - if (status != 0)  
150 - throw GException::fits_hdu_not_found(G_SAVE,  
151 - (m_fitsfile.HDUposition)+1,  
152 - status); 216 + // Allocate buffer
  217 + alloc_buffer();
153 218
154 - // Save the column data  
155 - // TBD 219 + // Transfer string into buffer
  220 + for (int i = 0; i < m_size; ++i)
  221 + strncpy(m_buffer[i], m_data[i].c_str(), m_width);
156 222
157 - } // endif: FITS file was connected 223 + // Save column
  224 + save_column();
  225 +
  226 + // Free buffer
  227 + free_buffer();
158 228
159 // Return 229 // Return
160 return; 230 return;
161 } 231 }
162 232
163 -/***************************************************************************  
164 - * Get string value *  
165 - * ----------------------------------------------------------------------- * 233 +
  234 +/***********************************************************************//**
  235 + * @brief Get string value
  236 + *
  237 + * @param[in] row Table row.
  238 + * @param[in] inx Table column vector index.
  239 + *
  240 + * @exception GException::out_of_range
  241 + * Table row or vector index are out of valid range.
  242 + *
  243 + * Returns value of specified row and vector index as string.
166 ***************************************************************************/ 244 ***************************************************************************/
167 -std::string GFitsTableStrCol::string(const int& row, const int& col) 245 +std::string GFitsTableStrCol::string(const int& row, const int& inx)
168 { 246 {
169 - // Make sure that data are loaded  
170 - if (m_data == NULL)  
171 - load(); 247 + // If data are not available then load them now
  248 + if (m_data == NULL) fetch_data();
172 249
173 // Check row value 250 // Check row value
174 if (row < 0 || row >= m_length) 251 if (row < 0 || row >= m_length)
175 throw GException::out_of_range(G_STRING, row, 0, m_length-1); 252 throw GException::out_of_range(G_STRING, row, 0, m_length-1);
176 253
177 - // Check col value  
178 - if (col < 0 || col >= m_number)  
179 - throw GException::out_of_range(G_STRING, col, 0, m_number-1); 254 + // Check inx value
  255 + if (inx < 0 || inx >= m_number)
  256 + throw GException::out_of_range(G_STRING, inx, 0, m_number-1);
180 257
181 - // Get string index  
182 - int inx = row * m_repeat + col;  
183 -  
184 - // Assign C string to C++ std::string  
185 - std::string value;  
186 - value.assign(m_data[inx]); 258 + // Get index
  259 + int offset = row * m_number + inx;
187 260
188 // Return value 261 // Return value
189 - return value; 262 + return m_data[offset];
190 } 263 }
191 264
192 265
193 -/***************************************************************************  
194 - * Get real value *  
195 - * ----------------------------------------------------------------------- * 266 +/***********************************************************************//**
  267 + * @brief Get double precision value
  268 + *
  269 + * @param[in] row Table row.
  270 + * @param[in] inx Table column vector index.
  271 + *
  272 + * @exception GException::out_of_range
  273 + * Table row or vector index are out of valid range.
  274 + *
  275 + * Returns value of specified row and vector index as double precision.
196 ***************************************************************************/ 276 ***************************************************************************/
197 -double GFitsTableStrCol::real(const int& row, const int& col) 277 +double GFitsTableStrCol::real(const int& row, const int& inx)
198 { 278 {
199 - // Make sure that data are loaded  
200 - if (m_data == NULL)  
201 - load(); 279 + // If data are not available then load them now
  280 + if (m_data == NULL) fetch_data();
202 281
203 // Check row value 282 // Check row value
204 if (row < 0 || row >= m_length) 283 if (row < 0 || row >= m_length)
205 - throw GException::out_of_range(G_STRING, row, 0, m_length-1); 284 + throw GException::out_of_range(G_REAL, row, 0, m_length-1);
206 285
207 - // Check col value  
208 - if (col < 0 || col >= m_number)  
209 - throw GException::out_of_range(G_STRING, col, 0, m_number-1); 286 + // Check inx value
  287 + if (inx < 0 || inx >= m_number)
  288 + throw GException::out_of_range(G_REAL, inx, 0, m_number-1);
210 289
211 - // Get string index  
212 - int inx = row * m_repeat + col; 290 + // Get index
  291 + int offset = row * m_number + inx;
213 292
214 // Assign C string to double 293 // Assign C string to double
215 - double value = atof(m_data[inx]); 294 + double value = atof(m_data[offset].c_str());
216 295
217 // Return value 296 // Return value
218 return value; 297 return value;
219 } 298 }
220 299
221 300
222 -/***************************************************************************  
223 - * Get int value *  
224 - * ----------------------------------------------------------------------- * 301 +/***********************************************************************//**
  302 + * @brief Get integer value
  303 + *
  304 + * @param[in] row Table row.
  305 + * @param[in] inx Table column vector index.
  306 + *
  307 + * @exception GException::out_of_range
  308 + * Table row or vector index are out of valid range.
  309 + *
  310 + * Returns value of specified row and vector index as integer.
225 ***************************************************************************/ 311 ***************************************************************************/
226 -int GFitsTableStrCol::integer(const int& row, const int& col) 312 +int GFitsTableStrCol::integer(const int& row, const int& inx)
227 { 313 {
228 - // Make sure that data are loaded  
229 - if (m_data == NULL)  
230 - load(); 314 + // If data are not available then load them now
  315 + if (m_data == NULL) fetch_data();
231 316
232 // Check row value 317 // Check row value
233 if (row < 0 || row >= m_length) 318 if (row < 0 || row >= m_length)
234 - throw GException::out_of_range(G_STRING, row, 0, m_length-1); 319 + throw GException::out_of_range(G_INTEGER, row, 0, m_length-1);
235 320
236 // Check col value 321 // Check col value
237 - if (col < 0 || col >= m_number)  
238 - throw GException::out_of_range(G_STRING, col, 0, m_number-1); 322 + if (inx < 0 || inx >= m_number)
  323 + throw GException::out_of_range(G_INTEGER, inx, 0, m_number-1);
239 324
240 - // Get string index  
241 - int inx = row * m_repeat + col; 325 + // Get index
  326 + int offset = row * m_number + inx;
242 327
243 // Assign C string to int 328 // Assign C string to int
244 - int value = atoi(m_data[inx]); 329 + int value = atoi(m_data[offset].c_str());
245 330
246 // Return value 331 // Return value
247 return value; 332 return value;
248 } 333 }
249 334
250 335
251 -/***************************************************************************  
252 - * Access to invalid data pointers *  
253 - * ----------------------------------------------------------------------- * 336 +/***********************************************************************//**
  337 + * @brief Clone column
254 ***************************************************************************/ 338 ***************************************************************************/
255 -float* GFitsTableStrCol::ptr_float(void) 339 +GFitsTableStrCol* GFitsTableStrCol::clone(void) const
256 { 340 {
257 - throw GException::fits_invalid_type(G_PTR_FLOAT, "No <float> pointer allowed to <string> array"); 341 + return new GFitsTableStrCol(*this);
258 } 342 }
259 -double* GFitsTableStrCol::ptr_double(void)  
260 -{  
261 - throw GException::fits_invalid_type(G_PTR_FLOAT, "No <double> pointer allowed to <string> array");  
262 -}  
263 -short* GFitsTableStrCol::ptr_short(void)  
264 -{  
265 - throw GException::fits_invalid_type(G_PTR_SHORT, "No <short> pointer allowed to <string> array");  
266 -}  
267 -long* GFitsTableStrCol::ptr_long(void)  
268 -{  
269 - throw GException::fits_invalid_type(G_PTR_LONG, "No <long> pointer allowed to <string> array");  
270 -}  
271 -int* GFitsTableStrCol::ptr_int(void) 343 +
  344 +
  345 +/***********************************************************************//**
  346 + * @brief Return pointer to std::string column
  347 + ***************************************************************************/
  348 +std::string* GFitsTableStrCol::data(void)
272 { 349 {
273 - throw GException::fits_invalid_type(G_PTR_INT, "No <int> pointer allowed to <string> array"); 350 + return m_data;
274 } 351 }
275 352
276 353
277 -/***************************************************************************  
278 - * Set NULL string *  
279 - * ----------------------------------------------------------------------- * 354 +
  355 +/***********************************************************************//**
  356 + * @brief Set NULL string
  357 + *
  358 + * @param[in] value Pointer on NULL string
  359 + *
  360 + * Allows the specification of the FITS table NULL string. If the string
  361 + * is empty the data will not be screened for NULL values.
280 ***************************************************************************/ 362 ***************************************************************************/
281 -void GFitsTableStrCol::set_nullstr(const std::string string) 363 +void GFitsTableStrCol::set_nullval(const std::string string)
282 { 364 {
283 // If NULL string is empty then reset the NULL string 365 // If NULL string is empty then reset the NULL string
284 if (string.empty()) { 366 if (string.empty()) {
285 - if (m_nulstr != NULL) delete [] m_nulstr;  
286 - m_nulstr = NULL; 367 + if (m_nulval != NULL) delete [] m_nulval;
  368 + m_nulval = NULL;
287 } 369 }
288 370
289 // ... otherwise copy string into NULL string 371 // ... otherwise copy string into NULL string
290 else { 372 else {
291 - if (m_nulstr != NULL) delete [] m_nulstr;  
292 - m_nulstr = new char[m_width+1];  
293 - strncpy(m_nulstr, string.c_str(), m_width); 373 + if (m_nulval != NULL) delete [] m_nulval;
  374 + m_nulval = new char[m_width+1];
  375 + strncpy(m_nulval, string.c_str(), m_width);
294 } 376 }
295 377
296 - // Re-load column  
297 - // NOTE: THIS WILL LEAD TO A LOSS OF MODIFICATIONS; ISSUE SAVE BEFORE !!! 378 + // Re-load column
  379 +/*
298 if (m_data != NULL) { 380 if (m_data != NULL) {
299 - //save(); 381 + save();
300 load(); 382 load();
301 } 383 }
  384 +*/
302 385
303 // Return 386 // Return
304 return; 387 return;
@@ -311,53 +394,40 @@ void GFitsTableStrCol::set_nullstr(const std::string string) @@ -311,53 +394,40 @@ void GFitsTableStrCol::set_nullstr(const std::string string)
311 = = 394 = =
312 ==========================================================================*/ 395 ==========================================================================*/
313 396
314 -/***************************************************************************  
315 - * Initialise class members *  
316 - * ----------------------------------------------------------------------- * 397 +/***********************************************************************//**
  398 + * @brief Initialise class members
317 ***************************************************************************/ 399 ***************************************************************************/
318 void GFitsTableStrCol::init_members(void) 400 void GFitsTableStrCol::init_members(void)
319 { 401 {
320 // Initialise members 402 // Initialise members
321 m_type = __TSTRING; 403 m_type = __TSTRING;
322 - m_size = 0;  
323 - m_data = NULL;  
324 - m_nulstr = NULL;  
325 - m_anynul = 0; 404 + m_data = NULL;
  405 + m_buffer = NULL;
  406 + m_nulval = NULL;
326 407
327 // Return 408 // Return
328 return; 409 return;
329 } 410 }
330 411
331 412
332 -/***************************************************************************  
333 - * Copy class members *  
334 - * ----------------------------------------------------------------------- *  
335 - * Note: it is assumed that no memory has been allocated so far for the *  
336 - * actual instance. * 413 +/***********************************************************************//**
  414 + * @brief Copy class members
  415 + *
  416 + * @param[in] column Column for which members should be copied.
337 ***************************************************************************/ 417 ***************************************************************************/
338 void GFitsTableStrCol::copy_members(const GFitsTableStrCol& column) 418 void GFitsTableStrCol::copy_members(const GFitsTableStrCol& column)
339 { 419 {
340 - // Copy string size  
341 - m_size = column.m_size;  
342 - m_anynul = column.m_anynul;  
343 -  
344 // Copy column data 420 // Copy column data
345 if (column.m_data != NULL && m_size > 0) { 421 if (column.m_data != NULL && m_size > 0) {
346 - m_data = new char*[m_size];  
347 - for (int i = 0; i < m_size; ++i) {  
348 - if (column.m_data[i] != NULL) {  
349 - m_data[i] = new char[m_width+1];  
350 - memcpy(m_data[i], column.m_data[i], m_width);  
351 - }  
352 - else  
353 - m_data[i] = NULL;  
354 - } 422 + m_data = new std::string[m_size];
  423 + for (int i = 0; i < m_size; ++i)
  424 + m_data[i] = column.m_data[i];
355 } 425 }
356 426
357 - // Copy nulstr data  
358 - if (column.m_nulstr != NULL) {  
359 - m_nulstr = new char[m_width+1];  
360 - strncpy(m_nulstr, column.m_nulstr, m_width); 427 + // Copy nulval data
  428 + if (column.m_nulval != NULL) {
  429 + m_nulval = new char[m_width+1];
  430 + strncpy(m_nulval, column.m_nulval, m_width);
361 } 431 }
362 432
363 // Return 433 // Return
@@ -365,65 +435,21 @@ void GFitsTableStrCol::copy_members(const GFitsTableStrCol&amp; column) @@ -365,65 +435,21 @@ void GFitsTableStrCol::copy_members(const GFitsTableStrCol&amp; column)
365 } 435 }
366 436
367 437
368 -/***************************************************************************  
369 - * Delete class members *  
370 - * ----------------------------------------------------------------------- * 438 +/***********************************************************************//**
  439 + * @brief Delete class members
371 ***************************************************************************/ 440 ***************************************************************************/
372 void GFitsTableStrCol::free_members(void) 441 void GFitsTableStrCol::free_members(void)
373 { 442 {
374 // Free memory 443 // Free memory
375 - if (m_data != NULL) {  
376 - for (int i = 0; i < m_size; ++i) {  
377 - if (m_data[i] != NULL) delete [] m_data[i];  
378 - }  
379 - delete [] m_data;  
380 - } 444 + if (m_data != NULL) delete [] m_data;
  445 + if (m_nulval != NULL) delete m_nulval;
381 446
382 // Mark memory as freed 447 // Mark memory as freed
383 - m_data = NULL;  
384 -  
385 - // Return  
386 - return;  
387 -}  
388 -  
389 -  
390 -/***************************************************************************  
391 - * Load column data *  
392 - * ----------------------------------------------------------------------- *  
393 - * The string column is read in a list of character buffers. The length of *  
394 - * each character buffer is 'm_width+1' to hold the final '\0'. The number *  
395 - * of strings is given by the number of rows of the table times the number *  
396 - * of substrings. *  
397 - ***************************************************************************/  
398 -void GFitsTableStrCol::load(void)  
399 -{  
400 - // Calculate total number of strings  
401 - m_size = m_number * m_length;  
402 -  
403 - // Free memory  
404 - free_members();  
405 -  
406 - // Reset number of NULLs  
407 - m_anynul = 0;  
408 -  
409 - // Load data only if some are available  
410 - if (m_size > 0) {  
411 -  
412 - // Allocate memory  
413 - m_data = new char*[m_size];  
414 - for (int i = 0; i < m_size; ++i)  
415 - m_data[i] = new char[m_width+1]; 448 + m_data = NULL;
  449 + m_nulval = NULL;
416 450
417 - // Load column data  
418 - int status = 0;  
419 - status = __ffmahd(&m_fitsfile, (m_fitsfile.HDUposition)+1, NULL,  
420 - &status);  
421 - status = __ffgcvs(&m_fitsfile, m_colnum, 1, 1, m_size, m_nulstr, m_data,  
422 - &m_anynul, &status);  
423 - if (status != 0)  
424 - throw GException::fits_error(G_LOAD, status);  
425 -  
426 - } // endif: data were available 451 + // Free buffer
  452 + free_buffer();
427 453
428 // Return 454 // Return
429 return; 455 return;
@@ -472,12 +498,144 @@ std::string GFitsTableStrCol::binary_format(void) const @@ -472,12 +498,144 @@ std::string GFitsTableStrCol::binary_format(void) const
472 } 498 }
473 499
474 500
  501 +/***********************************************************************//**
  502 + * @brief Allocates column data
  503 + ***************************************************************************/
  504 +void GFitsTableStrCol::alloc_data(void)
  505 +{
  506 + // Free memory
  507 + if (m_data != NULL) delete [] m_data;
  508 +
  509 + // Mark pointer as free
  510 + m_data = NULL;
  511 +
  512 + // Allocate new data
  513 + if (m_size > 0)
  514 + m_data = new std::string[m_size];
  515 +
  516 + // Return
  517 + return;
  518 +}
  519 +
  520 +
  521 +/***********************************************************************//**
  522 + * @brief Initialise column data
  523 + ***************************************************************************/
  524 +void GFitsTableStrCol::init_data(void)
  525 +{
  526 + // Initialise data if they exist
  527 + if (m_data != NULL) {
  528 + for (int i = 0; i < m_size; ++i)
  529 + m_data[i].clear();
  530 + }
  531 +
  532 + // Return
  533 + return;
  534 +}
  535 +
  536 +
  537 +/***********************************************************************//**
  538 + * @brief Fetch column data
  539 + *
  540 + * If a FITS file is attached to the column the data are loaded into memory
  541 + * from the FITS file. If no FITS file is attached, memory is allocated
  542 + * to hold the column data and all cells are set to 0.
  543 + *
  544 + * Refer to GFitsTableCol::load_column for more information.
  545 + ***************************************************************************/
  546 +void GFitsTableStrCol::fetch_data(void)
  547 +{
  548 + // Calculate size of memory
  549 + m_size = m_number * m_length;
  550 +
  551 + // Free old buffer memory
  552 + free_buffer();
  553 +
  554 + // Allocate buffer memory
  555 + alloc_buffer();
  556 +
  557 + // Save column
  558 + load_column();
  559 +
  560 + // Extract string from buffer
  561 + for (int i = 0; i < m_size; ++i) {
  562 + if (m_buffer[i] != NULL)
  563 + m_data[i].assign(m_buffer[i]);
  564 + }
  565 +
  566 + // Free buffer memory
  567 + free_buffer();
  568 +
  569 + // Return
  570 + return;
  571 +}
  572 +
  573 +
  574 +/***********************************************************************//**
  575 + * @brief Allocate buffer memory
  576 + ***************************************************************************/
  577 +void GFitsTableStrCol::alloc_buffer(void)
  578 +{
  579 + // Allocate buffer memory
  580 + if (m_size > 0) {
  581 + m_buffer = new char*[m_size];
  582 + for (int i = 0; i < m_size; ++i)
  583 + m_buffer[i] = new char[m_width+1];
  584 + }
  585 +
  586 + // Initialise buffer
  587 + if (m_buffer != NULL) {
  588 + for (int i = 0; i < m_size; ++i) {
  589 + for (int j = 0; j <= m_width; ++j)
  590 + (m_buffer[i])[j] = '\0';
  591 + }
  592 + }
  593 +
  594 + // Return
  595 + return;
  596 +}
  597 +
  598 +
  599 +/***********************************************************************//**
  600 + * @brief Free buffer memory
  601 + ***************************************************************************/
  602 +void GFitsTableStrCol::free_buffer(void)
  603 +{
  604 + // If there was a buffer allocated then free it
  605 + if (m_buffer != NULL) {
  606 + for (int i = 0; i < m_size; ++i) {
  607 + if (m_buffer[i] != NULL) delete [] m_buffer[i];
  608 + }
  609 + delete [] m_buffer;
  610 + m_buffer = NULL;
  611 + }
  612 +
  613 + // Return
  614 + return;
  615 +}
  616 +
  617 +
475 /*========================================================================== 618 /*==========================================================================
476 = = 619 = =
477 = GFitsTableStrCol friends = 620 = GFitsTableStrCol friends =
478 = = 621 = =
479 ==========================================================================*/ 622 ==========================================================================*/
480 623
  624 +/***********************************************************************//**
  625 + * @brief Output operator
  626 + *
  627 + * @param[in] os Output stream
  628 + * @param[in] column Column to put in output stream
  629 + ***************************************************************************/
  630 +ostream& operator<< (ostream& os, const GFitsTableStrCol& column)
  631 +{
  632 + // Dump column in output stream
  633 + column.dump_column(os, column.m_data);
  634 +
  635 + // Return output stream
  636 + return os;
  637 +}
  638 +
481 639
482 /*========================================================================== 640 /*==========================================================================
483 = = 641 = =
test/test_GFits.cpp
  View file @56d87b7
@@ -82,8 +82,8 @@ void test_columns(void) @@ -82,8 +82,8 @@ void test_columns(void)
82 } 82 }
83 else 83 else
84 std::cout << "."; 84 std::cout << ".";
85 - std::string nullstr = "empty";  
86 - str.set_nullstr(nullstr); 85 + std::string nullval = "empty";
  86 + str.set_nullval(nullval);
87 if (str.string(2) != "empty") { 87 if (str.string(2) != "empty") {
88 cout << endl << "TEST ERROR: Bad single TSTRING NULL value read (" 88 cout << endl << "TEST ERROR: Bad single TSTRING NULL value read ("
89 << str.string(2) << ")." << endl; 89 << str.string(2) << ")." << endl;
@@ -508,13 +508,31 @@ void test_bin_table(void) @@ -508,13 +508,31 @@ void test_bin_table(void)
508 system("rm -rf test_bintables.fits"); 508 system("rm -rf test_bintables.fits");
509 509
510 // Allocate reference sums 510 // Allocate reference sums
511 - double sum_dbl = 0.0;  
512 - int sum_dbl_int = 0; 511 + double sum_dbl = 0.0;
  512 + double sum_dbl10 = 0.0;
  513 + int sum_dbl_int = 0;
  514 + int sum_dbl10_int = 0;
513 std::string sum_dbl_str; 515 std::string sum_dbl_str;
514 - float sum_flt = 0.0;  
515 - int sum_flt_int = 0; 516 + std::string sum_dbl10_str;
  517 + float sum_flt = 0.0;
  518 + float sum_flt10 = 0.0;
  519 + int sum_flt_int = 0;
  520 + int sum_flt10_int = 0;
516 std::string sum_flt_str; 521 std::string sum_flt_str;
517 - 522 + std::string sum_flt10_str;
  523 + short sum_sht = 0;
  524 + short sum_sht10 = 0;
  525 + short sum_sht_int = 0;
  526 + short sum_sht10_int = 0;
  527 + std::string sum_sht_str;
  528 + std::string sum_sht10_str;
  529 + long sum_lng = 0;
  530 + long sum_lng10 = 0;
  531 + long sum_lng_int = 0;
  532 + long sum_lng10_int = 0;
  533 + std::string sum_lng_str;
  534 + std::string sum_lng10_str;
  535 +
518 // Build tables 536 // Build tables
519 try { 537 try {
520 // Open FITS file 538 // Open FITS file
@@ -523,17 +541,20 @@ void test_bin_table(void) @@ -523,17 +541,20 @@ void test_bin_table(void)
523 541
524 // Set number of rows 542 // Set number of rows
525 int nrows = 10; 543 int nrows = 10;
  544 + int nvec = 10;
526 545
527 // Initial control sums 546 // Initial control sums
528 float tot_flt = 0.0; 547 float tot_flt = 0.0;
529 double tot_dbl = 0.0; 548 double tot_dbl = 0.0;
530 int tot_int = 0; 549 int tot_int = 0;
  550 + long tot_lng = 0;
  551 + short tot_sht = 0;
531 std::string tot_str; 552 std::string tot_str;
532 553
533 // 554 //
534 // ===== D O U B L E ===== 555 // ===== D O U B L E =====
535 // 556 //
536 - 557 +
537 // Set double precision table 558 // Set double precision table
538 GFitsTableDblCol col_dbl = GFitsTableDblCol("DOUBLE", nrows); 559 GFitsTableDblCol col_dbl = GFitsTableDblCol("DOUBLE", nrows);
539 for (int i = 0; i < nrows; ++i) { 560 for (int i = 0; i < nrows; ++i) {
@@ -546,14 +567,15 @@ void test_bin_table(void) @@ -546,14 +567,15 @@ void test_bin_table(void)
546 sum_dbl_str += ":"+s_value.str(); 567 sum_dbl_str += ":"+s_value.str();
547 } 568 }
548 cout << "."; 569 cout << ".";
549 - 570 +
550 // Check double precision table (operator access) 571 // Check double precision table (operator access)
551 tot_dbl = 0.0; 572 tot_dbl = 0.0;
552 for (int i = 0; i < nrows; ++i) 573 for (int i = 0; i < nrows; ++i)
553 tot_dbl += col_dbl(i); 574 tot_dbl += col_dbl(i);
554 if (!dequal(tot_dbl, sum_dbl)) { 575 if (!dequal(tot_dbl, sum_dbl)) {
555 - cout << endl << "TEST ERROR: GFitsTableDblCol::operator()"  
556 - << endl; 576 + cout << endl << "TEST ERROR: GFitsTableDblCol::operator()";
  577 + cout << endl << " Reference sum: " << sum_dbl;
  578 + cout << endl << " Derived sum: " << tot_dbl << endl;
557 throw; 579 throw;
558 } 580 }
559 cout << "."; 581 cout << ".";
@@ -563,19 +585,21 @@ void test_bin_table(void) @@ -563,19 +585,21 @@ void test_bin_table(void)
563 for (int i = 0; i < nrows; ++i) 585 for (int i = 0; i < nrows; ++i)
564 tot_dbl += col_dbl.real(i); 586 tot_dbl += col_dbl.real(i);
565 if (!dequal(tot_dbl, sum_dbl)) { 587 if (!dequal(tot_dbl, sum_dbl)) {
566 - cout << endl << "TEST ERROR: GFitsTableDblCol::real()"  
567 - << endl; 588 + cout << endl << "TEST ERROR: GFitsTableDblCol::real()";
  589 + cout << endl << " Reference sum: " << sum_dbl;
  590 + cout << endl << " Derived sum: " << tot_dbl << endl;
568 throw; 591 throw;
569 } 592 }
570 cout << "."; 593 cout << ".";
571 594
572 // Check double precision table (int access) 595 // Check double precision table (int access)
573 - tot_int = 0.0; 596 + tot_int = 0;
574 for (int i = 0; i < nrows; ++i) 597 for (int i = 0; i < nrows; ++i)
575 tot_int += col_dbl.integer(i); 598 tot_int += col_dbl.integer(i);
576 if (tot_int != sum_dbl_int) { 599 if (tot_int != sum_dbl_int) {
577 - cout << endl << "TEST ERROR: GFitsTableDblCol::integer()"  
578 - << endl; 600 + cout << endl << "TEST ERROR: GFitsTableDblCol::integer()";
  601 + cout << endl << " Reference sum: " << sum_dbl_int;
  602 + cout << endl << " Derived sum: " << tot_int << endl;
579 throw; 603 throw;
580 } 604 }
581 cout << "."; 605 cout << ".";
@@ -585,8 +609,84 @@ void test_bin_table(void) @@ -585,8 +609,84 @@ void test_bin_table(void)
585 for (int i = 0; i < nrows; ++i) 609 for (int i = 0; i < nrows; ++i)
586 tot_str += ":"+col_dbl.string(i); 610 tot_str += ":"+col_dbl.string(i);
587 if (tot_str != sum_dbl_str) { 611 if (tot_str != sum_dbl_str) {
588 - cout << endl << "TEST ERROR: GFitsTableDblCol::string()"  
589 - << endl; 612 + cout << endl << "TEST ERROR: GFitsTableDblCol::string()";
  613 + cout << endl << " Reference sum: " << sum_dbl_str;
  614 + cout << endl << " Derived sum: " << tot_str << endl;
  615 + throw;
  616 + }
  617 + cout << ".";
  618 +
  619 + //
  620 + // ===== D O U B L E 1 0 =====
  621 + //
  622 +
  623 + // Set double precision table
  624 + GFitsTableDblCol col_dbl10 = GFitsTableDblCol("DOUBLE10", nrows, nvec);
  625 + for (int i = 0; i < nrows; ++i) {
  626 + for (int j = 0; j < nvec; ++j) {
  627 + double val_dbl = cos(double(i))*cos(0.33*double(j));
  628 + col_dbl10(i,j) = val_dbl;
  629 + sum_dbl10 += val_dbl;
  630 + sum_dbl10_int += int(val_dbl);
  631 + ostringstream s_value;
  632 + s_value << scientific << val_dbl;
  633 + sum_dbl10_str += ":"+s_value.str();
  634 + }
  635 + }
  636 + cout << ".";
  637 +
  638 + // Check double precision table (operator access)
  639 + tot_dbl = 0.0;
  640 + for (int i = 0; i < nrows; ++i) {
  641 + for (int j = 0; j < nvec; ++j)
  642 + tot_dbl += col_dbl10(i,j);
  643 + }
  644 + if (!dequal(tot_dbl, sum_dbl10)) {
  645 + cout << endl << "TEST ERROR: GFitsTableDblCol::operator() - 10";
  646 + cout << endl << " Reference sum: " << sum_dbl10;
  647 + cout << endl << " Derived sum: " << tot_dbl << endl;
  648 + throw;
  649 + }
  650 + cout << ".";
  651 +
  652 + // Check double precision table (real access)
  653 + tot_dbl = 0.0;
  654 + for (int i = 0; i < nrows; ++i) {
  655 + for (int j = 0; j < nvec; ++j)
  656 + tot_dbl += col_dbl10.real(i,j);
  657 + }
  658 + if (!dequal(tot_dbl, sum_dbl10)) {
  659 + cout << endl << "TEST ERROR: GFitsTableDblCol::real() - 10";
  660 + cout << endl << " Reference sum: " << sum_dbl10;
  661 + cout << endl << " Derived sum: " << tot_dbl << endl;
  662 + throw;
  663 + }
  664 + cout << ".";
  665 +
  666 + // Check double precision table (int access)
  667 + tot_int = 0;
  668 + for (int i = 0; i < nrows; ++i) {
  669 + for (int j = 0; j < nvec; ++j)
  670 + tot_int += col_dbl10.integer(i,j);
  671 + }
  672 + if (tot_int != sum_dbl10_int) {
  673 + cout << endl << "TEST ERROR: GFitsTableDblCol::integer() - 10";
  674 + cout << endl << " Reference sum: " << sum_dbl10_int;
  675 + cout << endl << " Derived sum: " << tot_int << endl;
  676 + throw;
  677 + }
  678 + cout << ".";
  679 +
  680 + // Check double precision table (string access)
  681 + tot_str.clear();
  682 + for (int i = 0; i < nrows; ++i) {
  683 + for (int j = 0; j < nvec; ++j)
  684 + tot_str += ":"+col_dbl10.string(i,j);
  685 + }
  686 + if (tot_str != sum_dbl10_str) {
  687 + cout << endl << "TEST ERROR: GFitsTableDblCol::string() - 10";
  688 + cout << endl << " Reference sum: " << sum_dbl10_str;
  689 + cout << endl << " Derived sum: " << tot_str << endl;
590 throw; 690 throw;
591 } 691 }
592 cout << "."; 692 cout << ".";
@@ -613,8 +713,9 @@ void test_bin_table(void) @@ -613,8 +713,9 @@ void test_bin_table(void)
613 for (int i = 0; i < nrows; ++i) 713 for (int i = 0; i < nrows; ++i)
614 tot_flt += col_flt(i); 714 tot_flt += col_flt(i);
615 if (!fequal(tot_flt, sum_flt)) { 715 if (!fequal(tot_flt, sum_flt)) {
616 - cout << endl << "TEST ERROR: GFitsTableFltCol::operator()"  
617 - << endl; 716 + cout << endl << "TEST ERROR: GFitsTableFltCol::operator()";
  717 + cout << endl << " Reference sum: " << sum_flt;
  718 + cout << endl << " Derived sum: " << tot_flt << endl;
618 throw; 719 throw;
619 } 720 }
620 cout << "."; 721 cout << ".";
@@ -624,19 +725,21 @@ void test_bin_table(void) @@ -624,19 +725,21 @@ void test_bin_table(void)
624 for (int i = 0; i < nrows; ++i) 725 for (int i = 0; i < nrows; ++i)
625 tot_flt += col_flt.real(i); 726 tot_flt += col_flt.real(i);
626 if (!fequal(tot_flt, sum_flt)) { 727 if (!fequal(tot_flt, sum_flt)) {
627 - cout << endl << "TEST ERROR: GFitsTableFltCol::real()"  
628 - << endl; 728 + cout << endl << "TEST ERROR: GFitsTableFltCol::real()";
  729 + cout << endl << " Reference sum: " << sum_flt;
  730 + cout << endl << " Derived sum: " << tot_flt << endl;
629 throw; 731 throw;
630 } 732 }
631 cout << "."; 733 cout << ".";
632 734
633 // Check single precision table (int access) 735 // Check single precision table (int access)
634 - tot_int = 0.0; 736 + tot_int = 0;
635 for (int i = 0; i < nrows; ++i) 737 for (int i = 0; i < nrows; ++i)
636 tot_int += col_flt.integer(i); 738 tot_int += col_flt.integer(i);
637 if (tot_int != sum_flt_int) { 739 if (tot_int != sum_flt_int) {
638 - cout << endl << "TEST ERROR: GFitsTableFltCol::integer()"  
639 - << endl; 740 + cout << endl << "TEST ERROR: GFitsTableFltCol::integer()";
  741 + cout << endl << " Reference sum: " << sum_flt_int;
  742 + cout << endl << " Derived sum: " << tot_int << endl;
640 throw; 743 throw;
641 } 744 }
642 cout << "."; 745 cout << ".";
@@ -646,27 +749,493 @@ void test_bin_table(void) @@ -646,27 +749,493 @@ void test_bin_table(void)
646 for (int i = 0; i < nrows; ++i) 749 for (int i = 0; i < nrows; ++i)
647 tot_str += ":"+col_flt.string(i); 750 tot_str += ":"+col_flt.string(i);
648 if (tot_str != sum_flt_str) { 751 if (tot_str != sum_flt_str) {
649 - cout << endl << "TEST ERROR: GFitsTableFltCol::string()"  
650 - << endl; 752 + cout << endl << "TEST ERROR: GFitsTableFltCol::string()";
  753 + cout << endl << " Reference sum: " << sum_flt_str;
  754 + cout << endl << " Derived sum: " << tot_str << endl;
651 throw; 755 throw;
652 } 756 }
653 cout << "."; 757 cout << ".";
654 758
655 // 759 //
  760 + // ===== F L O A T 1 0 =====
  761 + //
  762 +
  763 + // Set single precision table
  764 + GFitsTableFltCol col_flt10 = GFitsTableFltCol("FLOAT10", nrows, nvec);
  765 + for (int i = 0; i < nrows; ++i) {
  766 + for (int j = 0; j < nvec; ++j) {
  767 + float val_flt = cos(0.1*float(i))*cos(0.33*float(j));
  768 + col_flt10(i,j) = val_flt;
  769 + sum_flt10 += val_flt;
  770 + sum_flt10_int += int(val_flt);
  771 + ostringstream s_value;
  772 + s_value << scientific << val_flt;
  773 + sum_flt10_str += ":"+s_value.str();
  774 + }
  775 + }
  776 + cout << ".";
  777 +
  778 + // Check single precision table (operator access)
  779 + tot_flt = 0.0;
  780 + for (int i = 0; i < nrows; ++i) {
  781 + for (int j = 0; j < nvec; ++j)
  782 + tot_flt += col_flt10(i,j);
  783 + }
  784 + if (!fequal(tot_flt, sum_flt10)) {
  785 + cout << endl << "TEST ERROR: GFitsTableFltCol::operator() - 10";
  786 + cout << endl << " Reference sum: " << sum_flt10;
  787 + cout << endl << " Derived sum: " << tot_flt << endl;
  788 + throw;
  789 + }
  790 + cout << ".";
  791 +
  792 + // Check single precision table (real access)
  793 + tot_flt = 0.0;
  794 + for (int i = 0; i < nrows; ++i) {
  795 + for (int j = 0; j < nvec; ++j)
  796 + tot_flt += col_flt10.real(i,j);
  797 + }
  798 + if (!fequal(tot_flt, sum_flt10)) {
  799 + cout << endl << "TEST ERROR: GFitsTableFltCol::real() - 10";
  800 + cout << endl << " Reference sum: " << sum_flt10;
  801 + cout << endl << " Derived sum: " << tot_flt << endl;
  802 + throw;
  803 + }
  804 + cout << ".";
  805 +
  806 + // Check double precision table (int access)
  807 + tot_int = 0;
  808 + for (int i = 0; i < nrows; ++i) {
  809 + for (int j = 0; j < nvec; ++j)
  810 + tot_int += col_flt10.integer(i,j);
  811 + }
  812 + if (tot_int != sum_flt10_int) {
  813 + cout << endl << "TEST ERROR: GFitsTableFltCol::integer() - 10";
  814 + cout << endl << " Reference sum: " << sum_flt10_int;
  815 + cout << endl << " Derived sum: " << tot_int << endl;
  816 + throw;
  817 + }
  818 + cout << ".";
  819 +
  820 + // Check single precision table (string access)
  821 + tot_str.clear();
  822 + for (int i = 0; i < nrows; ++i) {
  823 + for (int j = 0; j < nvec; ++j)
  824 + tot_str += ":"+col_flt10.string(i,j);
  825 + }
  826 + if (tot_str != sum_flt10_str) {
  827 + cout << endl << "TEST ERROR: GFitsTableFltCol::string() - 10";
  828 + cout << endl << " Reference sum: " << sum_flt10_str;
  829 + cout << endl << " Derived sum: " << tot_str << endl;
  830 + throw;
  831 + }
  832 + cout << ".";
  833 +
  834 + //
  835 + // ===== S H O R T =====
  836 + //
  837 +
  838 + // Set short table
  839 + GFitsTableShtCol col_sht = GFitsTableShtCol("SHORT", nrows);
  840 + for (int i = 0; i < nrows; ++i) {
  841 + short val_sht = short(1000.0 * cos(0.1*float(i)));
  842 + col_sht(i) = val_sht;
  843 + sum_sht += val_sht;
  844 + sum_sht_int += int(val_sht);
  845 + ostringstream s_value;
  846 + s_value << val_sht;
  847 + sum_sht_str += ":"+s_value.str();
  848 + }
  849 + cout << ".";
  850 +
  851 + // Check short table (operator access)
  852 + tot_sht = 0;
  853 + for (int i = 0; i < nrows; ++i)
  854 + tot_sht += col_sht(i);
  855 + if (tot_sht != sum_sht) {
  856 + cout << endl << "TEST ERROR: GFitsTableShtCol::operator()";
  857 + cout << endl << " Reference sum: " << sum_sht;
  858 + cout << endl << " Derived sum: " << tot_sht << endl;
  859 + throw;
  860 + }
  861 + cout << ".";
  862 +
  863 + // Check short table (real access)
  864 + tot_dbl = 0.0;
  865 + for (int i = 0; i < nrows; ++i)
  866 + tot_dbl += col_sht.real(i);
  867 + if (!dequal(tot_dbl, double(sum_sht))) {
  868 + cout << endl << "TEST ERROR: GFitsTableShtCol::real()";
  869 + cout << endl << " Reference sum: " << sum_sht;
  870 + cout << endl << " Derived sum: " << tot_dbl << endl;
  871 + throw;
  872 + }
  873 + cout << ".";
  874 +
  875 + // Check short table (int access)
  876 + tot_int = 0;
  877 + for (int i = 0; i < nrows; ++i)
  878 + tot_int += col_sht.integer(i);
  879 + if (tot_int != sum_sht_int) {
  880 + cout << endl << "TEST ERROR: GFitsTableShtCol::integer()";
  881 + cout << endl << " Reference sum: " << sum_sht_int;
  882 + cout << endl << " Derived sum: " << tot_int << endl;
  883 + throw;
  884 + }
  885 + cout << ".";
  886 +
  887 + // Check single precision table (string access)
  888 + tot_str.clear();
  889 + for (int i = 0; i < nrows; ++i)
  890 + tot_str += ":"+col_sht.string(i);
  891 + if (tot_str != sum_sht_str) {
  892 + cout << endl << "TEST ERROR: GFitsTableShtCol::string()";
  893 + cout << endl << " Reference sum: " << sum_sht_str;
  894 + cout << endl << " Derived sum: " << tot_str << endl;
  895 + throw;
  896 + }
  897 + cout << ".";
  898 +
  899 + //
  900 + // ===== S H O R T 1 0 =====
  901 + //
  902 +
  903 + // Set short table
  904 + GFitsTableShtCol col_sht10 = GFitsTableShtCol("SHORT10", nrows, nvec);
  905 + for (int i = 0; i < nrows; ++i) {
  906 + for (int j = 0; j < nvec; ++j) {
  907 + short val_sht = short(100.0*cos(0.1*float(i))*
  908 + cos(0.33*float(j)));
  909 + col_sht10(i,j) = val_sht;
  910 + sum_sht10 += val_sht;
  911 + sum_sht10_int += int(val_sht);
  912 + ostringstream s_value;
  913 + s_value << val_sht;
  914 + sum_sht10_str += ":"+s_value.str();
  915 + }
  916 + }
  917 + cout << ".";
  918 +
  919 + // Check short table (operator access)
  920 + tot_sht = 0;
  921 + for (int i = 0; i < nrows; ++i) {
  922 + for (int j = 0; j < nvec; ++j)
  923 + tot_sht += col_sht10(i,j);
  924 + }
  925 + if (tot_sht != sum_sht10) {
  926 + cout << endl << "TEST ERROR: GFitsTableShtCol::operator() - 10";
  927 + cout << endl << " Reference sum: " << sum_sht10;
  928 + cout << endl << " Derived sum: " << tot_sht << endl;
  929 + throw;
  930 + }
  931 + cout << ".";
  932 +
  933 + // Check short table (real access)
  934 + tot_dbl = 0.0;
  935 + for (int i = 0; i < nrows; ++i) {
  936 + for (int j = 0; j < nvec; ++j)
  937 + tot_dbl += col_sht10.real(i,j);
  938 + }
  939 + if (!dequal(tot_dbl, sum_sht10)) {
  940 + cout << endl << "TEST ERROR: GFitsTableShtCol::real() - 10";
  941 + cout << endl << " Reference sum: " << sum_sht10;
  942 + cout << endl << " Derived sum: " << tot_dbl << endl;
  943 + throw;
  944 + }
  945 + cout << ".";
  946 +
  947 + // Check short table (int access)
  948 + tot_int = 0;
  949 + for (int i = 0; i < nrows; ++i) {
  950 + for (int j = 0; j < nvec; ++j)
  951 + tot_int += col_sht10.integer(i,j);
  952 + }
  953 + if (tot_int != sum_sht10_int) {
  954 + cout << endl << "TEST ERROR: GFitsTableShtCol::integer() - 10";
  955 + cout << endl << " Reference sum: " << sum_sht10_int;
  956 + cout << endl << " Derived sum: " << tot_int << endl;
  957 + throw;
  958 + }
  959 + cout << ".";
  960 +
  961 + // Check single precision table (string access)
  962 + tot_str.clear();
  963 + for (int i = 0; i < nrows; ++i) {
  964 + for (int j = 0; j < nvec; ++j)
  965 + tot_str += ":"+col_sht10.string(i,j);
  966 + }
  967 + if (tot_str != sum_sht10_str) {
  968 + cout << endl << "TEST ERROR: GFitsTableShtCol::string() - 10";
  969 + cout << endl << " Reference sum: " << sum_sht10_str;
  970 + cout << endl << " Derived sum: " << tot_str << endl;
  971 + throw;
  972 + }
  973 + cout << ".";
  974 +
  975 + //
  976 + // ===== L O N G =====
  977 + //
  978 +
  979 + // Set long table
  980 + GFitsTableLngCol col_lng = GFitsTableLngCol("LONG", nrows);
  981 + for (int i = 0; i < nrows; ++i) {
  982 + long val_lng = long(100000.0 * cos(0.1*float(i)));
  983 + col_lng(i) = val_lng;
  984 + sum_lng += val_lng;
  985 + sum_lng_int += int(val_lng);
  986 + ostringstream s_value;
  987 + s_value << val_lng;
  988 + sum_lng_str += ":"+s_value.str();
  989 + }
  990 + cout << ".";
  991 +
  992 + // Check long table (operator access)
  993 + tot_lng = 0;
  994 + for (int i = 0; i < nrows; ++i)
  995 + tot_lng += col_lng(i);
  996 + if (tot_lng != sum_lng) {
  997 + cout << endl << "TEST ERROR: GFitsTableLngCol::operator()";
  998 + cout << endl << " Reference sum: " << sum_lng;
  999 + cout << endl << " Derived sum: " << tot_lng << endl;
  1000 + throw;
  1001 + }
  1002 + cout << ".";
  1003 +
  1004 + // Check long table (real access)
  1005 + tot_dbl = 0.0;
  1006 + for (int i = 0; i < nrows; ++i)
  1007 + tot_dbl += col_lng.real(i);
  1008 + if (!dequal(tot_dbl, double(sum_lng))) {
  1009 + cout << endl << "TEST ERROR: GFitsTableLngCol::real()";
  1010 + cout << endl << " Reference sum: " << sum_lng;
  1011 + cout << endl << " Derived sum: " << tot_dbl << endl;
  1012 + throw;
  1013 + }
  1014 + cout << ".";
  1015 +
  1016 + // Check long table (int access)
  1017 + tot_int = 0;
  1018 + for (int i = 0; i < nrows; ++i)
  1019 + tot_int += col_lng.integer(i);
  1020 + if (tot_int != sum_lng_int) {
  1021 + cout << endl << "TEST ERROR: GFitsTableLngCol::integer()";
  1022 + cout << endl << " Reference sum: " << sum_lng_int;
  1023 + cout << endl << " Derived sum: " << tot_int << endl;
  1024 + throw;
  1025 + }
  1026 + cout << ".";
  1027 +
  1028 + // Check long table (string access)
  1029 + tot_str.clear();
  1030 + for (int i = 0; i < nrows; ++i)
  1031 + tot_str += ":"+col_lng.string(i);
  1032 + if (tot_str != sum_lng_str) {
  1033 + cout << endl << "TEST ERROR: GFitsTableLngCol::string()";
  1034 + cout << endl << " Reference sum: " << sum_lng_str;
  1035 + cout << endl << " Derived sum: " << tot_str << endl;
  1036 + throw;
  1037 + }
  1038 + cout << ".";
  1039 +
  1040 + //
  1041 + // ===== L O N G 1 0 =====
  1042 + //
  1043 +
  1044 + // Set long table
  1045 + GFitsTableLngCol col_lng10 = GFitsTableLngCol("LONG10", nrows, nvec);
  1046 + for (int i = 0; i < nrows; ++i) {
  1047 + for (int j = 0; j < nvec; ++j) {
  1048 + long val_lng = long(1000.0*cos(0.1*float(i))*
  1049 + cos(0.33*float(j)));
  1050 + col_lng10(i,j) = val_lng;
  1051 + sum_lng10 += val_lng;
  1052 + sum_lng10_int += int(val_lng);
  1053 + ostringstream s_value;
  1054 + s_value << val_lng;
  1055 + sum_lng10_str += ":"+s_value.str();
  1056 + }
  1057 + }
  1058 + cout << ".";
  1059 +
  1060 + // Check long table (operator access)
  1061 + tot_lng = 0;
  1062 + for (int i = 0; i < nrows; ++i) {
  1063 + for (int j = 0; j < nvec; ++j)
  1064 + tot_lng += col_lng10(i,j);
  1065 + }
  1066 + if (tot_lng != sum_lng10) {
  1067 + cout << endl << "TEST ERROR: GFitsTableLngCol::operator() - 10";
  1068 + cout << endl << " Reference sum: " << sum_lng10;
  1069 + cout << endl << " Derived sum: " << tot_lng << endl;
  1070 + throw;
  1071 + }
  1072 + cout << ".";
  1073 +
  1074 + // Check long table (real access)
  1075 + tot_dbl = 0.0;
  1076 + for (int i = 0; i < nrows; ++i) {
  1077 + for (int j = 0; j < nvec; ++j)
  1078 + tot_dbl += col_lng10.real(i,j);
  1079 + }
  1080 + if (!dequal(tot_dbl, sum_lng10)) {
  1081 + cout << endl << "TEST ERROR: GFitsTableLngCol::real() - 10";
  1082 + cout << endl << " Reference sum: " << sum_lng10;
  1083 + cout << endl << " Derived sum: " << tot_dbl << endl;
  1084 + throw;
  1085 + }
  1086 + cout << ".";
  1087 +
  1088 + // Check long table (int access)
  1089 + tot_int = 0;
  1090 + for (int i = 0; i < nrows; ++i) {
  1091 + for (int j = 0; j < nvec; ++j)
  1092 + tot_int += col_lng10.integer(i,j);
  1093 + }
  1094 + if (tot_int != sum_lng10_int) {
  1095 + cout << endl << "TEST ERROR: GFitsTableLngCol::integer() - 10";
  1096 + cout << endl << " Reference sum: " << sum_lng10_int;
  1097 + cout << endl << " Derived sum: " << tot_int << endl;
  1098 + throw;
  1099 + }
  1100 + cout << ".";
  1101 +
  1102 + // Check single precision table (string access)
  1103 + tot_str.clear();
  1104 + for (int i = 0; i < nrows; ++i) {
  1105 + for (int j = 0; j < nvec; ++j)
  1106 + tot_str += ":"+col_lng10.string(i,j);
  1107 + }
  1108 + if (tot_str != sum_lng10_str) {
  1109 + cout << endl << "TEST ERROR: GFitsTableLngCol::string() - 10";
  1110 + cout << endl << " Reference sum: " << sum_lng10_str;
  1111 + cout << endl << " Derived sum: " << tot_str << endl;
  1112 + throw;
  1113 + }
  1114 + cout << ".";
  1115 +
  1116 + //
  1117 + // ===== S T R I N G =====
  1118 + //
  1119 +
  1120 + // Set string table
  1121 + GFitsTableStrCol col_str = GFitsTableStrCol("STRING", nrows, 20);
  1122 + for (int i = 0; i < nrows; ++i) {
  1123 + double val_dbl = cos(0.1*double(i));
  1124 + ostringstream s_value;
  1125 + s_value << scientific << val_dbl;
  1126 + col_str(i) = s_value.str();
  1127 + }
  1128 + cout << ".";
  1129 +
  1130 + //
656 // ===== W R I T E T A B L E ===== 1131 // ===== W R I T E T A B L E =====
657 // 1132 //
658 - 1133 +
659 // Build binary table 1134 // Build binary table
660 GFitsBinTable table = GFitsBinTable(nrows); 1135 GFitsBinTable table = GFitsBinTable(nrows);
661 table.append_column(col_dbl); 1136 table.append_column(col_dbl);
662 table.append_column(col_flt); 1137 table.append_column(col_flt);
663 - 1138 + table.append_column(col_sht);
  1139 + table.append_column(col_lng);
  1140 + table.append_column(col_str);
  1141 + table.insert_column(1, col_dbl10);
  1142 + table.insert_column(1, col_flt10);
  1143 + table.insert_column(0, col_sht10);
  1144 + table.insert_column(99, col_lng10);
  1145 +
664 // Create HDU and append to FILE file 1146 // Create HDU and append to FILE file
665 GFitsHDU hdu(table); 1147 GFitsHDU hdu(table);
666 fits.append_hdu(hdu); 1148 fits.append_hdu(hdu);
667 1149
668 // Save FITS file 1150 // Save FITS file
669 fits.save(); 1151 fits.save();
  1152 + //cout << fits;
  1153 + cout << ".";
  1154 + }
  1155 + catch (exception &e) {
  1156 + cout << endl << "TEST ERROR: Unable to build tables." << endl;
  1157 + cout << e.what() << endl;
  1158 + throw;
  1159 + }
  1160 + cout << ".";
  1161 +
  1162 +
  1163 + //================================================================
  1164 + //================================================================
  1165 + //================================================================
  1166 + // Read tables
  1167 + //================================================================
  1168 + //================================================================
  1169 + //================================================================
  1170 + try {
  1171 + // Open FITS file
  1172 + GFits fits;
  1173 + fits.open("test_bintables.fits");
  1174 +
  1175 + // Set number of rows
  1176 + int nrows = 10;
  1177 + int nvec = 10;
  1178 +
  1179 + // Initial control sums
  1180 + float tot_flt = 0.0;
  1181 + double tot_dbl = 0.0;
  1182 + int tot_int = 0;
  1183 + std::string tot_str;
  1184 +
  1185 + //
  1186 + // ===== D O U B L E =====
  1187 + //
  1188 +
  1189 + // Get column
  1190 + GFitsTableDblCol* col_dbl =
  1191 + (GFitsTableDblCol*)fits.hdu(2)->column("DOUBLE");
  1192 +
  1193 + // Check double precision table (operator access)
  1194 + tot_dbl = 0.0;
  1195 + for (int i = 0; i < nrows; ++i)
  1196 + tot_dbl += (*col_dbl)(i);
  1197 + if (!dequal(tot_dbl, sum_dbl)) {
  1198 + cout << endl << "TEST ERROR: GFitsTableDblCol::operator()";
  1199 + cout << endl << " Reference sum: " << sum_dbl;
  1200 + cout << endl << " Derived sum: " << tot_dbl << endl;
  1201 + throw;
  1202 + }
  1203 + cout << ".";
  1204 +
  1205 + // Check double precision table (real access)
  1206 + tot_dbl = 0.0;
  1207 + for (int i = 0; i < nrows; ++i)
  1208 + tot_dbl += (*col_dbl).real(i);
  1209 + if (!dequal(tot_dbl, sum_dbl)) {
  1210 + cout << endl << "TEST ERROR: GFitsTableDblCol::real()";
  1211 + cout << endl << " Reference sum: " << sum_dbl;
  1212 + cout << endl << " Derived sum: " << tot_dbl << endl;
  1213 + throw;
  1214 + }
  1215 + cout << ".";
  1216 +
  1217 + // Check double precision table (int access)
  1218 + tot_int = 0;
  1219 + for (int i = 0; i < nrows; ++i)
  1220 + tot_int += (*col_dbl).integer(i);
  1221 + if (tot_int != sum_dbl_int) {
  1222 + cout << endl << "TEST ERROR: GFitsTableDblCol::integer()";
  1223 + cout << endl << " Reference sum: " << sum_dbl_int;
  1224 + cout << endl << " Derived sum: " << tot_int << endl;
  1225 + throw;
  1226 + }
  1227 + cout << ".";
  1228 +
  1229 + // Check double precision table (string access)
  1230 + tot_str.clear();
  1231 + for (int i = 0; i < nrows; ++i)
  1232 + tot_str += ":"+ (*col_dbl).string(i);
  1233 + if (tot_str != sum_dbl_str) {
  1234 + cout << endl << "TEST ERROR: GFitsTableDblCol::string()";
  1235 + cout << endl << " Reference sum: " << sum_dbl_str;
  1236 + cout << endl << " Derived sum: " << tot_str << endl;
  1237 + throw;
  1238 + }
670 cout << "."; 1239 cout << ".";
671 } 1240 }
672 catch (exception &e) { 1241 catch (exception &e) {
@@ -675,8 +1244,7 @@ void test_bin_table(void) @@ -675,8 +1244,7 @@ void test_bin_table(void)
675 throw; 1244 throw;
676 } 1245 }
677 cout << ". ok." << endl; 1246 cout << ". ok." << endl;
678 -  
679 - 1247 +
680 } 1248 }
681 1249
682 /*************************************************************************** 1250 /***************************************************************************