casa6

#include <stdcasa/StdCasa/CasacSupport.h>

#include <casacore/casa/Arrays/ArrayMath.h>

#include <casacore/casa/Exceptions/Error.h>

#include <casacore/casa/Containers/Record.h>

#include <casacore/casa/Containers/ValueHolder.h>

#include <casacore/casa/Quanta/QuantumHolder.h>

#include <casacore/casa/Quanta/MVAngle.h>

#include <casacore/measures/Measures/MeasureHolder.h>

#include <casacore/measures/Measures/MeasTable.h>

#include <algorithm>

​

using namespace casacore;

namespace casa {

​

Vector<String> toVectorString(const std::vector<std::string> &theVec){

       Vector<String> b(theVec.size());

       for(unsigned int i=0; i<theVec.size(); i++)

          b[i] = String(theVec[i]);

       return(b);

}

​

String toCasaString(const casac::variant& var){

​

  String out;

  //Going around a bug of toString when its a string vector

  if(var.type()==::casac::variant::STRINGVEC){

    Vector<String> outvec=toVectorString(var.toStringVec());

    if(outvec.nelements() >0)

      out=outvec[0];

    for (uInt k =1; k < outvec.nelements(); ++k){

      out=out+String(",")+outvec[k];

    }

  }

  else{

    out=String(var.toString());

  }

  // [] protection

  if (out.length()>1 && out.firstchar()=='[' && out.lastchar()==']')

    out = out.substr(1,out.length()-2);

​

  return out;

​

}

​

std::vector<string> fromVectorString(const Vector<String> &theVec){

    std::vector<string> b(theVec.size());

       for(unsigned int i=0; i<theVec.size(); i++)

          b[i] = theVec[i].c_str();

       return(b);

}

​

casac::Quantity casacQuantity(const Quantity &quant){

    casac::Quantity cquant(std::vector<double>(1,0.0), "");

    cquant.value[0] = quant.getValue();

    cquant.units = quant.getUnit().c_str();

    return cquant;

}

​

Quantity casaQuantity(const casac::Quantity &cquant){

     if(cquant.value.size() < 1)

        throw(AipsError("Bad quantity conversion"));

     return Quantity(cquant.value[0], Unit(cquant.units));

}

​

Quantity casaQuantity(const casac::variant &theVar){

   casacore::QuantumHolder qh;

   String error;

​

   // Strange "defaults" like BOOLVECs can come in are expected to go out as

   // 0.0.  Therefore unhandled types should produce a default Quantity, not an

   // exception.

   Bool triedAndFailed = false;

​

   const ::casac::variant::TYPE theType = theVar.type();

​

   if(theType == ::casac::variant::STRING ||

      theType == ::casac::variant::STRINGVEC){

     triedAndFailed = !qh.fromString(error, theVar.toString());

   }

   else if(theType == ::casac::variant::RECORD){

     //NOW the record has to be compatible with QuantumHolder::toRecord

     ::casac::variant localvar(theVar);     // Because theVar is const.

     std::unique_ptr<Record> ptrRec(toRecord(localvar.asRecord()));

​

     triedAndFailed = !qh.fromRecord(error, *ptrRec);

   }

   else if(::casac::variant::compatible_type(theType, ::casac::variant::DOUBLE)

       == ::casac::variant::DOUBLE){

     const casacore::Unit unitless("_");            // Dimensionless

​

     //qh = casacore::QuantumHolder(casacore::Quantity(const_cast<Double &>(const_cast<casac::variant &>(theVar).asDouble()),