|| || || || || ||

---

Reverse.h

Go to the documentation of this file.

#ifndef Impala_Core_Column_Reverse_h
#define Impala_Core_Column_Reverse_h

#include <iostream>
#include "Core/Column/ColumnTem.h"
#include "Util/Reverse.h"

namespace Impala
{
namespace Core
{
namespace Column
{


template <class C>
inline void
Reverse(C* column, int nrElem)
{
    ILOG_VAR(Impala.Core.Column.Reverse);
    if (nrElem > column->Capacity())
    {
        ILOG_ERROR("Too many elements");
        return;
    }

    Util::Reverse(column->GetData(), 0, nrElem - 1);
}

template <class C>
inline void
ReversePart(C* column, int left, int right)
{
    ILOG_VAR(Impala.Core.Column.ReversePart);
    if (column->Capacity() == 0)
        return;

    if(left<0 || right>=column->Capacity())
    {
        ILOG_ERROR("Invalid args");
        return;
    }

    Util::Reverse(column->GetData(), 0, column->Capacity()-1);
}

template <>
inline void
ReversePart(Vector::VectorSet<Array::Array2dScalarReal64>* data, int left,
            int right)
{
    ILOG_VAR(Impala.Core.Column.ReversePart);
    typedef Vector::VectorTem<Array::Array2dScalarReal64::StorType> Type;

    if(left<0 || right>=data->Capacity())
    {
        ILOG_ERROR("Invalid args");
        return;
    }

    while(left<right)
    {
        Type temp = data->Get(left);
        data->Set(left, data->Get(right));
        data->Set(right, temp);
        ++left;
        --right;
    }
}

template <>
inline void
Reverse(Vector::VectorSet<Array::Array2dScalarReal64>* data, int nrElem)
{
    int left = 0;
    int right = nrElem - 1;
    ReversePart(data, left, right);
}

template <>
inline void
Reverse(InvalidColumn* data, int nrElem)
{
    // ignore
}

} // namespace Column
} // namespace Core
} // namespace Impala

#endif

---