blace_index.h

#pragma once
 
#include "ml_core/callbacks.h"
#include <climits>
#include <memory>
#include <optional>
#include <stdint.h>
#include <vector>
 
namespace blace {
namespace ops {
class BaseOp;
typedef std::shared_ptr<blace::ops::BaseOp> OpP;
} // namespace ops
} // namespace blace
 
namespace blace {
 
namespace ml_core {
 
struct Slice final {
public:
  EXPORT_OR_IMPORT Slice(std::optional<int64_t> start_index = std::nullopt,
                         std::optional<int64_t> stop_index = std::nullopt,
                         std::optional<int64_t> step_index = std::nullopt);
 
  inline int64_t start() const { return start_; }
 
  inline int64_t stop() const { return stop_; }
 
  inline int64_t step() const { return step_; }
 
private:
  int64_t start_;
  int64_t stop_;
  int64_t step_;
};
 
enum class BlaceIndexType { None, Slice, OpP, Int };
 
struct BlaceIndex {
  BlaceIndex() : type_(BlaceIndexType::None) {}
 
  BlaceIndex(int64_t integer) : integer_(integer), type_(BlaceIndexType::Int) {}
 
  BlaceIndex(blace::ml_core::Slice slice)
      : slice_(std::move(slice)), type_(BlaceIndexType::Slice) {}
 
  BlaceIndex(blace::ops::OpP tensor)
      : node_op_to_eval_(std::move(tensor)), type_(BlaceIndexType::OpP) {}
 
  bool is_none() const;
 
  bool is_integer() const;
 
  int64_t integer() const;
 
  bool is_slice() const;
 
  const blace::ml_core::Slice &slice() const;
 
  bool is_node_op() const;
 
  const blace::ops::OpP &node_op() const;
 
  bool operator==(const BlaceIndex &rhs) const;
 
  BlaceIndexType getType();
 
  blace::ml_core::Slice getSlice();
 
  blace::ops::OpP getNodeOp();
 
private:
  int64_t integer_ = 0;
  blace::ml_core::Slice slice_;
  blace::ops::OpP node_op_to_eval_;
  BlaceIndexType type_;
};
 
typedef std::vector<BlaceIndex> BlaceIndexVec;
} // namespace ml_core
} // namespace blace