XmEdge.cpp

Go to the documentation of this file.

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

//----- Included files ---------------------------------------------------------

// 1. Precompiled header

// 2. My own header
#include <xmsgrid/ugrid/XmEdge.h>

// 3. Standard library headers
#include <algorithm>

// 4. External library headers

// 5. Shared code headers

// 6. Non-shared code headers

//----- Forward declarations ---------------------------------------------------

//----- External globals -------------------------------------------------------

//----- Namespace declaration --------------------------------------------------

namespace xms
{
//----- Constants / Enumerations -----------------------------------------------

//----- Classes / Structs ------------------------------------------------------

//----- Internal functions -----------------------------------------------------

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
XmEdge::XmEdge()
: m_pt1(0)
, m_pt2(0)
{
} // XmEdge::XmEdge
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
XmEdge::XmEdge(int a_pt1, int a_pt2, bool a_sorted /* =false */)
: m_pt1(a_pt1)
, m_pt2(a_pt2)
{
  if (a_sorted)
    SortIndexes();
} // XmEdge::XmEdge
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
XmEdge::XmEdge(const std::pair<int, int>& a_edge)
: m_pt1(a_edge.first)
, m_pt2(a_edge.second)
{
} // XmEdge::XmEdge
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool XmEdge::operator<(const XmEdge& a_rhs) const
{
  if (m_pt1 < a_rhs.m_pt1)
    return true;
  else if (m_pt1 > a_rhs.m_pt1)
    return false;
  else if (m_pt2 < a_rhs.m_pt2)
    return true;
  else
    return false;
} // XmEdge::operator<
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool XmEdge::operator==(const XmEdge& a_rhs) const
{
  return m_pt1 == a_rhs.m_pt1 && m_pt2 == a_rhs.m_pt2;
} // XmEdge::operator==
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
int XmEdge::GetFirst() const
{
  return m_pt1;
} // XmEdge::GetFirst
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void XmEdge::SetFirst(int a_pt1)
{
  m_pt1 = a_pt1;
} // XmEdge::SetFirst
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
int XmEdge::GetSecond() const
{
  return m_pt2;
} // XmEdge::GetSecond
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void XmEdge::SetSecond(int a_pt2)
{
  m_pt2 = a_pt2;
} // XmEdge::SetSecond
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool XmEdge::IsEquivalent(const XmEdge& a_edge) const
{
  int lhsIdx1 = std::min(m_pt1, m_pt2);
  int lhsIdx2 = std::max(m_pt1, m_pt2);
  int rhsIdx1 = std::min(a_edge.m_pt1, a_edge.m_pt2);
  int rhsIdx2 = std::max(a_edge.m_pt1, a_edge.m_pt2);
  return lhsIdx1 == rhsIdx1 && lhsIdx2 == rhsIdx2;
} // XmEdge::IsEquivalent
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void XmEdge::SortIndexes()
{
  if (m_pt1 > m_pt2)
    std::swap(m_pt1, m_pt2);
} // XmEdge::SortIndexes
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool XmEdgesEquivalent(const XmEdge& a_edge1, const XmEdge& a_edge2)
{
  return a_edge1.IsEquivalent(a_edge2);
} // XmEdgesEquivalent

} // namespace xms

#ifdef CXX_TEST
//------------------------------------------------------------------------------
// Unit Tests
//------------------------------------------------------------------------------
using namespace xms;
#include <xmsgrid/ugrid/XmEdge.t.h>

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void XmEdgeUnitTests::testLessThanOperator()
{
  XmEdge edge1(0, 1);
  XmEdge edge1a(1, 0);
  XmEdge edge2(1, 2);
  TS_ASSERT(edge1 < edge2);
  TS_ASSERT(edge1 < edge1a);
  TS_ASSERT(!(edge1a < edge1));
  TS_ASSERT(!(edge2 < edge1));
} // XmEdgeUnitTests::testLessThanOperator
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void XmEdgeUnitTests::testEqualsOperator()
{
  XmEdge edge1(0, 1);
  XmEdge edge1a(1, 0, false);
  XmEdge edge1b(1, 0, true);
  XmEdge edge2(1, 2);
  TS_ASSERT(edge1 == edge1);
  TS_ASSERT(!(edge1 == edge1a));
  TS_ASSERT(edge1 == edge1b);
  TS_ASSERT(!(edge2 == edge1));
} // XmEdgeUnitTests::testEqualsOperator
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void XmEdgeUnitTests::testIsEquivalent()
{
  XmEdge edge1(0, 1);
  XmEdge edge1a(1, 0);
  XmEdge edge2(1, 2);
  TS_ASSERT(edge1.IsEquivalent(edge1a));
  TS_ASSERT(!(edge1 == edge1a));
  TS_ASSERT(edge1a.IsEquivalent(edge1));
  TS_ASSERT(!edge1.IsEquivalent(edge2));
  TS_ASSERT(XmEdgesEquivalent(edge1, edge1a));
  TS_ASSERT(!XmEdgesEquivalent(edge1, edge2));
} // XmEdgeUnitTests::testIsEquivalent

#endif