Triple.cpp

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
#include "MantidGeometry/Math/Triple.h"
#include <string>
 
namespace Mantid {
 
template <typename T>
Triple<T>::Triple()
    : first(), second(), third()
{}
 
template <typename T>
Triple<T>::Triple(const Triple<T> &A)
    : first(A.first), second(A.second), third(A.third)
{}
 
template <typename T>
Triple<T>::Triple(const T &A, const T &B, const T &C)
    : first(A), second(B), third(C)
{}
 
template <typename T>
Triple<T> &Triple<T>::operator=(const Triple<T> &A)
{
  if (this != &A) {
    first = A.first;
    second = A.second;
    third = A.third;
  }
  return *this;
}
 
template <typename T>
Triple<T>::~Triple()
    = default;
 
template <typename T>
bool Triple<T>::operator==(const Triple<T> &A) const
{
  return (first == A.first && second == A.second && third == A.third);
}
 
template <typename T>
bool Triple<T>::operator!=(const Triple<T> &A) const
{
  return !(*this == A);
}
 
template <typename T>
bool Triple<T>::operator<(const Triple<T> &A) const
{
  if (first > A.first)
    return false;
  if (first < A.first)
    return true;
  if (second > A.second)
    return false;
  if (second < A.second)
    return true;
  if (third >= A.third)
    return false;
  return true;
}
 
template <typename T>
bool Triple<T>::operator>(const Triple<T> &A) const
{
  return A.operator<(*this);
}
 
template <typename T>
T &Triple<T>::operator[](const int A)
{
  switch (A) {
  case 0:
    return first;
  case 1:
    return second;
  case 2:
    return third;
  default:
    throw "Range Error";
  }
}
 
template <typename T>
T Triple<T>::operator[](const int A) const
{
  switch (A) {
  case 0:
    return first;
  case 1:
    return second;
  case 2:
    return third;
  default:
    throw "Range Error";
  }
}
 
/*
------------------------------------------------------------------
    Different Triple
------------------------------------------------------------------
*/
 
template <typename F, typename S, typename T>
DTriple<F, S, T>::DTriple()
    : first(), second(), third()
{}
 
template <typename F, typename S, typename T>
DTriple<F, S, T>::DTriple(const DTriple<F, S, T> &A)
    : first(A.first), second(A.second), third(A.third)
{}
 
template <typename F, typename S, typename T>
DTriple<F, S, T>::DTriple(const F &A, const S &B, const T &C)
    : first(A), second(B), third(C)
{}
 
template <typename F, typename S, typename T>
DTriple<F, S, T> &DTriple<F, S, T>::operator=(const DTriple<F, S, T> &A)
{
  if (this != &A) {
    first = A.first;
    second = A.second;
    third = A.third;
  }
  return *this;
}
 
template <typename F, typename S, typename T>
DTriple<F, S, T>::~DTriple()
    = default;
 
template <typename F, typename S, typename T>
bool DTriple<F, S, T>::operator==(const DTriple<F, S, T> &A) const
{
  return (first == A.first && second == A.second && third == A.third);
}
 
template <typename F, typename S, typename T>
bool DTriple<F, S, T>::operator!=(const DTriple<F, S, T> &A) const
{
  return !(*this == A);
}
 
template <typename F, typename S, typename T>
bool DTriple<F, S, T>::operator<(const DTriple<F, S, T> &A) const
{
  if (first > A.first)
    return false;
  if (first < A.first)
    return true;
  if (second > A.second)
    return false;
  if (second < A.second)
    return true;
  if (third >= A.third)
    return false;
  return true;
}
 
template <typename F, typename S, typename T>
bool DTriple<F, S, T>::operator>(const DTriple<F, S, T> &A) const
{
  return A.operator<(*this);
}
 
 
namespace Geometry {
class Rule;
}
 
template class DTriple<Geometry::Rule *, int, Geometry::Rule *>;
template class DTriple<std::string, int, int>;
template class DTriple<int, int, double>;
template class DTriple<int, int, std::string>;
template class DTriple<int, double, std::string>;
template class Triple<int>;
template class Triple<double>;
 
 
} // Namespace Mantid