LookUpTable< T, C > Class Template Reference

#include <LookUpTable.h>

Collaboration diagram for LookUpTable< T, C >:

Public Types
typedef T	val_type
typedef std::vector< val_type >	vec_type
typedef std::pair< val_type, val_type >	pair_type
typedef vec_type::iterator	vec_type_it
typedef vec_type::const_iterator	vec_type_cit

Public Member Functions
	LookUpTable ()=default
	~LookUpTable ()=default
bool	empty () const
void	setData (const vec_type &data)
const vec_type &	getData () const
vec_type_it	begin ()
vec_type_it	end ()
vec_type_cit	begin () const
vec_type_cit	end () const
vec_type_cit	lowerBound (const val_type &val)
pair_type	find (const val_type &val) const
template<class CC >
pair_type	find (const val_type &val, const CC &c) const

Private Attributes
vec_type	m_data

Detailed Description

template<class T, class C = std::less<T>>
class LookUpTable< T, C >

Generic lookup table. Uses comparison function objects or the < operator to sort and look up values in the table.

Definition at line 21 of file LookUpTable.h.

Member Typedef Documentation

pair_type

template<class T , class C = std::less<T>>

typedef std::pair<val_type, val_type> LookUpTable< T, C >::pair_type

Definition at line 25 of file LookUpTable.h.

val_type

template<class T , class C = std::less<T>>

typedef T LookUpTable< T, C >::val_type

Definition at line 23 of file LookUpTable.h.

vec_type

template<class T , class C = std::less<T>>

typedef std::vector<val_type> LookUpTable< T, C >::vec_type

Definition at line 24 of file LookUpTable.h.

vec_type_cit

template<class T , class C = std::less<T>>

typedef vec_type::const_iterator LookUpTable< T, C >::vec_type_cit

Definition at line 28 of file LookUpTable.h.

vec_type_it

template<class T , class C = std::less<T>>

typedef vec_type::iterator LookUpTable< T, C >::vec_type_it

Definition at line 27 of file LookUpTable.h.

Constructor & Destructor Documentation

LookUpTable()

template<class T , class C = std::less<T>>

LookUpTable< T, C >::LookUpTable ( )

default

~LookUpTable()

template<class T , class C = std::less<T>>

LookUpTable< T, C >::~LookUpTable ( )

default

Member Function Documentation

begin() [1/2]

template<class T , class C = std::less<T>>

vec_type_it LookUpTable< T, C >::begin ( )

inline

Definition at line 38 of file LookUpTable.h.

{ return m_data.begin(); }

begin() [2/2]

template<class T , class C = std::less<T>>

vec_type_cit LookUpTable< T, C >::begin ( ) const

inline

Definition at line 40 of file LookUpTable.h.

{ return m_data.begin(); }

empty()

template<class T , class C = std::less<T>>

bool LookUpTable< T, C >::empty ( ) const

inline

Definition at line 33 of file LookUpTable.h.

{ return m_data.empty(); }

end() [1/2]

template<class T , class C = std::less<T>>

vec_type_it LookUpTable< T, C >::end ( )

inline

Definition at line 39 of file LookUpTable.h.

{ return m_data.end(); }

end() [2/2]

template<class T , class C = std::less<T>>

vec_type_cit LookUpTable< T, C >::end ( ) const

inline

Definition at line 41 of file LookUpTable.h.

{ return m_data.end(); }

find() [1/2]

template<class T , class C >

LookUpTable< T, C >::pair_type LookUpTable< T, C >::find ( const val_type &  val ) const

inline

Definition at line 71 of file LookUpTable.h.

                                                                                                                        {
    vec_type_cit it = lower_bound(m_data.begin(), m_data.end(), val, C());
    if (it == m_data.end())
        return std::make_pair(*(it - 2), *(it - 1));
    else if (it == m_data.begin())
        return std::make_pair(*it, *(it + 1));
    else
        return std::make_pair(*(it - 1), *it);
}

find() [2/2]

template<class T , class C = std::less<T>>

template<class CC >

pair_type LookUpTable< T, C >::find ( const val_type &  val, const CC &  c  ) const

inline

Definition at line 46 of file LookUpTable.h.

                                                                               {
        vec_type_cit it = lower_bound(m_data.begin(), m_data.end(), val, c);
        if (it == m_data.end())
            return std::make_pair(*(it - 2), *(it - 1));
        else if (it == m_data.begin())
            return std::make_pair(*it, *(it + 1));
        else
            return std::make_pair(*(it - 1), *it);
    }

getData()

template<class T , class C = std::less<T>>

const vec_type& LookUpTable< T, C >::getData ( ) const

inline

Definition at line 36 of file LookUpTable.h.

{ return m_data; }

lowerBound()

template<class T , class C >

LookUpTable< T, C >::vec_type_cit LookUpTable< T, C >::lowerBound ( const val_type &  val )

inline

Definition at line 65 of file LookUpTable.h.

                                                                                                                           {
    vec_type_cit it = lower_bound(m_data.begin(), m_data.end(), val, C());
    if (it == m_data.end()) return m_data.end() - 1;
    return it;
}

setData()

template<class T , class C >

void LookUpTable< T, C >::setData ( const vec_type &  data )

inline

Definition at line 60 of file LookUpTable.h.

                                                                                       {
    m_data.assign(data.begin(), data.end());
    sort(m_data.begin(), m_data.end(), C());
}

Member Data Documentation

m_data

template<class T , class C = std::less<T>>

vec_type LookUpTable< T, C >::m_data

private

Definition at line 57 of file LookUpTable.h.

---

The documentation for this class was generated from the following file:

• LookUpTable.h