summaryrefslogtreecommitdiffstats
path: root/ast/table.c
diff options
context:
space:
mode:
Diffstat (limited to 'ast/table.c')
-rw-r--r--ast/table.c5246
1 files changed, 0 insertions, 5246 deletions
diff --git a/ast/table.c b/ast/table.c
deleted file mode 100644
index 0d283bc..0000000
--- a/ast/table.c
+++ /dev/null
@@ -1,5246 +0,0 @@
-/*
-*class++
-* Name:
-* Table
-
-* Purpose:
-* A 2-dimensional table of values.
-
-* Constructor Function:
-c astTable
-f AST_TABLE
-
-* Description:
-* The Table class is a type of KeyMap that represents a two-dimensional
-* table of values. The
-c astMapGet... and astMapPut...
-f AST_MAPGET... and AST_MAPPUT...
-* methods provided by the KeyMap class should be used for storing and
-* retrieving values from individual cells within a Table. Each entry
-* in the KeyMap represents a single cell of the table and has an
-* associated key of the form "<COL>(i)" where "<COL>" is the
-* upper-case name of a table column and "i" is the row index (the
-* first row is row 1). Keys of this form should always be used when
-* using KeyMap methods to access entries within a Table.
-*
-* Columns must be declared using the
-c astAddColumn
-f AST_ADDCOLUMN
-* method before values can be stored within them. This also fixes the
-* type and shape of the values that may be stored in any cell of the
-* column. Cells may contain scalar or vector values of any data type
-* supported by the KeyMap class. Multi-dimensional arrays may also be
-* stored, but these must be vectorised when storing and retrieving
-* them within a table cell. All cells within a single column must
-* have the same type and shape, as specified when the column is added
-* to the Table.
-*
-* Tables may have parameters that describe global properties of the
-* entire table. These are stored as entries in the parent KeyMap and
-* can be access using the get and set method of the KeyMap class.
-* However, parameters must be declared using the
-c astAddParameter
-f AST_ADDPARAMETER
-* method before being accessed.
-*
-* Note - since accessing entries within a KeyMap is a relatively slow
-* process, it is not recommended to use the Table class to store
-* very large tables.
-
-* Inheritance:
-* The Table class inherits from the KeyMap class.
-
-* Attributes:
-* In addition to those attributes common to all KeyMaps, every
-* Table also has the following attributes:
-*
-* - ColumnLenC(column): The largest string length of any value in a column
-* - ColumnLength(column): The number of elements in each value in a column
-* - ColumnNdim(column): The number of axes spanned by each value in a column
-* - ColumnType(column): The data type of each value in a column
-* - ColumnUnit(column): The unit string describing each value in a column
-* - Ncolumn: The number of columns currently in the Table
-* - Nrow: The number of rows currently in the Table
-* - Nparameter: The number of global parameters currently in the Table
-
-* Functions:
-c In addition to those functions applicable to all KeyMaps, the
-c following functions may also be applied to all Tables:
-f In addition to those routines applicable to all KeyMaps, the
-f following routines may also be applied to all Tables:
-*
-c - astAddColumn: Add a new column definition to a Table
-c - astAddParameter: Add a new global parameter definition to a Table
-c - astColumnName: Return the name of the column with a given index
-c - astColumnShape: Return the shape of the values in a named column
-c - astHasColumn: Checks if a column exists in a Table
-c - astHasParameter: Checks if a global parameter exists in a Table
-c - astParameterName: Return the name of the parameter with a given index
-c - astPurgeRows: Remove all empty rows from a Table
-c - astRemoveColumn: Remove a column from a Table
-c - astRemoveParameter: Remove a global parameter from a Table
-c - astRemoveRow: Remove a row from a Table
-f - AST_ADDCOLUMN: Add a new column definition to a Table
-f - AST_ADDPARAMETER: Add a new global parameter definition to a Table
-f - AST_COLUMNNAME: Return the name of the column with a given index
-f - AST_COLUMNSHAPE: Return the shape of the values in a named column
-f - AST_HASCOLUMN: Checks if a column exists in a Table
-f - AST_HASPARAMETER: Checks if a global parameter exists in a Table
-f - AST_PARAMETERNAME: Return the name of the parameter with a given index
-f - AST_PURGEROWS: Remove all empty rows from a Table
-f - AST_REMOVECOLUMN: Remove a column from a Table
-f - AST_REMOVEPARAMETER: Remove a global parameter from a Table
-f - AST_REMOVEROW: Remove a row from a Table
-
-* Copyright:
-* Copyright (C) 2010-2011 Science & Technology Facilities Council.
-* All Rights Reserved.
-
-* Licence:
-* This program is free software: you can redistribute it and/or
-* modify it under the terms of the GNU Lesser General Public
-* License as published by the Free Software Foundation, either
-* version 3 of the License, or (at your option) any later
-* version.
-*
-* This program is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU Lesser General Public License for more details.
-*
-* You should have received a copy of the GNU Lesser General
-* License along with this program. If not, see
-* <http://www.gnu.org/licenses/>.
-
-* Authors:
-* DSB: David S. Berry (Starlink)
-
-* History:
-* 22-NOV-2010 (DSB):
-* Original version.
-* 13-MAY-2011 (DSB):
-* Added support for table parameters.
-* 16-NOV-2013 (DSB):
-* Fix bug in forming keys in GetColumnLenC.
-*class--
-*/
-
-/* Module Macros. */
-/* ============== */
-/* Set the name of the class we are implementing. This indicates to
- the header files that define class interfaces that they should make
- "protected" symbols available. */
-#define astCLASS Table
-
-/* Fixed KeyMap entry names */
-#define LENGTH "Length"
-#define NAME "Name"
-#define NROW "Nrow"
-#define SHAPE "Shape"
-#define SIZE "Size"
-#define TYPE "Type"
-#define UNIT "Unit"
-
-/* A function macro that puts quotes around a value */
-#define STRING(w) #w
-
-/* Include files. */
-/* ============== */
-/* Interface definitions. */
-/* ---------------------- */
-
-#include "globals.h" /* Thread-safe global data access */
-#include "error.h" /* Error reporting facilities */
-#include "memory.h" /* Memory allocation facilities */
-#include "object.h" /* Base Object class */
-#include "keymap.h" /* Coordinate keymaps (parent class) */
-#include "channel.h" /* I/O channels */
-#include "table.h" /* Interface definition for this class */
-
-
-/* Error code definitions. */
-/* ----------------------- */
-#include "ast_err.h" /* AST error codes */
-
-/* C header files. */
-/* --------------- */
-#include <ctype.h>
-#include <stdarg.h>
-#include <stddef.h>
-#include <stdio.h>
-#include <string.h>
-
-
-/* Module Variables. */
-/* ================= */
-
-/* Address of this static variable is used as a unique identifier for
- member of this class. */
-static int class_check;
-
-/* Pointers to parent class methods which are extended by this class. */
-static const char *(* parent_getattrib)( AstObject *, const char *, int * );
-static void (* parent_setkeycase)( AstKeyMap *, int, int * );
-static void (* parent_clearkeycase)( AstKeyMap *, int * );
-static int (* parent_equal)( AstObject *, AstObject *, int * );
-static int (* parent_getobjsize)( AstObject *, int * );
-static int (* parent_mapget0a)( AstKeyMap *, const char *, AstObject * *, int *);
-static int (* parent_mapget0c)( AstKeyMap *, const char *, const char **, int *);
-static int (* parent_mapget0d)( AstKeyMap *, const char *, double *, int *);
-static int (* parent_mapget0f)( AstKeyMap *, const char *, float *, int *);
-static int (* parent_mapget0i)( AstKeyMap *, const char *, int *, int *);
-static int (* parent_mapget0p)( AstKeyMap *, const char *, void **, int *);
-static int (* parent_mapget0b)( AstKeyMap *, const char *, unsigned char *, int *);
-static int (* parent_mapget0s)( AstKeyMap *, const char *, short int *, int *);
-static int (* parent_mapget1a)( AstKeyMap *, const char *, int, int *, AstObject **, int * );
-static int (* parent_mapget1c)( AstKeyMap *, const char *, int, int, int *, char *, int * );
-static int (* parent_mapget1d)( AstKeyMap *, const char *, int, int *, double *, int * );
-static int (* parent_mapget1f)( AstKeyMap *, const char *, int, int *, float *, int * );
-static int (* parent_mapget1i)( AstKeyMap *, const char *, int, int *, int *, int * );
-static int (* parent_mapget1p)( AstKeyMap *, const char *, int, int *, void **, int * );
-static int (* parent_mapget1s)( AstKeyMap *, const char *, int, int *, short int *, int * );
-static int (* parent_mapget1b)( AstKeyMap *, const char *, int, int *, unsigned char *, int * );
-static int (* parent_mapgetelema)( AstKeyMap *, const char *, int, AstObject **, int * );
-static int (* parent_mapgetelemc)( AstKeyMap *, const char *, int, int, char *, int * );
-static int (* parent_mapgetelemd)( AstKeyMap *, const char *, int, double *, int * );
-static int (* parent_mapgetelemf)( AstKeyMap *, const char *, int, float *, int * );
-static int (* parent_mapgetelemi)( AstKeyMap *, const char *, int, int *, int * );
-static int (* parent_mapgetelemp)( AstKeyMap *, const char *, int, void **, int * );
-static int (* parent_mapgetelems)( AstKeyMap *, const char *, int, short int *, int * );
-static int (* parent_mapgetelemb)( AstKeyMap *, const char *, int, unsigned char *, int * );
-static int (* parent_testattrib)( AstObject *, const char *, int * );
-static void (* parent_clearattrib)( AstObject *, const char *, int * );
-static void (* parent_mapput0a)( AstKeyMap *, const char *, AstObject *, const char *, int *);
-static void (* parent_mapput0c)( AstKeyMap *, const char *, const char *, const char *, int *);
-static void (* parent_mapput0d)( AstKeyMap *, const char *, double, const char *, int *);
-static void (* parent_mapput0f)( AstKeyMap *, const char *, float, const char *, int *);
-static void (* parent_mapput0i)( AstKeyMap *, const char *, int, const char *, int *);
-static void (* parent_mapput0p)( AstKeyMap *, const char *, void *, const char *, int *);
-static void (* parent_mapput0b)( AstKeyMap *, const char *, unsigned char, const char *, int *);
-static void (* parent_mapput0s)( AstKeyMap *, const char *, short int, const char *, int *);
-static void (* parent_mapput1a)( AstKeyMap *, const char *, int, AstObject *const [], const char *, int * );
-static void (* parent_mapput1c)( AstKeyMap *, const char *, int, const char *const [], const char *, int * );
-static void (* parent_mapput1d)( AstKeyMap *, const char *, int, const double *, const char *, int * );
-static void (* parent_mapput1f)( AstKeyMap *, const char *, int, const float *, const char *, int * );
-static void (* parent_mapput1i)( AstKeyMap *, const char *, int, const int *, const char *, int * );
-static void (* parent_mapput1p)( AstKeyMap *, const char *, int, void *const [], const char *, int * );
-static void (* parent_mapput1b)( AstKeyMap *, const char *, int, const unsigned char *, const char *, int * );
-static void (* parent_mapput1s)( AstKeyMap *, const char *, int, const short int *, const char *, int * );
-static void (* parent_mapputelema)( AstKeyMap *, const char *, int, AstObject *, int * );
-static void (* parent_mapputelemc)( AstKeyMap *, const char *, int, const char *, int * );
-static void (* parent_mapputelemd)( AstKeyMap *, const char *, int, double, int * );
-static void (* parent_mapputelemf)( AstKeyMap *, const char *, int, float, int * );
-static void (* parent_mapputelemi)( AstKeyMap *, const char *, int, int, int * );
-static void (* parent_mapputelemp)( AstKeyMap *, const char *, int, void *, int * );
-static void (* parent_mapputelemb)( AstKeyMap *, const char *, int, unsigned char, int * );
-static void (* parent_mapputelems)( AstKeyMap *, const char *, int, short int, int * );
-static void (* parent_mapremove)( AstKeyMap *, const char *, int * );
-static void (* parent_setattrib)( AstObject *, const char *, int * );
-static void (* parent_mapputu)( AstKeyMap *, const char *, const char *, int * );
-
-#if defined(THREAD_SAFE)
-static int (* parent_managelock)( AstObject *, int, int, AstObject **, int * );
-#endif
-
-
-/* Define macros for accessing each item of thread specific global data. */
-#ifdef THREAD_SAFE
-
-/* Define how to initialise thread-specific globals. */
-#define GLOBAL_inits \
- globals->Class_Init = 0; \
- globals->GetAttrib_Buff[ 0 ] = 0;
-
-/* Create the function that initialises global data for this module. */
-astMAKE_INITGLOBALS(Table)
-
-/* Define macros for accessing each item of thread specific global data. */
-#define class_init astGLOBAL(Table,Class_Init)
-#define class_vtab astGLOBAL(Table,Class_Vtab)
-#define getattrib_buff astGLOBAL(Table,GetAttrib_Buff)
-
-
-
-/* If thread safety is not needed, declare and initialise globals at static
- variables. */
-#else
-
-static char getattrib_buff[ 101 ];
-
-/* Define the class virtual function table and its initialisation flag
- as static variables. */
-static AstTableVtab class_vtab; /* Virtual function table */
-static int class_init = 0; /* Virtual function table initialised? */
-
-#endif
-
-/* External Interface Function Prototypes. */
-/* ======================================= */
-/* The following functions have public prototypes only (i.e. no
- protected prototypes), so we must provide local prototypes for use
- within this module. */
-AstTable *astTableId_( const char *, ... );
-
-/* Prototypes for Private Member Functions. */
-/* ======================================== */
-static AstKeyMap *ColumnProps( AstTable *, int * );
-static AstKeyMap *ParameterProps( AstTable *, int * );
-static const char *ColumnName( AstTable *, int index, int * );
-static const char *ParameterName( AstTable *, int index, int * );
-static const char *GetColumnUnit( AstTable *, const char *, int * );
-static const char *TypeString( int );
-static int Equal( AstObject *, AstObject *, int * );
-static int GetColumnLenC( AstTable *, const char *, int * );
-static int GetColumnLength( AstTable *, const char *, int * );
-static int GetColumnNdim( AstTable *, const char *, int * );
-static int GetColumnType( AstTable *, const char *, int * );
-static int GetNcolumn( AstTable *, int * );
-static int GetNparameter( AstTable *, int * );
-static int GetObjSize( AstObject *, int * );
-static int HasColumn( AstTable *, const char *, int *);
-static int HasParameter( AstTable *, const char *, int *);
-static int MapGet0A( AstKeyMap *, const char *, AstObject **, int * );
-static int MapGet0B( AstKeyMap *, const char *, unsigned char *, int * );
-static int MapGet0C( AstKeyMap *, const char *, const char **, int * );
-static int MapGet0D( AstKeyMap *, const char *, double *, int * );
-static int MapGet0F( AstKeyMap *, const char *, float *, int * );
-static int MapGet0I( AstKeyMap *, const char *, int *, int * );
-static int MapGet0P( AstKeyMap *, const char *, void **, int * );
-static int MapGet0S( AstKeyMap *, const char *, short int *, int * );
-static int MapGet1A( AstKeyMap *, const char *, int, int *, AstObject **, int * );
-static int MapGet1B( AstKeyMap *, const char *, int, int *, unsigned char *, int * );
-static int MapGet1C( AstKeyMap *, const char *, int, int, int *, char *, int * );
-static int MapGet1D( AstKeyMap *, const char *, int, int *, double *, int * );
-static int MapGet1F( AstKeyMap *, const char *, int, int *, float *, int * );
-static int MapGet1I( AstKeyMap *, const char *, int, int *, int *, int * );
-static int MapGet1P( AstKeyMap *, const char *, int, int *, void **, int * );
-static int MapGet1S( AstKeyMap *, const char *, int, int *, short int *, int * );
-static int MapGetElemA( AstKeyMap *, const char *, int, AstObject **, int * );
-static int MapGetElemB( AstKeyMap *, const char *, int, unsigned char *, int * );
-static int MapGetElemC( AstKeyMap *, const char *, int, int, char *, int * );
-static int MapGetElemD( AstKeyMap *, const char *, int, double *, int * );
-static int MapGetElemF( AstKeyMap *, const char *, int, float *, int * );
-static int MapGetElemI( AstKeyMap *, const char *, int, int *, int * );
-static int MapGetElemP( AstKeyMap *, const char *, int, void **, int * );
-static int MapGetElemS( AstKeyMap *, const char *, int, short int *, int * );
-static int ParseKey( AstTable *, const char *, int, char *, int *, AstKeyMap **, const char *, int * );
-static void AddColumn( AstTable *, const char *, int, int, int *, const char *, int * );
-static void AddParameter( AstTable *, const char *, int * );
-static void ColumnShape( AstTable *, const char *, int, int *, int *, int *);
-static void Copy( const AstObject *, AstObject *, int * );
-static void Delete( AstObject *, int * );
-static void Dump( AstObject *, AstChannel *, int * );
-static void MapPut0A( AstKeyMap *, const char *, AstObject *, const char *, int * );
-static void MapPut0B( AstKeyMap *, const char *, unsigned char, const char *, int * );
-static void MapPut0C( AstKeyMap *, const char *, const char *, const char *, int * );
-static void MapPut0D( AstKeyMap *, const char *, double, const char *, int * );
-static void MapPut0F( AstKeyMap *, const char *, float, const char *, int * );
-static void MapPut0I( AstKeyMap *, const char *, int, const char *, int * );
-static void MapPut0P( AstKeyMap *, const char *, void *, const char *, int * );
-static void MapPut0S( AstKeyMap *, const char *, short int, const char *, int * );
-static void MapPut1A( AstKeyMap *, const char *, int, AstObject *const [], const char *, int * );
-static void MapPut1B( AstKeyMap *, const char *, int, const unsigned char *, const char *, int * );
-static void MapPut1C( AstKeyMap *, const char *, int, const char *const [], const char *, int * );
-static void MapPut1D( AstKeyMap *, const char *, int, const double *, const char *, int * );
-static void MapPut1F( AstKeyMap *, const char *, int, const float *, const char *, int * );
-static void MapPut1I( AstKeyMap *, const char *, int, const int *, const char *, int * );
-static void MapPut1P( AstKeyMap *, const char *, int, void *const [], const char *, int * );
-static void MapPut1S( AstKeyMap *, const char *, int, const short int *, const char *, int * );
-static void MapPutElemA( AstKeyMap *, const char *, int, AstObject *, int * );
-static void MapPutElemB( AstKeyMap *, const char *, int, unsigned char, int * );
-static void MapPutElemC( AstKeyMap *, const char *, int, const char *, int * );
-static void MapPutElemD( AstKeyMap *, const char *, int, double, int * );
-static void MapPutElemF( AstKeyMap *, const char *, int, float, int * );
-static void MapPutElemI( AstKeyMap *, const char *, int, int, int * );
-static void MapPutElemP( AstKeyMap *, const char *, int, void *, int * );
-static void MapPutElemS( AstKeyMap *, const char *, int, short int, int * );
-static void MapPutU( AstKeyMap *, const char *, const char *, int * );
-static void PurgeRows( AstTable *, int * );
-static void RemoveColumn( AstTable *, const char *, int * );
-static void RemoveParameter( AstTable *, const char *, int * );
-static void RemoveRow( AstTable *, int, int * );
-static void SetKeyCase( AstKeyMap *, int, int * );
-static void ClearKeyCase( AstKeyMap *, int * );
-
-#if defined(THREAD_SAFE)
-static int ManageLock( AstObject *, int, int, AstObject **, int * );
-#endif
-
-static const char *GetAttrib( AstObject *, const char *, int * );
-static int TestAttrib( AstObject *, const char *, int * );
-static void ClearAttrib( AstObject *, const char *, int * );
-static void SetAttrib( AstObject *, const char *, int * );
-
-static int GetNrow( AstTable *, int * );
-static void SetNrow( AstTable *, int, int * );
-
-static int GetNcolumn( AstTable *, int * );
-static int GetNparameter( AstTable *, int * );
-
-
-/* Member functions. */
-/* ================= */
-static void AddColumn( AstTable *this, const char *name, int type,
- int ndim, int *dims, const char *unit, int *status ) {
-/*
-*++
-* Name:
-c astAddColumn
-f AST_ADDCOLUMN
-
-* Purpose:
-* Add a new column definition to a table.
-
-* Type:
-* Public virtual function.
-
-* Synopsis:
-c #include "table.h"
-c void astAddColumn( AstTable *this, const char *name, int type, int ndim,
-c int *dims, const char *unit )
-f CALL AST_ADDCOLUMN( THIS, NAME, TYPE, NDIM, DIMS, UNIT, STATUS )
-
-* Class Membership:
-* Table method.
-
-* Description:
-* Adds the definition of a new column to the supplied table. Initially,
-* the column is empty. Values may be added subsequently using the
-* methods of the KeyMap class.
-
-* Parameters:
-c this
-f THIS = INTEGER (Given)
-* Pointer to the Table.
-c name
-f NAME = CHARACTER * ( * ) (Given)
-* The column name. Trailing spaces are ignored (all other spaces
-* are significant). The supplied string is converted to upper case.
-c type
-f TYPE = INTEGER (Given)
-* The data type associated with the column. See "Applicability:"
-* below.
-c ndim
-f NDIM = INTEGER (Given)
-* The number of dimensions spanned by the values stored in a single
-* cell of the column. Zero if the column holds scalar values.
-c dims
-f DIMS( NDIM ) = INTEGER (Given)
-* An array holding the the lengths of each of the axes spanned by
-* the values stored in a single cell of the column. Ignored if the
-* column holds scalara values.
-c unit
-f UNIT = CHARACTER * ( * ) (Given)
-* A string specifying the units of the column. Supply a blank
-* string if the column is unitless.
-f STATUS = INTEGER (Given and Returned)
-f The global status.
-
-* Applicability:
-* Table
-* Tables can hold columns with any of the following data types -
-* AST__INTTYPE (for integer), AST__SINTTYPE (for
-c short int),
-f INTEGER*2),
-* AST__BYTETYPE (for
-c unsigned bytes - i.e. unsigned chars),
-f bytes),
-* AST__DOUBLETYPE (for double
-* precision floating point), AST__FLOATTYPE (for single
-* precision floating point), AST__STRINGTYPE (for character string),
-* AST__OBJECTTYPE (for AST Object pointer), AST__POINTERTYPE (for
-* arbitrary C pointer) or AST__UNDEFTYPE (for undefined values
-* created by
-c astMapPutU).
-f AST_MAPPUTU).
-* FitsTable
-* FitsTables can hold columns with any of the following data types -
-* AST__INTTYPE (for integer), AST__SINTTYPE (for
-c short int),
-f INTEGER*2),
-* AST__BYTETYPE (for
-c unsigned bytes - i.e. unsigned chars),
-f bytes),
-* AST__DOUBLETYPE (for double
-* precision floating point), AST__FLOATTYPE (for single
-* precision floating point), AST__STRINGTYPE (for character string).
-
-* Notes:
-* - This
-c function
-f routine
-* returns without action if a column already exists in the Table
-* with the supplied name and properties. However an error is
-* reported if any of the properties differ.
-
-*--
-*/
-
-/* Local Variables: */
- AstKeyMap *cols; /* KeyMap holding all column details */
- AstKeyMap *col_km; /* KeyMap holding new column details */
- const char *oldunit; /* Pointer to the old coumn unit string */
- int *olddims; /* Shape of pre-existing column */
- int idim; /* Axis index */
- int namlen; /* Used length of "name" */
- int nval; /* Number of values returned */
- int oldtype; /* Data type of pre-existing column */
-
-/* Check the global error status. */
- if ( !astOK ) return;
-
-/* Verify supplied values. */
- namlen = astChrLen( name );
- if( namlen == 0 ) {
- astError( AST__BADKEY, "astAddColumn(%s): Illegal blank column name "
- "supplied.", status, astGetClass( this ) );
-
- } else if( namlen > AST__MXCOLNAMLEN ) {
- astError( AST__BADKEY, "astAddColumn(%s): Column name '%s' is too "
- "long (must be no more than %d characters).", status,
- astGetClass( this ), name, AST__MXCOLNAMLEN );
-
- } else if( ndim < 0 ) {
- astError( AST__NAXIN, "astAddColumn(%s): No of axes (%d) for values in "
- "new column %s is invalid.", status, astGetClass( this ),
- ndim, name );
-
- } else if( TypeString( type ) == NULL ) {
- astError( AST__NAXIN, "astAddColumn(%s): Bad data type supplied (%d) "
- "for new column %s.", status, astGetClass( this ), type,
- name );
-
- } else {
- for( idim = 0; idim < ndim; idim++ ) {
- if( dims[ idim ] < 1 ) {
- astError( AST__DIMIN, "astAddColumn(%s): Length of axis %d (%d) "
- "for new column %s is invalid.", status,
- astGetClass( this ), idim + 1, dims[ idim ], name );
- break;
- }
- }
- }
-
-/* If there is already a column with the given name, check its properties
- match the supplied properties. */
- if( astOK ) {
- cols = astColumnProps( this );
- if( astMapGet0A( cols, name, &col_km ) ) {
-
- astMapGet0I( col_km, TYPE, &oldtype );
- if( oldtype != type && astOK ) {
- astError( AST__OLDCOL, "astAddColumn(%s): A column called "
- "%s already exists in the table with a different "
- "data type (%s).", status, astGetClass( this ),
- name, TypeString( oldtype ) );
- }
-
- if( !astMapGet0C( col_km, UNIT, &oldunit ) ) oldunit = "";
- if( strcmp( oldunit, unit ) && astOK ) {
- astError( AST__OLDCOL, "astAddColumn(%s): A column called "
- "%s already exists in the table with a different "
- "unit string ('%s').", status, astGetClass( this ),
- name, oldunit );
- }
-
- if( ndim != astMapLength( col_km, SHAPE ) && astOK ) {
- astError( AST__OLDCOL, "astAddColumn(%s): A column called "
- "%s already exists in the table with a different "
- "number of axes (%d).", status, astGetClass( this ),
- name, astMapLength( col_km, SHAPE ) );
- }
-
- if( ndim > 0 && astOK ) {
- olddims = astMalloc( sizeof( int )*ndim );
- (void) astMapGet1I( col_km, SHAPE, ndim, &nval, olddims );
- for( idim = 0; idim < ndim && astOK; idim++ ) {
- if( dims[ idim ] != olddims[ idim ] ) {
- astError( AST__OLDCOL, "astAddColumn(%s): A column called "
- "%s already exists in the table with a different "
- "shape.", status, astGetClass( this ), name );
- }
- }
- olddims = astFree( olddims );
- }
-
-/* Otherwise, add a new column to the table. */
- } else {
-
-/* Add a suitable entry describing the column to the Columns KeyMap. */
- col_km = astKeyMap( " ", status );
- astMapPut0C( col_km, NAME, name, NULL );
- astMapPut0I( col_km, TYPE, type, NULL );
- if( ndim ) astMapPut1I( col_km, SHAPE, ndim, dims, NULL );
- astMapPut0C( col_km, UNIT, unit, NULL );
-
-/* Put the column KeyMap into the KeyMap holding details of all columns.
- Use the column name as the key. */
- astMapPut0A( cols, name, col_km, NULL );
- }
-
-/* Annul the local KeyMap pointers. */
- col_km = astAnnul( col_km );
- cols = astAnnul( cols );
- }
-}
-
-static void AddParameter( AstTable *this, const char *name, int *status ) {
-/*
-*++
-* Name:
-c astAddParameter
-f AST_ADDPARAMETER
-
-* Purpose:
-* Add a new global parameter definition to a table.
-
-* Type:
-* Public virtual function.
-
-* Synopsis:
-c #include "table.h"
-c void astAddParameter( AstTable *this, const char *name )
-f CALL AST_ADDPARAMETER( THIS, NAME, STATUS )
-
-* Class Membership:
-* Table method.
-
-* Description:
-* Adds the definition of a new global parameter to the supplied
-* table. Note, this does not store a value for the parameter. To get
-* or set the parameter value, the methods of the paremt KeyMap class
-* should be used, using the name of the parameter as the key.
-
-* Parameters:
-c this
-f THIS = INTEGER (Given)
-* Pointer to the Table.
-c name
-f NAME = CHARACTER * ( * ) (Given)
-* The parameter name. Trailing spaces are ignored (all other spaces
-* are significant). The supplied string is converted to upper case.
-f STATUS = INTEGER (Given and Returned)
-f The global status.
-
-* Notes:
-* - Unlike columns, the definition of a parameter does not specify its type,
-* size or dimensionality.
-
-*--
-*/
-
-/* Local Variables: */
- AstKeyMap *pars; /* KeyMap holding all parameter details */
- int namlen; /* Used length of "name" */
-
-/* Check the global error status. */
- if ( !astOK ) return;
-
-/* Verify supplied values. */
- namlen = astChrLen( name );
- if( namlen == 0 ) {
- astError( AST__BADKEY, "astAddParameter(%s): Illegal blank parameter name "
- "supplied.", status, astGetClass( this ) );
-
- } else if( namlen > AST__MXCOLNAMLEN ) {
- astError( AST__BADKEY, "astAddParameter(%s): Parameter name '%s' is too "
- "long (must be no more than %d characters).", status,
- astGetClass( this ), name, AST__MXCOLNAMLEN );
- }
-
-/* Do nothing if there is already a parameter with the given name. */
- if( astOK ) {
- pars = astParameterProps( this );
- if( !astMapHasKey( pars, name ) ) {
-
-/* Add a suitable entry to the Parameters KeyMap. The value is arbitrary
- and currently unused. */
- astMapPut0I( pars, name, 1, NULL );
- }
-
-/* Annul the local KeyMap pointer. */
- pars = astAnnul( pars );
- }
-}
-
-static void ClearAttrib( AstObject *this_object, const char *attrib, int *status ) {
-/*
-* Name:
-* ClearAttrib
-
-* Purpose:
-* Clear an attribute value for a Table.
-
-* Type:
-* Private function.
-
-* Synopsis:
-* #include "table.h"
-* void ClearAttrib( AstObject *this, const char *attrib )
-
-* Class Membership:
-* Table member function (over-rides the astClearAttrib protected
-* method inherited from the KeyMap class).
-
-* Description:
-* This function clears the value of a specified attribute for a
-* Table, so that the default value will subsequently be used.
-
-* Parameters:
-* this
-* Pointer to the Table.
-* attrib
-* Pointer to a null terminated string specifying the attribute
-* name. This should be in lower case with no surrounding white
-* space.
-*/
-
-/* Local Variables: */
- AstTable *this;
- int nc;
- int len;
-
-/* Check the global error status. */
- if ( !astOK ) return;
-
-/* Obtain a pointer to the Table structure. */
- this = (AstTable *) this_object;
-
-/* Get the length of the attribute string. */
- len = strlen( attrib );
-
-/* Check the attribute name and clear the appropriate attribute. */
- /* None yet */
-
-/* Define a macro to see if the attribute string matches any of the
- read-only column attributes of this class. */
-#define MATCH(attr) \
- ( nc = 0, ( 0 == astSscanf( attrib, attr "(%*s)%n", &nc ) ) && \
- ( nc >= len ) )
-
-/* If the name was not recognised, test if it matches any of the
- read-only attributes of this class. If it does, then report an
- error. */
- if ( !strcmp( attrib, "nrow" ) ||
- !strcmp( attrib, "ncolumn" ) ||
- !strcmp( attrib, "nparameter" ) ||
- MATCH( "columnlenc" ) ||
- MATCH( "columnlength" ) ||
- MATCH( "columnndim" ) ||
- MATCH( "columntype" ) ||
- MATCH( "columnunit" ) ) {
- astError( AST__NOWRT, "astClear: Invalid attempt to clear the \"%s\" "
- "value for a %s.", status, attrib, astGetClass( this ) );
- astError( AST__NOWRT, "This is a read-only attribute." , status);
-
-/* If the attribute is still not recognised, pass it on to the parent
- method for further interpretation. */
- } else {
- (*parent_clearattrib)( this_object, attrib, status );
- }
-
-#undef MATCH
-
-}
-
-static void ClearKeyCase( AstKeyMap *this, int *status ) {
-/*
-* Name:
-* ClearKeyCase
-
-* Purpose:
-* Clear the KeyCase attribute value for a Table.
-
-* Type:
-* Private function.
-
-* Synopsis:
-* #include "keymape.h"
-* void ClearKeyCase( AstKeyMap *this, int *status )
-
-* Class Membership:
-* Table member function (over-rides the astClearKeyCase protected
-* method inherited from the KeyMap class).
-
-* Description:
-* This function clears the value of the KeyCase attribute for a
-* Table. For a Table, the KeyCase attribute cannot be changed so this
-* function exits without action.
-
-* Parameters:
-* this
-* Pointer to the Table.
-*/
-
-}
-
-static const char *ColumnName( AstTable *this, int index, int *status ) {
-/*
-*++
-* Name:
-c astColumnName
-f AST_COLUMNNAME
-
-* Purpose:
-* Get the name of the column at a given index within the Table.
-
-* Type:
-* Public virtual function.
-
-* Synopsis:
-c #include "table.h"
-c const char *astColumnName( AstTable *this, int index )
-f RESULT = AST_COLUMNNAME( THIS, INDEX, STATUS )
-
-* Class Membership:
-* Table method.
-
-* Description:
-* This function returns a string holding the name of the column with
-* the given index within the Table.
-*
-* This function is intended primarily as a means of iterating round all
-* the columns in a Table. For this purpose, the number of columns in
-* the Table is given by the Ncolumn attribute of the Table. This function
-* could then be called in a loop, with the index value going from
-c zero to one less than Ncolumn.
-f one to Ncolumn.
-*
-* Note, the index associated with a column decreases monotonically with
-* the age of the column: the oldest Column in the Table will have index
-* one, and the Column added most recently to the Table will have the
-* largest index.
-
-* Parameters:
-c this
-f THIS = INTEGER (Given)
-* Pointer to the Table.
-c index
-f INDEX = INTEGER (Given)
-* The index into the list of columns. The first column has index
-* one, and the last has index "Ncolumn".
-f STATUS = INTEGER (Given and Returned)
-f The global status.
-
-* Returned Value:
-c astColumnName()
-c A pointer to a null-terminated string containing the
-f AST_COLUMNNAME = CHARACTER * ( AST__SZCHR )
-f The
-* upper case column name.
-
-* Notes:
-c - The returned pointer is guaranteed to remain valid and the
-c string to which it points will not be over-written for a total
-c of 50 successive invocations of this function. After this, the
-c memory containing the string may be re-used, so a copy of the
-c string should be made if it is needed for longer than this.
-c - A NULL pointer will be returned if this function is invoked
-c with the AST error status set, or if it should fail for any
-c reason.
-f - A blank string will be returned if this function is invoked
-f with STATUS set to an error value, or if it should fail for any
-f reason.
-*--
-*/
-
-/* Local Variables: */
- AstKeyMap *cols; /* KeyMap holding column definitions */
- const char *result;
-
-/* Check the global error status. */
- if ( !astOK ) return NULL;
-
-/* Get apointer to the KeyMap holding all column definitions. */
- cols = astColumnProps( this );
-
-/* Issue a more useful error message than that issued by astMapKey if the
- index is invalid. */
- if( index < 1 || index > astMapSize( cols ) ) {
- astError( AST__MPIND, "astColumnName(%s): Cannot find column "
- "%d (zero-based) of the %s - invalid index.", status,
- astGetClass( this ), index, astGetClass( this ) );
- }
-
-/* Get the column name. */
- result = astMapKey( cols, index - 1 );
-
-/* Free resources. */
- cols = astAnnul( cols );
-
-/* Return a pointer to the required column name. */
- return result;
-}
-
-static AstKeyMap *ColumnProps( AstTable *this, int *status ) {
-/*
-*+
-* Name:
-* astColumnProps
-
-* Purpose:
-* Returns a pointer to the KeyMap holding column properties.
-
-* Type:
-* Protected virtual function.
-
-* Synopsis:
-* #include "table.h"
-* AstKeyMap *astColumnProps( AstTable *this )
-
-* Class Membership:
-* Table method.
-
-* Description:
-* This function returns a pointer to the KeyMap that holds
-* definitions of all the coumns added to the Table.
-
-* Parameters:
-* this
-* Pointer to the Table.
-
-* Returned Value:
-* A pointer to the KeyMap. It shpould be annulled using astAnnul
-* when no longer needed.
-
-*-
-*/
-
-/* Check the global error status. */
- if ( !astOK ) return NULL;
-
-/* Return a cloned pointer to the required KeyMap. */
- return astClone( this->columns );
-}
-
-static void ColumnShape( AstTable *this, const char *column, int mxdim,
- int *ndim, int *dims, int *status ){
-/*
-*++
-* Name:
-c astColumnShape
-f AST_COLUMNSHAPE
-
-* Purpose:
-* Returns the shape of the values in a named column.
-
-* Type:
-* Public virtual function.
-
-* Synopsis:
-c #include "table.h"
-c void astColumnShape( AstTable *this, const char *column, int mxdim,
-c int *ndim, int *dims )
-f CALL AST_COLUMNSHAPE( THIS, COLUMN, MXDIM, NDIM, DIMS, STATUS )
-
-* Class Membership:
-* Table method.
-
-* Description:
-c This function
-f This routine
-* returns the number of dimensions spaned by each value in a named
-* column of a Table, together with the length of each dimension.
-* These are the values supplied when the column was created using
-c astAddColumn.
-f AST_ADDCOLUMN.
-
-* Parameters:
-c this
-f THIS = INTEGER (Given)
-* Pointer to the Table.
-c column
-f COLUMN = CHARACTER * ( * ) (Given)
-* The character string holding the upper case name of the column. Trailing
-* spaces are ignored.
-c mxdim
-f MXDIM = INTEGER (Given)
-* The length of the
-c "dims" array.
-f DIMS array.
-c ndim
-f NDIM = INTEGER (Returned)
-c Pointer to an int in which to return the
-f The
-* number of dimensions spanned by values in the named column.
-* This will be zero if the column contains scalar values.
-c dims
-f DIMS( MXDIM ) = INTEGER (Returned)
-c Pointer to an
-f An
-* array in which to return the length of each dimension. Any
-* excess trailing elements will be filled with the value 1.
-f STATUS = INTEGER (Given and Returned)
-f The global status.
-
-* Notes:
-* - No error is reported if the requested column cannot be found in the
-* given Table. A value of zero is returned for
-c "ndim" and the supplied values in "dims"
-f NDIM and the supplied values in DIMS
-* are left unchanged.
-* - A value of zero is returned for
-c "ndim"
-f NDIM
-* if an error occurs.
-
-*--
-*/
-
-/* Local Variables: */
- AstKeyMap *cols; /* Pointer to KeyMap holding all column info */
- AstKeyMap *col_km; /* Pointer to KeyMap holding requested column info */
- int idim; /* Axis index */
-
-/* Initialise */
- *ndim = 0;
-
-/* Check the inherited status. */
- if( !astOK ) return;
-
-
-/* Get the KeyMap holding information about the requested column. */
- cols = astColumnProps( this );
- if( astMapGet0A( cols, column, &col_km ) ) {
-
-/* Get the shape of the column values. */
- (void) astMapGet1I( col_km, SHAPE, mxdim, ndim, dims );
-
-/* Fill excess array elements with 1. */
- for( idim = *ndim; idim < mxdim; idim++ ) dims[ idim ] = 1;
-
-/* Free resources. */
- col_km = astAnnul( col_km );
- }
- cols = astAnnul( cols );
-
-/* If an error has occurred, set ndim to zero. */
- if( !astOK ) *ndim = 0;
-
-}
-
-static int Equal( AstObject *this_object, AstObject *that_object, int *status ) {
-/*
-* Name:
-* Equal
-
-* Purpose:
-* Test if two Tables are equivalent.
-
-* Type:
-* Private function.
-
-* Synopsis:
-* #include "table.h"
-* int Equal( AstObject *this, AstObject *that, int *status )
-
-* Class Membership:
-* Table member function (over-rides the astEqual protected
-* method inherited from the astKeyMap class).
-
-* Description:
-* This function returns a boolean result (0 or 1) to indicate whether
-* two Tables are equivalent.
-
-* Parameters:
-* this
-* Pointer to the first Object (a Table).
-* that
-* Pointer to the second Object.
-* status
-* Pointer to the inherited status variable.
-
-* Returned Value:
-* One if the Tables are equivalent, zero otherwise.
-
-* Notes:
-* - A value of zero will be returned if this function is invoked
-* with the global status set, or if it should fail for any reason.
-*/
-
-/* Local Variables: */
- AstKeyMap *this_km;
- AstKeyMap *that_km;
- AstTable *that;
- AstTable *this;
- int result;
-
-/* Initialise. */
- result = 0;
-
-/* Check the global error status. */
- if ( !astOK ) return result;
-
-/* Obtain pointers to the two Table structures. */
- this = (AstTable *) this_object;
- that = (AstTable *) that_object;
-
-/* Check the second object is a Table. We know the first is a
- Table since we have arrived at this implementation of the virtual
- function. */
- if( astIsATable( that ) ) {
-
-/* Check the Tables are equal when compared as KeyMaps. */
- if( (*parent_equal)( this_object, that_object, status ) ) {
-
-/* Check the Columns KeyMaps are equal. */
- this_km = astColumnProps( this );
- that_km = astColumnProps( that );
- result = astEqual( this_km, that_km );
- this_km = astAnnul( this_km );
- that_km = astAnnul( that_km );
-
-/* Check the Parameter KeyMaps are equal. */
- this_km = astParameterProps( this );
- that_km = astParameterProps( that );
- result = astEqual( this_km, that_km );
- this_km = astAnnul( this_km );
- that_km = astAnnul( that_km );
- }
- }
-
-/* If an error occurred, clear the result value. */
- if ( !astOK ) result = 0;
-
-/* Return the result, */
- return result;
-}
-
-static const char *GetAttrib( AstObject *this_object, const char *attrib, int *status ) {
-/*
-* Name:
-* GetAttrib
-
-* Purpose:
-* Get the value of a specified attribute for a Table.
-
-* Type:
-* Private function.
-
-* Synopsis:
-* #include "table.h"
-* const char *GetAttrib( AstObject *this, const char *attrib, int *status )
-
-* Class Membership:
-* Table member function (over-rides the protected astGetAttrib
-* method inherited from the KeyMap class).
-
-* Description:
-* This function returns a pointer to the value of a specified
-* attribute for a Table, formatted as a character string.
-
-* Parameters:
-* this
-* Pointer to the Table.
-* attrib
-* Pointer to a null terminated string containing the name of
-* the attribute whose value is required. This name should be in
-* lower case, with all white space removed.
-* status
-* Pointer to the inherited status variable.
-
-* Returned Value:
-* - Pointer to a null terminated string containing the attribute
-* value.
-
-* Notes:
-* - The returned string pointer may point at memory allocated
-* within the Table, or at static memory. The contents of the
-* string may be over-written or the pointer may become invalid
-* following a further invocation of the same function or any
-* modification of the Table. A copy of the string should
-* therefore be made if necessary.
-* - A NULL pointer will be returned if this function is invoked
-* with the global error status set, or if it should fail for any
-* reason.
-*/
-
-/* Local Variables: */
- astDECLARE_GLOBALS /* Pointer to thread-specific global data */
- char cname[ AST__MXCOLNAMLEN + 1 ]; /* Column name */
- AstTable *this; /* Pointer to the Table structure */
- const char *result; /* Pointer value to return */
- int ival; /* Int attribute value */
- int len; /* Length of attrib string */
- int nc; /* No. characters read by astSscanf */
-
-/* Initialise. */
- result = NULL;
-
-/* Check the global error status. */
- if ( !astOK ) return result;
-
-/* Get a pointer to the thread specific global data structure. */
- astGET_GLOBALS(this_object);
-
-/* Obtain a pointer to the Table structure. */
- this = (AstTable *) this_object;
-
-/* Obtain the length of the attrib string. */
- len = strlen( attrib );
-
-/* Compare "attrib" with each recognised attribute name in turn,
- obtaining the value of the required attribute. If necessary, write
- the value into "getattrib_buff" as a null terminated string in an
- appropriate format. Set "result" to point at the result string. */
-
-/* Table properties */
-/* ================ */
-
-/* Ncolumn */
-/* ------- */
- if( !strcmp( attrib, "ncolumn" ) ) {
- ival = astGetNcolumn( this );
- if ( astOK ) {
- (void) sprintf( getattrib_buff, "%d", ival );
- result = getattrib_buff;
- }
-
-/* Nrow */
-/* ---- */
- } else if( !strcmp( attrib, "nrow" ) ) {
- ival = astGetNrow( this );
- if ( astOK ) {
- (void) sprintf( getattrib_buff, "%d", ival );
- result = getattrib_buff;
- }
-
-/* Nparameter */
-/* ---------- */
- } else if( !strcmp( attrib, "nparameter" ) ) {
- ival = astGetNparameter( this );
- if ( astOK ) {
- (void) sprintf( getattrib_buff, "%d", ival );
- result = getattrib_buff;
- }
-
-
-
-/* Column properties */
-/* ================= */
-
-/* A macro that gives the scannf pattern to test for a given column
- property. Needed since the buffer length is defined by a macro
- (AST__MXCOLNAMLEN). */
-#define PATTERN(cnam,blen) #cnam "(%" STRING(blen) "[^()])%n"
-
-/* ColumnNdim */
- } else if ( nc = 0,
- ( 1 == astSscanf( attrib, PATTERN(columnndim,AST__MXCOLNAMLEN),
- cname, &nc ) ) && ( nc >= len ) ) {
- ival = astGetColumnNdim( this, cname );
- if ( astOK ) {
- (void) sprintf( getattrib_buff, "%d", ival );
- result = getattrib_buff;
- }
-
-/* ColumnLenC */
- } else if ( nc = 0,
- ( 1 == astSscanf( attrib, PATTERN(columnlenc,AST__MXCOLNAMLEN),
- cname, &nc ) ) && ( nc >= len ) ) {
- ival = astGetColumnLenC( this, cname );
- if ( astOK ) {
- (void) sprintf( getattrib_buff, "%d", ival );
- result = getattrib_buff;
- }
-
-/* ColumnType */
- } else if ( nc = 0,
- ( 1 == astSscanf( attrib, PATTERN(columntype,AST__MXCOLNAMLEN),
- cname, &nc ) ) && ( nc >= len ) ) {
- ival = astGetColumnType( this, cname );
- if ( astOK ) {
- (void) sprintf( getattrib_buff, "%d", ival );
- result = getattrib_buff;
- }
-
-/* ColumnLength */
- } else if ( nc = 0,
- ( 1 == astSscanf( attrib, PATTERN(columnlength,AST__MXCOLNAMLEN),
- cname, &nc ) ) && ( nc >= len ) ) {
- ival = astGetColumnLength( this, cname );
- if ( astOK ) {
- (void) sprintf( getattrib_buff, "%d", ival );
- result = getattrib_buff;
- }
-
-/* ColumnUnit */
- } else if ( nc = 0,
- ( 1 == astSscanf( attrib, PATTERN(columnunit,AST__MXCOLNAMLEN),
- cname, &nc ) ) && ( nc >= len ) ) {
- result = astGetColumnUnit( this, cname );
-
-#undef PATTERN
-
-
-/* Unknown attributes */
-/* ================== */
-
-/* If the attribute name was not recognised, pass it on to the parent
- method for further interpretation. */
- } else {
- result = (*parent_getattrib)( this_object, attrib, status );
- }
-
-/* Return the result. */
- return result;
-}
-
-static int GetColumnLenC( AstTable *this, const char *column, int *status ) {
-/*
-*+
-* Name:
-* astGetColumnLenC
-
-* Purpose:
-* Get the maximum formatted length of any value in a column.
-
-* Type:
-* Protected virtual function.
-
-* Synopsis:
-* #include "table.h"
-* int astGetColumnLenC( AstTable *this, const char *column )
-
-* Class Membership:
-* Table method.
-
-* Description:
-* This function returns the minimum length which a character variable
-* must have in order to be able to store the longest value currently
-* present (at any row) in a specified column of the supplied Table. If
-* the named column holds vector values, then the returned value is
-* the length of the longest element of the vector value.
-
-* Parameters:
-* this
-* Pointer to the Table.
-* column
-* The character string holding the upper-case name of the column.
-* Trailing spaces are ignored. An error is reported if the supplied
-* column is not found in the Table.
-
-* Returned Value:
-* The length (i.e. number of characters) of the longest formatted
-* value associated with the named column. This does not include the
-* trailing null character.
-
-* Notes:
-* - Automatic data type conversion occurs if the named column holds
-* numerical values.
-* - An error will be reported if named column does not exist or cannot
-* be formatted as a character
-* string.
-* - A function value of zero will be returned if an error has already
-* occurred, or if this function should fail for any reason.
-
-*-
-*/
-
-/* Local Variables: */
- AstKeyMap *cols; /* KeyMap holding column definitions */
- char key[ AST__MXCOLKEYLEN ]; /* Current cell key string */
- int irow; /* Current row index */
- int len; /* Length needed to format current cell */
- int nrow; /* Number of rows in table */
- int result; /* Returned value */
-
-/* Initialise */
- result = 0;
-
-/* Check the global error status. */
- if ( !astOK ) return result;
-
-/* Get the KeyMap holding information about all columns. */
- cols = astColumnProps( this );
-
-/* Check the table contains the requested column. */
- if( astMapHasKey( cols, column ) ) {
-
-/* Loop round all rows in the table. */
- nrow = astGetNrow( this );
- for( irow = 1; irow <= nrow; irow++ ) {
-
-/* Format the cell name. */
- sprintf( key, "%.*s(%d)", (int) astChrLen(column), column, irow );
-
-/* Get the maximum length needed to format a string in the current
- row/column. */
- len = astMapLenC( this, key );
-
-/* Return the largest value found for any row. */
- if( len > result ) result = len;
- }
-
-/* Report an error if the column does not exist. */
- } else if( astOK ) {
- astError( AST__BADCOL, "astGetColumnLenC(%s): No column named '%s' "
- "exists in the table.", status, astGetClass( this ), column );
- }
-
-/* Free resources */
- cols = astAnnul( cols );
-
-/* Return AST__BADTYPE if an error occurred. */
- if( !astOK ) result = 0;
-
-/* Return the result. */
- return result;
-}
-
-static int GetColumnLength( AstTable *this, const char *column, int *status ) {
-/*
-*+
-* Name:
-* astGetColumnLength
-
-* Purpose:
-* Get the number of elements in each value in a column.
-
-* Type:
-* Protected virtual function.
-
-* Synopsis:
-* #include "table.h"
-* int astGetColumnLength( AstTable *this, const char *column )
-
-* Class Membership:
-* Table method.
-
-* Description:
-* This function returns the number of elements in each value stored
-* in a named column. Each value can be a scalar (in which case the
-* ColumnLength attribute has a value of 1), or a multi-dimensional
-* array ( in which case the ColumnLength value is equal to the
-* product of the array dimensions).
-
-* Parameters:
-* this
-* Pointer to the Table.
-* column
-* The character string holding the upper-case name of the column.
-* Trailing spaces are ignored. An error is reported if the supplied
-* column is not found in the Table.
-
-* Returned Value:
-* The number of elements in each column value.
-
-* Notes:
-* - An error will be reported if named column does not exist or cannot
-* be formatted as a character
-* string.
-* - A function value of zero will be returned if an error has already
-* occurred, or if this function should fail for any reason.
-
-*-
-*/
-
-/* Local Variables: */
- AstKeyMap *col_km; /* KeyMap holding requested column definition */
- AstKeyMap *cols; /* KeyMap holding all column definitions */
- int *dims; /* Pointer to array holding dimensions */
- int idim; /* Index of dimension */
- int ndim; /* Number of dimensions */
- int result; /* Returned value */
-
-/* Initialise */
- result = 0;
-
-/* Check the global error status. */
- if ( !astOK ) return result;
-
-/* Get the KeyMap holding information about all columns. */
- cols = astColumnProps( this );
-
-/* Get the KeyMap holding information about the requested column. */
- if( astMapGet0A( cols, column, &col_km ) ) {
-
-/* If the Column properties includes the length, return it. Otherwise,
- calculate the length and store it in the KeyMap as a column property. */
- if( ! astMapGet0I( col_km, LENGTH, &result ) ) {
-
-/* Get the number of axes spanned by each column value, and allocate an
- array big enough to hold the dimensions of these axes. */
- ndim = astMapLength( col_km, SHAPE );
- dims = astMalloc( sizeof( int )*ndim );
- if( astOK ) {
-
-/* Get the dimensions. */
- astMapGet1I( col_km, SHAPE, ndim, &ndim, dims );
-
-/* Find the number of elements. */
- result = 1;
- for( idim = 0; idim < ndim; idim++ ) {
- result *= dims[ idim ];
- }
-
-/* Store the result in the column KeyMap. */
- astMapPut0I( col_km, LENGTH, result, NULL );
- }
- dims = astFree( dims );
- }
-
-/* Free resources */
- col_km = astAnnul( col_km );
-
-/* Report an error if the column does not exist. */
- } else if( astOK ) {
- astError( AST__BADCOL, "astGetColumnLength(%s): No column named '%s' "
- "exists in the table.", status, astGetClass( this ), column );
- }
-
-/* Free resources */
- cols = astAnnul( cols );
-
-/* Return AST__BADTYPE if an error occurred. */
- if( !astOK ) result = 0;
-
-/* Return the result. */
- return result;
-}
-
-static int GetColumnNdim( AstTable *this, const char *column, int *status ) {
-/*
-*+
-* Name:
-* astGetColumnNdim
-
-* Purpose:
-* Get the number of dimensions for a column in a Table.
-
-* Type:
-* Protected virtual function.
-
-* Synopsis:
-* #include "table.h"
-* int astGetColumnNdim( AstTable *this, const char *column )
-
-* Class Membership:
-* Table method.
-
-* Description:
-* This function attribute holds the number of axes spanned by each value
-* in a column. If each cell in the column is a scalar, ColumnNdim will
-* be zero. If each cell in the column is a 1D spectrum, ColumnNdim will
-* be one. If each cell in the column is a 2D image, ColumnNdim will be
-* two, etc.
-
-* Parameters:
-* this
-* Pointer to the Table.
-* column
-* The character string holding the upper-case name of the column.
-* Trailing spaces are ignored. An error is reported if the supplied
-* column is not found in the Table.
-
-* Returned Value:
-* The number of dimensions - zero for a scalar.
-
-* Notes:
-* - A function value of zero will be returned if an error has
-* already occurred, or if this function should fail for any reason.
-
-*-
-*/
-
-/* Local Variables: */
- AstKeyMap *cols; /* KeyMap holding column definitions */
- AstKeyMap *col_km; /* Pointer to KeyMap holding column info */
- int result; /* Returned value */
-
-/* Initialise */
- result = 0;
-
-/* Check the global error status. */
- if ( !astOK ) return result;
-
-/* Get the KeyMap holding information about all columns. */
- cols = astColumnProps( this );
-
-/* Get the KeyMap holding information about the requested column. */
- if( astMapGet0A( cols, column, &col_km ) ) {
-
-/* Get the number of dimensions. */
- result = astMapLength( col_km, SHAPE );
-
-/* Free resources */
- col_km = astAnnul( col_km );
-
-/* Report an error if the column does not exist. */
- } else if( astOK ) {
- astError( AST__BADCOL, "astGetColumnNdim(%s): No column named '%s' "
- "exists in the table.", status, astGetClass( this ), column );
- }
- cols = astAnnul( cols );
-
-/* Return AST__BADTYPE if an error occurred. */
- if( !astOK ) result = 0;
-
-/* Return the result. */
- return result;
-}
-
-static int GetColumnType( AstTable *this, const char *column, int *status ) {
-/*
-*+
-* Name:
-* astGetColumnType
-
-* Purpose:
-* Get the data type of a column in a Table.
-
-* Type:
-* Protected virtual function.
-
-* Synopsis:
-* #include "table.h"
-* int astGetColumnType( AstTable *this, const char *column )
-
-* Class Membership:
-* Table method.
-
-* Description:
-* This function returns a value indicating the data type of a
-* named column in a Table. This is the data type which was used
-* when the column was added to the Table using astAddColumn.
-
-* Parameters:
-* this
-* Pointer to the Table.
-* column
-* The character string holding the upper-case name of the column.
-* Trailing spaces are ignored. An error is reported if the supplied
-* column is not found in the Table.
-
-* Returned Value:
-* One of AST__INTTYPE (for integer), AST__SINTTYPE (for short int),
-* AST__BYTETYPE (for unsigned bytes - i.e. unsigned chars),
-* AST__DOUBLETYPE (for double precision floating point),
-* AST__FLOATTYPE (for single precision floating point), AST__STRINGTYPE
-* (for character string), AST__OBJECTTYPE (for AST Object pointer),
-* AST__POINTERTYPE (for arbitrary C pointer) or AST__UNDEFTYPE (for
-* undefined values created by astMapPutU).
-
-* Notes:
-* - A function value of AST__BADTYPE will be returned if an error has
-* already occurred, or if this function should fail for any reason.
-
-*-
-*/
-
-/* Local Variables: */
- AstKeyMap *cols; /* Pointer to KeyMap holding all column info */
- AstKeyMap *col_km; /* Pointer to KeyMap holding requested column info */
- int result; /* Returned value */
-
-/* Initialise */
- result = AST__BADTYPE;
-
-/* Check the global error status. */
- if ( !astOK ) return result;
-
-/* Get the KeyMap holding information about the requested column. */
- cols = astColumnProps( this );
- if( astMapGet0A( cols, column, &col_km ) ) {
-
-/* Get the column data type. */
- (void) astMapGet0I( col_km, TYPE, &result );
-
-/* Annul the KeyMap pointer. */
- col_km = astAnnul( col_km );
-
-/* Report an error if the column does not exist. */
- } else if( astOK ) {
- astError( AST__BADCOL, "astGetColumnType(%s): No column named '%s' "
- "exists in the table.", status, astGetClass( this ), column );
- }
- cols = astAnnul( cols );
-
-/* Return AST__BADTYPE if an error occurred. */
- if( !astOK ) result = AST__BADTYPE;
-
-/* Return the result. */
- return result;
-}
-
-static const char *GetColumnUnit( AstTable *this, const char *column, int *status ) {
-/*
-*+
-* Name:
-* astGetColumnUnit
-
-* Purpose:
-* Get the unit string for a column in a Table.
-
-* Type:
-* Protected virtual function.
-
-* Synopsis:
-* #include "table.h"
-* const char *astGetColumnUnit( AstTable *this, const char *column )
-
-* Class Membership:
-* Table method.
-
-* Description:
-* This function returns the unit string for a named column in a Table.
-* This is the unit string that was provided when the column was added to
-* the Table using astAddColumn.
-
-* Parameters:
-* this
-* Pointer to the Table.
-* column
-* The character string holding the upper-case name of the column.
-* Trailing spaces are ignored. An error is reported if the supplied
-* column is not found in the Table.
-
-* Returned Value:
-* A pointer to a null-terminated string containing the column units.
-
-*-
-*/
-
-/* Local Variables: */
- AstKeyMap *col_km; /* Pointer to KeyMap holding requested column info */
- AstKeyMap *cols; /* Pointer to KeyMap holding all column info */
- const char *result; /* Returned value */
-
-/* Initialise */
- result = NULL;
-
-/* Check the global error status. */
- if ( !astOK ) return result;
-
-/* Get the KeyMap holding information about the requested column. */
- cols = astColumnProps( this );
- if( astMapGet0A( cols, column, &col_km ) ) {
-
-/* Get the column unit string. */
- (void) astMapGet0C( col_km, UNIT, &result );
-
-/* Annul the KeyMap pointer. */
- col_km = astAnnul( col_km );
-
-/* Report an error if the column does not exist. */
- } else if( astOK ) {
- astError( AST__BADCOL, "astGetColumnUnit(%s): No column named '%s' "
- "exists in the table.", status, astGetClass( this ), column );
- }
- cols = astAnnul( cols );
-
-/* Return NULL if an error occurred. */
- if( !astOK ) result = NULL;
-
-/* Return the result. */
- return result;
-}
-
-static int GetNcolumn( AstTable *this, int *status ) {
-/*
-*+
-* Name:
-* astGetNcolumn
-
-* Purpose:
-* Get the number of columns in a Table.
-
-* Type:
-* Protected virtual function.
-
-* Synopsis:
-* #include "table.h"
-* int astGetNcolumn( AstTable *this )
-
-* Class Membership:
-* Table method.
-
-* Description:
-* This function returns the number of columns currently in the Table.
-
-* Parameters:
-* this
-* Pointer to the Table.
-
-* Returned Value:
-* Number of columns.
-
-* Notes:
-* - A value of zero will be returned if this function is invoked
-* with the global error status set, or if it should fail for any
-* reason.
-*-
-*/
-
-/* Local Variables: */
- AstKeyMap *cols;
- int result;
-
-/* Check the global error status. */
- if ( !astOK ) return 0;
-
-/* Get a pointer to the KeyMap holding the column definitions. */
- cols = astColumnProps( this );
-
-/* Get the number of column definitions in the KeyMap. */
- result = astMapSize( cols );
-
-/* Annul the KeyMap pointer. */
- cols = astAnnul( cols );
-
-/* Return the result. */
- return result;
-}
-
-static int GetNparameter( AstTable *this, int *status ) {
-/*
-*+
-* Name:
-* astGetNparameter
-
-* Purpose:
-* Get the number of global parameters in a Table.
-
-* Type:
-* Protected virtual function.
-
-* Synopsis:
-* #include "table.h"
-* int astGetNparameter( AstTable *this )
-
-* Class Membership:
-* Table method.
-
-* Description:
-* This function returns the number of global parameters currently in the Table.
-
-* Parameters:
-* this
-* Pointer to the Table.
-
-* Returned Value:
-* Number of parameters.
-
-* Notes:
-* - A value of zero will be returned if this function is invoked
-* with the global error status set, or if it should fail for any
-* reason.
-*-
-*/
-
-/* Local Variables: */
- AstKeyMap *pars;
- int result;
-
-/* Check the global error status. */
- if ( !astOK ) return 0;
-
-/* Get a pointer to the KeyMap holding the parameter definitions. */
- pars = astParameterProps( this );
-
-/* Get the number of parameter definitions in the KeyMap. */
- result = astMapSize( pars );
-
-/* Annul the KeyMap pointer. */
- pars = astAnnul( pars );
-
-/* Return the result. */
- return result;
-}
-
-static int GetObjSize( AstObject *this_object, int *status ) {
-/*
-* Name:
-* GetObjSize
-
-* Purpose:
-* Return the in-memory size of an Object.
-
-* Type:
-* Private function.
-
-* Synopsis:
-* #include "table.h"
-* int GetObjSize( AstObject *this, int *status )
-
-* Class Membership:
-* Table member function (over-rides the astGetObjSize protected
-* method inherited from the parent class).
-
-* Description:
-* This function returns the in-memory size of the supplied Tables,
-* in bytes.
-
-* Parameters:
-* this
-* Pointer to the Table.
-* status
-* Pointer to the inherited status variable.
-
-* Returned Value:
-* The Table size, in bytes.
-
-* Notes:
-* - A value of zero will be returned if this function is invoked
-* with the global status set, or if it should fail for any reason.
-*/
-
-/* Local Variables: */
- AstKeyMap *km; /* KeyMap holding column/parameter definitions */
- AstTable *this; /* Pointer to Table structure */
- int result; /* Result value to return */
-
-/* Initialise. */
- result = 0;
-
-/* Check the global error status. */
- if ( !astOK ) return result;
-
-/* Obtain a pointers to the Table structure. */
- this = (AstTable *) this_object;
-
-/* Invoke the GetObjSize method inherited from the parent KeyMap class, and
- then add on any components of the class structure defined by this class
- which are stored in dynamically allocated memory. */
- result = (*parent_getobjsize)( this_object, status );
-
- km = astColumnProps( this );
- result += astGetObjSize( km );
- km = astAnnul( km );
-
- km = astParameterProps( this );
- result += astGetObjSize( km );
- km = astAnnul( km );
-
-/* If an error occurred, clear the result value. */
- if ( !astOK ) result = 0;
-
-/* Return the result, */
- return result;
-}
-
-static int HasColumn( AstTable *this, const char *column, int *status ){
-/*
-*++
-* Name:
-c astHasColumn
-f AST_HASCOLUMN
-
-* Purpose:
-* Returns a flag indicating if a column is present in a Table.
-
-* Type:
-* Public virtual function.
-
-* Synopsis:
-c #include "table.h"
-c int astHasColumn( AstTable *this, const char *column )
-f RESULT = AST_HASCOLUMN( THIS, COLUMN, STATUS )
-
-* Class Membership:
-* Table method.
-
-* Description:
-c This function
-f This routine
-* returns a flag indicating if a named column exists in a Table, for
-* instance, by having been added to to the Table using
-c astAddColumn.
-f AST_ADDCOLUMN.
-
-* Parameters:
-c this
-f THIS = INTEGER (Given)
-* Pointer to the Table.
-c column
-f COLUMN = CHARACTER * ( * ) (Given)
-* The character string holding the upper case name of the column. Trailing
-* spaces are ignored.
-f STATUS = INTEGER (Given and Returned)
-f The global status.
-
-* Notes:
-* - A value of
-c zero
-f .FALSE.
-* is returned for if an error occurs.
-
-*--
-*/
-
-/* Local Variables: */
- AstKeyMap *cols;
- int result;
-
-/* Initialise */
- result = 0;
-
-/* Check the inherited status. */
- if( !astOK ) return result;
-
-/* Get the KeyMap holding information about all columns. */
- cols = astColumnProps( this );
-
-/* Seeif it contains an entry for the named column. */
- result = astMapHasKey( cols, column );
-
-/* Free resources. */
- cols = astAnnul( cols );
-
-/* If an error has occurred, return zero. */
- if( !astOK ) result = 0;
- return result;
-}
-
-static int HasParameter( AstTable *this, const char *parameter, int *status ){
-/*
-*++
-* Name:
-c astHasParameter
-f AST_HASPARAMETER
-
-* Purpose:
-* Returns a flag indicating if a named global parameter is present in a Table.
-
-* Type:
-* Public virtual function.
-
-* Synopsis:
-c #include "table.h"
-c int astHasParameter( AstTable *this, const char *parameter )
-f RESULT = AST_HASPARAMETER( THIS, PARAMETER, STATUS )
-
-* Class Membership:
-* Table method.
-
-* Description:
-c This function
-f This routine
-* returns a flag indicating if a named parameter exists in a Table, for
-* instance, by having been added to to the Table using
-c astAddParameter.
-f AST_ADDPARAMETER.
-
-* Parameters:
-c this
-f THIS = INTEGER (Given)
-* Pointer to the Table.
-c parameter
-f PARAMETER = CHARACTER * ( * ) (Given)
-* The character string holding the upper case name of the parameter. Trailing
-* spaces are ignored.
-f STATUS = INTEGER (Given and Returned)
-f The global status.
-
-* Notes:
-* - A value of
-c zero
-f .FALSE.
-* is returned for if an error occurs.
-
-*--
-*/
-
-/* Local Variables: */
- AstKeyMap *pars;
- int result;
-
-/* Initialise */
- result = 0;
-
-/* Check the inherited status. */
- if( !astOK ) return result;
-
-/* Get the KeyMap holding information about all parameters. */
- pars = astParameterProps( this );
-
-/* See if it contains an entry for the named parameter. */
- result = astMapHasKey( pars, parameter );
-
-/* Free resources. */
- pars = astAnnul( pars );
-
-/* If an error has occurred, return zero. */
- if( !astOK ) result = 0;
- return result;
-}
-
-void astInitTableVtab_( AstTableVtab *vtab, const char *name, int *status ) {
-/*
-*+
-* Name:
-* astInitTableVtab
-
-* Purpose:
-* Initialise a virtual function table for a Table.
-
-* Type:
-* Protected function.
-
-* Synopsis:
-* #include "table.h"
-* void astInitTableVtab( AstTableVtab *vtab, const char *name )
-
-* Class Membership:
-* Table vtab initialiser.
-
-* Description:
-* This function initialises the component of a virtual function
-* table which is used by the Table class.
-
-* Parameters:
-* vtab
-* Pointer to the virtual function table. The components used by
-* all ancestral classes will be initialised if they have not already
-* been initialised.
-* name
-* Pointer to a constant null-terminated character string which contains
-* the name of the class to which the virtual function table belongs (it
-* is this pointer value that will subsequently be returned by the Object
-* astClass function).
-*-
-*/
-
-/* Local Variables: */
- astDECLARE_GLOBALS /* Pointer to thread-specific global data */
- AstObjectVtab *object; /* Pointer to Object component of Vtab */
- AstKeyMapVtab *keymap; /* Pointer to KeyMap component of Vtab */
-
-/* Check the local error status. */
- if ( !astOK ) return;
-
-/* Get a pointer to the thread specific global data structure. */
- astGET_GLOBALS(NULL);
-
-/* Initialize the component of the virtual function table used by the
- parent class. */
- astInitKeyMapVtab( (AstKeyMapVtab *) vtab, name );
-
-/* Store a unique "magic" value in the virtual function table. This
- will be used (by astIsATable) to determine if an object belongs
- to this class. We can conveniently use the address of the (static)
- class_check variable to generate this unique value. */
- vtab->id.check = &class_check;
- vtab->id.parent = &(((AstKeyMapVtab *) vtab)->id);
-
-/* Initialise member function pointers. */
-/* ------------------------------------ */
-/* Store pointers to the member functions (implemented here) that provide
- virtual methods for this class. */
- vtab->AddColumn = AddColumn;
- vtab->AddParameter = AddParameter;
- vtab->ColumnName = ColumnName;
- vtab->ParameterName = ParameterName;
- vtab->ColumnProps = ColumnProps;
- vtab->ColumnShape = ColumnShape;
- vtab->GetColumnLenC = GetColumnLenC;
- vtab->GetColumnLength = GetColumnLength;
- vtab->GetColumnNdim = GetColumnNdim;
- vtab->GetColumnType = GetColumnType;
- vtab->GetColumnUnit = GetColumnUnit;
- vtab->GetNcolumn = GetNcolumn;
- vtab->GetNparameter = GetNparameter;
- vtab->GetNrow = GetNrow;
- vtab->HasColumn = HasColumn;
- vtab->HasParameter = HasParameter;
- vtab->ParameterProps = ParameterProps;
- vtab->PurgeRows = PurgeRows;
- vtab->RemoveColumn = RemoveColumn;
- vtab->RemoveParameter = RemoveParameter;
- vtab->RemoveRow = RemoveRow;
- vtab->SetNrow = SetNrow;
-
-/* Save the inherited pointers to methods that will be extended, and
- replace them with pointers to the new member functions. */
- object = (AstObjectVtab *) vtab;
- keymap = (AstKeyMapVtab *) vtab;
-
- parent_equal = object->Equal;
- object->Equal = Equal;
-
- parent_getobjsize = object->GetObjSize;
- object->GetObjSize = GetObjSize;
-
- parent_clearattrib = object->ClearAttrib;
- object->ClearAttrib = ClearAttrib;
-
- parent_getattrib = object->GetAttrib;
- object->GetAttrib = GetAttrib;
-
- parent_setattrib = object->SetAttrib;
- object->SetAttrib = SetAttrib;
-
- parent_testattrib = object->TestAttrib;
- object->TestAttrib = TestAttrib;
-
-#if defined(THREAD_SAFE)
- parent_managelock = object->ManageLock;
- object->ManageLock = ManageLock;
-#endif
-
- parent_mapremove = keymap->MapRemove;
-
-/* Define convenience macros for overriding methods inherited from the
- parent KeyMap class using all data type supported by KeyMap. */
-#define OVERRIDE(method,code,methodlc,codelc) \
- parent_##methodlc##codelc = keymap->method##code; \
- keymap->method##code = method##code; \
-
-#define OVERRIDE_METHOD(method,methodlc) \
- OVERRIDE(method,A,methodlc,a) \
- OVERRIDE(method,P,methodlc,p) \
- OVERRIDE(method,C,methodlc,c) \
- OVERRIDE(method,D,methodlc,d) \
- OVERRIDE(method,F,methodlc,f) \
- OVERRIDE(method,I,methodlc,i) \
- OVERRIDE(method,S,methodlc,s) \
- OVERRIDE(method,B,methodlc,b)
-
-/* Use these macros to override the required methods. */
- OVERRIDE_METHOD(MapPut0,mapput0)
- OVERRIDE_METHOD(MapGet0,mapget0)
- OVERRIDE_METHOD(MapPut1,mapput1)
- OVERRIDE_METHOD(MapGet1,mapget1)
- OVERRIDE_METHOD(MapPutElem,mapputelem)
- OVERRIDE_METHOD(MapGetElem,mapgetelem)
- OVERRIDE(MapPut,U,mapput,u)
- OVERRIDE(SetKeyCase,,setkeycase,)
- OVERRIDE(ClearKeyCase,,clearkeycase,)
-
-/* Remove the macros. */
-#undef OVERRIDE_METHOD
-#undef OVERRIDE
-
-/* Store replacement pointers for methods which will be over-ridden by
- new member functions implemented here. */
-
-/* Declare the copy constructor, destructor and class dump function. */
- astSetCopy( vtab, Copy );
- astSetDelete( vtab, Delete );
- astSetDump( vtab, Dump, "Table", "Two-dimensional table of data values" );
-
-/* If we have just initialised the vtab for the current class, indicate
- that the vtab is now initialised, and store a pointer to the class
- identifier in the base "object" level of the vtab. */
- if( vtab == &class_vtab ) {
- class_init = 1;
- astSetVtabClassIdentifier( vtab, &(vtab->id) );
- }
-}
-
-#if defined(THREAD_SAFE)
-static int ManageLock( AstObject *this_object, int mode, int extra,
- AstObject **fail, int *status ) {
-/*
-* Name:
-* ManageLock
-
-* Purpose:
-* Manage the thread lock on an Object.
-
-* Type:
-* Private function.
-
-* Synopsis:
-* #include "object.h"
-* AstObject *ManageLock( AstObject *this, int mode, int extra,
-* AstObject **fail, int *status )
-
-* Class Membership:
-* Table member function (over-rides the astManageLock protected
-* method inherited from the parent class).
-
-* Description:
-* This function manages the thread lock on the supplied Object. The
-* lock can be locked, unlocked or checked by this function as
-* deteremined by parameter "mode". See astLock for details of the way
-* these locks are used.
-
-* Parameters:
-* this
-* Pointer to the Object.
-* mode
-* An integer flag indicating what the function should do:
-*
-* AST__LOCK: Lock the Object for exclusive use by the calling
-* thread. The "extra" value indicates what should be done if the
-* Object is already locked (wait or report an error - see astLock).
-*
-* AST__UNLOCK: Unlock the Object for use by other threads.
-*
-* AST__CHECKLOCK: Check that the object is locked for use by the
-* calling thread (report an error if not).
-* extra
-* Extra mode-specific information.
-* fail
-* If a non-zero function value is returned, a pointer to the
-* Object that caused the failure is returned at "*fail". This may
-* be "this" or it may be an Object contained within "this". Note,
-* the Object's reference count is not incremented, and so the
-* returned pointer should not be annulled. A NULL pointer is
-* returned if this function returns a value of zero.
-* status
-* Pointer to the inherited status variable.
-
-* Returned Value:
-* A local status value:
-* 0 - Success
-* 1 - Could not lock or unlock the object because it was already
-* locked by another thread.
-* 2 - Failed to lock a POSIX mutex
-* 3 - Failed to unlock a POSIX mutex
-* 4 - Bad "mode" value supplied.
-
-* Notes:
-* - This function attempts to execute even if an error has already
-* occurred.
-*/
-
-/* Local Variables: */
- AstTable *this; /* Pointer to Table structure */
- int result; /* Returned status value */
-
-/* Initialise */
- result = 0;
-
-/* Check the supplied pointer is not NULL. */
- if( !this_object ) return result;
-
-/* Obtain a pointers to the Table structure. */
- this = (AstTable *) this_object;
-
-/* Invoke the ManageLock method inherited from the parent class. */
- if( !result ) result = (*parent_managelock)( this_object, mode, extra,
- fail, status );
-
-/* Invoke the astManageLock method on any Objects contained within
- the supplied Object. */
- if( !result && this->columns ) result = astManageLock( this->columns, mode, extra,
- fail );
-
- if( !result && this->parameters ) result = astManageLock( this->parameters, mode, extra,
- fail );
-
-/* Return the result. */
- return result;
-}
-#endif
-
-/*
-* Name:
-* MapGet0<X>
-
-* Purpose:
-* Get a scalar value from a cell of a Table.
-
-* Type:
-* Private function.
-
-* Synopsis:
-* #include "table.h"
-* int MapGet0<X>( AstKeyMap *this, const char *key, <X>type *value );
-
-* Class Membership:
-* Table member function (over-rides the astMapGet0<X> method inherited
-* from the KeyMap class).
-
-* Description:
-* This is a set of functions for retrieving a scalar value from a
-* cell of a Table. You should replace <X> in the generic function name
-* MapGet0<X> by an appropriate 1-character type code (see the "Data
-* Type Codes" section in the astMapGet0<X> docs). The stored value is
-* converted to the data type indiced by <X> before being returned (an
-* error is reported if it is not possible to convert the stored value
-* to the requested data type).
-
-* Parameters:
-* this
-* Pointer to the Table.
-* key
-* A character string identifying the cell from which the value is
-* to be retrieved. It should have the form "COLNAME(irow)", where
-* "COLNAME" is replaced by the name of a column that has been
-* defined previously using the astAddColumn method, and "irow" is
-* an integer row index (the first row is row 1).
-* value
-* A pointer to a buffer in which to return the requested value.
-* If the requested cell is not found, or if it is found but has an
-* undefined value (see astMapPutU), then the contents of the buffer
-* on entry to this function will be unchanged on exit. For pointer
-* types ("A" and "C"), the buffer should be a suitable pointer, and
-* the address of this pointer should be supplied as the "value"
-* parameter.
-* status
-* Pointer to inherited status value.
-
-* Returned Value:
-* A non-zero value is returned if the requested key name was found, and
-* does not have an undefined value (see astMapPutU). Zero is returned
-* otherwise.
-
-* Notes:
-* - No error is reported if the requested cell cannot be found in the
-* given KeyMap, but a zero value will be returned as the function value.
-* The supplied buffer will be returned unchanged.
-* - Key names are case insensitive, and white space is considered
-* significant.
-* - If the stored value is a vector value, then the first value in
-* the vector will be returned.
-* - A string pointer returned by astMapGet0C is guaranteed to remain
-* valid and the string to which it points will not be over-written for
-* a total of 50 successive invocations of this function. After this,
-* the memory containing the string may be re-used, so a copy of
-* the string should be made if it is needed for longer than this.
-* - If the returned value is an AST Object pointer, the Object's reference
-* count is incremented by this call. Any subsequent changes made to
-* the Object using the returned pointer will be reflected in any
-* any other active pointers for the Object. The returned pointer
-* should be annulled using astAnnul when it is no longer needed.
-*/
-
-/* Define a macro to implement the function for a specific data type. */
-#define MAKE_MAPGET0(X,Xlc,Xtype,Itype) \
-static int MapGet0##X( AstKeyMap *this_keymap, const char *key, Xtype *value, \
- int *status ) { \
-\
-/* Local Variables: */ \
- AstTable *this; /* Pointer to Table structure */ \
- char colname[ AST__MXCOLNAMLEN + 1 ]; /* Column name read from string */ \
- int irow; /* Row index within key string */ \
- int result; /* Returned flag */ \
-\
-/* Initialise */ \
- result = 0; \
-\
-/* Check the global error status. */ \
- if ( !astOK ) return result; \
-\
-/* Get a pointer to the Table structure. */ \
- this = (AstTable *) this_keymap; \
-\
-/* If the key is the name of a global table parameter, use the parent \
- method to get the value of hte parameter. */ \
- if( astHasParameter( this, key ) ) { \
- result = (*parent_mapget0##Xlc)( this_keymap, key, value, status ); \
-\
-/* Check the supplied key looks like a table cell key, and get the \
- the column name and the row number. Also checks that the table \
- contains a column with the specified name. */ \
- } else if( ParseKey( this, key, astGetKeyError( this ), colname, &irow, \
- NULL, "astMapGet0" #X, status ) ) { \
-\
-/* If the row index is larger than the current number of rows in the \
- table, do nothing more. */ \
- if( irow <= astGetNrow( this ) ){ \
-\
-/* Use the astMapGet0<X> method in the parent keyMap class to get the \
- cell contents. */ \
- result = (*parent_mapget0##Xlc)( this_keymap, key, value, status ); \
- } \
- } \
-\
-/* If an error occurred, return zero. */ \
- if( !astOK ) result = 0; \
-\
-/* Return the result.*/ \
- return result; \
-}
-
-/* Expand the above macro to generate a function for each required
- data type. */
-MAKE_MAPGET0(I,i,int,AST__INTTYPE)
-MAKE_MAPGET0(D,d,double,AST__DOUBLETYPE)
-MAKE_MAPGET0(F,f,float,AST__FLOATTYPE)
-MAKE_MAPGET0(C,c,const char *,AST__STRINGTYPE)
-MAKE_MAPGET0(A,a,AstObject *,AST__OBJECTTYPE)
-MAKE_MAPGET0(P,p,void *,AST__POINTERTYPE)
-MAKE_MAPGET0(S,s,short int,AST__SINTTYPE)
-MAKE_MAPGET0(B,b,unsigned char,AST__BYTETYPE)
-
-/* Undefine the macro. */
-#undef MAKE_MAPGET0
-
-/*
-* Name:
-* MapGet1<X>
-
-* Purpose:
-* Get a vector value from a cell of a Table.
-
-* Type:
-* Private function.
-
-* Synopsis:
-* #include "table.h"
-* int MapGet1<X>( AstKeyMap *this, const char *key, int mxval,
-* int *nval, <X>type *value )
-* int MapGet1C( AstKeyMap *this, const char *key, int l, int mxval,
-* int *nval, const char *value )
-
-* Class Membership:
-* Table member function (over-rides the astMapGet1<X> method inherited
-* from the KeyMap class).
-
-* Description:
-* This is a set of functions for retrieving a vector value from a
-* cell of a Table. You should replace <X> in the generic function name
-* MapGet1<X> by an appropriate 1-character type code (see the "Data
-* Type Codes" section in the astMapGet1<X> docs). The stored value is
-* converted to the data type indiced by <X> before being returned (an
-* error is reported if it is not possible to convert the stored value
-* to the requested data type).
-*
-* Note, the MapGet1C function has an extra parameter "l" which
-* specifies the maximum length of each string to be stored in the
-* "value" buffer (see the "astMapGet1C" docs).
-
-* Parameters:
-* this
-* Pointer to the Table.
-* key
-* A character string identifying the cell from which the value is
-* to be retrieved. It should have the form "COLNAME(irow)", where
-* "COLNAME" is replaced by the name of a column that has been
-* defined previously using the astAddColumn method, and "irow" is
-* an integer row index (the first row is row 1).
-* mxval
-* The number of elements in the "value" array.
-* nval
-* The address of an integer in which to put the number of elements
-* stored in the "value" array. Any unused elements of the array are
-* left unchanged.
-* value
-* A pointer to an array in which to return the requested values.
-* If the requested cell is not found, or if it is found but has an
-* undefined value (see astMapPutU), then the contents of the buffer
-* on entry to this function will be unchanged on exit.
-* status
-* Pointer to inherited status value.
-
-* Returned Value:
-* A non-zero value is returned if the requested key name was found, and
-* does not have an undefined value (see astMapPutU). Zero is returned
-* otherwise.
-
-* MapGet1C:
-* The "value" buffer supplied to the MapGet1C function should be a
-* pointer to a character array with "mxval*l" elements, where "l" is
-* the maximum length of a string to be returned. The value of "l"
-* should be supplied as an extra parameter following "key" when
-* invoking MapGet1C, and should include space for a terminating
-* null character.
-
-* Notes:
-* - No error is reported if the requested cell cannot be found in the
-* given KeyMap, but a zero value will be returned as the function value.
-* The supplied buffer will be returned unchanged.
-* - Key names are case insensitive, and white space is considered
-* significant.
-* - If the stored value is a scalar value, then the value will be
-* returned in the first element of the supplied array, and "nval"
-* will be returned set to 1.
-*/
-
-/* Define a macro to implement the function for a specific data type
- (excluding "C" since that needs an extra parameter). */
-#define MAKE_MAPGET1(X,Xlc,Xtype,Itype) \
-static int MapGet1##X( AstKeyMap *this_keymap, const char *key, int mxval, int *nval, \
- Xtype *value, int *status ) { \
-\
-/* Local Variables: */ \
- AstTable *this; /* Pointer to Table structure */ \
- char colname[ AST__MXCOLNAMLEN + 1 ]; /* Column name read from string */ \
- int irow; /* Row index within key string */ \
- int result; /* Returned flag */ \
-\
-/* Initialise */ \
- result = 0; \
-\
-/* Check the global error status. */ \
- if ( !astOK ) return result; \
-\
-/* Get a pointer to the Table structure. */ \
- this = (AstTable *) this_keymap; \
-\
-/* If the key is the name of a global table parameter, use the parent \
- method to get the value of hte parameter. */ \
- if( astHasParameter( this, key ) ) { \
- result = (*parent_mapget1##Xlc)( this_keymap, key, mxval, nval, \
- value, status ); \
-\
-/* Check the supplied key looks like a table cell key, and get the \
- the column name and the row number. Also checks that the table \
- contains a column with the specified name. */ \
- } else if( ParseKey( this, key, astGetKeyError( this ), colname, &irow, \
- NULL, "astMapGet1" #X, status ) ) { \
-\
-/* If the row index is larger than the current number of rows in the \
- table, do nothing more. */ \
- if( irow <= astGetNrow( this ) ){ \
-\
-/* Use the astMapGet1<X> method in the parent keyMap class to get the \
- cell contents. */ \
- result = (*parent_mapget1##Xlc)( this_keymap, key, mxval, nval, \
- value, status ); \
- } \
- } \
-\
-/* If an error occurred, return zero. */ \
- if( !astOK ) result = 0; \
-\
-/* Return the result.*/ \
- return result; \
-}
-
-/* Expand the above macro to generate a function for each required
- data type. */
-MAKE_MAPGET1(I,i,int,AST__INTTYPE)
-MAKE_MAPGET1(D,d,double,AST__DOUBLETYPE)
-MAKE_MAPGET1(F,f,float,AST__FLOATTYPE)
-MAKE_MAPGET1(A,a,AstObject *,AST__OBJECTTYPE)
-MAKE_MAPGET1(P,p,void *,AST__POINTERTYPE)
-MAKE_MAPGET1(S,s,short int,AST__SINTTYPE)
-MAKE_MAPGET1(B,b,unsigned char,AST__BYTETYPE)
-
-/* Undefine the macro. */
-#undef MAKE_MAPGET1
-
-
-static int MapGet1C( AstKeyMap *this_keymap, const char *key, int l, int mxval,
- int *nval, char *value, int *status ) {
-/*
-* Name:
-* MapGet1C
-
-* Purpose:
-* Get a vector value from a cell of a Table.
-
-* Type:
-* Private function.
-
-* Synopsis:
-* #include "table.h"
-* int MapGet1C( AstKeyMap *this, const char *key, int l, int mxval,
-* int *nval, const char *value )
-
-* Class Membership:
-* Table member function (over-rides the astMapGet1C method inherited
-* from the KeyMap class).
-
-* Description:
-* This is the implementation of MapGet1<X> for <X> = "C". We
-* cannot use the MAKE_MAPGET1 macro for this because the string
-* version of this function has an extra parameter giving the maximum
-* length of each string which can be stored in the supplied buffer.
-
-* Parameters:
-* (see MapGet1<X>)
-*/
-
-/* Local Variables: */
- AstTable *this; /* Pointer to Table structure */
- char colname[ AST__MXCOLNAMLEN + 1 ]; /* Column name read from string */
- int irow; /* Row index within key string */
- int result; /* Returned flag */
-
-/* Initialise */
- result = 0;
-
-/* Check the global error status. */
- if ( !astOK ) return result;
-
-/* Get a pointer to the Table structure. */
- this = (AstTable *) this_keymap;
-
-/* If the key is the name of a global table parameter, use the parent
- method to get the value of hte parameter. */
- if( astHasParameter( this, key ) ) {
- result = (*parent_mapget1c)( this_keymap, key, l, mxval, nval,
- value, status );
-
-/* Check the supplied key looks like a table cell key, and get the
- the column name and the row number. Also checks that the table
- contains a column with the specified name. */
- } else if( ParseKey( this, key, astGetKeyError( this ), colname, &irow,
- NULL, "astMapGet1C", status ) ) {
-
-/* If the row index is larger than the current number of rows in the
- table, do nothing more. */
- if( irow <= astGetNrow( this ) ){
-
-/* Use the astMapGet1<X> method in the parent keyMap class to get the
- cell contents. */
- result = (*parent_mapget1c)( this_keymap, key, l, mxval, nval,
- value, status );
- }
- }
-
-/* If an error occurred, return zero. */
- if( !astOK ) result = 0;
-
-/* Return the result.*/
- return result;
-}
-
-/*
-* Name:
-* MapGetElem<X>
-
-* Purpose:
-* Get a single element of a vector value from a cell of a Table.
-
-* Type:
-* Private function.
-
-* Synopsis:
-* #include "table.h"
-* int MapGetElem<X>( AstKeyMap *this, const char *key, int elem,
-* <X>type *value, int *status )
-* int MapGetElemC( AstKeyMap *this, const char *key, int l, int elem,
-* char *value, int *status )
-
-* Class Membership:
-* Table member function (over-rides the astMapGetElem<X> method inherited
-* from the KeyMap class).
-
-* Description:
-* This is a set of functions for retrieving a single element of a vector
-* value from a cell of a Table. You should replace <X> in the generic
-* function name MapGetElem<X> by an appropriate 1-character type code
-* (see the "Data Type Codes" section in the astMapGetElem<X> docs). The
-* stored value is converted to the data type indiced by <X> before being
-* returned (an error is reported if it is not possible to convert the
-* stored value to the requested data type).
-*
-* Note, the MapGetElemC function has an extra parameter "l" which
-* specifies the maximum length of each string to be stored in the
-* "value" buffer (see the "MapGetElemC" docs).
-
-* Parameters:
-* this
-* Pointer to the Table.
-* key
-* A character string identifying the cell from which the value is
-* to be retrieved. It should have the form "COLNAME(irow)", where
-* "COLNAME" is replaced by the name of a column that has been
-* defined previously using the astAddColumn method, and "irow" is
-* an integer row index (the first row is row 1).
-* elem
-* The index of the vector element to modify, starting at zero.
-* If the index is outside the range of the vector, an error will
-* be reported.
-* value
-* A pointer to a buffer in which to return the requested values.
-* If the requested cell is not found, or if it is found but has an
-* undefined value (see astMapPutU), then the contents of the buffer
-* on entry to this function will be unchanged on exit.
-* status
-* Pointer to inherited status value.
-
-* Returned Value:
-* A non-zero value is returned if the requested key name was found, and
-* does not have an undefined value (see astMapPutU). Zero is returned
-* otherwise.
-
-* MapGetElemC:
-* The "value" buffer supplied to the MapGetElemC function should be a
-* pointer to a character array with "l" elements, where "l" is
-* the maximum length of a string to be returned. The value of "l"
-* should be supplied as an extra parameter following "key" when
-* invoking MapGetElemC, and should include space for a terminating
-* null character.
-
-* Notes:
-* - No error is reported if the requested cell cannot be found in the
-* given KeyMap, but a zero value will be returned as the function value.
-* The supplied buffer will be returned unchanged.
-* - Key names are case insensitive, and white space is considered
-* significant.
-* - If the stored value is a scalar value, then the value will be
-* returned in the first element of the supplied array, and "nval"
-* will be returned set to 1.
-*/
-
-/* Define a macro to implement the function for a specific data type
-(excluding "C" since that needs an extra parameter). */
-#define MAKE_MAPGETELEM(X,Xlc,Xtype,Itype) \
-static int MapGetElem##X( AstKeyMap *this_keymap, const char *key, int elem, \
- Xtype *value, int *status ) { \
-\
-/* Local Variables: */ \
- AstTable *this; /* Pointer to Table structure */ \
- char colname[ AST__MXCOLNAMLEN + 1 ]; /* Column name read from string */ \
- int irow; /* Row index within key string */ \
- int result; /* Returned flag */ \
-\
-/* Initialise */ \
- result = 0; \
-\
-/* Check the global error status. */ \
- if ( !astOK ) return result; \
-\
-/* Get a pointer to the Table structure. */ \
- this = (AstTable *) this_keymap; \
-\
-/* If the key is the name of a global table parameter, use the parent \
- method to get the value of hte parameter. */ \
- if( astHasParameter( this, key ) ) { \
- result = (*parent_mapgetelem##Xlc)( this_keymap, key, elem, \
- value, status ); \
-\
-/* Check the supplied key looks like a table cell key, and get the \
- the column name and the row number. Also checks that the table \
- contains a column with the specified name. */ \
- } else if( ParseKey( this, key, astGetKeyError( this ), colname, &irow, \
- NULL, "astMapGetElem" #X, status ) ) { \
-\
-/* If the row index is larger than the current number of rows in the \
- table, do nothing more. */ \
- if( irow <= astGetNrow( this ) ){ \
-\
-/* Use the astMapGetElem<X> method in the parent keyMap class to get the \
- cell contents. */ \
- result = (*parent_mapgetelem##Xlc)( this_keymap, key, elem, \
- value, status ); \
- } \
- } \
-\
-/* If an error occurred, return zero. */ \
- if( !astOK ) result = 0; \
-\
-/* Return the result.*/ \
- return result; \
-}
-
-/* Expand the above macro to generate a function for each required
- data type. */
-MAKE_MAPGETELEM(I,i,int,AST__INTTYPE)
-MAKE_MAPGETELEM(D,d,double,AST__DOUBLETYPE)
-MAKE_MAPGETELEM(F,f,float,AST__FLOATTYPE)
-MAKE_MAPGETELEM(A,a,AstObject *,AST__OBJECTTYPE)
-MAKE_MAPGETELEM(P,p,void *,AST__POINTERTYPE)
-MAKE_MAPGETELEM(S,s,short int,AST__SINTTYPE)
-MAKE_MAPGETELEM(B,b,unsigned char,AST__BYTETYPE)
-
-/* Undefine the macro. */
-#undef MAKE_MAPGETELEM
-
-static int MapGetElemC( AstKeyMap *this_keymap, const char *key, int l,
- int elem, char *value, int *status ) {
-/*
-* Name:
-* MapGetElemC
-
-* Purpose:
-* Get a single element of a vector value from a cell of a Table.
-
-* Type:
-* Private function.
-
-* Synopsis:
-* #include "table.h"
-* int MapGetElemC( AstKeyMap *this, const char *key, int l, int elem,
-* char *value, int *status )
-
-* Class Membership:
-* Table member function (over-rides the astMapGetElemC method inherited
-* from the KeyMap class).
-
-* Description:
-* This is the implementation of MapGetElem<X> for <X> = "C". We
-* cannot use the MAKE_MAPGETELEM macro for this because the string
-* version of this function has an extra parameter giving the maximum
-* length of each string which can be stored in the supplied buffer.
-
-* Parameters:
-* (see MapGetElem<X>)
-*/
-
-/* Local Variables: */
- AstTable *this; /* Pointer to Table structure */
- char colname[ AST__MXCOLNAMLEN + 1 ]; /* Column name read from string */
- int irow; /* Row index within key string */
- int result; /* Returned flag */
-
-/* Initialise */
- result = 0;
-
-/* Check the global error status. */
- if ( !astOK ) return result;
-
-/* Get a pointer to the Table structure. */
- this = (AstTable *) this_keymap;
-
-/* If the key is the name of a global table parameter, use the parent
- method to get the value of hte parameter. */
- if( astHasParameter( this, key ) ) {
- result = (*parent_mapgetelemc)( this_keymap, key, l, elem,
- value, status );
-
-/* Check the supplied key looks like a table cell key, and get the
- the column name and the row number. Also checks that the table
- contains a column with the specified name. */
- } else if( ParseKey( this, key, astGetKeyError( this ), colname, &irow,
- NULL, "astMapGetElemC", status ) ) {
-
-/* If the row index is larger than the current number of rows in the
- table, do nothing more. */
- if( irow <= astGetNrow( this ) ){
-
-/* Use the astMapGetElem<X> method in the parent keyMap class to get the
- cell contents. */
- result = (*parent_mapgetelemc)( this_keymap, key, l, elem,
- value, status );
- }
- }
-
-/* If an error occurred, return zero. */
- if( !astOK ) result = 0;
-
-/* Return the result.*/
- return result;
-}
-
-/*
-* Name:
-* MapPut0<X>
-
-* Purpose:
-* Stores a scalar value in a cell of a Table.
-
-* Type:
-* Private function.
-
-* Synopsis:
-* #include "table.h"
-* void MapPut0<X>( AstKeyMap *this, const char *key, <X>type value,
-* const char *comment, int *status )
-
-* Class Membership:
-* Table member function (over-rides the astMapPut0<X> method inherited
-* from the KeyMap class).
-
-* Description:
-* This is a set of functions for storing a scalar value in a cell of
-* a Table. You should use a function which matches the data type of the
-* data you wish to add to the Table by replacing <X> in the generic
-* function name MapPut0<X> by an appropriate 1-character type code (see
-* the "Data Type Codes" section in the astMapPut0<X> docs).
-
-* Parameters:
-* this
-* Pointer to the Table in which to store the supplied value.
-* key
-* A character string identifying the cell in which the value is
-* to be stored. It should have the form "COLNAME(irow)", where
-* "COLNAME" is replaced by the name of a column that has been
-* defined previously using the astAddColumn method, and "irow" is
-* an integer row index (the first row is row 1).
-* value
-* The value to be stored. The data type of this value should match
-* the 1-character type code appended to the function name (e.g. if
-* you are using astMapPut0A, the type of this value should be "pointer
-* to AstObject"). An error will be reported if this data type is
-* different to the data type assigned to the column when it was
-* created via astAddColumn.
-* comment
-* A pointer to a null-terminated comment string to be stored with the
-* value. A NULL pointer may be supplied, in which case no comment is
-* stored.
-* status
-* Pointer to inherited status value.
-
-* Notes:
-* - Key names are case insensitive, and white space is considered
-* significant.
-* - The new value will replace any old value already stored in the
-* Table for the specified cell.
-* - If the stored value is an AST Object pointer, the Object's reference
-* count is incremented by this call. Any subsequent changes made to
-* the Object using the returned pointer will be reflected in any
-* any other active pointers for the Object, including any obtained
-* later using astMapget0A. The reference count for the Object will be
-* decremented when the KeyMap is destroyed, or the entry is removed or
-* over-written with a different pointer.
-
-*/
-/* Define a macro to implement the function for a specific data type. */
-#define MAKE_MAPPUT0(X,Xlc,Xtype,Itype,ValExp) \
-static void MapPut0##X( AstKeyMap *this_keymap, const char *key, Xtype value, \
- const char *comment, int *status ) { \
-\
-/* Local Variables: */ \
- AstKeyMap *col_km; /* KeyMap holding details of the requested column */ \
- AstTable *this; /* Pointer to Table structure */ \
- char colname[ AST__MXCOLNAMLEN + 1 ]; /* Column name read from string */ \
- int irow; /* Row index within key string */ \
- int type; /* Data type of the requested column */ \
-\
-/* Check the global error status. */ \
- if ( !astOK ) return; \
-\
-/* Get a pointer to the Table structure. */ \
- this = (AstTable *) this_keymap; \
-\
-/* If the key is the name of a global table parameter, use the parent \
- method to put the value of the parameter. */ \
- if( astHasParameter( this, key ) ) { \
- (*parent_mapput0##Xlc)( this_keymap, key, value, comment, status ); \
-\
-/* Check the supplied key looks like a table cell key, and get the \
- the column name and the row number. Also checks that the table \
- contains a column with the specified name. */ \
- } else if( ParseKey( this, key, 1, colname, &irow, &col_km, "astMapPut0" #X, \
- status ) ) { \
-\
-/* Check the column holds scalar values of the type implied by the <X> \
- code in the function name. */ \
- (void) astMapGet0I( col_km, TYPE, &type ); \
- if( type != Itype && astOK ) { \
- astError( AST__BADTYP, "astMapPut0" #X "(%s): Failed to store a " \
- #Xtype " value for cell \"%s\": column %s holds %s " \
- "values.", status, astGetClass( this ), key, colname, \
- TypeString( type ) ); \
- } \
-\
- if( astMapHasKey( col_km, SHAPE ) && astOK ) { \
- astError( AST__BADTYP, "astMapPut0" #X "(%s): Failed to store a " \
- "scalar value for cell \"%s\": column %s holds vector " \
- " values.", status, astGetClass( this ), key, colname ); \
- } \
-\
-/* If the row index is larger than the current number of rows in the \
- table, update the number of rows in the table. */ \
- if( irow > astGetNrow( this ) ) astSetNrow( this, irow ); \
-\
-/* Use the astMapPut0<X> method in the parent keyMap class to store the \
- new cell contents. */ \
- (*parent_mapput0##Xlc)( this_keymap, key, value, comment, status ); \
-\
-/* Free resources. */ \
- col_km = astAnnul( col_km ); \
- } \
-}
-
-/* Expand the above macro to generate a function for each required
- data type. */
-MAKE_MAPPUT0(I,i,int,AST__INTTYPE,value)
-MAKE_MAPPUT0(D,d,double,AST__DOUBLETYPE,value)
-MAKE_MAPPUT0(F,f,float,AST__FLOATTYPE,value)
-MAKE_MAPPUT0(C,c,const char *,AST__STRINGTYPE,astStore(NULL,value,strlen(value)+1))
-MAKE_MAPPUT0(A,a,AstObject *,AST__OBJECTTYPE,(value?astClone(value):NULL))
-MAKE_MAPPUT0(P,p,void *,AST__POINTERTYPE,value)
-MAKE_MAPPUT0(S,s,short int,AST__SINTTYPE,value)
-MAKE_MAPPUT0(B,b,unsigned char,AST__BYTETYPE,value)
-
-/* Undefine the macro. */
-#undef MAKE_MAPPUT0
-
-/*
-* Name:
-* MapPut1<X>
-
-* Purpose:
-* Stores a vectorised value in a cell of a Table.
-
-* Type:
-* Private function.
-
-* Synopsis:
-* #include "table.h"
-* void MapPut1<X>( AstKeyMap *this, const char *key, int size,
-* const <X>type value[], const char *comment,
-* int *status );
-
-* Class Membership:
-* Table member function (over-rides the astMapPut1<X> method inherited
-* from the KeyMap class).
-
-* Description:
-* This is a set of functions for storing a vectorised value in a cell of
-* a Table. You should use a function which matches the data type of the
-* data you wish to add to the Table by replacing <X> in the generic
-* function name MapPut1<X> by an appropriate 1-character type code (see
-* the "Data Type Codes" section in the astMapPut1<X> docs).
-
-* Parameters:
-* this
-* Pointer to the Table in which to store the supplied value.
-* key
-* A character string identifying the cell in which the value is
-* to be stored. It should have the form "COLNAME(irow)", where
-* "COLNAME" is replaced by the name of a column that has been
-* defined previously using the astAddColumn method, and "irow" is
-* an integer row index (the first row is row 1).
-* size
-* The number of elements in the supplied array of values.
-* value
-* The value to be stored. The data type of this value should match
-* the 1-character type code appended to the function name (e.g. if
-* you are using astMapPut0A, the type of this value should be "pointer
-* to AstObject"). An error will be reported if this data type is
-* different to the data type assigned to the column when it was
-* created via astAddColumn.
-* comment
-* A pointer to a null-terminated comment string to be stored with the
-* value. A NULL pointer may be supplied, in which case no comment is
-* stored.
-* status
-* Pointer to inherited status value.
-
-* Notes:
-* - Key names are case insensitive, and white space is considered
-* significant.
-* - The new value will replace any old value already stored in the
-* Table for the specified cell.
-
-*/
-
-/* Define a macro to implement the function for a specific data type. */
-#define MAKE_MAPPUT1(X,Xlc,Xtype,Itype,ValExp) \
-static void MapPut1##X( AstKeyMap *this_keymap, const char *key, int size, \
- Xtype value[], const char *comment, \
- int *status ) { \
-\
-/* Local Variables: */ \
- AstTable *this; /* Pointer to Table structure */ \
- char colname[ AST__MXCOLNAMLEN + 1 ]; /* Column name read from string */ \
- int irow; /* Row index within key string */ \
-\
-/* Check the global error status. */ \
- if ( !astOK ) return; \
-\
-/* Get a pointer to the Table structure. */ \
- this = (AstTable *) this_keymap; \
-\
-/* If the key is the name of a global table parameter, use the parent \
- method to put the value of the parameter. */ \
- if( astHasParameter( this, key ) ) { \
- (*parent_mapput1##Xlc)( this_keymap, key, size, value, \
- comment, status ); \
-\
-/* Check the supplied key looks like a table cell key, and get the \
- the column name and the row number. Also checks that the table \
- contains a column with the specified name. */ \
- } else if( ParseKey( this, key, 1, colname, &irow, NULL, "astMapPut1" #X, \
- status ) ) { \
-\
-/* Check the column holds vector values of the type implied by the <X> \
- code in the function name. */ \
- if( astGetColumnType( this, colname ) != Itype && astOK ) { \
- astError( AST__BADTYP, "astMapPut1" #X "(%s): Failed to store " \
- #Xtype " values for cell \"%s\": column %s holds %s values.", \
- status, astGetClass( this ), key, colname, \
- TypeString( astGetColumnType( this, colname ) ) ); \
- } \
-\
-/* Check the column holds vectors with length equal to the supplied vector. */ \
- if( astGetColumnLength( this, colname ) != size && astOK ) { \
- astError( AST__BADTYP, "astMapPut1" #X "(%s): Failed to " \
- "store a vector value for cell \"%s\": column " \
- "%s needs %d values per cell but %d were supplied.", \
- status, astGetClass( this ), key, colname, \
- astGetColumnLength( this, colname ), size ); \
- } \
-\
-/* If all is OK, update the number of rows in the table if required, and \
- store the vector in the parent KeyMap. */ \
- if( astOK ) { \
- if( irow > astGetNrow( this ) ) astSetNrow( this, irow ); \
- (*parent_mapput1##Xlc)( this_keymap, key, size, value, \
- comment, status ); \
- } \
-\
- } \
-}
-
-/* Expand the above macro to generate a function for each required
- data type. */
-MAKE_MAPPUT1(D,d,const double,AST__DOUBLETYPE,value[i])
-MAKE_MAPPUT1(F,f,const float,AST__FLOATTYPE,value[i])
-MAKE_MAPPUT1(I,i,const int,AST__INTTYPE,value[i])
-MAKE_MAPPUT1(C,c,const char *const,AST__STRINGTYPE,astStore(NULL,value[i],strlen(value[i])+1))
-MAKE_MAPPUT1(A,a,AstObject *const,AST__OBJECTTYPE,(value[i]?astClone(value[i]):NULL))
-MAKE_MAPPUT1(P,p,void *const,AST__POINTERTYPE,value[i])
-MAKE_MAPPUT1(S,s,const short int,AST__SINTTYPE,value[i])
-MAKE_MAPPUT1(B,b,const unsigned char,AST__BYTETYPE,value[i])
-
-/* Undefine the macro. */
-#undef MAKE_MAPPUT1
-
-/*
-* Name:
-* MapPutElem<X>
-
-* Purpose:
-* Put a value into an element of a vector value in a cell of a Table.
-
-* Type:
-* Private function.
-
-* Synopsis:
-* #include "table.h"
-* void MapPutElem<X>( AstKeyMap *this, const char *key, int elem,
-* <X>type *value, int *status )
-
-* Class Membership:
-* Table member function (over-rides the astMapPutElem<X> method inherited
-* from the KeyMap class).
-
-* Description:
-* This is a set of functions for storing a value in a single element
-* of a vector value stored in a cell of a Table. You should use a
-* function which matches the data type of the data you wish to add to
-* the Table by replacing <X> in the generic function name MapPutElem<X>
-* by an appropriate 1-character type code (see the "Data Type Codes"
-* section in the astMapPutElem<X> docs).
-
-* Parameters:
-* this
-* Pointer to the Table in which to store the supplied value.
-* key
-* A character string identifying the cell in which the value is
-* to be stored. It should have the form "COLNAME(irow)", where
-* "COLNAME" is replaced by the name of a column that has been
-* defined previously using the astAddColumn method, and "irow" is
-* an integer row index (the first row is row 1).
-* elem
-* The index of the vector element to modify, starting at zero.
-* If the index is outside the range of the vector, an error will
-* be reported.
-* value
-* The value to be stored. The data type of this value should match
-* the 1-character type code appended to the function name (e.g. if
-* you are using astMapPut0A, the type of this value should be "pointer
-* to AstObject"). An error will be reported if this data type is
-* different to the data type assigned to the column when it was
-* created via astAddColumn.
-* status
-* Pointer to inherited status value.
-
-* Notes:
-* - Key names are case insensitive, and white space is considered
-* significant.
-* - The new value will replace any old value already stored in the
-* Table for the specified cell.
-* - If the stored value is an AST Object pointer, the Object's reference
-* count is incremented by this call. Any subsequent changes made to
-* the Object using the returned pointer will be reflected in any
-* any other active pointers for the Object, including any obtained
-* later using astMapget0A. The reference count for the Object will be
-* decremented when the KeyMap is destroyed, or the entry is removed or
-* over-written with a different pointer.
-
-*/
-/* Define a macro to implement the function for a specific data type. */
-
-#define MAKE_MAPPUTELEM(X,Xlc,Xtype,Itype) \
-static void MapPutElem##X( AstKeyMap *this_keymap, const char *key, int elem, \
- Xtype value, int *status ) { \
-\
-/* Local Variables: */ \
- AstTable *this; /* Pointer to Table structure */ \
- char colname[ AST__MXCOLNAMLEN + 1 ]; /* Column name read from string */ \
- int irow; /* Row index within key string */ \
- int type; /* Data type of the requested column */ \
-\
-/* Check the global error status. */ \
- if ( !astOK ) return; \
-\
-/* Get a pointer to the Table structure. */ \
- this = (AstTable *) this_keymap; \
-\
-/* If the key is the name of a global table parameter, use the parent \
- method to put the value of the parameter. */ \
- if( astHasParameter( this, key ) ) { \
- (*parent_mapputelem##Xlc)( this_keymap, key, elem, value, \
- status ); \
-\
-/* Check the supplied key looks like a table cell key, and get the \
- the column name and the row number. Also checks that the table \
- contains a column with the specified name. */ \
- } else if( ParseKey( this, key, 1, colname, &irow, NULL, "astMapPutElem" #X, \
- status ) ) { \
-\
-/* Check the column holds vector values of the type implied by the <X> \
- code in the function name. */ \
- type = astGetColumnType( this, colname ); \
- if( type != Itype && astOK ) { \
- astError( AST__BADTYP, "astMapPutElem" #X "(%s): Failed to store a " \
- #Xtype " value in cell \"%s\": column %s holds %s values.", \
- status, astGetClass( this ), key, colname, \
- TypeString( type ) ); \
- } \
-\
-/* Check the column holds vectors with length equal to the supplied vector. */ \
- if( astGetColumnLength( this, colname ) <= elem && astOK ) { \
- astError( AST__BADTYP, "astMapPutElem" #X "(%s): Failed to " \
- "store a value for element %d (zero-based) of " \
- "cell \"%s\": column %s has only %d values per " \
- "cell.", status, astGetClass( this ), elem, key, \
- colname, astGetColumnLength( this, colname ) ); \
- } \
-\
-/* If all is OK, update the number of rows in the table if required, and \
- store the value in the parent KeyMap. */ \
- if( astOK ) { \
- if( irow > astGetNrow( this ) ) astSetNrow( this, irow ); \
- (*parent_mapputelem##Xlc)( this_keymap, key, elem, value, \
- status ); \
- } \
- } \
-}
-
-/* Expand the above macro to generate a function for each required
- data type. */
-MAKE_MAPPUTELEM(I,i,int,AST__INTTYPE)
-MAKE_MAPPUTELEM(D,d,double,AST__DOUBLETYPE)
-MAKE_MAPPUTELEM(F,f,float,AST__FLOATTYPE)
-MAKE_MAPPUTELEM(A,a,AstObject *,AST__OBJECTTYPE)
-MAKE_MAPPUTELEM(P,p,void *,AST__POINTERTYPE)
-MAKE_MAPPUTELEM(C,c,const char *,AST__STRINGTYPE)
-MAKE_MAPPUTELEM(S,s,short int,AST__SINTTYPE)
-MAKE_MAPPUTELEM(B,b,unsigned char,AST__BYTETYPE)
-
-/* Undefine the macro. */
-#undef MAKE_MAPPUTELEM
-
-static void MapPutU( AstKeyMap *this_keymap, const char *key, const char *comment,
- int *status ) {
-/*
-* Name:
-* MapPutU
-
-* Purpose:
-* Stores a undefined value in a cell of a Table.
-
-* Type:
-* Private function.
-
-* Synopsis:
-* #include "table.h"
-* void MapPutU( AstKeyMap *this, const char *key, const char *comment,
-* int *status )
-
-* Class Membership:
-* Table member function (over-rides the astMapPutU method inherited
-* from the KeyMap class).
-
-* Description:
-* This function adds a new cell to a Table, but no value is stored with
-* the cell. The cell therefore has a special data type represented by
-* symbolic constant AST__UNDEFTYPE.
-*
-* An example use is to add cells with undefined values to a Table
-* prior to locking them with the MapLocked attribute. Such cells
-* can act as placeholders for values that can be added to the KeyMap
-* later.
-
-* Parameters:
-* this
-* Pointer to the Table in which to store the supplied value.
-* key
-* A character string identifying the cell in which the value is
-* to be stored. It should have the form "COLNAME(irow)", where
-* "COLNAME" is replaced by the name of a column that has been
-* defined previously using the astAddColumn method, and "irow" is
-* an integer row index (the first row is row 1).
-* comment
-* A pointer to a null-terminated comment string to be stored with the
-* value. A NULL pointer may be supplied, in which case no comment is
-* stored.
-* status
-* Pointer to inherited status value.
-
-* Notes:
-* - Key names are case insensitive, and white space is considered
-* significant.
-* - The new undefined value will replace any old value already stored in
-* the Table for the specified cell.
-
-*/
-
-/* Local Variables: */
- AstTable *this; /* Pointer to Table structure */
- char colname[ AST__MXCOLNAMLEN + 1 ]; /* Column name read from string */
- int irow; /* Row index within key string */
-
-/* Check the global error status. */
- if ( !astOK ) return;
-
-/* Get a pointer to the Table structure. */
- this = (AstTable *) this_keymap;
-
-/* If the key is the name of a global table parameter, use the parent
- method to put the value of the parameter. */
- if( astHasParameter( this, key ) ) {
- (*parent_mapputu)( this_keymap, key, comment, status );
-
-/* Check the supplied key looks like a table cell key, and get the
- the column name and the row number. Also checks that the table
- contains a column with the specified name. */
- } else if( ParseKey( this, key, 1, colname, &irow, NULL, "astMapPutU",
- status ) ) {
-
-/* If the row index is larger than the current number of rows in the
- table, update the number of rows in the table. */
- if( irow > astGetNrow( this ) ) astSetNrow( this, irow );
-
-/* Use the astMapPutU method in the parent keyMap class to store the
- new cell contents. */
- (*parent_mapputu)( this_keymap, key, comment, status );
- }
-}
-
-static const char *ParameterName( AstTable *this, int index, int *status ) {
-/*
-*++
-* Name:
-c astParameterName
-f AST_PARAMETERNAME
-
-* Purpose:
-* Get the name of the global parameter at a given index within the Table.
-
-* Type:
-* Public virtual function.
-
-* Synopsis:
-c #include "table.h"
-c const char *astParameterName( AstTable *this, int index )
-f RESULT = AST_PARAMETERNAME( THIS, INDEX, STATUS )
-
-* Class Membership:
-* Table method.
-
-* Description:
-* This function returns a string holding the name of the global parameter with
-* the given index within the Table.
-*
-* This function is intended primarily as a means of iterating round all
-* the parameters in a Table. For this purpose, the number of parameters in
-* the Table is given by the Nparameter attribute of the Table. This function
-* could then be called in a loop, with the index value going from
-c zero to one less than Nparameter.
-f one to Nparameter.
-*
-* Note, the index associated with a parameter decreases monotonically with
-* the age of the parameter: the oldest Parameter in the Table will have index
-* one, and the Parameter added most recently to the Table will have the
-* largest index.
-
-* Parameters:
-c this
-f THIS = INTEGER (Given)
-* Pointer to the Table.
-c index
-f INDEX = INTEGER (Given)
-* The index into the list of parameters. The first parameter has index
-* one, and the last has index "Nparameter".
-f STATUS = INTEGER (Given and Returned)
-f The global status.
-
-* Returned Value:
-c astParameterName()
-c A pointer to a null-terminated string containing the
-f AST_PARAMETERNAME = CHARACTER * ( AST__SZCHR )
-f The
-* upper case parameter name.
-
-* Notes:
-c - The returned pointer is guaranteed to remain valid and the
-c string to which it points will not be over-written for a total
-c of 50 successive invocations of this function. After this, the
-c memory containing the string may be re-used, so a copy of the
-c string should be made if it is needed for longer than this.
-c - A NULL pointer will be returned if this function is invoked
-c with the AST error status set, or if it should fail for any
-c reason.
-f - A blank string will be returned if this function is invoked
-f with STATUS set to an error value, or if it should fail for any
-f reason.
-*--
-*/
-
-/* Local Variables: */
- AstKeyMap *pars; /* KeyMap holding parameter definitions */
- const char *result;
-
-/* Check the global error status. */
- if ( !astOK ) return NULL;
-
-/* Get apointer to the KeyMap holding all parameter definitions. */
- pars = astParameterProps( this );
-
-/* Issue a more useful error message than that issued by astMapKey if the
- index is invalid. */
- if( index < 1 || index > astMapSize( pars ) ) {
- astError( AST__MPIND, "astParameterName(%s): Cannot find parameter "
- "%d (zero-based) of the %s - invalid index.", status,
- astGetClass( this ), index, astGetClass( this ) );
- }
-
-/* Get the parameter name. */
- result = astMapKey( pars, index - 1 );
-
-/* Free resources. */
- pars = astAnnul( pars );
-
-/* Return a pointer to the required parameter name. */
- return result;
-}
-
-static AstKeyMap *ParameterProps( AstTable *this, int *status ) {
-/*
-*+
-* Name:
-* astParameterProps
-
-* Purpose:
-* Returns a pointer to the KeyMap holding parameter properties.
-
-* Type:
-* Protected virtual function.
-
-* Synopsis:
-* #include "table.h"
-* AstKeyMap *astParameterProps( AstTable *this )
-
-* Class Membership:
-* Table method.
-
-* Description:
-* This function returns a pointer to the KeyMap that holds
-* definitions of all the parameters added to the Table.
-
-* Parameters:
-* this
-* Pointer to the Table.
-
-* Returned Value:
-* A pointer to the KeyMap. It should be annulled using astAnnul
-* when no longer needed.
-
-*-
-*/
-
-/* Check the global error status. */
- if ( !astOK ) return NULL;
-
-/* Return a cloned pointer to the required KeyMap. */
- return astClone( this->parameters );
-}
-
-static int ParseKey( AstTable *this, const char *key, int report,
- char colname[ AST__MXCOLNAMLEN + 1 ], int *irow,
- AstKeyMap **col_km, const char *method, int *status ){
-/*
-* Name:
-* ParseKey
-
-* Purpose:
-* Find the column name and row index in a KeyMap key.
-
-* Type:
-* Private function.
-
-* Synopsis:
-* #include "table.h"
-* int ParseKey( AstTable *this, const char *key, int report,
-* char colname[ AST__MXCOLNAMLEN + 1 ], int *irow,
-* AstKeyMap **col_km, const char *method, int *status )
-
-* Class Membership:
-* Table member function
-
-* Description:
-* This function checks that the supplied KeyMap key conforms to the
-* format expected for Table cells: i.e. "COLNAME(irow)", where
-* "COLNAME" is the name of a column and "irow" is an integer row
-* index (the first row is row 1), An error is reported if this is
-* not the case.
-
-* Parameters:
-* this
-* Pointer to the table.
-* key
-* The key string to test.
-* report
-* If non-zero, an error will be reported if the key does not
-* correspond to a cell of an existing column. Otherwise, no
-* error will be reported.
-* colname
-* A buffer in which to return the column name.
-* irow
-* Address of an int in which to return the row index.
-* col_km
-* Address of a KeyMap pointer in which to return a pointer to the
-* KeyMap holding the information about the column. The returned
-* KeyMap pointer should be annulled using astAnnul when no lngerr
-* needed. If "col_km" is NULL, no KeyMap pointer is returned.
-* method
-* Pointer to a string holding the name of the method to include in
-* any error message.
-* status
-* Address of the inherited status value.
-
-* Returned Value:
-* Zero is returned if the key is not a valid Table cell key, or if an
-* error occurs.
-
-*/
-
-/* Local Variables: */
- AstKeyMap *cols; /* KeyMap holding column definitions */
- int result; /* Returned flag */
- int collen; /* Length of column name */
- int nctot; /* Number of characters read */
-
-/* Initialise */
- result = 0;
-
-/* Check the global error status. */
- if ( !astOK ) return result;
-
-/* Check the supplied key looks like a table cell key, and extract the
- column name and row number. */
- nctot = 0;
- if( 1 == astSscanf( key, "%*[^(]%n(%d) %n", &collen, irow, &nctot )
- && ( nctot >= strlen( key ) ) ) {
-
-/* Check the column name is not too long. */
- if( collen > AST__MXCOLNAMLEN ) {
- if( report ) {
- astError( AST__BADKEY, "%s(%s): Failed to store a value for cell "
- "\"%s\": column name is too long.", status, method,
- astGetClass( this ), key );
- }
-
-/* Check the row index is positive. */
- } else if( *irow < 1 ) {
- if( report ) {
- astError( AST__BADKEY, "%s(%s): Failed to store a value for cell "
- "\"%s\": row index %d is invalid.", status, method,
- astGetClass( this ), key, *irow );
- }
-
-/* If the key looks OK so far... */
- } else {
-
-/* Convert the column name to upper case and store in the returned buffer. */
- astChrCase( key, colname, 1, collen + 1 );
- colname[ collen ] = 0;
-
-/* check that the column exists in the Table, returning a pointer to the
- column KeyMap is reequired. */
- cols = astColumnProps( this );
- if( col_km ) {
- result = astMapGet0A( cols, colname, col_km );
- } else {
- result = astMapHasKey( cols, colname );
- }
- cols = astAnnul( cols );
-
-/* Report an error if the table does not contain the specified column. */
- if( !result && astOK && report) {
- astError( AST__BADKEY, "%s(%s): Failed to store a value for "
- "cell \"%s\": the table does not contain a column "
- "called '%s'.", status, method, astGetClass( this ),
- key, colname );
- }
- }
-
-/* Report an error if the cell key has the wrong format. */
- } else if( report ) {
- astError( AST__BADKEY, "%s(%s): Failed to store a value for cell "
- "\"%s\": the cell name is invalid.", status, method,
- astGetClass( this ), key );
- }
-
-/* Return the result.*/
- return result;
-}
-
-static void PurgeRows( AstTable *this, int *status ) {
-/*
-*++
-* Name:
-c astPurgeRows
-f AST_PURGEROWS
-
-* Purpose:
-* Remove all empty rows from a table.
-
-* Type:
-* Public virtual function.
-
-* Synopsis:
-c #include "table.h"
-c void astPurgeRows( AstTable *this )
-f CALL AST_PURGEROWS( THIS, STATUS )
-
-* Class Membership:
-* Table method.
-
-* Description:
-* This function removes all empty rows from the Table, renaming
-* the key associated with each table cell accordingly.
-
-* Parameters:
-c this
-f THIS = INTEGER (Given)
-* Pointer to the Table.
-f STATUS = INTEGER (Given and Returned)
-f The global status.
-
-*--
-*/
-
-/* Local Variables: */
- char newkey[ AST__MXCOLKEYLEN + 1 ]; /* New cell key string */
- char oldkey[ AST__MXCOLKEYLEN + 1 ]; /* Old cell key string */
- const char *col; /* Column name */
- const char *key; /* Pointer to key string */
- const char *op; /* Pointer to opening parenthesis */
- int *w1; /* Work space pointer */
- int icol; /* Column index */
- int inew; /* New row index */
- int iold; /* Old row index */
- int ncol; /* Number of columns in table */
- int nrow; /* Number of rows in table */
- int reset; /* Start a new pass through the KeyMap? */
-
-/* Check the global error status. */
- if ( !astOK ) return;
-
-/* Get the number of rows in the table. */
- nrow = astGetNrow( this );
-
-/* Create workspace to hold the number of defined values stored in each
- row. Initialise every row to have zero defined values. */
- w1 = astCalloc( nrow, sizeof( int ) );
- if( astOK ) {
-
-/* Iterate round all keys in the KeyMap. */
- reset = 1;
- while( ( key = astMapIterate( this, reset ) ) && astOK ) {
- reset = 0;
-
-/* Extract the row number from the key. */
- op = strchr( key, '(' );
- if( !op || astSscanf( op + 1, "%d", &iold ) != 1 ||
- iold > nrow ) {
- astError( AST__INTER, "astPurgeRows(%s): Illegal key '%s' "
- "found in a %s (internal programming error).",
- status, astGetClass( this ), key, astGetClass( this ) );
-
-/* Increment the number of values in this row. Note row indices are
- one-based. */
- } else {
- w1[ iold - 1 ]++;
- }
- }
-
-/* Loop round all columns in the Table. */
- ncol = astGetNcolumn( this );
- inew = nrow;
- for( icol = 1; icol <= ncol; icol++ ) {
-
-/* Get the column name */
- col = astColumnName( this, icol );
-
-/* Loop round all the old row numbers. Skip empty rows.*/
- inew = 0;
- for( iold = 0; iold < nrow; iold++ ) {
- if( w1[ iold ] > 0 ) {
-
-/* Increment the row number to use in place of the old row number. If the
- old and new row numbers are the same, we do not need to rename the cell. */
- if( iold != inew++ ) {
-
-/* For the old and new cell names */
- sprintf( oldkey, "%s(%d)", col, iold + 1 );
- sprintf( newkey, "%s(%d)", col, inew );
-
-/* Rename the KeyMap entry. */
- astMapRename( this, oldkey, newkey );
- }
- }
- }
-
-/* If all rows were used, we do not need to check any more columns. */
- if( iold == inew ) break;
- }
-
-/* Store the new number of rows. */
- astSetNrow( this, inew );
- }
-
-/* Free resources. */
- w1 = astFree( w1 );
-
-}
-
-static void RemoveColumn( AstTable *this, const char *name, int *status ) {
-/*
-*++
-* Name:
-c astRemoveColumn
-f AST_REMOVECOLUMN
-
-* Purpose:
-* Remove a column from a table.
-
-* Type:
-* Public virtual function.
-
-* Synopsis:
-c #include "table.h"
-c void astRemoveColumn( AstTable *this, const char *name )
-f CALL AST_REMOVECOLUMN( THIS, NAME, STATUS )
-
-* Class Membership:
-* Table method.
-
-* Description:
-* This function removes a specified column from the supplied table.
-* The
-c function
-f routine
-* returns without action if the named column does not exist in the
-* Table (no error is reported).
-
-* Parameters:
-c this
-f THIS = INTEGER (Given)
-* Pointer to the Table.
-c name
-f NAME = CHARACTER * ( * ) (Given)
-* The column name. Trailing spaces are ignored (all other spaces
-* are significant). Case is significant.
-f STATUS = INTEGER (Given and Returned)
-f The global status.
-
-*--
-*/
-
-/* Local Variables: */
- AstKeyMap *cols; /* KeyMap holding column definitions */
- char key[ AST__MXCOLKEYLEN + 1 ]; /* Cell key string */
- int irow; /* Row index */
- int namlen; /* Used length of "name" */
- int nrow; /* Number of rows in table */
-
-/* Check the global error status. */
- if ( !astOK ) return;
-
-/* Verify supplied values. */
- namlen = astChrLen( name );
- if( namlen == 0 ) {
- astError( AST__BADKEY, "astRemoveColumn(%s): Illegal blank column name "
- "supplied.", status, astGetClass( this ) );
- }
-
-/* Get the number of rows in the table. */
- nrow = astGetNrow( this );
-
-/* If there is no column with the given name in the Table, do nothing more. */
- cols = astColumnProps( this );
- if( astOK && astMapHasKey( cols, name ) ) {
-
-/* Remove the column description from the columns keymap. */
- astMapRemove( cols, name );
-
-/* Remove any column cells with defined values from the parent KeyMap. */
- for( irow = 1; irow <= nrow; irow++ ) {
- sprintf( key, "%.*s(%d)", namlen, name, irow );
- (*parent_mapremove)( (AstKeyMap *) this, key, status );
- }
- }
- cols = astAnnul( cols );
-}
-
-static void RemoveParameter( AstTable *this, const char *name, int *status ) {
-/*
-*++
-* Name:
-c astRemoveParameter
-f AST_REMOVEPARAMETER
-
-* Purpose:
-* Remove a global parameter from a table.
-
-* Type:
-* Public virtual function.
-
-* Synopsis:
-c #include "table.h"
-c void astRemoveParameter( AstTable *this, const char *name )
-f CALL AST_REMOVEPARAMETER( THIS, NAME, STATUS )
-
-* Class Membership:
-* Table method.
-
-* Description:
-* This function removes a specified global parameter from the supplied table.
-* The
-c function
-f routine
-* returns without action if the named parameter does not exist in the
-* Table (no error is reported).
-
-* Parameters:
-c this
-f THIS = INTEGER (Given)
-* Pointer to the Table.
-c name
-f NAME = CHARACTER * ( * ) (Given)
-* The parameter name. Trailing spaces are ignored (all other spaces
-* are significant). Case is significant.
-f STATUS = INTEGER (Given and Returned)
-f The global status.
-
-*--
-*/
-
-/* Local Variables: */
- AstKeyMap *pars; /* KeyMap holding parameter definitions */
-
-/* Check the global error status. */
- if ( !astOK ) return;
-
-/* Verify supplied values. */
- if( astChrLen( name ) == 0 ) {
- astError( AST__BADKEY, "astRemoveParameter(%s): Illegal blank parameter name "
- "supplied.", status, astGetClass( this ) );
- }
-
-/* If there is no parameter with the given name in the Table, do nothing more. */
- pars = astParameterProps( this );
- if( astOK && astMapHasKey( pars, name ) ) {
-
-/* Remove the parameter description from the parameters keymap. */
- astMapRemove( pars, name );
-
-/* Remove any entry holding the parameter value from the parent KeyMap. */
- (*parent_mapremove)( (AstKeyMap *) this, name, status );
- }
- pars = astAnnul( pars );
-}
-
-static void RemoveRow( AstTable *this, int index, int *status ) {
-/*
-*++
-* Name:
-c astRemoveRow
-f AST_REMOVEROW
-
-* Purpose:
-* Remove a row from a table.
-
-* Type:
-* Public virtual function.
-
-* Synopsis:
-c #include "table.h"
-c void astRemoveRow( AstTable *this, int index )
-f CALL AST_REMOVEROW( THIS, INDEX, STATUS )
-
-* Class Membership:
-* Table method.
-
-* Description:
-* This function removes a specified row from the supplied table.
-* The
-c function
-f routine
-* returns without action if the row does not exist in the
-* Table (no error is reported).
-
-* Parameters:
-c this
-f THIS = INTEGER (Given)
-* Pointer to the Table.
-c index
-f INDEX = INTEGER (Given)
-* The index of the row to be removed. The first row has index 1.
-f STATUS = INTEGER (Given and Returned)
-f The global status.
-
-*--
-*/
-
-/* Local Variables: */
- AstKeyMap *cols; /* KeyMap holding column definitions */
- char key[ AST__MXCOLKEYLEN + 1 ]; /* Cell key string */
- const char *col; /* Column name */
- int icol; /* Column index */
- int ncol; /* Number of columns in table */
- int nrow; /* Number of rows in table */
-
-/* Check the global error status. */
- if ( !astOK ) return;
-
-/* Get the number of rows in the table. */
- nrow = astGetNrow( this );
-
-/* Do nothing if the specified row is out of bounds. */
- if( index > 0 && index <= nrow ) {
-
-/* Loop round all columns in the table. */
- cols = astColumnProps( this );
- ncol = astMapSize( cols );
- for( icol = 0; icol < ncol; icol++ ) {
- col = astMapKey( cols, icol );
-
-/* Remove the cell of the current column at the requested row. */
- sprintf( key, "%s(%d)", col, index );
- (*parent_mapremove)( (AstKeyMap *) this, key, status );
- }
- cols = astAnnul( cols );
-
-/* If the removed row was the last row, reduce the number of rows in the
- Table. */
- if( index == nrow ) astSetNrow( this, index - 1 );
- }
-}
-
-static void SetAttrib( AstObject *this_object, const char *setting, int *status ) {
-/*
-* Name:
-* SetAttrib
-
-* Purpose:
-* Set an attribute value for a Table.
-
-* Type:
-* Private function.
-
-* Synopsis:
-* #include "table.h"
-* void SetAttrib( AstObject *this, const char *setting, int *status )
-
-* Class Membership:
-* Table member function (over-rides the astSetAttrib protected
-* method inherited from the KeyMap class).
-
-* Description:
-* This function assigns an attribute value for a Table, the
-* attribute and its value being specified by means of a string of
-* the form:
-*
-* "attribute= value "
-*
-* Here, "attribute" specifies the attribute name and should be in
-* lower case with no white space present. The value to the right
-* of the "=" should be a suitable textual representation of the
-* value to be assigned and this will be interpreted according to
-* the attribute's data type. White space surrounding the value is
-* only significant for string attributes.
-
-* Parameters:
-* this
-* Pointer to the Table.
-* setting
-* Pointer to a null terminated string specifying the new attribute
-* value.
-* status
-* Pointer to the inherited status variable.
-*/
-
-/* Local Variables: */
- AstTable *this; /* Pointer to the Table structure */
- int len; /* Length of setting string */
- int nc; /* Number of characters read by astSscanf */
-
-/* Check the global error status. */
- if ( !astOK ) return;
-
-/* Obtain a pointer to the Table structure. */
- this = (AstTable *) this_object;
-
-/* Obtain the length of the setting string. */
- len = (int) strlen( setting );
-
-/* Test for each recognised attribute in turn, using "astSscanf" to parse
- the setting string and extract the attribute value (or an offset to
- it in the case of string values). In each case, use the value set
- in "nc" to check that the entire string was matched. Once a value
- has been obtained, use the appropriate method to set it. */
- /* None as yet */
-
-/* Define a macro to see if the setting string matches any of the
- read-only attributes of this class. */
-#define MATCH(attrib) \
- ( nc = 0, ( 0 == astSscanf( setting, attrib "=%*[^\n]%n", &nc ) ) && \
- ( nc >= len ) )
-
-#define MATCH2(attrib) \
- ( nc = 0, ( 0 == astSscanf( setting, attrib "(%*s) =%*[^\n]%n", &nc ) ) && \
- ( nc >= len ) )
-
-/* If the attribute was not recognised, use this macro to report an error
- if a read-only attribute has been specified. */
- if ( MATCH( "ncolumn" ) ||
- MATCH( "nparameter" ) ||
- MATCH( "nrow" ) ||
- MATCH2( "columnlenc" ) ||
- MATCH2( "columnlength" ) ||
- MATCH2( "columnndim" ) ||
- MATCH2( "columntype" ) ||
- MATCH2( "columnunit" ) ) {
- astError( AST__NOWRT, "astSet: The setting \"%s\" is invalid for a %s.", status,
- setting, astGetClass( this ) );
- astError( AST__NOWRT, "This is a read-only attribute." , status);
-
-/* If the attribute is still not recognised, pass it on to the parent
- method for further interpretation. */
- } else {
- (*parent_setattrib)( this_object, setting, status );
- }
-
-/* Undefine macros local to this function. */
-#undef MATCH
-#undef MATCH2
-}
-
-static void SetKeyCase( AstKeyMap *this, int keycase, int *status ) {
-/*
-* Name:
-* SetKeyCase
-
-* Purpose:
-* Set a value for the KeyCase attribute value for a Table.
-
-* Type:
-* Private function.
-
-* Synopsis:
-* #include "keymape.h"
-* void SetKeyCase( AstKeyMap *this, int keycase, int *status )
-
-* Class Membership:
-* Table member function (over-rides the astSetKeyCase protected
-* method inherited from the KeyMap class).
-
-* Description:
-* This function assigns a new valeu to the KeyCase attribute for a
-* Table. For a Table, the KeyCase attribute cannot be changed so this
-* function exits without action.
-
-* Parameters:
-* this
-* Pointer to the Table.
-* keycase
-* The new value to set.
-*/
-
-}
-
-static int TestAttrib( AstObject *this_object, const char *attrib, int *status ) {
-/*
-* Name:
-* TestAttrib
-
-* Purpose:
-* Test if a specified attribute value is set for a Table.
-
-* Type:
-* Private function.
-
-* Synopsis:
-* #include "table.h"
-* int TestAttrib( AstObject *this, const char *attrib, int *status )
-
-* Class Membership:
-* Table member function (over-rides the astTestAttrib protected
-* method inherited from the KeyMap class).
-
-* Description:
-* This function returns a boolean result (0 or 1) to indicate whether
-* a value has been set for one of a Table's attributes.
-
-* Parameters:
-* this
-* Pointer to the Table.
-* attrib
-* Pointer to a null terminated string specifying the attribute
-* name. This should be in lower case with no surrounding white
-* space.
-* status
-* Pointer to the inherited status variable.
-
-* Returned Value:
-* One if a value has been set, otherwise zero.
-
-* Notes:
-* - A value of zero will be returned if this function is invoked
-* with the global status set, or if it should fail for any reason.
-*/
-
-/* Local Variables: */
- int len; /* Length of attribute string */
- int nc; /* Number of characters read by astSscanf */
- int result; /* Result value to return */
-
-/* Initialise. */
- result = 0;
-
-/* Check the global error status. */
- if ( !astOK ) return result;
-
-/* Get the length of the attribute string. */
- len = strlen( attrib );
-
-/* Check the attribute name and test the appropriate attribute. */
- /* None as yet */
-
-/* Define a macro to see if the attribute string matches any of the
- read-only column attributes of this class. */
-#define MATCH(attr) \
- ( nc = 0, ( 0 == astSscanf( attrib, attr "(%*s)%n", &nc ) ) && \
- ( nc >= len ) )
-
-/* If the name is not recognised, test if it matches any of the
- read-only attributes of this class. If it does, then return
- zero. */
- if ( !strcmp( attrib, "ncolumn" ) ||
- !strcmp( attrib, "nparameter" ) ||
- !strcmp( attrib, "nrow" ) ||
- MATCH( "columnlenc" ) ||
- MATCH( "columnlength" ) ||
- MATCH( "columnndim" ) ||
- MATCH( "columntype" ) ||
- MATCH( "columnunit" ) ) {
- result = 0;
-
-/* If the attribute is still not recognised, pass it on to the parent
- method for further interpretation. */
- } else {
- result = (*parent_testattrib)( this_object, attrib, status );
- }
-
-/* Return the result, */
- return result;
-
-#undef MATCH
-}
-
-static const char *TypeString( int type ) {
-/*
-* Name:
-* TypeString
-
-* Purpose:
-* Return a pointer to a string describing a data type.
-
-* Type:
-* Private function.
-
-* Synopsis:
-* const char *TypeString( int type );
-
-* Description:
-* This function returns a pointer to a string describing a data type.
-
-* Parameters:
-* type
-* The integer data type code.
-
-* Returned Value:
-* Pointer to a a string descirbing the data type (typically the C
-* data type).
-
-*/
-
-/* Local Variables: */
- const char *result;
-
-/* Compare the supplied type code against each supported value. */
- if( type == AST__INTTYPE ) {
- result = "int";
-
- } else if( type == AST__BYTETYPE ) {
- result = "byte";
-
- } else if( type == AST__DOUBLETYPE ) {
- result = "double";
-
- } else if( type == AST__STRINGTYPE ) {
- result = "string";
-
- } else if( type == AST__OBJECTTYPE ) {
- result = "Object";
-
- } else if( type == AST__FLOATTYPE ) {
- result = "float";
-
- } else if( type == AST__POINTERTYPE ) {
- result = "pointer";
-
- } else if( type == AST__SINTTYPE ) {
- result = "short int";
-
- } else if( type == AST__UNDEFTYPE ) {
- result = "undefined";
-
- } else {
- result = NULL;
- }
-
-/* Return the result. */
- return result;
-}
-
-
-/* Functions which access class attributes. */
-/* ---------------------------------------- */
-/* Implement member functions to access the attributes associated with
- this class using the macros defined for this purpose in the
- "object.h" file. For a description of each attribute, see the class
- interface (in the associated .h file). */
-
-/*
-*att++
-* Name:
-* ColumnLenC(column)
-
-* Purpose:
-* The largest string length of any value in a column
-
-* Type:
-* Public attribute.
-
-* Synopsis:
-* Integer, read-only.
-
-* Description:
-* This attribute holds the minimum length which a character variable
-* must have in order to be able to store the longest value currently
-* present (at any row) in a specified column of the supplied Table.
-c This does not include room for a trailing null character.
-* The required column name should be placed inside the parentheses in
-* the attribute name. If the named column holds vector values, then
-* the attribute value is the length of the longest element of the
-* vector value.
-
-* Applicability:
-* Table
-* All Tables have this attribute.
-
-* Notes:
-* - If the named column holds numerical values, the length returned
-* is the length of the largest string that would be generated if the
-* column values were accessed as strings.
-
-*att--
-*/
-
-/*
-*att++
-* Name:
-* ColumnLength(column)
-
-* Purpose:
-* The number of elements in each value in a column
-
-* Type:
-* Public attribute.
-
-* Synopsis:
-* Integer, read-only.
-
-* Description:
-* This attribute holds the number of elements in each value stored
-* in a named column. Each value can be a scalar (in which case the
-* ColumnLength attribute has a value of 1), or a multi-dimensional
-* array ( in which case the ColumnLength value is equal to the
-* product of the array dimensions).
-
-* Applicability:
-* Table
-* All Tables have this attribute.
-
-*att--
-*/
-
-/*
-*att++
-* Name:
-* ColumnNdim(column)
-
-* Purpose:
-* The number of axes spanned by each value in a column
-
-* Type:
-* Public attribute.
-
-* Synopsis:
-* Integer, read-only.
-
-* Description:
-* This attribute holds the number of axes spanned by each value in a
-* column. If each cell in the column is a scalar, ColumnNdim will be
-* zero. If each cell in the column is a 1D spectrum, ColumnNdim will
-* be one. If each cell in the column is a 2D image, ColumnNdim will be
-* two, etc. The required column name should be placed inside the
-* parentheses in the attribute name.
-
-* Applicability:
-* Table
-* All Tables have this attribute.
-
-*att--
-*/
-
-/*
-*att++
-* Name:
-* ColumnType(column)
-
-* Purpose:
-* The data type of each value in a column
-
-* Type:
-* Public attribute.
-
-* Synopsis:
-* Integer, read-only.
-
-* Description:
-* This attribute holds a integer value indicating the data type of
-* a named column in a Table. This is the data type which was used
-* when the column was added to the Table using astAddColumn. The
-* required column name should be placed inside the parentheses in
-* the attribute name.
-*
-* The attribute value will be one of AST__INTTYPE (for integer),
-* AST__SINTTYPE (for
-c short int),
-f INTEGER*2),
-* AST__BYTETYPE (for
-c unsigned bytes - i.e. unsigned chars),
-f bytes),
-* AST__DOUBLETYPE (for double
-* precision floating point), AST__FLOATTYPE (for single
-* precision floating point), AST__STRINGTYPE (for character string),
-* AST__OBJECTTYPE (for AST Object pointer), AST__POINTERTYPE (for
-* arbitrary C pointer) or AST__UNDEFTYPE (for undefined values
-* created by
-c astMapPutU).
-f AST_MAPPUTU).
-
-* Applicability:
-* Table
-* All Tables have this attribute.
-
-*att--
-*/
-
-/*
-*att++
-* Name:
-* Ncolumn
-
-* Purpose:
-* The number of columns in the table.
-
-* Type:
-* Public attribute.
-
-* Synopsis:
-* Integer, read-only.
-
-* Description:
-* This attribute holds the number of columns currently in the table. Columns
-* are added and removed using the
-c astAddColumn and astRemoveColumn
-f AST_ADDCOLUMN and AST_REMOVECOLUMN
-* functions.
-
-* Applicability:
-* Table
-* All Tables have this attribute.
-
-*att--
-*/
-
-/*
-*att++
-* Name:
-* Nparameter
-
-* Purpose:
-* The number of global parameters in the table.
-
-* Type:
-* Public attribute.
-
-* Synopsis:
-* Integer, read-only.
-
-* Description:
-* This attribute holds the number of global parameters currently in the table.
-* Parameters are added and removed using the
-c astAddParameter and astRemoveParameter
-f AST_ADDPARAMETER and AST_REMOVEPARAMETER
-* functions.
-
-* Applicability:
-* Table
-* All Tables have this attribute.
-
-*att--
-*/
-
-/*
-*att++
-* Name:
-* Nrow
-
-* Purpose:
-* The number of rows in the table.
-
-* Type:
-* Public attribute.
-
-* Synopsis:
-* Integer, read-only.
-
-* Description:
-* This attribute holds the index of the last row to which any
-* contents have been added using any of the
-* astMapPut...
-* AST_MAPPUT...
-* functions. The first row has index 1.
-
-* Applicability:
-* Table
-* All Tables have this attribute.
-
-*att--
-*/
-astMAKE_GET(Table,Nrow,int,0,this->nrow)
-astMAKE_SET(Table,Nrow,int,nrow,value)
-
-
-
-/* Copy constructor. */
-/* ----------------- */
-static void Copy( const AstObject *objin, AstObject *objout, int *status ) {
-/*
-* Name:
-* Copy
-
-* Purpose:
-* Copy constructor for Table objects.
-
-* Type:
-* Private function.
-
-* Synopsis:
-* void Copy( const AstObject *objin, AstObject *objout, int *status )
-
-* Description:
-* This function implements the copy constructor for Table objects.
-
-* Parameters:
-* objin
-* Pointer to the object to be copied.
-* objout
-* Pointer to the object being constructed.
-* status
-* Pointer to the inherited status variable.
-
-* Returned Value:
-* void
-
-* Notes:
-* - This constructor makes a deep copy, including a copy of the component
-* Mappings within the Table.
-*/
-
-/* Local Variables: */
- AstTable *in; /* Pointer to input Table */
- AstTable *out; /* Pointer to output Table */
-
-/* Check the global error status. */
- if ( !astOK ) return;
-
-/* Obtain pointers to the input and output Tables. */
- in = (AstTable *) objin;
- out = (AstTable *) objout;
-
-/* Make copies of the component KeyMaps and store pointers to them in the
- output Table structure. */
- out->columns = in->columns ? astCopy( in->columns ) : NULL;
- out->parameters = in->parameters ? astCopy( in->parameters ) : NULL;
-}
-
-
-/* Destructor. */
-/* ----------- */
-static void Delete( AstObject *obj, int *status ) {
-/*
-* Name:
-* Delete
-
-* Purpose:
-* Destructor for Table objects.
-
-* Type:
-* Private function.
-
-* Synopsis:
-* void Delete( AstObject *obj, int *status )
-
-* Description:
-* This function implements the destructor for Table objects.
-
-* Parameters:
-* obj
-* Pointer to the object to be deleted.
-* status
-* Pointer to the inherited status variable.
-
-* Returned Value:
-* void
-
-* Notes:
-* This function attempts to execute even if the global error status is
-* set.
-*/
-
-/* Local Variables: */
- AstTable *this; /* Pointer to Table */
-
-/* Obtain a pointer to the Table structure. */
- this = (AstTable *) obj;
-
-/* Annul the pointers to the component KeyMaps. */
- if( this->columns ) this->columns = astAnnul( this->columns );
- if( this->parameters ) this->parameters = astAnnul( this->parameters );
-
-}
-
-
-/* Dump function. */
-/* -------------- */
-static void Dump( AstObject *this_object, AstChannel *channel, int *status ) {
-/*
-* Name:
-* Dump
-
-* Purpose:
-* Dump function for Table objects.
-
-* Type:
-* Private function.
-
-* Synopsis:
-* void Dump( AstObject *this, AstChannel *channel, int *status )
-
-* Description:
-* This function implements the Dump function which writes out data
-* for the Table class to an output Channel.
-
-* Parameters:
-* this
-* Pointer to the Table whose data are being written.
-* channel
-* Pointer to the Channel to which the data are being written.
-* status
-* Pointer to the inherited status variable.
-*/
-
-/* Local Variables: */
- AstTable *this; /* Pointer to the Table structure */
-
-/* Check the global error status. */
- if ( !astOK ) return;
-
-/* Obtain a pointer to the Table structure. */
- this = (AstTable *) this_object;
-
-/* Write out values representing the instance variables for the Table
- class. Note, the primitive data in the Table will be written out
- by the parent KeyMap Dump function. This function deals just with the
- extra information held in the Table structure. */
-
-/* Write out the number of rows in the table. */
- astWriteInt( channel, "Nrow", 1, 1, astGetNrow( this ),
- "Number of rows in table" );
-
-/* Write out the KeyMap holding definitions of each column. */
- if( this->columns ) {
- astWriteObject( channel, "Columns", 1, 0, this->columns, "KeyMap holding "
- "column definitions" );
- }
-
-/* Write out the KeyMap holding definitions of each global parameter. */
- if( this->parameters ) {
- astWriteObject( channel, "Params", 1, 0, this->parameters, "KeyMap holding "
- "parameter definitions" );
- }
-}
-
-
-
-
-
-
-/* Standard class functions. */
-/* ========================= */
-/* Implement the astIsATable and astCheckTable functions using the macros
- defined for this purpose in the "object.h" header file. */
-astMAKE_ISA(Table,KeyMap)
-astMAKE_CHECK(Table)
-
-AstTable *astTable_( const char *options, int *status, ...) {
-/*
-*++
-* Name:
-c astTable
-f AST_TABLE
-
-* Purpose:
-* Create a Table.
-
-* Type:
-* Public function.
-
-* Synopsis:
-c #include "table.h"
-c AstTable *astTable( const char *options, ... )
-f RESULT = AST_TABLE( OPTIONS, STATUS )
-
-* Class Membership:
-* Table constructor.
-
-* Description:
-* This function creates a new empty Table and optionally initialises
-* its attributes.
-*
-* The Table class is a type of KeyMap that represents a two-dimensional
-* table of values. The
-c astMapGet... and astMapPut...
-f AST_MAPGET... and AST_MAPPUT...
-* methods provided by the KeyMap class should be used for storing and
-* retrieving values from individual cells within a Table. Each entry
-* in the KeyMap represents a single cell of the table and has an
-* associated key of the form "<COL>(i)" where "<COL>" is the name of a
-* table column and "i" is the row index (the first row is row 1). Keys
-* of this form should always be used when using KeyMap methods to access
-* entries within a Table.
-*
-* Columns must be declared using the
-c astAddColumn
-f AST_ADDCOLUMN
-* method before values can be stored within them. This also fixes the
-* type and shape of the values that may be stored in any cell of the
-* column. Cells may contain scalar or vector values of any data type
-* supported by the KeyMap class. Multi-dimensional arrays may also be
-* stored, but these must be vectorised when storing and retrieving
-* them within a table cell. All cells within a single column must
-* have the same type and shape (specified when the column is declared).
-*
-* Tables may have parameters that describe global properties of the
-* entire table. These are stored as entries in the parent KeyMap and
-* can be access using the get and set method of the KeyMap class.
-* However, parameters must be declared using the
-c astAddParameter
-f AST_ADDPARAMETER
-* method before being accessed.
-*
-* Note - since accessing entries within a KeyMap is a relatively slow
-* process, it is not recommended to use the Table class to store
-* very large tables.
-
-* Parameters:
-c options
-f OPTIONS = CHARACTER * ( * ) (Given)
-c Pointer to a null-terminated string containing an optional
-c comma-separated list of attribute assignments to be used for
-c initialising the new Table. The syntax used is identical to
-c that for the astSet function and may include "printf" format
-c specifiers identified by "%" symbols in the normal way.
-f A character string containing an optional comma-separated
-f list of attribute assignments to be used for initialising the
-f new Table. The syntax used is identical to that for the
-f AST_SET routine.
-c ...
-c If the "options" string contains "%" format specifiers, then
-c an optional list of additional arguments may follow it in
-c order to supply values to be substituted for these
-c specifiers. The rules for supplying these are identical to
-c those for the astSet function (and for the C "printf"
-c function).
-f STATUS = INTEGER (Given and Returned)
-f The global status.
-
-* Returned Value:
-c astTable()
-f AST_TABLE = INTEGER
-* A pointer to the new Table.
-
-* Notes:
-* - A null Object pointer (AST__NULL) will be returned if this
-c function is invoked with the AST error status set, or if it
-f function is invoked with STATUS set to an error value, or if it
-* should fail for any reason.
-
-* Status Handling:
-* The protected interface to this function includes an extra
-* parameter at the end of the parameter list described above. This
-* parameter is a pointer to the integer inherited status
-* variable: "int *status".
-
-*--
-*/
-
-/* Local Variables: */
- astDECLARE_GLOBALS /* Pointer to thread-specific global data */
- AstTable *new; /* Pointer to new Table */
- va_list args; /* Variable argument list */
-
-/* Get a pointer to the thread specific global data structure. */
- astGET_GLOBALS(NULL);
-
-/* Check the global status. */
- if ( !astOK ) return NULL;
-
-/* Initialise the Table, allocating memory and initialising the
- virtual function table as well if necessary. */
- new = astInitTable( NULL, sizeof( AstTable ), !class_init, &class_vtab,
- "Table" );
-
-/* If successful, note that the virtual function table has been
- initialised. */
- if ( astOK ) {
- class_init = 1;
-
-/* Obtain the variable argument list and pass it along with the options string
- to the astVSet method to initialise the new Table's attributes. */
- va_start( args, status );
- astVSet( new, options, NULL, args );
- va_end( args );
-
-/* If an error occurred, clean up by deleting the new object. */
- if ( !astOK ) new = astDelete( new );
- }
-
-/* Return a pointer to the new Table. */
- return new;
-}
-
-AstTable *astTableId_( const char *options, ... ) {
-/*
-* Name:
-* astTableId_
-
-* Purpose:
-* Create a Table.
-
-* Type:
-* Private function.
-
-* Synopsis:
-* #include "table.h"
-* AstTable *astTableId_( const char *options, ... )
-
-* Class Membership:
-* Table constructor.
-
-* Description:
-* This function implements the external (public) interface to the
-* astTable constructor function. It returns an ID value (instead
-* of a true C pointer) to external users, and must be provided
-* because astTable_ has a variable argument list which cannot be
-* encapsulated in a macro (where this conversion would otherwise
-* occur).
-*
-* The variable argument list also prevents this function from
-* invoking astTable_ directly, so it must be a re-implementation
-* of it in all respects, except for the final conversion of the
-* result to an ID value.
-
-* Parameters:
-* As for astTable_.
-
-* Returned Value:
-* The ID value associated with the new Table.
-*/
-
-/* Local Variables: */
- astDECLARE_GLOBALS /* Pointer to thread-specific global data */
- AstTable *new; /* Pointer to new Table */
- va_list args; /* Variable argument list */
-
- int *status; /* Pointer to inherited status value */
-
-/* Get a pointer to the inherited status value. */
- status = astGetStatusPtr;
-
-/* Get a pointer to the thread specific global data structure. */
- astGET_GLOBALS(NULL);
-
-/* Check the global status. */
- if ( !astOK ) return NULL;
-
-/* Initialise the Table, allocating memory and initialising the
- virtual function table as well if necessary. */
- new = astInitTable( NULL, sizeof( AstTable ), !class_init, &class_vtab,
- "Table" );
-
-/* If successful, note that the virtual function table has been
- initialised. */
- if ( astOK ) {
- class_init = 1;
-
-/* Obtain the variable argument list and pass it along with the options string
- to the astVSet method to initialise the new Table's attributes. */
- va_start( args, options );
- astVSet( new, options, NULL, args );
- va_end( args );
-
-/* If an error occurred, clean up by deleting the new object. */
- if ( !astOK ) new = astDelete( new );
- }
-
-/* Return an ID value for the new Table. */
- return astMakeId( new );
-}
-
-AstTable *astInitTable_( void *mem, size_t size, int init,
- AstTableVtab *vtab, const char *name, int *status ) {
-/*
-*+
-* Name:
-* astInitTable
-
-* Purpose:
-* Initialise a Table.
-
-* Type:
-* Protected function.
-
-* Synopsis:
-* #include "table.h"
-* AstTable *astInitTable( void *mem, size_t size, int init,
-* AstTableVtab *vtab, const char *name )
-
-* Class Membership:
-* Table initialiser.
-
-* Description:
-* This function is provided for use by class implementations to initialise
-* a new Table object. It allocates memory (if necessary) to accommodate
-* the Table plus any additional data associated with the derived class.
-* It then initialises a Table structure at the start of this memory. If
-* the "init" flag is set, it also initialises the contents of a virtual
-* function table for a Table at the start of the memory passed via the
-* "vtab" parameter.
-
-* Parameters:
-* mem
-* A pointer to the memory in which the Table is to be initialised.
-* This must be of sufficient size to accommodate the Table data
-* (sizeof(Table)) plus any data used by the derived class. If a value
-* of NULL is given, this function will allocate the memory itself using
-* the "size" parameter to determine its size.
-* size
-* The amount of memory used by the Table (plus derived class data).
-* This will be used to allocate memory if a value of NULL is given for
-* the "mem" parameter. This value is also stored in the Table
-* structure, so a valid value must be supplied even if not required for
-* allocating memory.
-* init
-* A logical flag indicating if the Table's virtual function table is
-* to be initialised. If this value is non-zero, the virtual function
-* table will be initialised by this function.
-* vtab
-* Pointer to the start of the virtual function table to be associated
-* with the new Table.
-* name
-* Pointer to a constant null-terminated character string which contains
-* the name of the class to which the new object belongs (it is this
-* pointer value that will subsequently be returned by the astGetClass
-* method).
-
-* Returned Value:
-* A pointer to the new Table.
-
-* Notes:
-* - A null pointer will be returned if this function is invoked with the
-* global error status set, or if it should fail for any reason.
-*-
-*/
-
-/* Local Variables: */
- AstTable *new; /* Pointer to new Table */
-
-/* Check the global status. */
- if ( !astOK ) return NULL;
-
-/* If necessary, initialise the virtual function table. */
- if ( init ) astInitTableVtab( vtab, name );
-
-/* Initialise. */
- new = NULL;
-
-/* Initialise a KeyMap structure (the parent class) as the first component
- within the Table structure, allocating memory if necessary. Specify that
- the KeyMap should be defined in both the forward and inverse directions. */
- new = (AstTable *) astInitKeyMap( mem, size, 0, (AstKeyMapVtab *) vtab,
- name );
- if ( astOK ) {
-
-/* Initialise the Table data. */
-/* ---------------------------- */
- new->nrow = 0;
- new->columns = astKeyMap( "KeyCase=0,Sortby=AgeDown", status );
- new->parameters = astKeyMap( "KeyCase=0,Sortby=AgeDown", status );
-
-/* Tables require the KeyCase attribute to be zero. */
- (*parent_setkeycase)( (AstKeyMap *) new, 0, status );
-
-/* If an error occurred, clean up by deleting the new Table. */
- if ( !astOK ) new = astDelete( new );
- }
-
-/* Return a pointer to the new Table. */
- return new;
-}
-
-AstTable *astLoadTable_( void *mem, size_t size, AstTableVtab *vtab,
- const char *name, AstChannel *channel, int *status ) {
-/*
-*+
-* Name:
-* astLoadTable
-
-* Purpose:
-* Load a Table.
-
-* Type:
-* Protected function.
-
-* Synopsis:
-* #include "table.h"
-* AstTable *astLoadTable( void *mem, size_t size, AstTableVtab *vtab,
-* const char *name, AstChannel *channel )
-
-* Class Membership:
-* Table loader.
-
-* Description:
-* This function is provided to load a new Table using data read
-* from a Channel. It first loads the data used by the parent class
-* (which allocates memory if necessary) and then initialises a
-* Table structure in this memory, using data read from the input
-* Channel.
-*
-* If the "init" flag is set, it also initialises the contents of a
-* virtual function table for a Table at the start of the memory
-* passed via the "vtab" parameter.
-
-
-* Parameters:
-* mem
-* A pointer to the memory into which the Table is to be
-* loaded. This must be of sufficient size to accommodate the
-* Table data (sizeof(Table)) plus any data used by derived
-* classes. If a value of NULL is given, this function will
-* allocate the memory itself using the "size" parameter to
-* determine its size.
-* size
-* The amount of memory used by the Table (plus derived class
-* data). This will be used to allocate memory if a value of
-* NULL is given for the "mem" parameter. This value is also
-* stored in the Table structure, so a valid value must be
-* supplied even if not required for allocating memory.
-*
-* If the "vtab" parameter is NULL, the "size" value is ignored
-* and sizeof(AstTable) is used instead.
-* vtab
-* Pointer to the start of the virtual function table to be
-* associated with the new Table. If this is NULL, a pointer
-* to the (static) virtual function table for the Table class
-* is used instead.
-* name
-* Pointer to a constant null-terminated character string which
-* contains the name of the class to which the new object
-* belongs (it is this pointer value that will subsequently be
-* returned by the astGetClass method).
-*
-* If the "vtab" parameter is NULL, the "name" value is ignored
-* and a pointer to the string "Table" is used instead.
-
-* Returned Value:
-* A pointer to the new Table.
-
-* Notes:
-* - A null pointer will be returned if this function is invoked
-* with the global error status set, or if it should fail for any
-* reason.
-*-
-*/
-
-/* Local Variables: */
- astDECLARE_GLOBALS /* Pointer to thread-specific global data */
- AstTable *new; /* Pointer to the new Table */
-
-/* Initialise. */
- new = NULL;
-
-/* Check the global error status. */
- if ( !astOK ) return new;
-
-/* Get a pointer to the thread specific global data structure. */
- astGET_GLOBALS(channel);
-
-/* If a NULL virtual function table has been supplied, then this is
- the first loader to be invoked for this Table. In this case the
- Table belongs to this class, so supply appropriate values to be
- passed to the parent class loader (and its parent, etc.). */
- if ( !vtab ) {
- size = sizeof( AstTable );
- vtab = &class_vtab;
- name = "Table";
-
-/* If required, initialise the virtual function table for this class. */
- if ( !class_init ) {
- astInitTableVtab( vtab, name );
- class_init = 1;
- }
- }
-
-/* Invoke the parent class loader to load data for all the ancestral
- classes of the current one, returning a pointer to the resulting
- partly-built Table. */
- new = astLoadKeyMap( mem, size, (AstKeyMapVtab *) vtab, name,
- channel );
-
- if ( astOK ) {
-
-/* Read input data. */
-/* ================ */
-/* Request the input Channel to read all the input data appropriate to
- this class into the internal "values list". */
- astReadClassData( channel, "Table" );
-
-/* Now read each individual data item from this list and use it to
- initialise the appropriate instance variable(s) for this class. */
-
-/* The number of rows. */
- new->nrow = astReadInt( channel, "nrow", 0 );
-
-/* KeyMap holding columns definitions. */
- new->columns = astReadObject( channel, "columns", NULL );
-
-/* KeyMap holding parameter definitions. */
- new->parameters = astReadObject( channel, "params", NULL );
-
-/* If an error occurred, clean up by deleting the new Table. */
- if ( !astOK ) new = astDelete( new );
- }
-
-/* Return the new Table pointer. */
- return new;
-}
-
-/* Virtual function interfaces. */
-/* ============================ */
-/* These provide the external interface to the virtual functions defined by
- this class. Each simply checks the global error status and then locates and
- executes the appropriate member function, using the function pointer stored
- in the object's virtual function table (this pointer is located using the
- astMEMBER macro defined in "object.h").
-
- Note that the member function may not be the one defined here, as it may
- have been over-ridden by a derived class. However, it should still have the
- same interface. */
-
-void astAddColumn_( AstTable *this, const char *name, int type,
- int ndim, int *dims, const char *unit, int *status ) {
- if ( !astOK ) return;
- (**astMEMBER(this,Table,AddColumn))(this,name,type,ndim,dims,unit,status);
-}
-void astAddParameter_( AstTable *this, const char *name, int *status ) {
- if ( !astOK ) return;
- (**astMEMBER(this,Table,AddParameter))(this,name,status);
-}
-void astRemoveColumn_( AstTable *this, const char *name, int *status ){
- if ( !astOK ) return;
- (**astMEMBER(this,Table,RemoveColumn))(this,name,status);
-}
-void astRemoveParameter_( AstTable *this, const char *name, int *status ){
- if ( !astOK ) return;
- (**astMEMBER(this,Table,RemoveParameter))(this,name,status);
-}
-void astRemoveRow_( AstTable *this, int index, int *status ){
- if ( !astOK ) return;
- (**astMEMBER(this,Table,RemoveRow))(this,index,status);
-}
-void astPurgeRows_( AstTable *this, int *status ){
- if ( !astOK ) return;
- (**astMEMBER(this,Table,PurgeRows))(this,status);
-}
-int astGetNcolumn_( AstTable *this, int *status ) {
- if ( !astOK ) return 0;
- return (**astMEMBER(this,Table,GetNcolumn))( this, status );
-}
-int astGetNparameter_( AstTable *this, int *status ) {
- if ( !astOK ) return 0;
- return (**astMEMBER(this,Table,GetNparameter))( this, status );
-}
-const char *astColumnName_( AstTable *this, int index, int *status ){
- if ( !astOK ) return NULL;
- return (**astMEMBER(this,Table,ColumnName))(this,index,status);
-}
-const char *astParameterName_( AstTable *this, int index, int *status ){
- if ( !astOK ) return NULL;
- return (**astMEMBER(this,Table,ParameterName))(this,index,status);
-}
-int astGetColumnType_( AstTable *this, const char *column, int *status ){
- if ( !astOK ) return 0;
- return (**astMEMBER(this,Table,GetColumnType))(this,column,status);
-}
-const char *astGetColumnUnit_( AstTable *this, const char *column, int *status ){
- if ( !astOK ) return NULL;
- return (**astMEMBER(this,Table,GetColumnUnit))(this,column,status);
-}
-int astGetColumnLenC_( AstTable *this, const char *column, int *status ){
- if ( !astOK ) return 0;
- return (**astMEMBER(this,Table,GetColumnLenC))(this,column,status);
-}
-int astGetColumnLength_( AstTable *this, const char *column, int *status ){
- if ( !astOK ) return 0;
- return (**astMEMBER(this,Table,GetColumnLength))(this,column,status);
-}
-int astGetColumnNdim_( AstTable *this, const char *column, int *status ){
- if ( !astOK ) return 0;
- return (**astMEMBER(this,Table,GetColumnNdim))(this,column,status);
-}
-void astColumnShape_( AstTable *this, const char *column, int mxdim,
- int *ndim, int *dims, int *status ){
- if ( !astOK ) return;
- (**astMEMBER(this,Table,ColumnShape))( this, column, mxdim, ndim,
- dims, status );
-}
-AstKeyMap *astColumnProps_( AstTable *this, int *status ){
- if ( !astOK ) return NULL;
- return (**astMEMBER(this,Table,ColumnProps))(this,status);
-}
-AstKeyMap *astParameterProps_( AstTable *this, int *status ){
- if ( !astOK ) return NULL;
- return (**astMEMBER(this,Table,ParameterProps))(this,status);
-}
-int astHasColumn_( AstTable *this, const char *column, int *status ){
- if ( !astOK ) return 0;
- return (**astMEMBER(this,Table,HasColumn))(this,column,status);
-}
-int astHasParameter_( AstTable *this, const char *parameter, int *status ){
- if ( !astOK ) return 0;
- return (**astMEMBER(this,Table,HasParameter))(this,parameter,status);
-}