CapacityEdge.hpp

Go to the documentation of this file.

 
// Copyright (c) 2017 Czech Technical University in Prague | Faculty of Information Technology. All rights reserved.
 
#pragma once
 
#include <ostream>
#include <alib/pair>
#include <object/Object.h>
#include <alib/tuple>
 
#include <edge/EdgeFeatures.hpp>
#include <edge/EdgeBase.hpp>
 
namespace edge {
 
template<typename TNode, typename TCapacity>
class CapacityEdge : public ext::pair<TNode, TNode>, public EdgeBase {
// ---------------------------------------------------------------------------------------------------------------------
 public:
  using node_type = TNode;
  using capacity_type = TCapacity;
  using normalized_type = WeightedEdge<>;
 
// ---------------------------------------------------------------------------------------------------------------------
 
 protected:
  TCapacity m_capacity;
 
// =====================================================================================================================
// Constructor, Destructor, Operators
 
 public:
  explicit CapacityEdge(TNode _first, TNode _second, TCapacity capacity);
 
// ---------------------------------------------------------------------------------------------------------------------
 
  TCapacity capacity() const;
  void capacity(TCapacity &&capacity);
 
// =====================================================================================================================
// EdgeBase interface
 
 public:
    auto operator <=> (const CapacityEdge &other) const {
        return ext::tie(this->first, this->second, m_capacity) <=> ext::tie(other.first, other.second, other.m_capacity);
    }
 
    bool operator == (const CapacityEdge &other) const {
        return ext::tie(this->first, this->second, m_capacity) == ext::tie(other.first, other.second, other.m_capacity);
    }
 
  void operator>>(ext::ostream &ostream) const override;
 
// =====================================================================================================================
 public:
 
  virtual std::string name() const;
 
// ---------------------------------------------------------------------------------------------------------------------
};
// =====================================================================================================================
 
template<typename TNode, typename TCapacity>
CapacityEdge<TNode, TCapacity>::CapacityEdge(TNode _first, TNode _second, TCapacity capacity)
    : ext::pair<TNode, TNode>(_first, _second), m_capacity(capacity) {
 
}
 
// ---------------------------------------------------------------------------------------------------------------------
 
template<typename TNode, typename TCapacity>
TCapacity CapacityEdge<TNode, TCapacity>::capacity() const {
  return m_capacity;
}
 
template<typename TNode, typename TCapacity>
void CapacityEdge<TNode, TCapacity>::capacity(TCapacity &&capacity) {
  m_capacity = std::forward<TCapacity>(capacity);
}
 
// ---------------------------------------------------------------------------------------------------------------------
 
template<typename TNode, typename TCapacity>
std::string CapacityEdge<TNode, TCapacity>::name() const {
  return "CapacityEdge";
}
 
// ---------------------------------------------------------------------------------------------------------------------
 
template<typename TNode, typename TCapacity>
void CapacityEdge<TNode, TCapacity>::operator>>(ext::ostream &ostream) const {
  ostream << "(" << name() << "(first=" << this->first << ", second=" << this->second << ", weight="
          << m_capacity << "))";
}
 
// ---------------------------------------------------------------------------------------------------------------------
 
} // namespace edge
 
// =====================================================================================================================