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_; }                   \
};