Program Listing for File multi.hpp

            

            
#pragma once

#include "morpheus/messages/meta.hpp"
#include "morpheus/objects/table_info.hpp"
#include "morpheus/objects/tensor_object.hpp"

#include <cudf/types.hpp>
#include <glog/logging.h>// for DCHECK_NOTNULL
#include <pybind11/pytypes.h>
#include <pybind11/stl.h>// IWYU pragma: keep

#include <cstddef>// for size_t
#include <memory>
#include <string>
#include <utility>// for pair
#include <vector>

namespace morpheus {
/****** Component public implementations *******************/
/****** MultiMessage****************************************/

#pragma GCC visibility push(default)

class MultiMessage;

template <typename DerivedT, typename... BasesT>
class DerivedMultiMessage : public BasesT...
{
  public:
    virtual ~DerivedMultiMessage() = default;

    std::shared_ptr<DerivedT> get_slice(std::size_t start, std::size_t stop) const
    {
        std::shared_ptr<MultiMessage> new_message = this->clone_impl();

        this->get_slice_impl(new_message, start, stop);

        return DCHECK_NOTNULL(std::dynamic_pointer_cast<DerivedT>(new_message));
    }

    std::shared_ptr<DerivedT> copy_ranges(const std::vector<std::pair<size_t, size_t>> &ranges,
                                          size_t num_selected_rows) const
    {
        std::shared_ptr<MultiMessage> new_message = this->clone_impl();

        this->copy_ranges_impl(new_message, ranges, num_selected_rows);

        return DCHECK_NOTNULL(std::dynamic_pointer_cast<DerivedT>(new_message));
    }

  protected:
    virtual void get_slice_impl(std::shared_ptr<MultiMessage> new_message,
                                std::size_t start,
                                std::size_t stop) const = 0;

    virtual void copy_ranges_impl(std::shared_ptr<MultiMessage> new_message,
                                  const std::vector<std::pair<size_t, size_t>> &ranges,
                                  size_t num_selected_rows) const = 0;

  private:
    virtual std::shared_ptr<MultiMessage> clone_impl() const
    {
        // Cast `this` to the derived type
        auto derived_this = static_cast<const DerivedT *>(this);

        // Use copy constructor to make a clone
        return std::make_shared<DerivedT>(*derived_this);
    }
};

// Single base class version. Should be the version used by default
template <typename DerivedT, typename BaseT>
class DerivedMultiMessage<DerivedT, BaseT> : public BaseT
{
  public:
    using BaseT::BaseT;
    virtual ~DerivedMultiMessage() = default;

    std::shared_ptr<DerivedT> get_slice(std::size_t start, std::size_t stop) const
    {
        std::shared_ptr<MultiMessage> new_message = this->clone_impl();

        this->get_slice_impl(new_message, start, stop);

        return DCHECK_NOTNULL(std::dynamic_pointer_cast<DerivedT>(new_message));
    }

    std::shared_ptr<DerivedT> copy_ranges(const std::vector<std::pair<size_t, size_t>> &ranges,
                                          size_t num_selected_rows) const
    {
        std::shared_ptr<MultiMessage> new_message = this->clone_impl();

        this->copy_ranges_impl(new_message, ranges, num_selected_rows);

        return DCHECK_NOTNULL(std::dynamic_pointer_cast<DerivedT>(new_message));
    }

  protected:
    virtual void get_slice_impl(std::shared_ptr<MultiMessage> new_message, std::size_t start, std::size_t stop) const
    {
        return BaseT::get_slice_impl(new_message, start, stop);
    }

    virtual void copy_ranges_impl(std::shared_ptr<MultiMessage> new_message,
                                  const std::vector<std::pair<size_t, size_t>> &ranges,
                                  size_t num_selected_rows) const
    {
        return BaseT::copy_ranges_impl(new_message, ranges, num_selected_rows);
    }

  private:
    virtual std::shared_ptr<MultiMessage> clone_impl() const
    {
        // Cast `this` to the derived type
        auto derived_this = static_cast<const DerivedT *>(this);

        // Use copy constructor to make a clone
        return std::make_shared<DerivedT>(*derived_this);
    }
};

// No base class version. This should only be used by `MultiMessage` itself.
template <typename DerivedT>
class DerivedMultiMessage<DerivedT>
{
  public:
    virtual ~DerivedMultiMessage() = default;

    std::shared_ptr<DerivedT> get_slice(std::size_t start, std::size_t stop) const
    {
        std::shared_ptr<MultiMessage> new_message = this->clone_impl();

        this->get_slice_impl(new_message, start, stop);

        return DCHECK_NOTNULL(std::dynamic_pointer_cast<DerivedT>(new_message));
    }

    std::shared_ptr<DerivedT> copy_ranges(const std::vector<std::pair<size_t, size_t>> &ranges,
                                          size_t num_selected_rows) const
    {
        std::shared_ptr<MultiMessage> new_message = this->clone_impl();

        this->copy_ranges_impl(new_message, ranges, num_selected_rows);

        return DCHECK_NOTNULL(std::dynamic_pointer_cast<DerivedT>(new_message));
    }

  protected:
    virtual void get_slice_impl(std::shared_ptr<MultiMessage> new_message,
                                std::size_t start,
                                std::size_t stop) const = 0;

    virtual void copy_ranges_impl(std::shared_ptr<MultiMessage> new_message,
                                  const std::vector<std::pair<size_t, size_t>> &ranges,
                                  size_t num_selected_rows) const = 0;

  private:
    virtual std::shared_ptr<MultiMessage> clone_impl() const
    {
        // Cast `this` to the derived type
        auto derived_this = static_cast<const DerivedT *>(this);

        // Use copy constructor to make a clone
        return std::make_shared<DerivedT>(*derived_this);
    }
};

class MultiMessage : public DerivedMultiMessage<MultiMessage>
{
  public:
    MultiMessage(const MultiMessage &other) = default;
    MultiMessage(std::shared_ptr<MessageMeta> m, size_t o, size_t c);

    std::shared_ptr<MessageMeta> meta;
    size_t mess_offset{0};
    size_t mess_count{0};

    TableInfo get_meta();

    TableInfo get_meta(const std::string &col_name);

    TableInfo get_meta(const std::vector<std::string> &column_names);

    void set_meta(const std::string &col_name, TensorObject tensor);

    void set_meta(const std::vector<std::string> &column_names, const std::vector<TensorObject> &tensors);

  protected:
    void get_slice_impl(std::shared_ptr<MultiMessage> new_message, std::size_t start, std::size_t stop) const override;

    void copy_ranges_impl(std::shared_ptr<MultiMessage> new_message,
                          const std::vector<std::pair<size_t, size_t>> &ranges,
                          size_t num_selected_rows) const override;

    virtual std::shared_ptr<MessageMeta> copy_meta_ranges(const std::vector<std::pair<size_t, size_t>> &ranges) const;

    std::vector<std::pair<TensorIndex, TensorIndex>> apply_offset_to_ranges(
        std::size_t offset, const std::vector<std::pair<size_t, size_t>> &ranges) const;
};

/****** MultiMessageInterfaceProxy**************************/
struct MultiMessageInterfaceProxy
{
    static std::shared_ptr<MultiMessage> init(std::shared_ptr<MessageMeta> meta,
                                              cudf::size_type mess_offset,
                                              cudf::size_type mess_count);

    static std::shared_ptr<MessageMeta> meta(const MultiMessage &self);

    static std::size_t mess_offset(const MultiMessage &self);

    static std::size_t mess_count(const MultiMessage &self);

    static pybind11::object get_meta(MultiMessage &self);

    static pybind11::object get_meta(MultiMessage &self, std::string col_name);

    static pybind11::object get_meta(MultiMessage &self, std::vector<std::string> columns);

    static pybind11::object get_meta_by_col(MultiMessage &self, pybind11::object columns);

    static pybind11::object get_meta_list(MultiMessage &self, pybind11::object col_name);

    static void set_meta(MultiMessage &self, pybind11::object columns, pybind11::object value);

    static std::shared_ptr<MultiMessage> get_slice(MultiMessage &self, std::size_t start, std::size_t stop);

    static std::shared_ptr<MultiMessage> copy_ranges(MultiMessage &self,
                                                     const std::vector<std::pair<size_t, size_t>> &ranges,
                                                     pybind11::object num_selected_rows);
};

#pragma GCC visibility pop// end of group
}  // namespace morpheus