rotgen/include/rotgen/impl/payload.hpp

//==================================================================================================
/*
  ROTGEN - Runtime Overlay for Eigen
  Copyright : CODE RECKONS
  SPDX-License-Identifier: BSL-1.0
*/
//==================================================================================================
#pragma once

#include <cstddef>
#include <memory>
#include <rotgen/impl/matrix.hpp>
#include <rotgen/impl/map.hpp>
#include <Eigen/Dense>

namespace rotgen
{
  //==================================================================================================
  // Internal payload - Required for cross-referencing from block_impl*
  //==================================================================================================
  struct matrix_impl64_col::payload
  {
    using data_type = Eigen::Matrix<double,Eigen::Dynamic,Eigen::Dynamic,Eigen::ColMajor>;

    data_type data;
    payload(std::size_t r=0, std::size_t c=0) : data(r, c) {}
    payload(std::initializer_list<std::initializer_list<double>> init) : data(init) {}
    payload(data_type&& matrix) : data(std::move(matrix)) {}

    void assign(Eigen::Block<data_type> ref) { data = ref; }
    void assign(data_type const& mat) { data = mat; }
    void assign(data_type&& mat) { data = std::move(mat); }
  };

  struct matrix_impl64_row::payload
  {
    using data_type = Eigen::Matrix<double,Eigen::Dynamic,Eigen::Dynamic,Eigen::RowMajor>;

    data_type data;
    payload(std::size_t r=0, std::size_t c=0) : data(r, c) {}
    payload(std::initializer_list<std::initializer_list<double>> init) : data(init) {}
    payload(data_type&& matrix) : data(std::move(matrix)) {}

    void assign(Eigen::Block<data_type> ref) { data = ref; }
    void assign(data_type const& mat) { data = mat; }
    void assign(data_type&& mat) { data = std::move(mat); }
  };

  struct matrix_impl32_col::payload
  {
    using data_type = Eigen::Matrix<float,Eigen::Dynamic,Eigen::Dynamic,Eigen::ColMajor>;

    data_type data;
    payload(std::size_t r=0, std::size_t c=0) : data(r, c) {}
    payload(std::initializer_list<std::initializer_list<float>> init) : data(init) {}
    payload(data_type&& matrix) : data(std::move(matrix)) {}

    void assign(Eigen::Block<data_type> ref) { data = ref; }
    void assign(data_type const& mat) { data = mat; }
    void assign(data_type&& mat) { data = std::move(mat); }
  };

  struct matrix_impl32_row::payload
  {
    using data_type = Eigen::Matrix<float,Eigen::Dynamic,Eigen::Dynamic,Eigen::RowMajor>;

    data_type data;
    payload(std::size_t r=0, std::size_t c=0) : data(r, c) {}
    payload(std::initializer_list<std::initializer_list<float>> init) : data(init) {}
    payload(data_type&& matrix) : data(std::move(matrix)) {}

    void assign(Eigen::Block<data_type> ref) { data = ref; }
    void assign(data_type const& mat) { data = mat; }
    void assign(data_type&& mat) { data = std::move(mat); }
  };

  //==================================================================================================
  // Internal payload - Required for cross-referencing from mixed order on map operators
  //==================================================================================================
  struct map_const_impl32_col::payload
  {
    using stride_type = Eigen::Stride<Eigen::Dynamic,Eigen::Dynamic>;
    using base_type   = Eigen::Matrix<float,Eigen::Dynamic,Eigen::Dynamic,Eigen::ColMajor>;
    using data_type   = Eigen::Map<base_type const,Eigen::ColMajor,stride_type>;

    data_type data;

    payload (data_type const& o) : data(o) {}
    payload (float const* ptr, Index r, Index c) : data(ptr,r,c) {}
    payload (float const* ptr, Index r, Index c, stride_type s) : data(ptr,r,c,s) {}
  };

  struct map_const_impl32_row::payload
  {
    using stride_type = Eigen::Stride<Eigen::Dynamic,Eigen::Dynamic>;
    using base_type   = Eigen::Matrix<float,Eigen::Dynamic,Eigen::Dynamic,Eigen::RowMajor>;
    using data_type   = Eigen::Map<base_type const,Eigen::RowMajor,stride_type>;

    data_type data;

    payload (data_type const& o) : data(o) {}
    payload (float const* ptr, Index r, Index c) : data(ptr,r,c) {}
    payload (float const* ptr, Index r, Index c, stride_type s) : data(ptr,r,c,s) {}
  };

  struct map_impl32_col::payload
  {
    using stride_type = Eigen::Stride<Eigen::Dynamic,Eigen::Dynamic>;
    using base_type   = Eigen::Matrix<float,Eigen::Dynamic,Eigen::Dynamic,Eigen::ColMajor>;
    using data_type   = Eigen::Map<base_type,Eigen::ColMajor,stride_type>;

    data_type data;

    payload (data_type const& o) : data(o) {}
    payload (float* ptr, Index r, Index c) : data(ptr,r,c) {}
    payload (float* ptr, Index r, Index c, stride_type s) : data(ptr,r,c,s) {}
  };

  struct map_impl32_row::payload
  {
    using stride_type = Eigen::Stride<Eigen::Dynamic,Eigen::Dynamic>;
    using base_type   = Eigen::Matrix<float,Eigen::Dynamic,Eigen::Dynamic,Eigen::RowMajor>;
    using data_type   = Eigen::Map<base_type,Eigen::RowMajor,stride_type>;

    data_type data;

    payload (data_type const& o) : data(o) {}
    payload (float* ptr, Index r, Index c) : data(ptr,r,c) {}
    payload (float* ptr, Index r, Index c, stride_type s) : data(ptr,r,c,s) {}
  };


  struct map_const_impl64_col::payload
  {
    using stride_type = Eigen::Stride<Eigen::Dynamic,Eigen::Dynamic>;
    using base_type   = Eigen::Matrix<double,Eigen::Dynamic,Eigen::Dynamic,Eigen::ColMajor>;
    using data_type   = Eigen::Map<base_type const,Eigen::ColMajor,stride_type>;

    data_type data;

    payload (data_type const& o) : data(o) {}
    payload (double const* ptr, Index r, Index c) : data(ptr,r,c) {}
    payload (double const* ptr, Index r, Index c, stride_type s) : data(ptr,r,c,s) {}
  };

  struct map_const_impl64_row::payload
  {
    using stride_type = Eigen::Stride<Eigen::Dynamic,Eigen::Dynamic>;
    using base_type   = Eigen::Matrix<double,Eigen::Dynamic,Eigen::Dynamic,Eigen::RowMajor>;
    using data_type   = Eigen::Map<base_type const,Eigen::RowMajor,stride_type>;

    data_type data;

    payload (data_type const& o) : data(o) {}
    payload (double const* ptr, Index r, Index c) : data(ptr,r,c) {}
    payload (double const* ptr, Index r, Index c, stride_type s) : data(ptr,r,c,s) {}
  };

  struct map_impl64_col::payload
  {
    using stride_type = Eigen::Stride<Eigen::Dynamic,Eigen::Dynamic>;
    using base_type   = Eigen::Matrix<double,Eigen::Dynamic,Eigen::Dynamic,Eigen::ColMajor>;
    using data_type   = Eigen::Map<base_type,Eigen::ColMajor,stride_type>;

    data_type data;

    payload (data_type const& o) : data(o) {}
    payload (double* ptr, Index r, Index c) : data(ptr,r,c) {}
    payload (double* ptr, Index r, Index c, stride_type s) : data(ptr,r,c,s) {}
  };

  struct map_impl64_row::payload
  {
    using stride_type = Eigen::Stride<Eigen::Dynamic,Eigen::Dynamic>;
    using base_type   = Eigen::Matrix<double,Eigen::Dynamic,Eigen::Dynamic,Eigen::RowMajor>;
    using data_type   = Eigen::Map<base_type,Eigen::RowMajor,stride_type>;

    data_type data;

    payload (data_type const& o) : data(o) {}
    payload (double* ptr, Index r, Index c) : data(ptr,r,c) {}
    payload (double* ptr, Index r, Index c, stride_type s) : data(ptr,r,c,s) {}
  };
}