column_t.hpp

/****************************************************************************
 *  hipipe library
 *  Copyright (c) 2018, Iterait a.s.
 *  Author(s) Filip Matzner
 *
 *  This file is distributed under the MIT License.
 *  See the accompanying file LICENSE.txt for the complete license agreement.
 ****************************************************************************/

#pragma once

#include <hipipe/build_config.hpp>

#ifdef HIPIPE_BUILD_PYTHON
#include <hipipe/core/python/utility/ndim_vector_converter.hpp>
#endif

#include <initializer_list>
#include <memory>
#include <stdexcept>
#include <string>
#include <vector>

namespace hipipe::stream {

class abstract_column {
private:

    template<typename Column>
    std::runtime_error extraction_error() const
    {
        return std::runtime_error{
          std::string{"Trying to extract column `"} + Column{}.name()
          + "` from a column of type `" + this->name() + "`."};
    }

public:
    // typed data extractor //

    template<typename Column>
    typename Column::data_type& extract()
    {
        try {
            return dynamic_cast<Column&>(*this).data();
        } catch (const std::bad_cast&) {
            throw extraction_error<Column>();
        }
    }

    template<typename Column>
    const typename Column::data_type& extract() const
    {
        try {
            return dynamic_cast<const Column&>(*this).data();
        } catch (const std::bad_cast&) {
            throw extraction_error<Column>();
        }
    }

    // name accessor //

    virtual std::string name() const = 0;

    // batch utilities //

    virtual std::size_t size() const = 0;

    virtual void push_back(std::unique_ptr<abstract_column> rhs) = 0;

    virtual std::unique_ptr<abstract_column> take(std::size_t n) = 0;

    // python conversion //

    #ifdef HIPIPE_BUILD_PYTHON
    virtual boost::python::object to_python() = 0;
    #endif

    // virtual destructor //

    virtual ~abstract_column() = default;
};


template <typename ColumnName, typename ExampleType>
class column_base : public abstract_column {
public:

    using example_type = ExampleType;
    using data_type = std::vector<example_type>;

private:

    data_type data_;

public:

    // constructors //

    column_base() = default;
    column_base(column_base&&) = default;

    template <typename... Args>
    column_base(Args&&... args)
      : data_{std::forward<Args>(args)...}
    { }

    // batching utilities //

    std::size_t size() const override
    {
        return data_.size();
    }

    std::unique_ptr<abstract_column> take(std::size_t n) override
    {
        if (n > data_.size()) {
            throw std::runtime_error{"hipipe: Attempting to take "
              + std::to_string(n) + " examples out of column `" + name()
              + "` with " + std::to_string(size()) + " examples."};
        }
        data_type taken_examples(n);
        std::move(data_.begin(), data_.begin() + n, taken_examples.begin());
        data_.erase(data_.begin(), data_.begin() + n);
        return std::make_unique<ColumnName>(std::move(taken_examples));
    }

    void push_back(std::unique_ptr<abstract_column> rhs) override
    {
        try {
            ColumnName& typed_rhs = dynamic_cast<ColumnName&>(*rhs);
            data_.reserve(data_.size() + typed_rhs.data_.size());
            for (example_type& example : typed_rhs.data_) {
                data_.push_back(std::move(example));
            }
        } catch (const std::bad_cast&) {
            throw std::runtime_error{"hipipe: Attempting to push back "
              "column `" + rhs->name() + "` to column `" + name() + "."};
        }
    }

    // data accessors //

    data_type& data() { return data_; }

    const data_type& data() const { return data_; }

    // python converter //

    #ifdef HIPIPE_BUILD_PYTHON
    boost::python::object to_python() override
    {
        return hipipe::python::utility::to_python(std::move(data_));
    }
    #endif
};

}  // namespace hipipe::stream


#define HIPIPE_DEFINE_COLUMN(column_name_, example_type_)                         \
struct column_name_ : hipipe::stream::column_base<column_name_, example_type_> {  \
    using hipipe::stream::column_base<column_name_, example_type_>::column_base;  \
    std::string name() const override { return #column_name_; }                   \
};