ichannelarray.h

Go to the documentation of this file.

/*
 * Copyright 2022 Ingemar Hedvall
 * SPDX-License-Identifier: MIT
 */
 
#pragma once
#include <cstdint>
#include <vector>
#include <optional>
#include "mdf/iblock.h"
 
namespace mdf {
 
class IChannel;
class IChannelConversion;
class IChannelGroup;
class IDataGroup;
 
enum class ArrayType : uint8_t {
  Array = 0, 
  ScalingAxis = 1, 
  LookUp = 2, 
  IntervalAxis = 3, 
  ClassificationResult = 4 
};
 
enum class ArrayStorage : uint8_t {
  CnTemplate = 0, 
  CgTemplate = 1, 
  DgTemplate = 2  
};
 
namespace CaFlag {
constexpr uint32_t DynamicSize = 0x0001; 
constexpr uint32_t InputQuantity = 0x0002; 
constexpr uint32_t OutputQuantity = 0x0004; 
constexpr uint32_t ComparisonQuantity = 0x0008; 
constexpr uint32_t Axis = 0x0010; 
constexpr uint32_t FixedAxis = 0x0020; 
constexpr uint32_t InverseLayout = 0x0040; 
constexpr uint32_t LeftOpenInterval = 0x0080; 
constexpr uint32_t StandardAxis = 0x0100; 
}  // namespace CaFlag
 
struct  CaTripleReference {
  const mdf::IDataGroup* DataGroup = nullptr; 
  const mdf::IChannelGroup* ChannelGroup = nullptr; 
  const mdf::IChannel* Channel = nullptr; 
};
 
 
class IChannelArray : public IBlock {
 public:
 
  virtual void Type(ArrayType type) = 0; 
  [[nodiscard]] virtual ArrayType Type() const = 0; 
 
  virtual void Storage(ArrayStorage storage) = 0; 
  [[nodiscard]] virtual ArrayStorage Storage() const = 0; 
 
  virtual void Flags(uint32_t flags) = 0; 
  [[nodiscard]] virtual uint32_t Flags() const = 0; 
 
  [[nodiscard]] virtual size_t Dimensions() const = 0; 
 
  virtual void Shape(const std::vector<uint64_t>& dim_sizes) = 0;
 
  [[nodiscard]] virtual const std::vector<uint64_t>& Shape() const = 0;
 
  [[nodiscard]] virtual uint64_t DimensionSize(size_t dimension) const = 0;
 
  [[nodiscard]] virtual const std::vector<double>&  AxisValues() const = 0;
 
  [[nodiscard]] virtual std::vector<double>&  AxisValues() = 0;
 
  [[nodiscard]] virtual const std::vector<uint64_t>& CycleCounts() const = 0;
 
  [[nodiscard]] virtual std::vector<uint64_t>& CycleCounts() = 0;
 
  [[nodiscard]] uint64_t NofArrayValues() const;
 
  [[nodiscard]] std::string DimensionAsString() const;
 
  virtual void ResizeArrays();
 
  [[nodiscard]] const std::vector<int64_t>& DataLinks() const {
    return data_links_;
  }
  [[nodiscard]] std::vector<int64_t>& DataLinks();
 
  [[nodiscard]] const std::vector<CaTripleReference>& DynamicSizeList() const {
    return dynamic_size_list_;
  }
  [[nodiscard]] std::vector<CaTripleReference>& DynamicSizeList();
 
  [[nodiscard]] const std::vector<CaTripleReference>& InputQuantityList() const {
    return input_quantity_list_;
  }
  [[nodiscard]] std::vector<CaTripleReference>& InputQuantityList();
 
  [[nodiscard]] const CaTripleReference& OutputQuantity() const {
    return output_quantity_;
  }
  [[nodiscard]] CaTripleReference& OutputQuantity() {
    return output_quantity_;
  }
 
  [[nodiscard]] const CaTripleReference& ComparisonQuantity() const {
    return comparison_quantity_;
  }
  [[nodiscard]] CaTripleReference& ComparisonQuantity()  {
    return comparison_quantity_;
  }
 
  [[nodiscard]] const std::vector<const IChannelConversion*>& AxisConversionList() const {
    return axis_conversion_list_;
  }
  [[nodiscard]] std::vector<const IChannelConversion*>& AxisConversionList();
 
  [[nodiscard]] const std::vector<CaTripleReference>& AxisList() const {
    return axis_list_;
  }
  [[nodiscard]] std::vector<CaTripleReference>& AxisList();
 
  [[nodiscard]] virtual uint64_t SumOfArray() const = 0;
 
  [[nodiscard]] virtual uint64_t ProductOfArray() const = 0;
 protected:
  std::vector<int64_t> data_links_; 
  std::vector<CaTripleReference> dynamic_size_list_; 
  std::vector<CaTripleReference> input_quantity_list_; 
  CaTripleReference output_quantity_; 
  CaTripleReference comparison_quantity_; 
  std::vector<const IChannelConversion*> axis_conversion_list_; 
  std::vector<CaTripleReference> axis_list_; 
 
 
};
 
}  // namespace mdf