xrb_ntuple.hpp

// ///////////////////////////////////////////////////////////////////////////
// xrb_ntuple.hpp by Victor Dods, created 2005/06/12
// ///////////////////////////////////////////////////////////////////////////
// Unless a different license was explicitly granted in writing by the
// copyright holder (Victor Dods), this software is freely distributable under
// the terms of the GNU General Public License, version 2.  Any works deriving
// from this work must also be released under the GNU GPL.  See the included
// file LICENSE for details.
// ///////////////////////////////////////////////////////////////////////////

#if !defined(_XRB_NTUPLE_HPP_)
#define _XRB_NTUPLE_HPP_

#include "xrb.hpp"

#include <stdio.h>

#include "xrb_enums.hpp"

namespace Xrb
{

// ///////////////////////////////////////////////////////////////////////////
// NTuple - generalized type ordered value set of arbitrary size
// ///////////////////////////////////////////////////////////////////////////

template <typename T, Uint32 size>
class NTuple
{
public:

    T m[size];

    // ///////////////////////////////////////////////////////////////////////
    // constructors and destructor
    // ///////////////////////////////////////////////////////////////////////

    inline NTuple ()
    {
    }
    inline NTuple (
        T const component0,
        T const component1)
    {
        ASSERT1(size == 2);
        m[0] = component0;
        m[1] = component1;
    }
    inline NTuple (
        T const component0,
        T const component1,
        T const component2)
    {
        ASSERT1(size == 3);
        m[0] = component0;
        m[1] = component1;
        m[2] = component2;
    }
    inline NTuple (
        T const component0,
        T const component1,
        T const component2,
        T const component3)
    {
        ASSERT1(size == 4);
        m[0] = component0;
        m[1] = component1;
        m[2] = component2;
        m[3] = component3;
    }
    inline NTuple (T const *const components)
    {
        ASSERT1(components != NULL);
    #if defined(XRB_NTUPLE_USES_MEMCPY)
        memcpy(m, components, sizeof(T) * size);
    #else
        for (Uint32 i = 0; i < size; ++i)
            m[i] = components[i];
    #endif
    }
    inline NTuple (NTuple<T, size> const &source)
    {
    #if defined(XRB_NTUPLE_USES_MEMCPY)
        memcpy(m, source.m, sizeof(T) * size);
    #else
        for (Uint32 i = 0; i < size; ++i)
            m[i] = source.m[i];
    #endif
    }
    inline ~NTuple ()
    {
    }

    // ///////////////////////////////////////////////////////////////////////
    // overloaded operators
    // ///////////////////////////////////////////////////////////////////////

    inline void operator = (NTuple<T, size> const &operand)
    {
    #if defined(XRB_NTUPLE_USES_MEMCPY)
        memcpy(m, operand.m, sizeof(T) * size);
    #else
        for (Uint32 i = 0; i < size; ++i)
            m[i] = operand.m[i];
    #endif
    }
    inline bool operator == (NTuple<T, size> const &operand) const
    {
    #if defined(XRB_NTUPLE_USES_MEMCMP)
        return memcmp(m, operand.m, sizeof(T) * size) == 0;
    #else
        for (Uint32 i = 0; i < size; ++i)
            if (m[i] != operand.m[i])
                return false;
        return true;
    #endif
    }
    inline bool operator != (NTuple<T, size> const &operand) const
    {
    #if defined(XRB_NTUPLE_USES_MEMCMP)
        return memcmp(m, operand.m, sizeof(T) * size) != 0;
    #else
        for (Uint32 i = 0; i < size; ++i)
            if (m[i] != operand.m[i])
                return true;
        return false;
    #endif
    }
    inline T const &operator [] (Uint32 const index) const
    {
        ASSERT3(index < size);
        return m[index];
    }
    inline T &operator [] (Uint32 const index)
    {
        ASSERT3(index < size);
        return m[index];
    }
    inline void operator += (NTuple<T, size> const &operand)
    {
        for (Uint32 i = 0; i < size; ++i)
            m[i] += operand.m[i];
    }
    inline void operator -= (NTuple<T, size> const &operand)
    {
        for (Uint32 i = 0; i < size; ++i)
            m[i] -= operand.m[i];
    }
    inline void operator *= (NTuple<T, size> const &operand)
    {
        for (Uint32 i = 0; i < size; ++i)
            m[i] *= operand.m[i];
    }
    inline void operator *= (T const operand)
    {
        for (Uint32 i = 0; i < size; ++i)
            m[i] *= operand;
    }
    inline void operator /= (NTuple<T, size> const &operand)
    {
        for (Uint32 i = 0; i < size; ++i)
            m[i] /= operand.m[i];
    }
    inline void operator /= (T const operand)
    {
        for (Uint32 i = 0; i < size; ++i)
            m[i] /= operand;
    }
    inline NTuple<T, size> operator - () const
    {
        NTuple<T, size> retval;
        for (Uint32 i = 0; i < size; ++i)
            retval.m[i] = -m[i];
        return retval;
    }

    // ///////////////////////////////////////////////////////////////////////
    // accessors
    // ///////////////////////////////////////////////////////////////////////

    template <typename U>
    inline NTuple<U, size> StaticCast () const
    {
        NTuple<U, size> retval;
        for (Uint32 i = 0; i < size; ++i)
            retval.m[i] = static_cast<U>(m[i]);
        return retval;
    }

    // ///////////////////////////////////////////////////////////////////////
    // modifiers
    // ///////////////////////////////////////////////////////////////////////

    inline void FillWith (T const fill_with)
    {
        for (Uint32 i = 0; i < size; ++i)
            m[i] = fill_with;
    }
    inline void Negate ()
    {
        for (Uint32 i = 0; i < size; ++i)
            m[i] = -m[i];
    }
    inline void SetComponents (
        T const component0,
        T const component1)
    {
        ASSERT1(size == 2);
        m[0] = component0;
        m[1] = component1;
    }
    inline void SetComponents (
        T const component0,
        T const component1,
        T const component2)
    {
        ASSERT1(size == 3);
        m[0] = component0;
        m[1] = component1;
        m[2] = component2;
    }
    inline void SetComponents (
        T const component0,
        T const component1,
        T const component2,
        T const component3)
    {
        ASSERT1(size == 4);
        m[0] = component0;
        m[1] = component1;
        m[2] = component2;
        m[3] = component3;
    }
    inline void SetComponents (T const *const components)
    {
        ASSERT1(components != NULL);
    #if defined(XRB_NTUPLE_USES_MEMCPY)
        memcpy(m, components, sizeof(T) * size);
    #else
        for (Uint32 i = 0; i < size; ++i)
            m[i] = components[i];
    #endif
    }
    template <typename U>
    inline void StaticCastAssign (NTuple<U, size> const &source)
    {
        for (Uint32 i = 0; i < size; ++i)
            m[i] = static_cast<T>(source.m[i]);
    }

    // ///////////////////////////////////////////////////////////////////////
    // procedures
    // ///////////////////////////////////////////////////////////////////////

    void Fprint (FILE *const fptr,
                 char const *const component_printf_format,
                 bool const add_newline = true) const
    {
        fprintf(fptr, "%uTuple = (", size);
        Uint32 i;
        for (i = 0; i < size-1; ++i)
        {
            fprintf(fptr, component_printf_format, m[i]);
            fprintf(fptr, ", ");
        }
        ASSERT1(i == size-1);
        fprintf(fptr, component_printf_format, m[i]);
        fprintf(fptr, ")%c", add_newline ? '\n' : '\0');
    }

}; // end of class NTuple

template <typename T, Uint32 size>
inline NTuple<T, size> operator + (
    NTuple<T, size> const &left_operand,
    NTuple<T, size> const &right_operand)
{
    NTuple<T, size> retval;
    for (Uint32 i = 0; i < size; ++i)
        retval.m[i] = left_operand.m[i] + right_operand.m[i];
    return retval;
}

template <typename T, Uint32 size>
inline NTuple<T, size> operator - (
    NTuple<T, size> const &left_operand,
    NTuple<T, size> const &right_operand)
{
    NTuple<T, size> retval;
    for (Uint32 i = 0; i < size; ++i)
        retval.m[i] = left_operand.m[i] - right_operand.m[i];
    return retval;
}

template <typename T, Uint32 size>
inline NTuple<T, size> operator * (
    NTuple<T, size> const &left_operand,
    NTuple<T, size> const &right_operand)
{
    NTuple<T, size> retval;
    for (Uint32 i = 0; i < size; ++i)
        retval.m[i] = left_operand.m[i] * right_operand.m[i];
    return retval;
}

template <typename T, Uint32 size>
inline NTuple<T, size> operator * (
    T const left_operand,
    NTuple<T, size> const &right_operand)
{
    NTuple<T, size> retval;
    for (Uint32 i = 0; i < size; ++i)
        retval.m[i] = left_operand * right_operand.m[i];
    return retval;
}

template <typename T, Uint32 size>
inline NTuple<T, size> operator * (
    NTuple<T, size> const &left_operand,
    T const right_operand)
{
    NTuple<T, size> retval;
    for (Uint32 i = 0; i < size; ++i)
        retval.m[i] = left_operand.m[i] * right_operand;
    return retval;
}

template <typename T, Uint32 size>
inline NTuple<T, size> operator / (
    NTuple<T, size> const &left_operand,
    NTuple<T, size> const &right_operand)
{
    NTuple<T, size> retval;
    for (Uint32 i = 0; i < size; ++i)
        retval.m[i] = left_operand.m[i] / right_operand.m[i];
    return retval;
}

template <typename T, Uint32 size>
inline NTuple<T, size> operator / (
    T const left_operand,
    NTuple<T, size> const &right_operand)
{
    NTuple<T, size> retval;
    for (Uint32 i = 0; i < size; ++i)
        retval.m[i] = left_operand / right_operand.m[i];
    return retval;
}

template <typename T, Uint32 size>
inline NTuple<T, size> operator / (
    NTuple<T, size> const &left_operand,
    T const right_operand)
{
    NTuple<T, size> retval;
    for (Uint32 i = 0; i < size; ++i)
        retval.m[i] = left_operand.m[i] / right_operand;
    return retval;
}

// ///////////////////////////////////////////////////////////////////////////
// convenience typedefs for n-tuples of different types and dimensions,
// and format-specific Fprint functions for each typedef.
// ///////////////////////////////////////////////////////////////////////////

typedef NTuple<bool, 2> Bool2;
typedef NTuple<Alignment, 2> Alignment2;

void Fprint (
    FILE *fptr,
    Bool2 const &ntuple,
    bool add_newline = true);
void Fprint (
    FILE *fptr,
    Alignment2 const &ntuple,
    bool add_newline = true);

} // end of namespace Xrb

#endif // !defined(_XRB_NTUPLE_HPP_)

---