Data.h

Go to the documentation of this file.

/*
 * Fimex
 *
 * (C) Copyright 2008, met.no
 *
 * Project Info:  https://wiki.met.no/fimex/start
 *
 * This library is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 2.1 of the License, or
 * (at your option) any later version.
 *
 * This library 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 Lesser General Public
 * License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
 * USA.
 */

#ifndef DATA_H_
#define DATA_H_

#include "fimex/DataDecl.h"
#include <boost/shared_array.hpp>
#include <string>
#include <sstream>
#include <iostream>
#include "fimex/CDMDataType.h"
#include "fimex/CDMException.h"
#include "fimex/Utils.h"
#include "fimex/deprecated.h"

namespace MetNoFimex
{
    // forward decl.
    class UnitsConverter;

    class Data
    {
    public:
        virtual ~Data() = 0;

        virtual size_t size() const = 0;

        virtual int bytes_for_one() const = 0;
        virtual void* getDataPtr() = 0;
        virtual void toStream(std::ostream&, std::string separator = "") const = 0;

        MIFI_DEPRECATED(virtual const boost::shared_array<char> asConstChar() const) = 0;
        virtual boost::shared_array<char> asChar() const = 0;
        MIFI_DEPRECATED(virtual const boost::shared_array<short> asConstShort() const) = 0;
        virtual boost::shared_array<short> asShort() const = 0;
        MIFI_DEPRECATED(virtual const boost::shared_array<int> asConstInt() const) = 0;
        virtual boost::shared_array<int> asInt() const = 0;
        MIFI_DEPRECATED(virtual const boost::shared_array<long long> asConstInt64() const) = 0;
        virtual boost::shared_array<long long> asInt64() const = 0;
        MIFI_DEPRECATED(virtual const boost::shared_array<unsigned char> asConstUChar() const) = 0;
        virtual boost::shared_array<unsigned char> asUChar() const = 0;
        MIFI_DEPRECATED(virtual const boost::shared_array<unsigned short> asConstUShort() const) = 0;
        virtual boost::shared_array<unsigned short> asUShort() const = 0;
        MIFI_DEPRECATED(virtual const boost::shared_array<unsigned int> asConstUInt() const) = 0;
        virtual boost::shared_array<unsigned int> asUInt() const = 0;
        MIFI_DEPRECATED(virtual const boost::shared_array<unsigned long long> asConstUInt64() const) = 0;
        virtual boost::shared_array<unsigned long long> asUInt64() const = 0;
        MIFI_DEPRECATED(virtual const boost::shared_array<float> asConstFloat() const) = 0;
        virtual boost::shared_array<float> asFloat() const = 0;
        MIFI_DEPRECATED(virtual const boost::shared_array<double> asConstDouble() const) = 0;
        virtual boost::shared_array<double> asDouble() const = 0;
        virtual boost::shared_array<std::string> asStrings() const = 0;
        virtual std::string asString(std::string separator = "") const = 0;


        virtual double getDouble(size_t pos) = 0;
        virtual long long getLongLong(size_t pos) = 0;

        virtual void setValue(size_t pos, double val) = 0;
        virtual void setValues(size_t startPos, const Data& data, size_t first = 0, size_t end = -1) = 0;
        virtual void setAllValues(double val) = 0;
        virtual DataPtr clone() const = 0;
        virtual DataPtr slice(std::vector<size_t> orgDimSize, std::vector<size_t> startDims, std::vector<size_t> outputDimSize) = 0;
        virtual DataPtr convertDataType(double oldFill, double oldScale, double oldOffset, CDMDataType newType, double newFill, double newScale, double newOffset) = 0;

        virtual DataPtr convertDataType(double oldFill, double oldScale, double oldOffset, boost::shared_ptr<UnitsConverter> unitConverter, CDMDataType newType, double newFill, double newScale, double newOffset) = 0;
        virtual CDMDataType getDataType() const = 0;
    };

    DataPtr createData(CDMDataType datatype, size_t length, double val = 0);

    DataPtr createData(size_t length, boost::shared_array<double> array);
    DataPtr createData(size_t length, boost::shared_array<float> array);
    DataPtr createData(size_t length, boost::shared_array<int> array);
    DataPtr createData(size_t length, boost::shared_array<short> array);
    DataPtr createData(size_t length, boost::shared_array<char> array);
    DataPtr createData(size_t length, boost::shared_array<unsigned int> array);
    DataPtr createData(size_t length, boost::shared_array<long long> array);
    DataPtr createData(size_t length, boost::shared_array<unsigned long long> array);
    DataPtr createData(size_t length, boost::shared_array<unsigned short> array);
    DataPtr createData(size_t length, boost::shared_array<unsigned char> array);
    DataPtr createData(size_t length, boost::shared_array<std::string> array);

    template<class InputIterator>
    DataPtr createData(CDMDataType datatype, InputIterator first, InputIterator last);

    DataPtr createDataSlice(CDMDataType datatype, const Data& data, size_t dataStartPos, size_t dataSize);

    /* BELOW follow template implementations */
    template<class InputIterator>
    DataPtr createData(CDMDataType datatype, InputIterator first, InputIterator last)
    {
        size_t length = std::distance(first, last);
        switch (datatype) {
            case CDM_DOUBLE: { boost::shared_array<double> ary(new double[length]);     std::copy(first, last, ary.get()); return createData(length, ary); }
            case CDM_FLOAT:  { boost::shared_array<float> ary(new float[length]);   std::copy(first, last, ary.get()); return createData(length, ary); }
            case CDM_INT64:    { boost::shared_array<long long> ary(new long long[length]);       std::copy(first, last, ary.get()); return createData(length, ary); }
            case CDM_INT:    { boost::shared_array<int> ary(new int[length]);       std::copy(first, last, ary.get()); return createData(length, ary); }
            case CDM_SHORT:  { boost::shared_array<short> ary(new short[length]);   std::copy(first, last, ary.get()); return createData(length, ary); }
            case CDM_CHAR:   { boost::shared_array<char> ary(new char[length]);     std::copy(first, last, ary.get()); return createData(length, ary); }
            case CDM_UINT64:    { boost::shared_array<unsigned long long> ary(new unsigned long long[length]);       std::copy(first, last, ary.get()); return createData(length, ary); }
            case CDM_UINT:    { boost::shared_array<unsigned int> ary(new unsigned int[length]);       std::copy(first, last, ary.get()); return createData(length, ary); }
            case CDM_USHORT:  { boost::shared_array<unsigned short> ary(new unsigned short[length]);   std::copy(first, last, ary.get()); return createData(length, ary); }
            case CDM_UCHAR:   { boost::shared_array<unsigned char> ary(new unsigned char[length]);     std::copy(first, last, ary.get()); return createData(length, ary); }
            case CDM_NAT:
            default: break;
         }
         return createData(0, boost::shared_array<char>(new char[0])); // a dummy dataset
    }

}

#endif /*DATA_H_*/