\( \newcommand{\E}{\mathrm{E}} \) \( \newcommand{\A}{\mathrm{A}} \) \( \newcommand{\R}{\mathrm{R}} \) \( \newcommand{\N}{\mathrm{N}} \) \( \newcommand{\Q}{\mathrm{Q}} \) \( \newcommand{\Z}{\mathrm{Z}} \) \( \def\ccSum #1#2#3{ \sum_{#1}^{#2}{#3} } \def\ccProd #1#2#3{ \sum_{#1}^{#2}{#3} }\)
CGAL 5.0 - STL Extensions for CGAL
CGAL::Quadruple< T1, T2, T3, T4 > Class Template Reference

#include <CGAL/utility.h>

Definition

The Quadruple class is an extension of std::pair.

Quadruple is a heterogeneous quadruple: it holds one object of type T1, one of type T2, one of type T3, and one of type T4. A Quadruple is much like a container, in that it "owns" its elements. It is not actually a model of container, though, because it does not support the standard methods (such as iterators) for accessing the elements of a container.

std::tuple or std::array instead for new uses.

Requirements

T1, T2, T3 and T4 must be Assignable. Additional operations have additional requirements.

Public Member Functions

template<class T1 , class T2 , class T3 , class T4 >
bool operator< (Quadruple< T1, T2, T3, T4 > x, Quadruple< T1, T2, T3, T4 > y)
 The comparison operator. More...
 
template<class T1 , class T2 , class T3 , class T4 >
bool operator== (Quadruple< T1, T2, T3, T4 > x, Quadruple< T1, T2, T3, T4 > y)
 The equality operator. More...
 

Related Functions

(Note that these are not member functions.)

template<class T1 , class T2 , class T3 , class T4 >
Quadruple< T1, T2, T3, T4 > make_quadruple (T1 x, T2 y, T3 z, T4 w)
 Equivalent to Quadruple<T1, T2, T3, T4>(x, y, z, w).
 
template<class T1 , class T2 , class T3 , class T4 >
Quadruple< T1, T2, T3, T4 > make_tuple (T1 x, T2 y, T3 z, T4 w)
 Equivalent to Quadruple<T1, T2, T3, T4>(x, y, z, w).
 

Types

typedef T1 first_type
 
typedef T2 second_type
 
typedef T3 third_type
 
typedef T4 fourth_type
 

Variables

T1 first
 first element. More...
 
T2 second
 second element. More...
 
T3 third
 third element. More...
 
T4 fourth
 fourth element. More...
 

Creation

 Quadruple ()
 introduces a quadruple using the default constructor of the four elements.
 
 Quadruple (T1 x, T2 y, T3 z, T4 w)
 constructs a quadruple such that first is constructed from x, second is constructed from y, third is constructed from z, and fourth is constructed from w.
 
template<class U , class V , class W , class X >
 Quadruple (U u, V v, W w, X x)
 constructs a quadruple such that first is constructed from u, second is constructed from v, third is constructed from w, and fourth is constructed from x. More...
 
template<int i>
get ()
 Gives access to first, second, third or fourth whenever i is 0, 1, 2 or 3, via a, potentially const, reference. More...
 

Constructor & Destructor Documentation

◆ Quadruple()

template<typename T1 , typename T2 , typename T3 , typename T4 >
template<class U , class V , class W , class X >
CGAL::Quadruple< T1, T2, T3, T4 >::Quadruple ( u,
v,
w,
x 
)

constructs a quadruple such that first is constructed from u, second is constructed from v, third is constructed from w, and fourth is constructed from x.

Proper conversion operators must exist from U to T1, V to T2, W to T3, and X to T4.

Member Function Documentation

◆ get()

template<typename T1 , typename T2 , typename T3 , typename T4 >
template<int i>
T CGAL::Quadruple< T1, T2, T3, T4 >::get ( )

Gives access to first, second, third or fourth whenever i is 0, 1, 2 or 3, via a, potentially const, reference.

Note: T stands for T1, T2, T3 or T4 depending on i.

◆ operator
template<typename T1 , typename T2 , typename T3 , typename T4 >
template<class T1 , class T2 , class T3 , class T4 >
bool CGAL::Quadruple< T1, T2, T3, T4 >::operator< ( Quadruple< T1, T2, T3, T4 >  x,
Quadruple< T1, T2, T3, T4 >  y 
)

The comparison operator.

It uses lexicographic comparison: the return value is true if the first element of x is less than the first element of y, and false if the first element of y is less than the first element of x. If neither of these is the case, then it returns true if the second element of x is less than the second element of y, and false if the second element of y is less than the second element of x. If neither of these is the case, then it returns true if the third element of x is less than the third element of y, and false if the third element of y is less than the third element of x. If neither of these is the case, then it returns the result of comparing the fourth elements of x and y. This operator may only be used if T1, T2, T3, and T4 define the comparison operator.

◆ operator==()

template<typename T1 , typename T2 , typename T3 , typename T4 >
template<class T1 , class T2 , class T3 , class T4 >
bool CGAL::Quadruple< T1, T2, T3, T4 >::operator== ( Quadruple< T1, T2, T3, T4 >  x,
Quadruple< T1, T2, T3, T4 >  y 
)

The equality operator.

The return value is true if and only the first elements of x and y are equal, the second elements of x and y are equal, the third elements of x and y are equal, and the fourth elements of x and y are equal. This operator may only be used if T1, T2, T3, and T4 define the equality operator.

Member Data Documentation

◆ first

template<typename T1 , typename T2 , typename T3 , typename T4 >
T1 CGAL::Quadruple< T1, T2, T3, T4 >::first

first element.

Please access it using get<0>().

◆ fourth

template<typename T1 , typename T2 , typename T3 , typename T4 >
T4 CGAL::Quadruple< T1, T2, T3, T4 >::fourth

fourth element.

Please access it using get<3>().

◆ second

template<typename T1 , typename T2 , typename T3 , typename T4 >
T2 CGAL::Quadruple< T1, T2, T3, T4 >::second

second element.

Please access it using get<1>().

◆ third

template<typename T1 , typename T2 , typename T3 , typename T4 >
T3 CGAL::Quadruple< T1, T2, T3, T4 >::third

third element.

Please access it using get<2>().