Map.h

// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2007-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
// SPDX-License-Identifier: MPL-2.0
 
#ifndef EIGEN_MAP_H
#define EIGEN_MAP_H
 
// IWYU pragma: private
#include "./InternalHeaderCheck.h"
 
namespace Eigen {
 
namespace internal {
template <typename PlainObjectType, int MapOptions, typename StrideType>
struct traits<Map<PlainObjectType, MapOptions, StrideType> > : public traits<PlainObjectType> {
  using TraitsBase = traits<PlainObjectType>;
  enum {
    PlainObjectTypeInnerSize = ((traits<PlainObjectType>::Flags & RowMajorBit) == RowMajorBit)
                                   ? PlainObjectType::ColsAtCompileTime
                                   : PlainObjectType::RowsAtCompileTime,
 
    InnerStrideAtCompileTime = StrideType::InnerStrideAtCompileTime == 0
                                   ? int(PlainObjectType::InnerStrideAtCompileTime)
                                   : int(StrideType::InnerStrideAtCompileTime),
    OuterStrideAtCompileTime = StrideType::OuterStrideAtCompileTime == 0
                                   ? (InnerStrideAtCompileTime == Dynamic || PlainObjectTypeInnerSize == Dynamic
                                          ? Dynamic
                                          : int(InnerStrideAtCompileTime) * int(PlainObjectTypeInnerSize))
                                   : int(StrideType::OuterStrideAtCompileTime),
    Alignment = int(MapOptions) & int(AlignedMask),
    Flags0 = TraitsBase::Flags & (~NestByRefBit),
    Flags = is_lvalue<PlainObjectType>::value ? int(Flags0) : (int(Flags0) & ~LvalueBit)
  };
 
 private:
  enum { Options };  // Expressions don't have Options
};
}  // namespace internal

template <typename PlainObjectType, int MapOptions, typename StrideType>
class Map : public MapBase<Map<PlainObjectType, MapOptions, StrideType> > {
 public:
  using Base = MapBase<Map>;
  EIGEN_DENSE_PUBLIC_INTERFACE(Map)
 
  using PointerType = typename Base::PointerType;
  using PointerArgType = PointerType;
  EIGEN_DEVICE_FUNC constexpr inline PointerType cast_to_pointer_type(PointerArgType ptr) const { return ptr; }
 
  EIGEN_DEVICE_FUNC constexpr Index innerStride() const {
    return StrideType::InnerStrideAtCompileTime != 0 ? m_stride.inner() : 1;
  }
 
  EIGEN_DEVICE_FUNC constexpr Index outerStride() const {
    return StrideType::OuterStrideAtCompileTime != 0 ? m_stride.outer()
           : internal::traits<Map>::OuterStrideAtCompileTime != Dynamic
               ? Index(internal::traits<Map>::OuterStrideAtCompileTime)
           : IsVectorAtCompileTime    ? (this->size() * innerStride())
           : int(Flags) & RowMajorBit ? (this->cols() * innerStride())
                                      : (this->rows() * innerStride());
  }

  EIGEN_DEVICE_FUNC constexpr explicit inline Map(PointerArgType dataPtr, const StrideType& stride = StrideType())
      : Base(cast_to_pointer_type(dataPtr)), m_stride(stride) {}

  EIGEN_DEVICE_FUNC constexpr inline Map(PointerArgType dataPtr, Index size, const StrideType& stride = StrideType())
      : Base(cast_to_pointer_type(dataPtr), size), m_stride(stride) {}

  EIGEN_DEVICE_FUNC constexpr inline Map(PointerArgType dataPtr, Index rows, Index cols,
                                         const StrideType& stride = StrideType())
      : Base(cast_to_pointer_type(dataPtr), rows, cols), m_stride(stride) {}
 
  EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Map)
 
 protected:
  StrideType m_stride;
};
 
}  // end namespace Eigen
 
#endif  // EIGEN_MAP_H