PHDU.h

//  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 PHDU_H
#define PHDU_H 1

// valarray
#include <valarray>
// HDU
#include "HDU.h"
// FITS
#include "FITS.h"
// FITSUtil
#include "FITSUtil.h"

namespace CCfits {
  class FITS;

} // namespace CCfits
// for CLONE_DEFECT
#ifdef _MSC_VER
#include "MSconfig.h"
#endif


namespace CCfits {

/* !\fn  PHDU::PHDU (FITS* p)

    \brief Reading Primary HDU constructor.
   Constructor used  when reading the primary HDU from an existing file.
    Does nothing except initialize, with the real work done by the subclass
    PrimaryHDU<T>.

*/

  class PHDU : public HDU  //## Inherits: <unnamed>%394E6F9800C3
  {

    public:
        virtual ~PHDU();

        //  Read data reads the image if readFlag is true and
        //  optional keywords if supplied. Thus, with no arguments,
        //  readData() does nothing.
        virtual void readData (bool readFlag = false, const std::vector<String>& keys = std::vector<String>()) = 0;
        virtual PHDU * clone (FITS* p) const = 0;
        virtual void zero (double value);
        virtual void scale (double value);
        virtual double zero () const;
        virtual double scale () const;

        bool simple () const;
        bool extend () const;

    public:
      // Additional Public Declarations
      // image reading/writing interface. 

      // The S template parameter, like for Column, denotes the fact that
      // the type of the input array and the object to be read may not match.


      // the rw interface for images consists of equivalents for fits_read_img,
      // fits_read_pix, and fits_read_subset.

      // the paradigm for reading is that the image object (a valarray<T> type)
      // is the size of the data already read.

      // write_subset has no null value aware analogue.
        template <typename S>
        void write(const std::vector<long>& first,
                        long nElements,
                        const std::valarray<S>& data,
                        S* nullValue);


        template <typename S>
        void write(long first,
                        long nElements,
                        const std::valarray<S>& data,
                        S* nullValue);


        template <typename S>
        void write(const std::vector<long>& first,
                        long nElements,
                        const std::valarray<S>& data);


        template <typename S>
        void write(long first,
                        long nElements,
                        const std::valarray<S>& data);

        template <typename S>
        void write(const std::vector<long>& firstVertex,
                        const std::vector<long>& lastVertex,
                        const std::vector<long>& stride, 
                        const std::valarray<S>& data); 

        // read image data and return an array. Can't return a reference
        // because the type conversion needs to allocate a new object in general.

        template<typename S>
        void read(std::valarray<S>& image) ; 

    template<typename S>
        void  read (std::valarray<S>& image, long first,long nElements); 

    template<typename S>
        void read (std::valarray<S>& image, long first,long nElements, S* nullValue) ; 

    template<typename S>
        void read (std::valarray<S>& image, const std::vector<long>& first,long nElements)  ; 

    template<typename S>
        void read (std::valarray<S>& image, const std::vector<long>& first, long nElements, 
                                        S* nullValue); 

        template<typename S>
        void read (std::valarray<S>& image, const std::vector<long>& firstVertex, 
                const std::vector<long>& lastVertex, 
                const std::vector<long>& stride)  ;      

        template<typename S>
        void read (std::valarray<S>& image, const std::vector<long>& firstVertex, 
                const std::vector<long>& lastVertex, 
                const std::vector<long>& stride, 
                                S* nullValue) ; 


    protected:
        PHDU(const PHDU &right);
        //  Constructor for new FITS objects, takes as arguments
        //  the required keywords for a primary HDU.
        PHDU (FITS* p, int bpix, int naxis, const std::vector<long>& axes);
        //  Custom constructor. Allows specification of data to be read and whether to read data at
        //  construction or wait until the image data are requested. The default is 'lazy initialization:'
        //  wait until asked.
        PHDU (FITS* p = 0);

        virtual void initRead ();
        void simple (bool value);
        void extend (bool value);

      // Additional Protected Declarations

    private:
      // Additional Private Declarations

    private: //## implementation
      // Data Members for Class Attributes
        bool m_simple;
        bool m_extend;

      // Additional Implementation Declarations

  };

  // Class CCfits::PHDU 

  inline bool PHDU::simple () const
  {
    return m_simple;
  }

  inline void PHDU::simple (bool value)
  {
    m_simple = value;
  }

  inline bool PHDU::extend () const
  {
    return m_extend;
  }

  inline void PHDU::extend (bool value)
  {
    m_extend = value;
  }

} // namespace CCfits


#endif