hydrocouplehelpers.h

Go to the documentation of this file.

 
#ifndef HYDROCOUPLEHELPERS_H
#define HYDROCOUPLEHELPERS_H
 
#include "hydrocouple.h"
 
namespace HydroCouple
{
  namespace Helpers
  {
    constexpr int64_t dataKindSize(DataKind kind)
    {
      switch (kind)
      {
        case DataKind::Int8:
        case DataKind::UInt8:
        case DataKind::Boolean: return 1;
        case DataKind::Int16:
        case DataKind::UInt16:  return 2;
        case DataKind::Int32:
        case DataKind::UInt32:
        case DataKind::Float32: return 4;
        case DataKind::Int64:
        case DataKind::UInt64:
        case DataKind::Float64: return 8;
        default:                return 0;
      }
    }

    template <typename T>
    struct DataKindOf { static constexpr DataKind kind = DataKind::Opaque; };
    template <> struct DataKindOf<int8_t>      { static constexpr DataKind kind = DataKind::Int8; };
    template <> struct DataKindOf<uint8_t>     { static constexpr DataKind kind = DataKind::UInt8; };
    template <> struct DataKindOf<int16_t>     { static constexpr DataKind kind = DataKind::Int16; };
    template <> struct DataKindOf<uint16_t>    { static constexpr DataKind kind = DataKind::UInt16; };
    template <> struct DataKindOf<int32_t>     { static constexpr DataKind kind = DataKind::Int32; };
    template <> struct DataKindOf<uint32_t>    { static constexpr DataKind kind = DataKind::UInt32; };
    template <> struct DataKindOf<int64_t>     { static constexpr DataKind kind = DataKind::Int64; };
    template <> struct DataKindOf<uint64_t>    { static constexpr DataKind kind = DataKind::UInt64; };
    template <> struct DataKindOf<float>       { static constexpr DataKind kind = DataKind::Float32; };
    template <> struct DataKindOf<double>      { static constexpr DataKind kind = DataKind::Float64; };
    template <> struct DataKindOf<bool>        { static constexpr DataKind kind = DataKind::Boolean; };
    template <> struct DataKindOf<std::string> { static constexpr DataKind kind = DataKind::String; };

    [[nodiscard]] constexpr int64_t elementCount(const BufferDescriptor &d)
    {
      int64_t n = 1;
      for (int32_t k = 0; k < d.rank; ++k)
        n *= d.shape[k];
      return n;
    }

    [[nodiscard]] constexpr bool isContiguous(const BufferDescriptor &d)
    {
      if (d.stridesBytes == nullptr)
        return true;
      int64_t expected = dataKindSize(d.kind);
      for (int32_t k = d.rank - 1; k >= 0; --k)
      {
        if (d.shape[k] != 1 && d.stridesBytes[k] != expected)
          return false;
        expected *= d.shape[k];
      }
      return true;
    }

    [[nodiscard]] constexpr int64_t byteOffset(const BufferDescriptor &d, std::span<const int64_t> index)
    {
      int64_t offset = 0;
      if (d.stridesBytes == nullptr)
      {
        int64_t stride = dataKindSize(d.kind);
        for (int32_t k = d.rank - 1; k >= 0; --k)
        {
          offset += index[k] * stride;
          stride *= d.shape[k];
        }
      }
      else
      {
        for (int32_t k = 0; k < d.rank; ++k)
          offset += index[k] * d.stridesBytes[k];
      }
      return offset;
    }

    [[nodiscard]] constexpr int64_t contiguousByteSize(const BufferDescriptor &d)
    {
      return elementCount(d) * dataKindSize(d.kind);
    }

    [[nodiscard]] constexpr BufferDescriptor makeContiguous(void *data, DataKind kind, std::span<const int64_t> shape)
    {
      BufferDescriptor d;
      d.data = data;
      d.kind = kind;
      d.rank = static_cast<int32_t>(shape.size());
      d.shape = shape.data();
      return d;
    }

    [[nodiscard]] constexpr bool isValidComponentStatusTransition(IModelComponent::ComponentStatus from,
                                                                  IModelComponent::ComponentStatus to)
    {
      using CS = IModelComponent::ComponentStatus;
      switch (from)
      {
        case CS::Created:        return to == CS::Initializing;
        case CS::Initializing:   return to == CS::Initialized || to == CS::Failed;
        case CS::Initialized:    return to == CS::Validating || to == CS::Initializing;
        case CS::Validating:     return to == CS::Valid || to == CS::Invalid;
        case CS::Valid:          return to == CS::Preparing || to == CS::Validating;
        case CS::Invalid:        return to == CS::Validating;
        case CS::Preparing:      return to == CS::Updated || to == CS::Failed;
        case CS::Updating:       return to == CS::Updated || to == CS::Done ||
                                        to == CS::WaitingForData || to == CS::Failed;
        case CS::WaitingForData: return to == CS::Updating || to == CS::Failed;
        case CS::Updated:        return to == CS::Updating || to == CS::Checkpointing ||
                                        to == CS::Finishing;
        case CS::Checkpointing:  return to == CS::Updated || to == CS::Failed;
        case CS::Done:           return to == CS::Finishing;
        case CS::Finishing:      return to == CS::Finished || to == CS::Created;
        case CS::Finished:       return false;
        case CS::Failed:         return to == CS::Initializing || to == CS::Finishing;
      }
      return false;
    }

    template <typename T>
    [[nodiscard]] bool getValue(const IComponentDataItem &item, T &value, std::span<const int64_t> index)
    {
      std::vector<int64_t> ones(index.size(), 1);
      const int64_t one = 1;
      return item.getValuesInto(makeContiguous(&value, DataKindOf<T>::kind, std::span<const int64_t>(&one, 1)),
                                index, ones);
    }

    template <typename T>
    [[nodiscard]] bool setValue(IComponentDataItem &item, const T &value, std::span<const int64_t> index)
    {
      std::vector<int64_t> ones(index.size(), 1);
      const int64_t one = 1;
      return item.setValuesFrom(makeContiguous(const_cast<T *>(&value), DataKindOf<T>::kind, std::span<const int64_t>(&one, 1)),
                                index, ones);
    }

    template <typename T>
    [[nodiscard]] bool getValues(const IComponentDataItem &item, std::span<T> destination,
                                 std::span<const int64_t> start, std::span<const int64_t> count)
    {
      return item.getValuesInto(makeContiguous(destination.data(), DataKindOf<T>::kind, count), start, count);
    }

    template <typename T>
    [[nodiscard]] bool setValues(IComponentDataItem &item, std::span<const T> source,
                                 std::span<const int64_t> start, std::span<const int64_t> count)
    {
      return item.setValuesFrom(makeContiguous(const_cast<T *>(source.data()), DataKindOf<T>::kind, count), start, count);
    }
  }
}
 
#endif // HYDROCOUPLEHELPERS_H