Program Listing for File Dimensions.hpp

↰ Return to documentation for file (include/nix/Dimensions.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_DIMENSIONS_H
#define NIX_DIMENSIONS_H

#include <nix/base/ImplContainer.hpp>
#include <nix/base/IDimensions.hpp>

#include <nix/DataFrame.hpp>

namespace nix {
class DataArray;
class Dimension;

enum class PositionMatch {
                          Equal,
                          Less,
                          Greater,
                          GreaterOrEqual,
                          LessOrEqual
};

enum class RangeMatch {
                       Inclusive,
                       Exclusive
};

enum class PositionInRange{
                          InRange,
                          Greater,
                          Less,

                          NoRange = -1
};

class NIXAPI SampledDimension : public base::ImplContainer<base::ISampledDimension> {

public:

    SampledDimension();

    SampledDimension(const std::shared_ptr<base::ISampledDimension> &p_impl);

    SampledDimension(std::shared_ptr<base::ISampledDimension> &&ptr);

    SampledDimension(const SampledDimension &other);

    ndsize_t index() const {
        return backend()->index();
    }

    DimensionType dimensionType() const {
        return backend()->dimensionType();
    }

    boost::optional<std::string> label() const {
        return backend()->label();
    }

    void label(const std::string &label);

    void label(const none_t t) {
        backend()->label(t);
    }

    boost::optional<std::string> unit() const {
        return backend()->unit();
    }

    void unit(const std::string &unit);

    void unit(const none_t t) {
        backend()->unit(t);
    }

    double samplingInterval() const {
       return backend()->samplingInterval();
    }

    void samplingInterval(double interval);

    boost::optional<double> offset() const {
        return backend()->offset();
    }

    void offset(double offset) {
        return backend()->offset(offset);
    }

    void offset(const boost::none_t t) {
        backend()->offset(t);
    }

    DEPRECATED ndsize_t indexOf(const double position) const;

    boost::optional<ndsize_t> indexOf(const double position, PositionMatch match) const;


    boost::optional<std::pair<ndsize_t, ndsize_t>> indexOf(const double start, const double end, RangeMatch match) const;

    DEPRECATED std::pair<ndsize_t, ndsize_t> indexOf(const double start, const double end) const;

    boost::optional<std::pair<ndsize_t, ndsize_t>> indexOf(double start, double end, const double sampling_interval, const double offset,
                                                           const RangeMatch match) const;


    std::vector<boost::optional<std::pair<ndsize_t, ndsize_t>>> indexOf(const std::vector<double> &start_positions,
                                                                        const std::vector<double> &end_positions,
                                                                        const RangeMatch match) const;

    DEPRECATED std::vector<std::pair<ndsize_t, ndsize_t>> indexOf(const std::vector<double> &start_positions,
                                                                  const std::vector<double> &end_positions) const;



    double positionAt(const ndsize_t index) const;

    std::vector<double> axis(const ndsize_t count, const ndsize_t startIndex = 0) const;

    SampledDimension& operator=(const SampledDimension &other);

    SampledDimension& operator=(const Dimension &other);

    SampledDimension &operator=(const none_t &t) {
        ImplContainer::operator=(t);
        return *this;
    }

    double operator[](const ndsize_t index) {
        return positionAt(index);
    }
};


class NIXAPI DataFrameDimension : public base::ImplContainer<base::IDataFrameDimension> {

 public:
    DataFrameDimension();

    DataFrameDimension(const std::shared_ptr<base::IDataFrameDimension> &p_impl);

    DataFrameDimension(std::shared_ptr<base::IDataFrameDimension> &&ptr);

    DataFrameDimension(const DataFrameDimension &other);

    boost::optional<unsigned> columnIndex() const {
        return backend()->columnIndex();
    }

    std::shared_ptr<base::IDataFrame> data() const {
        return backend()->dataFrame();
    };

    std::string label(boost::optional<unsigned> col_index = {}) const {
        return backend()->label(col_index);
    }

    std::string unit(boost::optional<unsigned> col_index = {}) const {
        return backend()->unit(col_index);
    }

    nix::DataType columnDataType(boost::optional<unsigned> col_index = {}) const {
        return backend()->columnDataType(col_index);
    }

    template<typename T>
    void ticks(std::vector<T> &ticks, boost::optional<unsigned> col_index = {}, bool resize=false, ndsize_t offset=0) const {
        nix::DataFrame df = data();
        boost::optional<unsigned> column_index;
        if (!col_index) {
            column_index = columnIndex();
        } else {
            column_index = col_index;
        }
        if (!column_index) {
            throw nix::OutOfBounds("DataFrameDimension: Error accessing column, no column index was given and no default is specified.");
        }
        std::vector<Column> cols = df.columns();
        if (static_cast<size_t>(*column_index) >= cols.size()) {
            throw nix::OutOfBounds("DataFrameDimension: Error accessing column, column index exceeds number of columns!");
        }
        df.readColumn(*column_index, ticks, true, offset);
    }

    boost::optional<ndsize_t> indexOf(const double position, const PositionMatch match) const;

    boost::optional<std::pair<ndsize_t, ndsize_t>> indexOf(double start_position, double end_position, RangeMatch range_match) const;

    boost::optional<std::pair<ndsize_t, ndsize_t>> indexOf(double start_position, double end_position, ndsize_t tick_count, RangeMatch range_match) const;

    std::vector<boost::optional<std::pair<ndsize_t, ndsize_t>>> indexOf(const std::vector<double> &start_positions,
                                                                        const std::vector<double> &end_positions,
                                                                        const RangeMatch range_match) const;

    ndsize_t size() const {
        nix::DataFrame df = data();
        return df.rows();
    }

    DimensionType dimensionType() const {
        return backend()->dimensionType();
    }

    DataFrameDimension& operator=(const DataFrameDimension &other);

    DataFrameDimension& operator=(const Dimension &other);

    DataFrameDimension &operator=(const none_t &t) {
        ImplContainer::operator=(t);
        return *this;
    }
};

class NIXAPI SetDimension : public base::ImplContainer<base::ISetDimension> {

public:

    SetDimension();

    SetDimension(const std::shared_ptr<base::ISetDimension> &p_impl);

    SetDimension(std::shared_ptr<base::ISetDimension> &&ptr);

    SetDimension(const SetDimension &other);

    ndsize_t index() const {
        return backend()->index();
    }

    DimensionType dimensionType() const {
        return backend()->dimensionType();
    }

    boost::optional<std::string> label() const {
        return backend()->label();
    }

    void label(const std::string &label);

    void label(const none_t t) {
        backend()->label(t);
    }

    std::vector<std::string> labels() const {
        return backend()->labels();
    }

    void labels(const std::vector<std::string> &labels) {
        backend()->labels(labels);
    }

    void labels(const boost::none_t t) {
        backend()->labels(t);
    }

    boost::optional<ndsize_t> indexOf(const double position, const PositionMatch match) const;


    boost::optional<std::pair<ndsize_t, ndsize_t>> indexOf(const double start, const double end, const RangeMatch match) const;

    boost::optional<std::pair<ndsize_t, ndsize_t>> indexOf(const double start, const double end, std::vector<std::string> &set_labels, const RangeMatch match) const;

    std::vector<boost::optional<std::pair<ndsize_t, ndsize_t>>> indexOf(const std::vector<double> &start_positions,
                                                                        const std::vector<double> &end_positions,
                                                                        const RangeMatch match) const;


    SetDimension& operator=(const SetDimension &other);

    SetDimension& operator=(const Dimension &other);

    SetDimension &operator=(const none_t &t) {
        ImplContainer::operator=(t);
        return *this;
    }

};


class NIXAPI RangeDimension : public base::ImplContainer<base::IRangeDimension> {

public:

    RangeDimension();

    RangeDimension(const DataArray &array);

    RangeDimension(const std::shared_ptr<base::IRangeDimension> &p_impl);

    RangeDimension(std::shared_ptr<base::IRangeDimension> &&ptr);

    RangeDimension(const RangeDimension &other);

    bool alias() const {
        return backend()->alias();
    }
    ndsize_t index() const {
        return backend()->index();
    }

    DimensionType dimensionType() const {
        return backend()->dimensionType();
    }

    boost::optional<std::string> label() const {
        return backend()->label();
    }

    void label(const std::string &label);

    void label(const none_t t) {
        backend()->label(t);
    }

    boost::optional<std::string> unit() const {
        return backend()->unit();
    }

    void unit(const std::string &unit);

    void unit(const none_t t) {
        backend()->unit(t);
    }

    std::vector<double> ticks() const {
        return backend()->ticks();
    }

    std::vector<double> ticks(ndsize_t start, size_t count) const {
        return backend()->ticks(start, count);
    }

    void ticks(const std::vector<double> &ticks);


    double tickAt(const ndsize_t index) const;


    PositionInRange positionInRange(const double position) const;


    boost::optional<ndsize_t> indexOf(const double position, PositionMatch matching) const;


    boost::optional<std::pair<ndsize_t, ndsize_t>> indexOf(double start, double end, std::vector<double> ticks,
                                                           RangeMatch match = RangeMatch::Exclusive) const;


    DEPRECATED ndsize_t indexOf(const double position, bool less_or_equal = true) const;


    DEPRECATED std::pair<ndsize_t, ndsize_t> indexOf(const double start, const double end) const;


    DEPRECATED std::vector<std::pair<ndsize_t, ndsize_t>> indexOf(const std::vector<double> &start_positions,
                                                                  const std::vector<double> &end_positions,
                                                                  bool strict, RangeMatch match = RangeMatch::Inclusive) const;


    std::vector<boost::optional<std::pair<ndsize_t, ndsize_t>>> indexOf(const std::vector<double> &start_positions,
                                                                        const std::vector<double> &end_positions,
                                                                        RangeMatch match = RangeMatch::Exclusive) const;

    std::vector<double> axis(const ndsize_t count, const ndsize_t startIndex = 0) const;

    RangeDimension& operator=(const RangeDimension &other);

    RangeDimension& operator=(const Dimension &other);

    RangeDimension &operator=(const none_t &t) {
        ImplContainer::operator=(t);
        return *this;
    }

    double operator[](const ndsize_t index) {
        return tickAt(index);
    }

};


class NIXAPI Dimension : public base::ImplContainer<base::IDimension> {

public:

    Dimension();

    Dimension(const std::shared_ptr<base::IDimension> &p_impl);

    Dimension(std::shared_ptr<base::IDimension> &&ptr);


    Dimension(const Dimension &other);

    Dimension(const SampledDimension &other);

    Dimension(const RangeDimension &other);

    Dimension(const SetDimension &other);

    Dimension(const DataFrameDimension &other);

    ndsize_t index() const {
        return backend()->index();
    }

    DimensionType dimensionType() const {
        return backend()->dimensionType();
    }

    SetDimension asSetDimension() const;

    SampledDimension asSampledDimension() const;

    RangeDimension asRangeDimension() const;

    DataFrameDimension asDataFrameDimension() const;

    Dimension& operator=(const SampledDimension &other);

    Dimension& operator=(const RangeDimension &other);

    Dimension& operator=(const SetDimension &other);

    Dimension &operator=(const DataFrameDimension &other);

    Dimension &operator=(const Dimension &other)  {
        ImplContainer::operator=(other);
        return *this;
    }

    Dimension &operator=(const none_t &t) {
        ImplContainer::operator=(t);
        return *this;
    }

};

template<>
struct objectToType<nix::SetDimension> {
    static const bool isValid = true;
    static const ObjectType value = ObjectType::SetDimension;
    typedef nix::base::ISetDimension backendType;
};


template<>
struct objectToType<nix::SampledDimension> {
    static const bool isValid = true;
    static const ObjectType value = ObjectType::SampledDimension;
    typedef nix::base::ISampledDimension backendType;
};



template<>
struct objectToType<nix::RangeDimension> {
    static const bool isValid = true;
    static const ObjectType value = ObjectType::RangeDimension;
    typedef nix::base::IRangeDimension backendType;
};

template<>
struct objectToType<nix::DataFrameDimension> {
    static const bool isValid = true;
    static const ObjectType value = ObjectType::DataFrameDimension;
    typedef nix::base::IDataFrameDimension backendType;
};

} // namespace nix

#endif // NIX_DIMENSIONS_H