Program Listing for File IDataArray.hpp

↰ Return to documentation for file (include/nix/base/IDataArray.hpp)

// Copyright (c) 2013, German Neuroinformatics Node (G-Node)
//
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted under the terms of the BSD License. See
// LICENSE file in the root of the Project.

#ifndef NIX_I_DATA_ARRAY_H
#define NIX_I_DATA_ARRAY_H

#include <nix/base/IEntityWithSources.hpp>
#include <nix/base/IDimensions.hpp>
#include <nix/DataFrame.hpp>
#include <nix/Compression.hpp>
#include <nix/DataType.hpp>
#include <nix/NDSize.hpp>
#include <nix/ObjectType.hpp>

#include <string>
#include <vector>

namespace nix {
namespace base {

class NIXAPI IDataArray : virtual public base::IEntityWithSources {

public:

    //--------------------------------------------------
    // Element getters and setters
    //--------------------------------------------------

    virtual boost::optional<std::string> label() const = 0;


    virtual void label(const std::string &label) = 0;


    virtual void label(const none_t t) = 0;


    virtual boost::optional<std::string> unit() const = 0;


    virtual void unit(const std::string &unit) = 0;


    virtual void unit(const none_t t) = 0;


    virtual boost::optional<double> expansionOrigin()const = 0;


    virtual void expansionOrigin(double expansion_origin) = 0;


    virtual void expansionOrigin(const none_t t) = 0;


    virtual void polynomCoefficients(const std::vector<double> &polynom_coefficients,
                                     const Compression &compression) = 0;


    virtual std::vector<double> polynomCoefficients() const = 0;



    virtual void polynomCoefficients(const none_t t) = 0;

    //--------------------------------------------------
    // Methods concerning dimensions
    //--------------------------------------------------


    virtual ndsize_t dimensionCount() const = 0;


    virtual std::shared_ptr<base::IDimension> getDimension(ndsize_t id) const = 0;


    virtual std::shared_ptr<base::ISetDimension> createSetDimension(ndsize_t id) = 0;


    virtual std::shared_ptr<base::IRangeDimension> createRangeDimension(ndsize_t id, const std::vector<double> &ticks) = 0;


    virtual std::shared_ptr<base::IRangeDimension> createAliasRangeDimension() = 0;


    virtual std::shared_ptr<base::ISampledDimension> createSampledDimension(ndsize_t id, double sampling_interval) = 0;


    virtual std::shared_ptr<base::IDataFrameDimension> createDataFrameDimension(ndsize_t id, const DataFrame &frame) = 0;



    virtual std::shared_ptr<base::IDataFrameDimension> createDataFrameDimension(ndsize_t id, const DataFrame &frame, unsigned column_index) = 0;


    virtual bool deleteDimensions() = 0;

    //--------------------------------------------------
    // Methods concerning data access.
    //--------------------------------------------------

    virtual void createData(DataType dtype, const NDSize &size, const Compression &compression) = 0;

    virtual bool hasData() const = 0;

    virtual void write(DataType dtype, const void *data, const NDSize &count, const NDSize &offset) = 0;

    virtual void read(DataType dtype, void *buffer, const NDSize &count, const NDSize &offset) const = 0;


    virtual NDSize dataExtent(void) const = 0;


    virtual void dataExtent(const NDSize &extent) = 0;


    virtual DataType dataType(void) const = 0;

    virtual ~IDataArray() {}

};


} // namespace base

template<>
struct objectToType<nix::base::IDataArray> {
    static const bool isValid = true;
    static const ObjectType value = ObjectType::DataArray;
};

} // namespace nix

#endif // NIX_I_DATA_ARRAY_H