casa6

#ifndef __casac_variant_h__

#define __casac_variant_h__

​

#include <string>

#include <vector>

#include <complex>

​

namespace casac {

​

class record;

​

class variant {

​

    public:

​

    enum TYPE { RECORD, BOOL, INT, UINT, DOUBLE, COMPLEX, STRING, BOOLVEC, INTVEC, UINTVEC, DOUBLEVEC, COMPLEXVEC, STRINGVEC };

​

    static TYPE compatible_type( TYPE one, TYPE two );

​

    class error {

        public:

        error( std::string msg ) : message_(msg) { }

        const std::string &message( ) const { return message_; }

        private:

        std::string message_;

    };

​

    class overflow : public error {

        public:

        overflow( std::string lbl ) : error(lbl + ": overflow error") { }

    };

​

        variant *clone() const { return new variant(*this); }

        int compare(const variant*) const;

​

    variant( );

    variant(const variant &);

​

    variant(bool arg) : typev(BOOL), shape_(1,1) { val.b = arg;  }

    variant(long arg) : typev(INT), shape_(1,1) { val.i = arg; }

    variant(unsigned long arg) : typev(UINT), shape_(1,1) { val.ui = arg; }

    variant(double arg) : typev(DOUBLE), shape_(1,1) { val.d = arg; }

    variant(std::complex<double> arg) : typev(COMPLEX) { val.c = new std::complex<double>(arg); }

    variant(const char *arg) : typev(STRING), shape_(1,1)

            { val.s = new std::string(arg); }

    variant(const std::string &arg) : typev(STRING), shape_(1,1)

            { val.s = new std::string(arg); }

//

    variant(const std::vector<bool> &arg) : typev(BOOLVEC), shape_(1,arg.size())

            { val.bv = new std::vector<bool>(arg); }

    variant(const std::vector<bool> &arg, const std::vector<ssize_t> &theshape) : typev(BOOLVEC), shape_(theshape)

            { val.bv = new std::vector<bool>(arg); }

    variant(std::vector<bool> *arg) : typev(BOOLVEC), shape_(1,arg->size())

                        { val.bv = arg; }

    variant(std::vector<bool> *arg, std::vector<ssize_t> &theshape) : typev(BOOLVEC), shape_(theshape)

                        { val.bv = arg; }

//

    variant(const std::vector<long> &arg) : typev(INTVEC), shape_(1,arg.size())

            { val.iv = new std::vector<long>(arg); }

    variant(const std::vector<long> &arg, const std::vector<ssize_t> &theshape) : typev(INTVEC), shape_(theshape)

            { val.iv = new std::vector<long>(arg); }

    variant(std::vector<long> *arg) : typev(INTVEC), shape_(1, arg->size())

                        { val.iv = arg; }

    variant(std::vector<long> *arg, std::vector<ssize_t> &theshape) : typev(INTVEC), shape_(theshape)

            { val.iv = arg; }

​

        variant(const std::vector<unsigned long> &arg) : typev(UINTVEC), shape_(1,arg.size())

                        { val.uiv = new std::vector<unsigned long>(arg); }

        variant(const std::vector<unsigned long> &arg, const std::vector<ssize_t> &theshape) : typev(UINTVEC), shape_(theshape)

                        { val.uiv = new std::vector<unsigned long>(arg); }

        variant(std::vector<unsigned long> *arg) : typev(UINTVEC), shape_(1, arg->size())

                        { val.uiv = arg; }

        variant(std::vector<unsigned long> *arg, std::vector<ssize_t> &theshape) : typev(UINTVEC), shape_(theshape)

                        { val.uiv = arg; }

​

//

    variant(const std::vector<double> &arg) : typev(DOUBLEVEC), shape_(1,arg.size())

            { val.dv = new std::vector<double>(arg); }

    variant(const std::vector<double> &arg, const std::vector<ssize_t> &theshape) : typev(DOUBLEVEC), shape_(theshape)

            { val.dv = new std::vector<double>(arg); }

    variant(std::vector<double> *arg) : typev(DOUBLEVEC), shape_(1,arg->size())

            { val.dv = arg; }

    variant(std::vector<double> *arg, std::vector<ssize_t> &theshape) : typev(DOUBLEVEC), shape_(theshape)

            { val.dv = arg; }

​

    variant(const std::vector<std::complex<double> > &arg) : typev(COMPLEXVEC), shape_(1, arg.size())

            { val.cv = new std::vector<std::complex<double> >(arg); }

    variant(const std::vector<std::complex<double> > &arg, const std::vector<ssize_t> &theshape) : typev(COMPLEXVEC), shape_(theshape)

            { val.cv = new std::vector<std::complex<double> >(arg); }

    variant(std::vector<std::complex<double> > *arg) : typev(COMPLEXVEC), shape_(1,arg->size())

                        { val.cv = arg; }