ColumnT.h

//1
//2
//3
//4

//      This is version 2.0 release dated Jan 2008

//      Astrophysics Science Division,
//      NASA/ Goddard Space Flight Center
//      HEASARC
//      http://heasarc.gsfc.nasa.gov
//      e-mail: ccfits@legacy.gsfc.nasa.gov
//
//      Original author: Ben Dorman

#ifndef COLUMNT_H
#define COLUMNT_H

#ifdef _MSC_VER
#include "MSconfig.h"
#endif

#include "ColumnData.h"
#include "ColumnVectorData.h"
#include "FITSUtil.h"
#include <typeinfo>
#include <vector>
#include <algorithm>
#include "NewKeyword.h"

#ifdef SSTREAM_DEFECT
#       include <strstream>
#else
#       include <sstream>
#endif


// by design, if the data are not read yet we will return an exception.
// here the test is if the entire column has already been read. 
using std::complex;
using std::valarray;

// get specified elements of a scalar column. These two functions allow the
// user to return either a vector or a valarray depending on the input container.

namespace CCfits 
{
        template <typename S>
        void Column::read(std::vector<S>& vals, long first, long last) 
        {
                read(vals,first,last,static_cast<S*>(0));
        }


        template <typename S>
        void Column::read(std::vector<S>& vals, long first, long last, S* nullValue) 
        {
                // problem: S does not give the type of the Column, but the return type,
                // so the user must specify this.
                parent()->makeThisCurrent();
                long nelements = numberOfElements(first,last);

                if  (ColumnData<S>* col = dynamic_cast<ColumnData<S>*>(this))
                {
                        // fails if user requested outputType different from input type.


                        if (!isRead()) col->readColumnData(first,nelements,nullValue);
                        // scalar column with vector output can just be assigned.
                        FITSUtil::fill(vals,col->data(),first,last);
                }
                else
                {
                        FITSUtil::MatchType<S> outputType;
                        if ( outputType() == type() ) 
                        { 
                                // in this case user tried to read vector data from scalar,
                                // (i.e. first argument was vector<valarray<S> >.
                                // since the cast won't fail on template parameter grounds.
                                throw Column::WrongColumnType(name());
                        }

                        try
                        {
                            // about exceptions. The dynamic_casts could throw
                            // std::bad_cast. If this happens something is seriously
                            // wrong since the Column stores the value of type() 
                            // appropriate to each of the casts on construction.
                            // 
                            // the InvalidDataType exception should not be possible.
                            if  ( type() == Tdouble )
                            {
                                    ColumnData<double>& col 
                                              = dynamic_cast<ColumnData<double>&>(*this);
                                    if (!isRead()) col.readColumnData(first,nelements);                                  
                                    FITSUtil::fill(vals,col.data(),first,last);

                            }
                            else if (type() == Tfloat)
                            {
                                    ColumnData<float>& col 
                                            = dynamic_cast<ColumnData<float>&>(*this);
                                    if (!isRead()) col.readColumnData(first,nelements);                                  
                                    FITSUtil::fill(vals,col.data(),first,last);
                            }
                            else if (type() == Tint)
                            {
                                    int nullVal(0);
                                    if (nullValue) nullVal = static_cast<int>(*nullValue);
                                    ColumnData<int>& col  
                                       = dynamic_cast<ColumnData<int>&>(*this);
                                    if (!isRead()) col.readColumnData(first,nelements,&nullVal);                                  
                                    FITSUtil::fill(vals,col.data(),first,last);
                            }
                            else if (type() == Tshort)
                            {
                                    short nullVal(0);
                                    if (nullValue) nullVal = static_cast<short>(*nullValue);
                                    ColumnData<short>& col 
                                     = dynamic_cast<ColumnData<short>&>(*this);
                                    if (!isRead()) col.readColumnData(first,nelements,&nullVal);                                  
                                    FITSUtil::fill(vals,col.data(),first,last);
                            }
                            else if (type() == Tlong)
                            {   
                                    long nullVal(0);
                                    if (nullValue) nullVal = static_cast<long>(*nullValue); 
                                    ColumnData<long>& col 
                                      = dynamic_cast<ColumnData<long>&>(*this);
                                    if (!isRead()) col.readColumnData(first,nelements,&nullVal);                                  
                                    FITSUtil::fill(vals,col.data(),first,last);
                            }
                            else if (type() == Tlonglong)
                            {   
                                    LONGLONG nullVal(0);
                                    if (nullValue) nullVal = static_cast<LONGLONG>(*nullValue); 
                                    ColumnData<LONGLONG>& col 
                                      = dynamic_cast<ColumnData<LONGLONG>&>(*this);
                                    if (!isRead()) col.readColumnData(first,nelements,&nullVal);                                  
                                    FITSUtil::fill(vals,col.data(),first,last);
                            }
                            else if (type() == Tlogical)
                            {   
                                    bool nullVal(0);
                                    if (nullValue) nullVal = static_cast<bool>(*nullValue); 
                                    ColumnData<bool>& col 
                                      = dynamic_cast<ColumnData<bool>&>(*this);
                                    if (!isRead()) col.readColumnData(first,nelements,&nullVal);                                  
                                    FITSUtil::fill(vals,col.data(),first,last);
                            }
                            else if (type() == Tbit || type() == Tbyte)
                            {
                                    unsigned char nullVal(0);
                                    if (nullValue) nullVal = static_cast<unsigned char>(*nullValue); 
                                    ColumnData<unsigned char>& col 
                                            = dynamic_cast<ColumnData<unsigned char>&>(*this);
                                    if (!isRead()) col.readColumnData(first,nelements,&nullVal); 
                                    FITSUtil::fill(vals,col.data(),first,last);
                            }
                            else if (type() == Tushort)
                            {
                                    unsigned short nullVal(0);
                                    if (nullValue) nullVal= static_cast<unsigned short>(*nullValue);
                                    ColumnData<unsigned short>& col 
                                            = dynamic_cast<ColumnData<unsigned short>&>(*this);
                                    if (!isRead()) col.readColumnData(first,nelements,&nullVal);                                  
                                    FITSUtil::fill(vals,col.data(),first,last);
                            }
                            else if (type() == Tuint)
                            {
                                    unsigned int nullVal(0);
                                    if (nullValue) nullVal = static_cast<unsigned int>(*nullValue);
                                    ColumnData<unsigned int>& col 
                                            = dynamic_cast<ColumnData<unsigned int>&>(*this);
                                    if (!isRead()) col.readColumnData(first,nelements,&nullVal);                                  
                                    FITSUtil::fill(vals,col.data(),first,last);
                            }
                            else if (type() == Tulong)
                            {
                                    unsigned long nullVal(0);
                                    if (nullValue) nullVal = static_cast<unsigned long>(*nullValue);
                                    ColumnData<unsigned long>& col 
                                             = dynamic_cast<ColumnData<unsigned long>&>(*this);
                                    if (!isRead()) col.readColumnData(first,nelements,&nullVal);                                  
                                    FITSUtil::fill(vals,col.data(),first,last);
                            }
                            else
                            {
                                      throw InvalidDataType(name());

                            }

                        }
                        catch (std::bad_cast)
                        {
                                throw WrongColumnType(name());
                        }
                }

        }

        template <typename S>
        void Column::read(std::valarray<S>& vals, long first, long last) 
        {
                read(vals,first,last,static_cast<S*>(0));
        }


        template <typename S>
        void Column::read(std::valarray<S>& vals, long first, long last, S* nullValue) 
        {        
                // require the whole scalar column to have been read.


                long nelements = numberOfElements(first,last);
                parent()->makeThisCurrent();                
                if ( ColumnData<S>* col = dynamic_cast<ColumnData<S>*>(this))
                {
                        // fails if user requested outputType different from input type.


                        if (!isRead()) col->readColumnData(first,nelements,nullValue);                                  
                        FITSUtil::fill(vals,col->data(),first,last);

                }
                else
                {
                        FITSUtil::MatchType<S> outputType;
                        if ( outputType() == type() ) 
                        { 
                                // in this case user tried to read vector data from scalar,
                                // (i.e. first argument was vector<valarray<S> >.
                                // since the cast won't fail on template parameter grounds.
                                throw Column::WrongColumnType(name());
                        }

                        try
                        {
                            // about exceptions. The dynamic_casts could throw
                            // std::bad_cast. If this happens something is seriously
                            // wrong since the Column stores the value of type() 
                            // appropriate to each of the casts on construction.
                            // 
                            // the InvalidDataType exception should not be possible.
                            if  ( type() == Tdouble )
                            {
                                    ColumnData<double>& col 
                                              = dynamic_cast<ColumnData<double>&>(*this);
                                    if (!isRead()) col.readColumnData(first,nelements);                                  
                                    FITSUtil::fill(vals,col.data(),first,last);
                            }
                            else if (type() == Tfloat)
                            {
                                    ColumnData<float>& col 
                                            = dynamic_cast<ColumnData<float>&>(*this);
                                    if (!isRead()) col.readColumnData(first,nelements);                                  
                                    FITSUtil::fill(vals,col.data(),first,last);
                            }
                            else if (type() == Tint)
                            {
                                    int nullVal(0);
                                    if (nullValue) nullVal = static_cast<int>(*nullValue); 
                                    ColumnData<int>& col  
                                            = dynamic_cast<ColumnData<int>&>(*this);
                                    if (!isRead()) col.readColumnData(first,nelements,&nullVal);                                    
                                    FITSUtil::fill(vals,col.data(),first,last);
                            }
                            else if (type() == Tshort)
                            {
                                    short nullVal(0);
                                    if (nullValue) nullVal = static_cast<short>(*nullValue); 
                                    ColumnData<short>& col 
                                            = dynamic_cast<ColumnData<short>&>(*this);
                                    if (!isRead()) col.readColumnData(first,nelements,&nullVal);                                    
                                    FITSUtil::fill(vals,col.data(),first,last);
                            }
                            else if (type() == Tlong)
                            {   
                                    long nullVal(0);
                                    if (nullValue) nullVal = static_cast<long>(*nullValue); 
                                    ColumnData<long>& col 
                                            = dynamic_cast<ColumnData<long>&>(*this);
                                    if (!isRead()) col.readColumnData(first,nelements,&nullVal);
                                    FITSUtil::fill(vals,col.data(),first,last);
                            }
                            else if (type() == Tlonglong)
                            {   
                                    LONGLONG nullVal(0);
                                    if (nullValue) nullVal = static_cast<LONGLONG>(*nullValue); 
                                    ColumnData<LONGLONG>& col 
                                            = dynamic_cast<ColumnData<LONGLONG>&>(*this);
                                    if (!isRead()) col.readColumnData(first,nelements,&nullVal);
                                    FITSUtil::fill(vals,col.data(),first,last);
                            }
                            else if (type() == Tlogical)
                            {   
                                    bool nullVal(0);
                                    if (nullValue) nullVal = static_cast<bool>(*nullValue); 
                                    ColumnData<bool>& col 
                                            = dynamic_cast<ColumnData<bool>&>(*this);
                                    if (!isRead()) col.readColumnData(first,nelements,&nullVal);                                    
                                    FITSUtil::fill(vals,col.data(),first,last);
                            }
                            else if (type() == Tbit || type() == Tbyte)
                            {
                                    unsigned char nullVal(0);
                                    if (nullValue) nullVal = static_cast<unsigned char>(*nullValue); 
                                    ColumnData<unsigned char>& col 
                                            = dynamic_cast<ColumnData<unsigned char>&>(*this);
                                    if (!isRead()) col.readColumnData(first,nelements,&nullVal);                                    
                                    FITSUtil::fill(vals,col.data(),first,last);
                            }
                            else if (type() == Tushort)
                            {
                                    unsigned short nullVal(0);
                                    if (nullValue) nullVal 
                                            = static_cast<unsigned short>(*nullValue); 
                                    ColumnData<unsigned short>& col 
                                            = dynamic_cast<ColumnData<unsigned short>&>(*this);
                                    if (!isRead()) col.readColumnData(first,nelements,&nullVal);                                    
                                    FITSUtil::fill(vals,col.data(),first,last);
                            }
                            else if (type() == Tuint)
                            {
                                    unsigned int nullVal(0);
                                    if (nullValue) nullVal 
                                            = static_cast<unsigned int>(*nullValue); 
                                    ColumnData<unsigned int>& col 
                                            = dynamic_cast<ColumnData<unsigned int>&>(*this);
                                    if (!isRead()) col.readColumnData(first,nelements,&nullVal);                                    
                                    FITSUtil::fill(vals,col.data(),first,last);
                            }
                            else if (type() == Tulong)
                            {
                                    unsigned long nullVal(0);
                                    if (nullValue) nullVal 
                                            = static_cast<unsigned long>(*nullValue); 
                                    ColumnData<unsigned long>& col 
                                            = dynamic_cast<ColumnData<unsigned long>&>(*this);
                                    if (!isRead()) col.readColumnData(first,nelements,&nullVal);                                    
                                    FITSUtil::fill(vals,col.data(),first,last);
                            }
                            else
                            {
                                      throw InvalidDataType(name());

                            }

                        }
                        catch (std::bad_cast)
                        {
                             throw WrongColumnType(name());
                        }
                    }

        }

        // get a single row from a vector column. There's no default row number, must
        // be specified.
        template <typename S>
        void Column::read(std::valarray<S>& vals, long row) 
        {
                read(vals,row,static_cast<S*>(0));
        }


        template <typename S>
        void Column::read(std::valarray<S>& vals, long row, S* nullValue) 
        {
                if (row > parent()->rows())
                {
                   throw Column::InvalidRowNumber(name());
                }
                parent()->makeThisCurrent();                
                // isRead() returns true if the data were read in the ctor.
                if ( ColumnVectorData<S>* col = dynamic_cast<ColumnVectorData<S>*>(this))
                {
                        // fails if user requested outputType different from input type.



                        // input and output are both valarrays. Since one should not
                        // be able to call a constructor for a non-numeric valarray type,
                        // there shouldn't be any InvalidType problems. However, there
                        // is still the vector/scalar possibility and the implicit
                        // conversion request to deal with.

                        if (!isRead()) col->readRow(row,nullValue);
                        FITSUtil::fill(vals,col->data(row));
                }
                else
                {
                        FITSUtil::MatchType<S> outputType;
                        if ( outputType() == type() ) 
                        { 
                                // in this case user tried to read vector row from scalar column.
                                // one could be charitable and return a valarray of size 1,
                                // but... I'm going to throw an exception suggesting the user
                                // might not have meant that.

                                throw Column::WrongColumnType(name());
                        }

                        // the InvalidDataType exception should not be possible.
                        try
                        {
                            // about exceptions. The dynamic_casts could throw
                            // std::bad_cast. If this happens something is seriously
                            // wrong since the Column stores the value of type() 
                            // appropriate to each of the casts on construction.
                            // 
                            // the InvalidDataType exception should not be possible.
                            if  ( type() == Tdouble || type() == VTdouble )
                            {
                                    ColumnVectorData<double>& col 
                                              = dynamic_cast<ColumnVectorData<double>&>(*this);
                                    if (!isRead()) col.readRow(row);                                  
                                    FITSUtil::fill(vals,col.data(row));

                            }
                            else if (type() == Tfloat  || type() == VTfloat )
                            { 
                                    ColumnVectorData<float>& col 
                                          = dynamic_cast<ColumnVectorData<float>&>(*this);
                                    if (!isRead()) col.readRow(row); 
                                    FITSUtil::fill(vals,col.data(row));
                            }
                            else if (type() == Tint  || type() == VTint )
                            {
                                    int nullVal(0);
                                    if (nullValue) nullVal = static_cast<int>(*nullValue); 
                                    ColumnVectorData<int>& col  
                                            = dynamic_cast<ColumnVectorData<int>&>(*this);
                                    if (!isRead()) col.readRow(row,&nullVal); 
                                    FITSUtil::fill(vals,col.data(row));
                            }
                            else if (type() == Tshort  || type() == VTshort  )
                            {
                                    short nullVal(0);
                                    if (nullValue) nullVal = static_cast<short>(*nullValue); 
                                    ColumnVectorData<short>& col 
                                            = dynamic_cast<ColumnVectorData<short>&>(*this);
                                    if (!isRead()) col.readRow(row,&nullVal); 
                                    FITSUtil::fill(vals,col.data(row));
                            }
                            else if (type() == Tlong  || type() == VTlong )
                            {   
                                    long nullVal(0);
                                    if (nullValue) nullVal = static_cast<long>(*nullValue); 
                                    ColumnVectorData<long>& col 
                                            = dynamic_cast<ColumnVectorData<long>&>(*this);
                                    if (!isRead()) col.readRow(row,&nullVal); 
                                    FITSUtil::fill(vals,col.data(row));
                            }
                            else if (type() == Tlonglong  || type() == VTlonglong )
                            {   
                                    LONGLONG nullVal(0);
                                    if (nullValue) nullVal = static_cast<LONGLONG>(*nullValue); 
                                    ColumnVectorData<LONGLONG>& col 
                                            = dynamic_cast<ColumnVectorData<LONGLONG>&>(*this);
                                    if (!isRead()) col.readRow(row,&nullVal); 
                                    FITSUtil::fill(vals,col.data(row));
                            }
                            else if (type() == Tlogical  || type() == VTlogical )
                            {   
                                    bool nullVal(0);
                                    if (nullValue) nullVal = static_cast<bool>(*nullValue); 
                                    ColumnVectorData<bool>& col 
                                            = dynamic_cast<ColumnVectorData<bool>&>(*this);
                                    if (!isRead()) col.readRow(row,&nullVal); 
                                    FITSUtil::fill(vals,col.data(row));
                            }
                            else if (type() == Tbit || type() == Tbyte ||  
                                    type() == VTbit || type() == VTbyte )
                            {
                                    unsigned char nullVal(0);
                                    if (nullValue) nullVal 
                                                = static_cast<unsigned char>(*nullValue); 
                                    ColumnVectorData<unsigned char>& col 
                                          = dynamic_cast<ColumnVectorData<unsigned char>&>(*this);
                                    if (!isRead()) col.readRow(row,&nullVal); 
                                    FITSUtil::fill(vals,col.data(row));
                            }
                            else if (type() == Tushort || type() == VTushort)
                            {
                                    unsigned short nullVal(0);
                                    if (nullValue) nullVal 
                                                = static_cast<unsigned short>(*nullValue); 
                                    ColumnVectorData<unsigned short>& col 
                                          = dynamic_cast<ColumnVectorData<unsigned short>&>(*this);
                                    if (!isRead()) col.readRow(row,&nullVal); 
                                    FITSUtil::fill(vals,col.data(row));
                            }
                            else if (type() == Tuint || type() == VTuint)
                            {
                                    unsigned int nullVal(0);
                                    if (nullValue) nullVal 
                                                = static_cast<unsigned int>(*nullValue); 
                                    ColumnVectorData<unsigned int>& col 
                                          = dynamic_cast<ColumnVectorData<unsigned int>&>(*this);
                                    if (!isRead()) col.readRow(row,&nullVal); 
                                    FITSUtil::fill(vals,col.data(row));
                            }
                            else if (type() == Tulong || type() == VTulong)
                            {
                                    unsigned long nullVal(0);
                                    if (nullValue) nullVal 
                                                = static_cast<unsigned long>(*nullValue); 
                                    ColumnVectorData<unsigned long>& col 
                                            = dynamic_cast<ColumnVectorData<unsigned long>&>(*this);
                                    if (!isRead()) col.readRow(row,&nullVal); 
                                    FITSUtil::fill(vals,col.data(row));
                            }
                            else
                            {
                                    throw InvalidDataType(name());

                            }

                        }
                        catch (std::bad_cast)
                        {
                            throw WrongColumnType(name());
                        }     
                 }
        }

        template <typename S>
        void Column::readArrays(std::vector<std::valarray<S> >& vals, long first, long last)  
        {
                readArrays(vals,first,last,static_cast<S*>(0));
        }

        template <typename S>
        void Column::readArrays(std::vector<std::valarray<S> >& vals, 
                                long first, long last, S* nullValue)
        {

                parent()->makeThisCurrent();
                // again, can only call this if the entire column has been read from disk.
                // user expects 1 based indexing. If 0 based indices are supplied,
                // add one to both ranges.
                long range = numberOfElements(first,last);

                vals.resize(range);


                if ( ColumnVectorData<S>* col = dynamic_cast<ColumnVectorData<S>*>(this))
                {
                        for (int j = 0; j < range; ++j) 
                        {
                                if (!isRead()) col->readRow(j + first,nullValue);                             
                                FITSUtil::fill(vals[j],col->data(j+first));
                        }
                }
                else
                {
                        FITSUtil::MatchType<S> outputType;
                        if ( outputType() == type() ) 
                        { 
                                // in this case user tried to read vector data from scalar,
                                // (i.e. first argument was vector<valarray<S> >.
                                // since the cast won't fail on template parameter grounds.
                                throw Column::WrongColumnType(name());
                        }
                        // the InvalidDataType exception should not be possible.
                        try
                        {
                            if  ( type() == Tdouble || type() == VTdouble )
                            {
                                    ColumnVectorData<double>& col 
                                            = dynamic_cast<ColumnVectorData<double>&>(*this);
                                    for (int j = 0; j < range; ++j) 
                                    {
                                        if (!isRead()) col.readRow(j + first); 
                                        FITSUtil::fill(vals[j],col.data(j+first));
                                    }
                            }
                            else if  ( type() == Tfloat || type() == VTfloat  )
                            {
                                    ColumnVectorData<float>& col 
                                            = dynamic_cast<ColumnVectorData<float>&>(*this);
                                    for (int j = 0; j < range; ++j) 
                                    {
                                        if (!isRead()) col.readRow(j + first); 
                                        FITSUtil::fill(vals[j],col.data(j+first));
                                    }
                            }
                            else if  ( type() == Tint   || type() == VTint )
                            {
                                    int nullVal(0);
                                    if (nullValue) nullVal  = static_cast<int>(*nullValue); 
                                    ColumnVectorData<int>& col  
                                            = dynamic_cast<ColumnVectorData<int>&>(*this);
                                    for (int j = 0; j < range; ++j) 
                                    {
                                        if (!isRead()) col.readRow(j + first,&nullVal); 
                                        FITSUtil::fill(vals[j],col.data(j+first));
                                    }
                            }
                            else if  ( type() == Tshort  || type() == VTshort )
                            {
                                    short nullVal(0);
                                    if (nullValue) nullVal  = static_cast<short>(*nullValue); 
                                    ColumnVectorData<short>& col 
                                            = dynamic_cast<ColumnVectorData<short>&>(*this);
                                    for (int j = 0; j < range; ++j) 
                                    {
                                        if (!isRead()) col.readRow(j + first,&nullVal); 
                                        FITSUtil::fill(vals[j],col.data(j+first));
                                    }
                            }
                            else if  ( type() == Tlong   || type() == VTlong )
                            {
                                    long nullVal(0);
                                    if (nullValue) nullVal  = static_cast<long>(*nullValue); 
                                    ColumnVectorData<long>& col 
                                            = dynamic_cast<ColumnVectorData<long>&>(*this);
                                    for (int j = 0; j < range; ++j) 
                                    {
                                        if (!isRead()) col.readRow(j + first,&nullVal); 
                                        FITSUtil::fill(vals[j],col.data(j+first));
                                    }
                            }
                            else if  ( type() == Tlonglong   || type() == VTlonglong )
                            {
                                    LONGLONG nullVal(0);
                                    if (nullValue) nullVal  = static_cast<LONGLONG>(*nullValue); 
                                    ColumnVectorData<LONGLONG>& col 
                                            = dynamic_cast<ColumnVectorData<LONGLONG>&>(*this);
                                    for (int j = 0; j < range; ++j) 
                                    {
                                        if (!isRead()) col.readRow(j + first,&nullVal); 
                                        FITSUtil::fill(vals[j],col.data(j+first));
                                    }
                            }
                            else if  ( type() == Tlogical   || type() == VTlogical )
                            {
                                    bool nullVal(0);
                                    if (nullValue) nullVal   = static_cast<bool>(*nullValue); 
                                    ColumnVectorData<bool>& col 
                                            = dynamic_cast<ColumnVectorData<bool>&>(*this);
                                    for (int j = 0; j < range; ++j) 
                                    {
                                        if (!isRead()) col.readRow(j + first,&nullVal); 
                                        FITSUtil::fill(vals[j],col.data(j+first));
                                    }
                            }
                            else if (type() == Tbit || type() == Tbyte ||  
                                    type() == VTbit || type() == VTbyte )
                            {
                                    unsigned char nullVal(0);
                                    if (nullValue) nullVal 
                                                = static_cast<unsigned char>(*nullValue); 
                                    ColumnVectorData<unsigned char>& col 
                                           = dynamic_cast<ColumnVectorData<unsigned char>&>(*this);
                                    for (int j = 0; j < range; ++j) 
                                    {
                                        if (!isRead()) col.readRow(j + first,&nullVal); 
                                        FITSUtil::fill(vals[j],col.data(j+first));
                                    }
                            }                            
                            else if  ( type() == Tushort   || type() == VTushort )
                            {
                                    unsigned short nullVal(0);
                                    if (nullValue) nullVal 
                                                = static_cast<unsigned short>(*nullValue); 
                                    ColumnVectorData<unsigned short>& col 
                                        = dynamic_cast<ColumnVectorData<unsigned short>&>(*this);
                                    for (int j = 0; j < range; ++j) 
                                    {
                                        if (!isRead()) col.readRow(j + first,&nullVal); 
                                        FITSUtil::fill(vals[j],col.data(j+first));
                                    }
                            }
                            else if  ( type() == Tuint   || type() == VTuint )
                            {
                                    unsigned int nullVal(0);
                                    if (nullValue) nullVal 
                                                = static_cast<unsigned int>(*nullValue); 
                                    ColumnVectorData<unsigned int>& col 
                                            = dynamic_cast<ColumnVectorData<unsigned int>&>(*this);
                                    for (int j = 0; j < range; ++j) 
                                    {
                                        if (!isRead()) col.readRow(j + first,&nullVal); 
                                        FITSUtil::fill(vals[j],col.data(j+first));
                                    }
                            }
                            else if  ( type() == Tulong   || type() == VTulong  )
                            {
                                    unsigned long nullVal(0);
                                    if (nullValue) nullVal 
                                                = static_cast<unsigned long>(*nullValue); 
                                    ColumnVectorData<unsigned long>& col 
                                          = dynamic_cast<ColumnVectorData<unsigned long>&>(*this);
                                    for (int j = 0; j < range; ++j) 
                                    {
                                        if (!isRead()) col.readRow(j + first,&nullVal); 
                                        FITSUtil::fill(vals[j],col.data(j+first));
                                    }
                            } 
                            else
                            {
                                    throw InvalidDataType(name());
                            }

                        }
                        catch (std::bad_cast)
                        {
                            throw WrongColumnType(name());

                        }     

                }        
        }

        template <typename S>                   
        void Column::write (const std::vector<S>& indata, long firstRow)
        {
                // nullValue is now a pointer, so this is ok. 
                // got to cast the 0 to a pointer to S to avoid
                // overloading ambiguities.      
                write(indata,firstRow,static_cast<S*>(0));
        }

        template <typename S>                   
        void Column::write (const std::valarray<S>& indata, long firstRow)
        {
                size_t n(indata.size());
                std::vector<S> __tmp(n);
                for (size_t j = 0; j < n; ++j) __tmp[j] = indata[j];
                write(__tmp,firstRow,static_cast<S*>(0));
        }

        template <typename S>                   
        void Column::write (S* indata, long nRows, long firstRow)
        {
                write(indata,nRows,firstRow,static_cast<S*>(0));                
        }


        template <typename S>                   
        void Column::write (const std::vector<S>& indata, long firstRow, S* nullValue)
        {
                // although underlying code needs to convert the input vector
                // into a C array, this must be the underlying implementation
                // [which the others call] because it accepts string arguments
                // which the version with a pointer won't. [no version that
                // translates to a char** argument].


                parent()->makeThisCurrent();
                firstRow = std::max(firstRow,static_cast<long>(1));
                if (ColumnData<S>* col = dynamic_cast<ColumnData<S>*>(this))
                {
                        col->writeData(indata,firstRow,nullValue);
                }
                else
                {
                        // alright, input data type has to be rewritten as output
                        // data type.
                        FITSUtil::MatchType<S> inType;
                        if ( inType() == type()) 
                        {
                                String msg("Incorrect call: writing to vector column ");
                                msg += name();
                                msg += " requires specification of # rows or vector lengths";
                                throw WrongColumnType(msg);
                        }
                        else
                        {
                            if  ( type() == Tdouble )
                            {
                                ColumnData<double>& col 
                                        = dynamic_cast<ColumnData<double>&>(*this);
                                std::vector<double> __tmp;
                                FITSUtil::fill(__tmp,indata,1,indata.size());
                                col.writeData(__tmp,firstRow);
                            }
                            else if  ( type() == Tfloat )
                            {
                                ColumnData<float>& col 
                                        = dynamic_cast<ColumnData<float>&>(*this);
                                std::vector<float> __tmp;
                                FITSUtil::fill(__tmp,indata,1,indata.size());
                                col.writeData(__tmp,firstRow);
                            }
                            else if  ( type() == Tint )
                            {
                                int nullVal = 0;
                                int* pNullVal = 0;
                                if (nullValue)
                                {
                                   nullVal = static_cast<int>(*nullValue);
                                   pNullVal = &nullVal;
                                }
                                if (nullValue) nullVal = static_cast<int>(*nullValue); 
                                ColumnData<int>& col  
                                        = dynamic_cast<ColumnData<int>&>(*this);
                                std::vector<int> __tmp;
                                FITSUtil::fill(__tmp,indata,1,indata.size());
                                col.writeData(__tmp,firstRow,pNullVal);
                            }
                            else if  ( type() == Tshort )
                            {
                                short nullVal(0);
                                short* pNullVal = 0;
                                if (nullValue) 
                                {
                                   nullVal = static_cast<short>(*nullValue); 
                                   pNullVal = &nullVal;
                                }
                                ColumnData<short>& col 
                                        = dynamic_cast<ColumnData<short>&>(*this);
                                std::vector<short> __tmp;
                                FITSUtil::fill(__tmp,indata,1,indata.size());
                                col.writeData(__tmp,firstRow,pNullVal);
                            }
                            else if  ( type() == Tlong )
                            {
                                long nullVal(0);
                                long* pNullVal = 0;
                                if (nullValue)
                                {
                                   nullVal = static_cast<long>(*nullValue); 
                                   pNullVal = &nullVal;
                                }
                                ColumnData<long>& col 
                                        = dynamic_cast<ColumnData<long>&>(*this);
                                std::vector<long> __tmp;
                                FITSUtil::fill(__tmp,indata,1,indata.size());
                                col.writeData(__tmp,firstRow,pNullVal);
                            }
                            else if  ( type() == Tlonglong )
                            {
                                LONGLONG nullVal(0);
                                LONGLONG* pNullVal = 0;
                                if (nullValue)
                                {
                                   nullVal = static_cast<LONGLONG>(*nullValue); 
                                   pNullVal = &nullVal;
                                }
                                ColumnData<LONGLONG>& col 
                                        = dynamic_cast<ColumnData<LONGLONG>&>(*this);
                                std::vector<LONGLONG> __tmp;
                                FITSUtil::fill(__tmp,indata,1,indata.size());
                                col.writeData(__tmp,firstRow,pNullVal);
                            }
                            else if  ( type() == Tlogical )
                            {
                                bool nullVal(0);
                                bool* pNullVal = 0;
                                if (nullValue)
                                {
                                   nullVal = static_cast<bool>(*nullValue); 
                                   pNullVal = &nullVal;
                                }
                                ColumnData<bool>& col 
                                        = dynamic_cast<ColumnData<bool>&>(*this);
                                std::vector<bool> __tmp;
                                FITSUtil::fill(__tmp,indata,1,indata.size());
                                col.writeData(__tmp,firstRow,pNullVal);
                            }
                            else if  ( type() == Tbyte )
                            {
                                unsigned char nullVal(0);
                                unsigned char* pNullVal = 0;
                                if (nullValue)
                                {
                                   nullVal = static_cast<unsigned char>(*nullValue); 
                                   pNullVal = &nullVal;
                                }
                                ColumnData<unsigned char>& col 
                                        = dynamic_cast<ColumnData<unsigned char>&>(*this);
                                std::vector<unsigned char> __tmp;
                                FITSUtil::fill(__tmp,indata,1,indata.size());
                                col.writeData(__tmp,firstRow,pNullVal);
                            }                            
                            else if  ( type() == Tushort )
                            {
                                unsigned short nullVal(0);
                                unsigned short* pNullVal = 0;
                                if (nullValue)
                                {
                                   nullVal = static_cast<unsigned short>(*nullValue);
                                   pNullVal = &nullVal;
                                } 
                                ColumnData<unsigned short>& col 
                                        = dynamic_cast<ColumnData<unsigned short>&>(*this);
                                std::vector<unsigned short> __tmp;
                                FITSUtil::fill(__tmp,indata,1,indata.size());
                                col.writeData(__tmp,firstRow,pNullVal);
                            }
                            else if  ( type() == Tuint )
                            {
                                unsigned int nullVal(0);
                                unsigned int* pNullVal = 0;
                                if (nullValue)
                                {
                                   nullVal = static_cast<unsigned int>(*nullValue);
                                   pNullVal = &nullVal;
                                } 
                                ColumnData<unsigned int>& col 
                                        = dynamic_cast<ColumnData<unsigned int>&>