Tuple.H

Go to the documentation of this file.

#ifdef CH_LANG_CC
/*
*      _______              __
*     / ___/ /  ___  __ _  / /  ___
*    / /__/ _ \/ _ \/  V \/ _ \/ _ \
*    \___/_//_/\___/_/_/_/_.__/\___/
*    Please refer to Copyright.txt, in Chombo's root directory.
*/
#endif

#ifndef _TUPLE_H_
#define _TUPLE_H_

#include <cstdlib>
#include "CH_assert.H"
#include "BaseNamespaceHeader.H"
using namespace std;

//

template <class T, size_t N>
class Tuple
{
public:

    Tuple ();

  //explicit Tuple (const T* v);
    //
    // The copy constructor.
    //
    Tuple (const Tuple& rhs);
    //
    // The copy assignment operator.
    //
    Tuple& operator= (const Tuple& rhs);

    T& operator[] (int i);

    const T& operator[] (int i) const;

    operator const T* () const;

protected:
    //
    // The underlying vector of T representing the Tuple.
    //
    T vect[N];
};

//
// Inlines.
//

template <class T, size_t N>
inline
Tuple<T,N>::Tuple()
{}

template <class T, size_t N>
inline
T&
Tuple<T,N>::operator[] (int i)
{
    CH_assert(0 <= i && i < (int)N);
    return vect[i];
}

template <class T, size_t N>
inline
const T&
Tuple<T,N>::operator[] (int i) const
{
    CH_assert(0 <= i && i < (int)N);
    return vect[i];
}

template <class T, size_t N>
inline
Tuple<T,N>::operator const T* () const
{
    return &vect[0];
}

//template <class T, size_t N>
//Tuple<T,N>::Tuple (const T* v)
//{
//    CH_assert(v != 0);
//    for (size_t i = 0; i < N; ++i)
//        vect[i] = v[i];
//}

template <class T, size_t N>
Tuple<T,N>::Tuple (const Tuple<T,N>& rhs)
{
    for (size_t i = 0; i < N; ++i)
        vect[i] = rhs.vect[i];
}

template <class T, size_t N>
Tuple<T,N>&
Tuple<T,N>::operator= (const Tuple<T,N>& rhs)
{
    for (size_t i = 0; i < N; ++i)
        vect[i] = rhs.vect[i];
    return *this;
}

#include "BaseNamespaceFooter.H"
#endif /*CH_TUPLE_H*/

---