bool FitsFile::OpenNewTable	(	const string &	tableName,
		int	maxtry = 1
	)

This looks for a suitable table in the fits file, i.e. that corresponds to the name and column names. (no format check yet)

Parameters

tableName.	the base table name to be obtained. If not suitable, numbers are appened to the name
allNames.	the name of all columns
allDataTypes.	the data types of all columns
allUnits.	the units of the columns

Returns

a pointer to the newly retrieved/created table

Definition at line 206 of file FitsFile.cc.

References Error(), i, and str.

Referenced by AddColumn().

{
    if (!fFile)
    {
        Error("FitsFile::OpenNewTable - No file open.");
        return false;
    }

    if (fTable)
    {
        Error("FitsFile::OpenNewTable - Table already open.");
        return false;
    }

    //first, let's check if the table already exist in the file
    fFile->read(vector<string>(1, tableName));

    // FIXME: Check for fFile and fTable
    const multimap<string, CCfits::ExtHDU *> &extMap = fFile->extension();

    for (int i=0; i<maxtry; i++)
    {
        //if (i==10)
        //    fMess->Warn("Already 10 different tables with different formats exist in this file. Please consider re-creating the file entirely (i.e. delete it please)");

        ostringstream str;
        str << tableName;
        if (i != 0)
            str << "-" << i;

        const string tname = str.str();

        const multimap<string,CCfits::ExtHDU*>::const_iterator it = extMap.find(tname);

        //current table name does not exist yet. return its associated fits table newly created
        if (it == extMap.end())
        {
            // What is this for?
            //for (multimap<string, CCfits::ExtHDU*>::const_iterator it=extMap.begin();
            //     it!= extMap.end(); it++)
            //    fMess->Debug(it->first);

            return OpenTable(tname);
        }

        CCfits::Table *table = dynamic_cast<CCfits::Table*>(it->second);

        // something wrong happened while getting the table pointer
        if (!table)
        {
            Error("HDU '"+tname+"' found in file, but it is not a proper CCfits::Table.");
            return false;
        }

        //now check that the table columns are the same
        //as the service columns
        table->makeThisCurrent();

        // FIXME: To be checked...
        /*
         const map<string, Column*> cMap = table->column();
         for (vector<string>::const_iterator ii=fFile->fColNames;
         ii!=fFile->fColNames.end(); ii++)
         if (cMap.find(*ii) == cMap.end())
         continue;
         */

        fNumRows = table->rows();

        // ----------- This is just a simple sanity check ----------

        // This is not necessary this is done already in
        // findSuitableTable (either directly or indirectly through OpenTable)
        // fFile->fTable->makeThisCurrent();

        //If the file already existed, then we must load its data to memory before writing to it.
        if (fNumRows>0)
        {
            CCfits::BinTable* bTable = dynamic_cast<CCfits::BinTable*>(table);
            if (!bTable)
            {
                Error("Table '"+tableName+"' found in '"+fFile->name()+"' is not a binary table.");
                return false;
            }

            //read the table binary data.
            vector<string> colName;
            bTable->readData(true, colName);

            // double check that the data was indeed read from the disk.
            // Go through the fTable instead as colName is empty (yes, it is !)
            const map<string,CCfits::Column*> &cMap = table->column();

            //check that the existing columns are the same as the ones we want to write
            for (map<string, CCfits::Column*>::const_iterator mapIt = cMap.begin(); mapIt != cMap.end(); mapIt++)
            {
                bool found = false;
                for (unsigned int ii=0;ii<fColNames.size();ii++)
                {
                    if (mapIt->first == fColNames[ii])
                    {
                        found = true;
                        if (mapIt->second->format() != fColTypes[ii])
                        {
                            Error("Column "+fColNames[ii]+" has wrong format ("+fColTypes[ii]+" vs "+mapIt->second->format()+" in file)");
                            return false;
                        }
                    }
                }
                if (!found)
                {
                    Error("Column "+mapIt->first+" only exist in written file");
                    return false;
                }
            }
            //now we know that all the file's columns are requested. Let's do it the other way around
            for (unsigned int ii=0;ii<fColNames.size();ii++)
            {
                bool found = false;
                for (map<string, CCfits::Column*>::const_iterator mapIt = cMap.begin(); mapIt != cMap.end(); mapIt++)
                {
                    if (fColNames[ii] == mapIt->first)
                    {
                        found = true;
                        if (fColTypes[ii] != mapIt->second->format())
                        {
                            Error("Column "+fColNames[ii]+" has wrong format ("+fColTypes[ii]+" vs "+mapIt->second->format()+" in file)");
                            return false;
                        }
                    }
                }
                if (!found)
                {
                    Error("Column "+fColNames[ii]+" only exist in requested description");
                    return false;
                }
            }

            for (map<string,CCfits::Column*>::const_iterator cMapIt = cMap.begin();
                 cMapIt != cMap.end(); cMapIt++)
            {
                if (!cMapIt->second->isRead())
                {
                    Error("Reading column '"+cMapIt->first+"' back from '"+fFile->name()+"' failed.");
                    return false;
                }
            }
        }

        // Set this as last - we use it for IsOpen()
        fTable = table;

        return true;
    }

    ostringstream str;
    str << "FitsFile::OpenNewTable failed - more than " << maxtry << " tables tried." << endl;
    Error(str);

    return false;
}

Here is the call graph for this function:

Here is the caller graph for this function: