Graph< vert_t, weight_t >::Edge Class Reference

Public Member Functions
	Edge ()=delete
	Edge (const std::pair< vert_t, vert_t > &edge_pair)
	Edge (const std::pair< vert_t, vert_t > &edge_pair, weight_t weight)
	Edge (const std::tuple< vert_t, vert_t, weight_t > &edge_tuple)
	Edge (const vert_t &start_vert, vert_t end_vert, weight_t weight)
	Edge (const vert_t start_vert, const vert_t &end_vert)
vert_t	EndVert () const
bool	IsWeighted () const
const std::string &	Name () const
bool	operator!= (const Edge &rhs) const
auto	operator<=> (const Edge &rhs) const
bool	operator== (const Edge &rhs) const
void	SetWeight (weight_t new_weight)
vert_t	StartVert () const
weight_t	Weight () const

Private Attributes
vert_t	end_vert_
vert_t	start_vert_
weight_t	weight_ = 0

Constructor & Destructor Documentation

Edge() [1/6]

template<AllowedVertType vert_t = std::string, AllowedWeightType weight_t = size_t>

Graph< vert_t, weight_t >::Edge::Edge ( )

delete

Edge() [2/6]

template<AllowedVertType vert_t = std::string, AllowedWeightType weight_t = size_t>

Graph< vert_t, weight_t >::Edge::Edge ( const vert_t start_vert, const vert_t & end_vert )

inline

        : start_vert_{start_vert}, end_vert_{end_vert} {}

Edge() [3/6]

template<AllowedVertType vert_t = std::string, AllowedWeightType weight_t = size_t>

Graph< vert_t, weight_t >::Edge::Edge ( const vert_t & start_vert, vert_t end_vert, weight_t weight )

inline

        : start_vert_{start_vert}, end_vert_{end_vert}, weight_{weight} {}

Edge() [4/6]

template<AllowedVertType vert_t = std::string, AllowedWeightType weight_t = size_t>

Graph< vert_t, weight_t >::Edge::Edge ( const std::pair< vert_t, vert_t > & edge_pair )

inline

        : start_vert_{edge_pair.first}, end_vert_{edge_pair.second} {}

Edge() [5/6]

template<AllowedVertType vert_t = std::string, AllowedWeightType weight_t = size_t>

Graph< vert_t, weight_t >::Edge::Edge ( const std::pair< vert_t, vert_t > & edge_pair, weight_t weight )

inline

        : start_vert_{edge_pair.first},
          end_vert_{edge_pair.second},
          weight_{weight} {}

Edge() [6/6]

template<AllowedVertType vert_t = std::string, AllowedWeightType weight_t = size_t>

Graph< vert_t, weight_t >::Edge::Edge ( const std::tuple< vert_t, vert_t, weight_t > & edge_tuple )

inline

        : start_vert_{StartVertFromTuple(edge_tuple)},
          end_vert_{EndVertFromTuple(edge_tuple)},
          weight_{WeightFromTuple(edge_tuple)} {}

Member Function Documentation

EndVert()

template<AllowedVertType vert_t = std::string, AllowedWeightType weight_t = size_t>

vert_t Graph< vert_t, weight_t >::Edge::EndVert ( ) const

inline

{ return end_vert_; }

Here is the caller graph for this function:

IsWeighted()

template<AllowedVertType vert_t = std::string, AllowedWeightType weight_t = size_t>

bool Graph< vert_t, weight_t >::Edge::IsWeighted ( ) const

inline

{ return weight_ != 0; }

Here is the caller graph for this function:

Name()

template<AllowedVertType vert_t = std::string, AllowedWeightType weight_t = size_t>

const std::string & Graph< vert_t, weight_t >::Edge::Name ( ) const

inline

                                  {
      static std::string name;
 
      if constexpr (std::is_arithmetic_v<vert_t>) {
        if (IsWeighted())
          name = "[" + std::to_string(StartVert()) + "->" +
                 std::to_string(EndVert()) +
                 ", w: " + std::to_string(Weight()) + "]";
        else
          name = "[" + std::to_string(StartVert()) + "->" +
                 std::to_string(EndVert()) + "]";
 
        // example: "[4->5]"
 
      } else if constexpr (std::is_same_v<vert_t, std::string>) {
        if (IsWeighted())
          name = "['" + StartVert() + "'->'" + EndVert() +
                 "', w: " + std::to_string(Weight()) + "]";
        else
          name = "['" + StartVert() + "'->'" + EndVert() + "']";
 
        // example: "["Paris"->"Berlin"]"
      }
 
      return name;
    }

Here is the call graph for this function:

operator!=()

template<AllowedVertType vert_t = std::string, AllowedWeightType weight_t = size_t>

bool Graph< vert_t, weight_t >::Edge::operator!= ( const Edge & rhs ) const

inline

{ return !(*this == rhs); }

operator<=>()

template<AllowedVertType vert_t = std::string, AllowedWeightType weight_t = size_t>

auto Graph< vert_t, weight_t >::Edge::operator<=> ( const Edge & rhs ) const

inline

{ return weight_ <=> rhs.Weight(); }

operator==()

template<AllowedVertType vert_t = std::string, AllowedWeightType weight_t = size_t>

bool Graph< vert_t, weight_t >::Edge::operator== ( const Edge & rhs ) const

inline

                                           {
      if (StartVert() != rhs.StartVert() || EndVert() != rhs.EndVert())
        return false;
 
      if (IsWeighted() && rhs.IsWeighted()) return Weight() == rhs.Weight();
 
      return true;
    }

Here is the call graph for this function:

SetWeight()

template<AllowedVertType vert_t = std::string, AllowedWeightType weight_t = size_t>

void Graph< vert_t, weight_t >::Edge::SetWeight ( weight_t new_weight )

inline

{ weight_ = new_weight; }

StartVert()

template<AllowedVertType vert_t = std::string, AllowedWeightType weight_t = size_t>

vert_t Graph< vert_t, weight_t >::Edge::StartVert ( ) const

inline

{ return start_vert_; }

Here is the caller graph for this function:

Weight()

template<AllowedVertType vert_t = std::string, AllowedWeightType weight_t = size_t>

weight_t Graph< vert_t, weight_t >::Edge::Weight ( ) const

inline

{ return weight_; }

Here is the caller graph for this function:

Member Data Documentation

end_vert_

template<AllowedVertType vert_t = std::string, AllowedWeightType weight_t = size_t>

vert_t Graph< vert_t, weight_t >::Edge::end_vert_

private

start_vert_

template<AllowedVertType vert_t = std::string, AllowedWeightType weight_t = size_t>

vert_t Graph< vert_t, weight_t >::Edge::start_vert_

private

weight_

template<AllowedVertType vert_t = std::string, AllowedWeightType weight_t = size_t>

weight_t Graph< vert_t, weight_t >::Edge::weight_ = 0

private

---

The documentation for this class was generated from the following file:

• lib/src/graph.hpp