FitsChan.h

Go to the documentation of this file.

/*
 * LSST Data Management System
 * Copyright 2017 AURA/LSST.
 *
 * This product includes software developed by the
 * LSST Project (http://www.lsst.org/).
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU 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 General Public License for more details.
 *
 * You should have received a copy of the LSST License Statement and
 * the GNU General Public License along with this program.  If not,
 * see <https://www.lsstcorp.org/LegalNotices/>.
 */
#ifndef ASTSHIM_FITSCHAN_H
#define ASTSHIM_FITSCHAN_H
 
#include <complex>
#include <string>
#include <vector>
 
#include "astshim/base.h"
#include "astshim/Object.h"
#include "astshim/Stream.h"
#include "astshim/Channel.h"
#include "astshim/KeyMap.h"
 
namespace ast {
 
enum class FitsKeyState {
    ABSENT = 0,  
    NOVALUE,     
    PRESENT      
};
 
enum class CardType {
    NOTYPE = AST__NOTYPE,      
    COMMENT = AST__COMMENT,    
    INT = AST__INT,            
    FLOAT = AST__FLOAT,        
    STRING = AST__STRING,      
    COMPLEXF = AST__COMPLEXF,  
    COMPLEXI = AST__COMPLEXI,  
    LOGICAL = AST__LOGICAL,    
    CONTINUE = AST__CONTINUE,  
    UNDEF = AST__UNDEF,        
};
 
template <typename T>
class FoundValue {
public:
    FoundValue(bool found, T const &value) : found(found), value(value) {}
 
    FoundValue() : found(false), value() {}
    bool found;  
    T value;     
};
 
class FitsChan : public Channel {
public:
    explicit FitsChan(Stream &stream, std::string const &options = "");
 
    virtual ~FitsChan();
 
    FitsChan(FitsChan const &) = delete;
    FitsChan(FitsChan &&) = default;
    FitsChan &operator=(FitsChan const &) = delete;
    FitsChan &operator=(FitsChan &&) = default;
 
    void delFits() {
        astDelFits(getRawPtr());
        assertOK();
    }
 
    void emptyFits() {
        astEmptyFits(getRawPtr());
        assertOK();
    }
 
    FoundValue<std::string> findFits(std::string const &name, bool inc);
 
    FoundValue<std::complex<double>> getFitsCF(std::string const &name = "",
                                               std::complex<double> defval = {0, 0}) const;
 
    FoundValue<std::string> getFitsCN(std::string const &name = "", std::string defval = "") const;
 
    FoundValue<double> getFitsF(std::string const &name = "", double defval = 0) const;
 
    FoundValue<int> getFitsI(std::string const &name = "", int defval = 0) const;
 
    FoundValue<bool> getFitsL(std::string const &name = "", bool defval = false) const;
 
    FoundValue<std::string> getFitsS(std::string const &name = "", std::string defval = "") const;
 
    std::vector<std::string> getAllCardNames();
 
    std::string getAllWarnings() const { return getC("AllWarnings"); }
 
    int getCard() const { return getI("Card"); }
 
    std::string getCardComm() const { return getC("CardComm"); }
 
    std::string getCardName() const { return getC("CardName"); }
 
    CardType getCardType() const { return static_cast<CardType>(getI("CardType")); }
 
    bool getCarLin() const { return getB("CarLin"); }
 
    bool getCDMatrix() const { return getB("CDMatrix"); }
 
    bool getClean() const { return getB("Clean"); }
 
    bool getDefB1950() const { return getB("DefB1950"); }
 
    std::string getEncoding() const { return getC("Encoding"); }
 
    std::string getFitsAxisOrder() const { return getC("FitsAxisOrder"); }
 
    int getFitsDigits() const { return getI("FitsDigits"); }
 
    double getFitsTol() const { return getD("FitsTol"); }
 
    bool getIwc() const { return getB("Iwc"); }
 
    int getNCard() const { return getI("NCard"); }
 
    int getNKey() const { return getI("NKey"); }
 
    bool getSipOK() const { return getB("SipOK"); }
 
    bool getSipReplace() const { return getB("SipReplace"); }
 
    int getTabOK() const { return getI("TabOK"); }
 
    int getPolyTan() const { return getI("PolyTan"); }
 
    std::string getWarnings() const { return getC("Warnings"); }
 
    void purgeWcs() {
        astPurgeWCS(getRawPtr());
        assertOK();
    }
 
    void putCards(std::string const &cards) {
        astPutCards(getRawPtr(), cards.c_str());
        assertOK();
    }
 
    void putFits(std::string const &card, bool overwrite) {
        astPutFits(getRawPtr(), card.c_str(), overwrite);
        assertOK();
    }
 
    void readFits() {
        astReadFits(getRawPtr());
        assertOK();
    }
 
    void retainFits() {
        astRetainFits(getRawPtr());
        assertOK();
    }
 
    void setFitsCF(std::string const &name, std::complex<double> value, std::string const &comment = "",
                   bool overwrite = false) {
        // this use of reinterpret_cast is explicitly permitted, for C compatibility
        astSetFitsCF(getRawPtr(), name.c_str(), reinterpret_cast<double(&)[2]>(value), comment.c_str(),
                     overwrite);
        assertOK();
    }
 
    void setFitsCM(std::string const &comment, bool overwrite = false) {
        astSetFitsCM(getRawPtr(), comment.c_str(), overwrite);
        assertOK();
    }
 
    void setFitsCN(std::string const &name, std::string value, std::string const &comment = "",
                   bool overwrite = false) {
        astSetFitsCN(getRawPtr(), name.c_str(), value.c_str(), comment.c_str(), overwrite);
        assertOK();
    }
 
    void setFitsF(std::string const &name, double value, std::string const &comment = "",
                  bool overwrite = false) {
        astSetFitsF(getRawPtr(), name.c_str(), value, comment.c_str(), overwrite);
        assertOK();
    }
 
    void setFitsI(std::string const &name, int value, std::string const &comment = "",
                  bool overwrite = false) {
        astSetFitsI(getRawPtr(), name.c_str(), value, comment.c_str(), overwrite);
        assertOK();
    }
 
    void setFitsL(std::string const &name, bool value, std::string const &comment = "",
                  bool overwrite = false) {
        astSetFitsL(getRawPtr(), name.c_str(), value, comment.c_str(), overwrite);
        assertOK();
    }
 
    void setFitsS(std::string const &name, std::string value, std::string const &comment = "",
                  bool overwrite = false) {
        astSetFitsS(getRawPtr(), name.c_str(), value.c_str(), comment.c_str(), overwrite);
        assertOK();
    }
 
    void setFitsU(std::string const &name, std::string const &comment = "", bool overwrite = false) {
        astSetFitsU(getRawPtr(), name.c_str(), comment.c_str(), overwrite);
        assertOK();
    }
 
    void setCarLin(bool cdMatrix) { setB("CarLin", cdMatrix); }
 
    void setCDMatrix(bool cdMatrix) { setB("CDMatrix", cdMatrix); }
 
    void setClean(bool clean) { setB("Clean", clean); }
 
    void setDefB1950(bool defB1950) { setB("DefB1950", defB1950); }
 
    void setEncoding(std::string const &encoding) { setC("Encoding", encoding); }
 
    void setFitsAxisOrder(std::string const &order) { setC("FitsAxisOrder", order); }
 
    void setFitsDigits(int digits) { setI("FitsDigits", digits); }
 
    void setFitsTol(double tol) { return setD("FitsTol", tol); }
 
    void setIwc(bool iwcs) { setB("Iwc", iwcs); }
 
    void setSipOK(bool sipOK) { setB("SipOK", sipOK); }
 
    void setSipReplace(bool replace) { setB("SipReplace", replace); }
 
    void setTabOK(int tabOK) { setI("TabOK", tabOK); }
 
    void setPolyTan(int polytan) { setI("PolyTan", polytan); }
 
    void setWarnings(std::string const &warnings) { setC("Warnings", warnings); }
 
    void showFits() const {
        astShowFits(getRawPtr());
        assertOK();
    }
 
    FitsKeyState testFits(std::string const &name = "") const;
 
    void writeFits() {
        astWriteFits(getRawPtr());
        assertOK();
    }
 
    void clearCard() { clear("Card"); }
 
    void setCard(int ind) { setI("Card", ind); }
 
    std::shared_ptr<KeyMap> getTables() const {
        auto *rawKeyMap = reinterpret_cast<AstObject *>(astGetTables(getRawPtr()));
        assertOK(rawKeyMap);
        if (!rawKeyMap) {
            throw std::runtime_error("getTables failed (returned a null keymap)");
        }
        return Object::fromAstObject<KeyMap>(rawKeyMap, true);
    }
 
 
    explicit FitsChan(AstFitsChan *rawFitsChan) : Channel(reinterpret_cast<AstChannel *>(rawFitsChan)) {
        if (!astIsAFitsChan(getRawPtr())) {
            std::ostringstream os;
            os << "this is a " << getClassName() << ", which is not a FitsChan";
            throw std::invalid_argument(os.str());
        }
        assertOK();
    }
};
 
}  // namespace ast
 
#endif