entry_types.h

Go to the documentation of this file.

/*    This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
 *    See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
 *    Author(s):       Hannah Schreiber
 *
 *    Copyright (C) 2022 Inria
 *
 *    Modification(s):
 *      - YYYY/MM Author: Description of the modification
 */

 
#ifndef PM_MATRIX_ENTRY_H
#define PM_MATRIX_ENTRY_H
 
#include <utility>     //std::swap, std::exchange & std::move
#include <functional>  //std::hash
 
namespace Gudhi {
namespace persistence_matrix {

struct Dummy_entry_column_index_mixin {
  Dummy_entry_column_index_mixin() = default;
 
  template <typename Index>
  Dummy_entry_column_index_mixin([[maybe_unused]] Index columnIndex)
  {}
};

struct Dummy_entry_field_element_mixin {
  Dummy_entry_field_element_mixin() = default;
 
  template <class Field_element>
  Dummy_entry_field_element_mixin([[maybe_unused]] Field_element t)
  {}
 
  static constexpr bool get_element() { return true; };
  static constexpr void set_element(bool /* element */) {}
};

template <typename Index>
class Entry_column_index
{
 public:
  Entry_column_index() : columnIndex_(-1) {};
  Entry_column_index(Index columnIndex) : columnIndex_(columnIndex) {};

  Index get_column_index() const { return columnIndex_; };

  void set_column_index(Index columnIndex) { columnIndex_ = columnIndex; }
 
 private:
  Index columnIndex_; 
};

template <class Field_element>
class Entry_field_element
{
 public:
  Entry_field_element() : element_(0) {};
  Entry_field_element(Field_element element) : element_(std::move(element)) {};

  Field_element& get_element() { return element_; };

  const Field_element& get_element() const { return element_; };

  void set_element(const Field_element& element) { element_ = element; }
 
 private:
  Field_element element_; 
};

template <class Master_matrix>
class Entry : public Master_matrix::Entry_column_index_option,
              public Master_matrix::Entry_field_element_option,
              public Master_matrix::Row_hook,
              public Master_matrix::Column_hook
{
 private:
  using col_opt = typename Master_matrix::Entry_column_index_option;
  using field_opt = typename Master_matrix::Entry_field_element_option;
 
 public:
  using Master = Master_matrix;                          
  using Index = typename Master_matrix::Index;           
  using ID_index = typename Master_matrix::ID_index;     
  using Field_element = typename Master_matrix::Element; 

  Entry() = default;
  Entry(ID_index rowIndex) : col_opt(), field_opt(), rowIndex_(rowIndex) {};
  Entry(Index columnIndex, ID_index rowIndex) : col_opt(columnIndex), field_opt(), rowIndex_(rowIndex) {};
  Entry(const Entry& entry)
      : col_opt(static_cast<const col_opt&>(entry)),
        field_opt(static_cast<const field_opt&>(entry)),
        rowIndex_(entry.rowIndex_) {};

  Entry(Entry&& entry) noexcept
      : col_opt(std::move(static_cast<col_opt&>(entry))),
        field_opt(std::move(static_cast<field_opt&>(entry))),
        rowIndex_(std::exchange(entry.rowIndex_, 0)) {};
 
  ~Entry() = default;

  ID_index get_row_index() const { return rowIndex_; };

  void set_row_index(ID_index rowIndex) { rowIndex_ = rowIndex; };

  Entry& operator=(Entry other) &
  {
    col_opt::operator=(std::move(other));
    field_opt::operator=(std::move(other));
    std::swap(rowIndex_, other.rowIndex_);
    return *this;
  };

  Entry& operator=(Entry&& other) && noexcept
  {
    if (this == &other) return *this;
 
    col_opt::operator=(std::move(other));
    field_opt::operator=(std::move(other));
    rowIndex_ = std::exchange(other.rowIndex_, 0);
    return *this;
  };

  friend bool operator<(const Entry& c1, const Entry& c2) { return c1.get_row_index() < c2.get_row_index(); }

  friend bool operator==(const Entry& c1, const Entry& c2) { return c1.get_row_index() == c2.get_row_index(); }

  operator ID_index() const { return rowIndex_; }

  operator std::pair<ID_index, Field_element>() const
  {
    return {rowIndex_, field_opt::get_element()};
  }
 
 private:
  ID_index rowIndex_; 
};
 
}  // namespace persistence_matrix
}  // namespace Gudhi

template <class Master_matrix>
struct std::hash<Gudhi::persistence_matrix::Entry<Master_matrix> > {
  std::size_t operator()(const Gudhi::persistence_matrix::Entry<Master_matrix>& entry) const
  {
    return std::hash<unsigned int>()(entry.get_row_index());
  }
};
 
#endif  // PM_MATRIX_ENTRY_H