CCfits  2.4
Column.h
1 // Astrophysics Science Division,
2 // NASA/ Goddard Space Flight Center
3 // HEASARC
4 // http://heasarc.gsfc.nasa.gov
5 // e-mail: ccfits@legacy.gsfc.nasa.gov
6 //
7 // Original author: Ben Dorman
8 
9 #ifndef COLUMN_H
10 #define COLUMN_H 1
11 #include <iostream>
12 
13 // CCfitsHeader
14 #include "CCfits.h"
15 // Table
16 #include "Table.h"
17 // FitsError
18 #include "FitsError.h"
19 // FITSUtil
20 #include "FITSUtil.h"
21 
22 #include <complex>
23 
24 
25 namespace CCfits {
26 
27 
28 
827  class Column
828  {
829 
830  public:
831 
832 
833 
834  class RangeError : public FitsException //## Inherits: <unnamed>%3946526D031A
835  {
836  public:
837  RangeError (const String& msg, bool silent = true);
838 
839  protected:
840  private:
841  private: //## implementation
842  };
843 
844 
845 
846  class InvalidDataType : public FitsException //## Inherits: <unnamed>%3947CF30033E
847  {
848  public:
849  InvalidDataType (const String& str = string(), bool silent = true);
850 
851  protected:
852  private:
853  private: //## implementation
854  };
855 
856 
857 
858  class InvalidRowParameter : public FitsException //## Inherits: <unnamed>%39B5310F01A0
859  {
860  public:
861  InvalidRowParameter (const String& diag, bool silent = true);
862 
863  protected:
864  private:
865  private: //## implementation
866  };
867 
868 
869 
870  class WrongColumnType : public FitsException //## Inherits: <unnamed>%39B545780082
871  {
872  public:
873  WrongColumnType (const String& diag, bool silent = true);
874 
875  protected:
876  private:
877  private: //## implementation
878  };
879 
880 
881 
882  class UnspecifiedLengths : public FitsException //## Inherits: <unnamed>%3A018C9D007D
883  {
884  public:
885  UnspecifiedLengths (const String& diag, bool silent = true);
886 
887  protected:
888  private:
889  private: //## implementation
890  };
891 
892 
893 
894  class InvalidRowNumber : public FitsException //## Inherits: <unnamed>%3B0A850F0307
895  {
896  public:
897  InvalidRowNumber (const String& diag, bool silent = true);
898 
899  protected:
900  private:
901  private: //## implementation
902  };
903 
904 
905 
906  class InsufficientElements : public FitsException //## Inherits: <unnamed>%3B0BE611010A
907  {
908  public:
909  InsufficientElements (const String& msg, bool silent = true);
910 
911  protected:
912  private:
913  private: //## implementation
914  };
915 
916 
917 
918  class NoNullValue : public FitsException //## Inherits: <unnamed>%3B0D589A0092
919  {
920  public:
921  NoNullValue (const String& diag, bool silent = true);
922 
923  protected:
924  private:
925  private: //## implementation
926  };
927 
928 
929 
930  class InvalidNumberOfRows : public FitsException //## Inherits: <unnamed>%3B20EB8B0205
931  {
932  public:
933  InvalidNumberOfRows (size_t number, bool silent = true);
934 
935  protected:
936  private:
937  private: //## implementation
938  };
939  Column(const Column &right);
940  virtual ~Column();
941  bool operator==(const Column &right) const;
942 
943  bool operator!=(const Column &right) const;
944 
945  virtual void readData (long firstRow, long nelements, long firstElem = 1) = 0;
946  // Virtual copy constructor.
947  virtual Column * clone () const = 0;
948  int rows () const;
949  void setDisplay ();
950  virtual void setDimen ();
951  friend std::ostream& operator << (std::ostream& s, const Column& right);
952  Table* parent () const;
953  // Inequality operators for imposing sort order on columns.
954  friend bool operator < (const Column& left, const Column& right);
955  // Inequality operators for imposing sort order on columns.
956  friend bool operator > (const Column& left, const Column& right);
957  void setLimits (ValueType type);
958  void unit (const String& value);
959  void resetRead ();
960  int index () const;
961  void index (int value);
962  bool isRead () const;
963  void isRead (bool value);
964  long width () const;
965  void width (long value);
966  size_t repeat () const;
967  bool varLength () const;
968  double scale () const;
969  void scale (double value);
970  double zero () const;
971  void zero (double value);
972  const String& display () const;
973  const String& dimen () const;
974  void dimen (const String& value);
975  ValueType type () const;
976  void type (ValueType value);
977  static const String& TFORM ();
978  static const String& TDISP ();
979  static const String& TSCAL ();
980  static const String& TZERO ();
981  static const String& TDIM ();
982  const String& format () const;
983  const String& unit () const;
984  const String& name () const;
985 
986  public:
987  // Additional Public Declarations
988 
989  // scalar column interface. Column's Data Member is a std::vector<T>,
990  // input data is std::vector<S>, std::valarray<S> or S* where S is not
991  // in general the same as T.
992 
993  template <typename S>
994  void write (const std::vector<S>& indata, long firstRow);
995 
996  void write (const std::vector<std::complex<float> >& indata, long firstRow);
997 
998  void write (const std::vector<std::complex<double> >& indata, long firstRow);
999 
1000  template <typename S>
1001  void write (const std::valarray<S>& indata, long firstRow);
1002 
1003  void write (const std::valarray<std::complex<float> >& indata, long firstRow);
1004 
1005  void write (const std::valarray<std::complex<double> >& indata, long firstRow);
1006 
1007  template <typename S>
1008  void write (S* indata, long nRows, long firstRow);
1009 
1010 
1011  template <typename S>
1012  void write (const std::vector<S>& indata, long firstRow, S* nullValue);
1013 
1014  template <typename S>
1015  void write (const std::valarray<S>& indata, long firstRow, S* nullValue);
1016 
1017  template <typename S>
1018  void write (S* indata, long nRows, long firstRow, S* nullValue);
1019  // vector column interface. We provide an interface that allows input of a vector, valarray and C-array.
1020  // there are versions that write variable numbers of elements per row as specified
1021  // in the vectorLengths argument. The user also can directly write a vector<valarray<T> >
1022  // object which is how the data are stored in the ColumnVectorData object.
1023  // this last one is also used internally to implement the variable lengths versions.
1024 
1025  // fixed length write to binary table from valarray.
1026 
1027 
1028  template <typename S>
1029  void write (const std::valarray<S>& indata, long nRows, long firstRow);
1030 
1031  void write (const std::valarray<std::complex<float> >& indata, long nRows, long firstRow);
1032 
1033  void write (const std::valarray<std::complex<double> >& indata, long nRows, long firstRow);
1034 
1035 
1036  template <typename S>
1037  void write (const std::vector<S>& indata, long nRows, long firstRow);
1038 
1039  void write (const std::vector<std::complex<float> >& indata, long nRows, long firstRow);
1040 
1041  void write (const std::vector<std::complex<double> >& indata, long nRows, long firstRow);
1042 
1043 
1044 
1045  template <typename S>
1046  void write (S* indata, long nElements, long nRows, long firstRow);
1047 
1048 
1049  template <typename S>
1050  void write (const std::valarray<S>& indata, long nRows, long firstRow, S* nullValue);
1051 
1052 
1053  template <typename S>
1054  void write (const std::vector<S>& indata, long nRows, long firstRow, S* nullValue);
1055 
1056  template <typename S>
1057  void write (S* indata, long nElements, long nRows, long firstRow, S* nullValue);
1058 
1059  // variable-length write to vector column from valarray or vector.
1060 
1061  template <typename S>
1062  void write (const std::valarray<S>& indata,
1063  const std::vector<long>& vectorLengths,
1064  long firstRow);
1065 
1066  void write (const std::valarray<std::complex<float> >& indata,
1067  const std::vector<long>& vectorLengths,
1068  long firstRow);
1069 
1070  void write (const std::valarray<std::complex<double> >& indata,
1071  const std::vector<long>& vectorLengths,
1072  long firstRow);
1073 
1074  template <typename S>
1075  void write (const std::vector<S>& indata,
1076  const std::vector<long>& vectorLengths,
1077  long firstRow);
1078 
1079 
1080 
1081  void write (const std::vector<std::complex<float> >& indata,
1082  const std::vector<long>& vectorLengths,
1083  long firstRow);
1084 
1085  void write (const std::vector<std::complex<double> >& indata,
1086  const std::vector<long>& vectorLengths,
1087  long firstRow);
1088 
1089  template <typename S>
1090  void write (S* indata, long nElements,
1091  const std::vector<long>& vectorLengths,
1092  long firstRow);
1093 
1094  template <typename S>
1095  void writeArrays (const std::vector<std::valarray<S> >& indata, long firstRow);
1096 
1097  void writeArrays (const std::vector<std::valarray<std::complex<float> > >& indata, long firstRow);
1098 
1099  void writeArrays (const std::vector<std::valarray<std::complex<double> > >& indata, long firstRow);
1100 
1101  template <typename S>
1102  void writeArrays (const std::vector<std::valarray<S> >& indata, long firstRow, S* nullValue);
1103 
1104  // get specified elements of a scalar column, returned as a std::vector
1105  // S is NOT the type of the column data itself, it is the type of the returned
1106  // data.
1107 
1108  template <typename S>
1109  void read(std::vector<S>& vals, long first, long last) ;
1110 
1111  // VC++, at least, won't compile these as template covering std::complex instances.
1112  void read(std::vector< std::complex<float> >& , long first, long last);
1113 
1114  void read(std::vector< std::complex<double> >& , long first, long last);
1115 
1116  void read(std::vector<String>& vals, long first, long last);
1117 
1118  // return a set of rows from a scalar column as a valarray.
1119  template <typename S>
1120  void read(std::valarray<S>& vals, long first, long last) ;
1121 
1122  void read(std::valarray<std::complex<float> >& vals, long first, long last) ;
1123 
1124  void read(std::valarray<std::complex<double> >& vals, long first, long last) ;
1125 
1126  // return a single row of a vector column.
1127  template <typename S>
1128  void read(std::valarray<S>& vals, long rows) ;
1129 
1130  void read(std::valarray<std::complex<float> >& vals, long rows) ;
1131 
1132  void read(std::valarray<std::complex<double> >& vals, long rows) ;
1133 
1134  // get a set of rows from a vector column.
1135  template <typename S>
1136  void readArrays(std::vector<std::valarray<S> >& vals, long first, long last) ;
1137 
1138  void readArrays(std::vector<std::valarray<std::complex<float> > >& vals, long first, long last) ;
1139 
1140  void readArrays(std::vector<std::valarray<std::complex<double> > >& vals, long first, long last) ;
1141 
1142  // nullValue has no meaning when the target column has floating point/std::complex
1143  // type. Also, implict conversion of std::complex to pure real is not supported
1144  // by cfitsio.
1145 
1146  template <typename S>
1147  void read(std::vector<S>& vals, long first, long last, S* nullValue) ;
1148 
1149  // return a set of rows from a scalar column as a valarray.
1150  template <typename S>
1151  void read(std::valarray<S>& vals, long first, long last, S* nullValue);
1152 
1153  // return a single row of a vector column.
1154  template <typename S>
1155  void read(std::valarray<S>& vals, long rows, S* nullValue) ;
1156 
1157  // get a set of rows from a vector column.
1158  template <typename S>
1159  void readArrays(std::vector<std::valarray<S> >& vals, long first, long last, S* nullValue);
1160 
1161  // add a null value to the column
1162  template <typename T>
1163  void addNullValue(T nullVal);
1164 
1165  // get the TNULL setting
1166  template <typename T>
1167  bool getNullValue(T* nullVal) const;
1168 
1169  void write (const std::vector<String>& indata, long firstRow);
1170 
1171  friend void Table::insertRows(long first, long number);
1172 
1173  friend void Table::deleteRows(long first, long number);
1174 
1175  friend void Table::deleteRows(const std::vector<long>& rowList);
1176 
1177  friend void Table::initRead();
1178 
1179  friend void Table::reindex();
1180 
1181  friend void Table::copyData(const Table& right);
1182  protected:
1183  Column (int columnIndex, // The column index, i.e. the integer n in the keyword TCOLn
1184  const String &columnName, // The column name, curiously TTYPEn
1185  ValueType type, const String &format, // The TFORMn keyword.
1186  const String &unit, // The TUNITn keyword
1187  Table* p, // ! The Table containing the Column object
1188  int rpt = 1, long w = 1, const String &comment = "");
1189  Column (Table* p = 0);
1190 
1191  virtual bool compare (const Column &right) const;
1192  fitsfile* fitsPointer ();
1193  // Protected method to set the current HDU to be the one containing this Column object. For use in
1194  // public read/write methods to ensure that data regarding numbers of rows and width relate to the
1195  // right HDU
1196  void makeHDUCurrent ();
1197  virtual std::ostream& put (std::ostream& s) const;
1198  void varLength (bool value);
1199  static const String& TBCOL ();
1200  static const String& TTYPE ();
1201  static const String& TUNIT ();
1202  static const String& TNULL ();
1203  static const String& TLMIN ();
1204  static const String& TLMAX ();
1205  static const String& TDMAX ();
1206  static const String& TDMIN ();
1207  static const std::vector<String>& columnKeys ();
1208  const String& comment () const;
1209 
1210  // Additional Protected Declarations
1211 
1212  private:
1213  Column & operator=(const Column &right);
1214 
1215  // Insert one or more blank rows into a FITS column.
1216  virtual void insertRows (long first, long number = 1) = 0;
1217  virtual void deleteRows (long first, long number = 1) = 0;
1218  static void loadColumnKeys ();
1219  void name (const String& value);
1220  void format (const String& value);
1221  long numberOfElements (long& first, long& last);
1222 
1223  // Data Members for Class Attributes
1224  static const String s_TBCOL;
1225  static const String s_TTYPE;
1226  static const String s_TFORM;
1227  static const String s_TDISP;
1228  static const String s_TUNIT;
1229  static const String s_TSCAL;
1230  static const String s_TZERO;
1231  static const String s_TDIM;
1232  static const String s_TNULL;
1233  static const String s_TLMIN;
1234  static const String s_TLMAX;
1235  static const String s_TDMAX;
1236  static const String s_TDMIN;
1237 
1238  // Additional Private Declarations
1239 
1240  private: //## implementation
1241  // Data Members for Class Attributes
1242  int m_index;
1243  bool m_isRead;
1244  long m_width;
1245  size_t m_repeat;
1246  bool m_varLength;
1247  double m_scale;
1248  double m_zero;
1249  String m_display;
1250  String m_dimen;
1251  ValueType m_type;
1252  static const short LLIMITSHORT;
1253  static const long LLIMITLONG;
1254  static const unsigned short LLIMITUSHORT;
1255  static const unsigned long LLIMITULONG;
1256  static const unsigned char LLIMITUCHAR;
1257  static const float LLIMITFLOAT;
1258  static const double LLIMITDOUBLE;
1259  static const short ULIMITSHORT;
1260  static const long ULIMITLONG;
1261  static const unsigned short ULIMITUSHORT;
1262  static const unsigned long ULIMITULONG;
1263  static const unsigned char ULIMITUCHAR;
1264  static const float ULIMITFLOAT;
1265  static const double ULIMITDOUBLE;
1266  static const int LLIMITINT;
1267  static const int ULIMITINT;
1268  static const unsigned int LLIMITUINT;
1269  static const unsigned int ULIMITUINT;
1270  static const LONGLONG LLIMITLONGLONG;
1271  static const LONGLONG ULIMITLONGLONG;
1272 
1273  // Data Members for Associations
1274  Table* m_parent;
1275  static std::vector<String> s_columnKeys;
1276  String m_comment;
1277  String m_format;
1278  String m_unit;
1279  String m_name;
1280 
1281  // Additional Implementation Declarations
1282 
1283  };
1284 
1285  // Class CCfits::Column::RangeError
1286 
1287  // Class CCfits::Column::InvalidDataType
1288 
1289  // Class CCfits::Column::InvalidRowParameter
1290 
1291  // Class CCfits::Column::WrongColumnType
1292 
1293  // Class CCfits::Column::UnspecifiedLengths
1294 
1295  // Class CCfits::Column::InvalidRowNumber
1296 
1297  // Class CCfits::Column::InsufficientElements
1298 
1299  // Class CCfits::Column::NoNullValue
1300 
1301  // Class CCfits::Column::InvalidNumberOfRows
1302 
1303  // Class CCfits::Column
1304 
1305  inline void Column::setDimen ()
1306  {
1307  // default implementation: do nothing. Overridden by ColumnVectorData.
1308  }
1309 
1310  inline std::ostream& operator << (std::ostream& s, const Column& right)
1311  {
1312 
1313  return right.put(s);
1314  }
1315 
1316  inline bool operator < (const Column& left, const Column& right)
1317  {
1318 
1319  return left.m_index < right.m_index;
1320  }
1321 
1322  inline bool operator > (const Column& left, const Column& right)
1323  {
1324 
1325  return left.m_index > right.m_index;
1326  }
1327 
1328  inline void Column::resetRead ()
1329  {
1330  m_isRead = false;
1331  }
1332 
1333  inline int Column::index () const
1334  {
1335  return m_index;
1336  }
1337 
1338  inline void Column::index (int value)
1339  {
1340  m_index = value;
1341  }
1342 
1343  inline bool Column::isRead () const
1344  {
1345  return m_isRead;
1346  }
1347 
1348  inline void Column::isRead (bool value)
1349  {
1350  m_isRead = value;
1351  }
1352 
1353  inline long Column::width () const
1354  {
1355  return m_width;
1356  }
1357 
1358  inline void Column::width (long value)
1359  {
1360  m_width = value;
1361  }
1362 
1363  inline size_t Column::repeat () const
1364  {
1365  return m_repeat;
1366  }
1367 
1368  inline bool Column::varLength () const
1369  {
1370  return m_varLength;
1371  }
1372 
1373  inline double Column::scale () const
1374  {
1375  return m_scale;
1376  }
1377 
1378  inline void Column::scale (double value)
1379  {
1380  m_scale = value;
1381  int status(0);
1382  if (fits_set_tscale(fitsPointer(),m_index,value,m_zero,&status)) throw FitsError(status);
1383  }
1384 
1385  inline double Column::zero () const
1386  {
1387  return m_zero;
1388  }
1389 
1390  inline void Column::zero (double value)
1391  {
1392  m_zero = value;
1393  }
1394 
1395  inline const String& Column::display () const
1396  {
1397  return m_display;
1398  }
1399 
1400  inline const String& Column::dimen () const
1401  {
1402  return m_dimen;
1403  }
1404 
1405  inline void Column::dimen (const String& value)
1406  {
1407  m_dimen = value;
1408  }
1409 
1410  inline ValueType Column::type () const
1411  {
1412  return m_type;
1413  }
1414 
1415  inline void Column::type (ValueType value)
1416  {
1417  m_type = value;
1418  }
1419 
1420  inline const String& Column::TBCOL ()
1421  {
1422  return s_TBCOL;
1423  }
1424 
1425  inline const String& Column::TTYPE ()
1426  {
1427  return s_TTYPE;
1428  }
1429 
1430  inline const String& Column::TFORM ()
1431  {
1432  return s_TFORM;
1433  }
1434 
1435  inline const String& Column::TDISP ()
1436  {
1437  return s_TDISP;
1438  }
1439 
1440  inline const String& Column::TUNIT ()
1441  {
1442  return s_TUNIT;
1443  }
1444 
1445  inline const String& Column::TSCAL ()
1446  {
1447  return s_TSCAL;
1448  }
1449 
1450  inline const String& Column::TZERO ()
1451  {
1452  return s_TZERO;
1453  }
1454 
1455  inline const String& Column::TDIM ()
1456  {
1457  return s_TDIM;
1458  }
1459 
1460  inline const String& Column::TNULL ()
1461  {
1462  return s_TNULL;
1463  }
1464 
1465  inline const String& Column::TLMIN ()
1466  {
1467  return s_TLMIN;
1468  }
1469 
1470  inline const String& Column::TLMAX ()
1471  {
1472  return s_TLMAX;
1473  }
1474 
1475  inline const String& Column::TDMAX ()
1476  {
1477  return s_TDMAX;
1478  }
1479 
1480  inline const String& Column::TDMIN ()
1481  {
1482  return s_TDMIN;
1483  }
1484 
1485  inline const std::vector<String>& Column::columnKeys ()
1486  {
1487  return s_columnKeys;
1488  }
1489 
1490  inline const String& Column::comment () const
1491  {
1492  return m_comment;
1493  }
1494 
1495  inline const String& Column::format () const
1496  {
1497  return m_format;
1498  }
1499 
1500  inline const String& Column::unit () const
1501  {
1502  return m_unit;
1503  }
1504 
1505  inline const String& Column::name () const
1506  {
1507  return m_name;
1508  }
1509 
1510 } // namespace CCfits
1511 
1512 
1513 #endif
virtual ~Column()
destructor.
Definition: Column.cxx:234
Exception thrown if a null value is specified without support from existing column header...
Definition: Column.h:918
const String & name() const
return name of Column (TTYPEn keyword)
Definition: Column.h:1505
Exception thrown for invalid data type inputs.
Definition: Column.h:846
size_t repeat() const
get the repeat count for the rows
Definition: Column.h:1363
fitsfile * fitsPointer()
fits pointer corresponding to fits file containing column data.
Definition: Column.cxx:264
int rows() const
return the number of rows in the table.
Definition: Column.cxx:275
long width() const
return column data width
Definition: Column.h:1353
void resetRead()
reset the Column&#39;s isRead flag to false
Definition: Column.h:1328
void makeHDUCurrent()
make HDU containing this the current HDU of the fits file.
Definition: Column.cxx:270
bool getNullValue(T *nullVal) const
Get the value of the TNULLn keyword for the column.
Definition: ColumnT.h:1363
FitsError is the exception thrown by non-zero cfitsio status codes.
Definition: FitsError.h:112
const String & display() const
return TDISPn keyword
Definition: Column.h:1395
void write(const std::vector< S > &indata, long firstRow)
write a vector of values into a scalar column starting with firstRow
Definition: ColumnT.h:711
Exception thrown if user enters a non-positive number for the number of rows to write.
Definition: Column.h:930
RangeError(const String &msg, bool silent=true)
Exception ctor, prefixes the string "FitsError: Range error in operation " before the specific messag...
Definition: Column.cxx:43
Exception thrown if the data supplied for a write operation is less than declared.
Definition: Column.h:906
const String & dimen() const
return TDIMn keyword
Definition: Column.h:1400
double scale() const
get TSCALn value
Definition: Column.h:1373
void read(std::vector< S > &vals, long first, long last)
Retrieve data from a scalar column into a std::vector.
Definition: ColumnT.h:42
bool isRead() const
flag set to true if the entire column data has been read from disk
Definition: Column.h:1343
exception to be thrown for inputs that cause range errors in column read operations.
Definition: Column.h:834
virtual std::ostream & put(std::ostream &s) const
internal implementation of << operator.
Definition: Column.cxx:302
double zero() const
get TZEROn value
Definition: Column.h:1385
void readArrays(std::vector< std::valarray< S > > &vals, long first, long last)
return a set of rows of a vector column into a vector of valarrays
Definition: ColumnT.h:522
FitsException is the base class for all exceptions thrown by this library.
Definition: FitsError.h:93
Namespace enclosing all CCfits classes and globals definitions.
Definition: AsciiTable.cxx:26
void writeArrays(const std::vector< std::valarray< S > > &indata, long firstRow)
write a vector of valarray objects to the column, starting at row firstRow >= 1
Definition: ColumnT.h:1100
virtual void setDimen()
set the TDIMn keyword.
Definition: Column.h:1305
const String & unit() const
get units of data in Column (TUNITn keyword)
Definition: Column.h:1500
ValueType
CCfits value types and their CFITSIO equivalents (in caps)
Definition: CCfits.h:79
Exception thrown on attempting to access a scalar column as vector data.
Definition: Column.h:870
void setDisplay()
set the TDISPn keyword
Definition: Column.cxx:280
void addNullValue(T nullVal)
Set the TNULLn keyword for the column.
Definition: ColumnT.h:1328
Column(const Column &right)
copy constructor, used in copying Columns to standard library containers.
Definition: Column.cxx:171
Definition: Table.h:280
int index() const
get the Column index (the n in TTYPEn etc).
Definition: Column.h:1333
const String & comment() const
retrieve comment for Column
Definition: Column.h:1490
Exception thrown on attempting to read a row number beyond the end of a table.
Definition: Column.h:894
ValueType type() const
returns the data type of the column
Definition: Column.h:1410
bool varLength() const
boolean, set to true if Column has variable length vector rows.
Definition: Column.h:1368
const String & format() const
return TFORMn keyword
Definition: Column.h:1495
Abstract base class for Column objects.
Definition: Column.h:827
Exception thrown on incorrect row writing request.
Definition: Column.h:858
virtual void readData(long firstRow, long nelements, long firstElem=1)=0
Read (or reread) data from the disk into the Column object&#39;s internal arrays.
void insertRows(long first, long number=1)
insert empty rows into the table
Definition: Table.cxx:331
Table * parent() const
return a pointer to the Table which owns this Column
Definition: Column.cxx:312
void deleteRows(long first, long number=1)
delete a range of rows in a table.
Definition: Table.cxx:350