// Copyright (C) 2003 Davis E. King (davis@dlib.net)
// License: Boost Software License See LICENSE.txt for the full license.
#ifndef DLIB_MAP_KERNEl_1_
#define DLIB_MAP_KERNEl_1_
#include "map_kernel_abstract.h"
#include "../algs.h"
#include "../interfaces/enumerable.h"
#include "../interfaces/map_pair.h"
#include "../interfaces/remover.h"
#include "../serialize.h"
namespace dlib
{
template <
typename domain,
typename range,
typename bst_base,
typename mem_manager = default_memory_manager
>
class map_kernel_1 : public enumerable<map_pair<domain,range> >,
public asc_pair_remover<domain,range,typename bst_base::compare_type>
{
/*!
REQUIREMENTS ON BST_BASE
bst_base is instantiated with domain and range and
implements binary_search_tree/binary_search_tree_kernel_abstract.h
INITIAL VALUE
bst has its initial value
CONVENTION
bst.size() == the number of elements in the map and
the elements in map are stored in bst_base
!*/
public:
typedef domain domain_type;
typedef range range_type;
typedef typename bst_base::compare_type compare_type;
typedef mem_manager mem_manager_type;
map_kernel_1(
)
{}
virtual ~map_kernel_1(
)
{}
inline void clear(
);
inline void add (
domain& d,
range& r
);
inline bool is_in_domain (
const domain& d
) const;
inline void remove_any (
domain& d,
range& r
);
inline void remove (
const domain& d,
domain& d_copy,
range& r
);
inline void destroy (
const domain& d
);
inline range& operator[] (
const domain& d
);
inline const range& operator[] (
const domain& d
) const;
inline void swap (
map_kernel_1& item
);
// functions from the enumerable interface
inline unsigned long size (
) const;
inline bool at_start (
) const;
inline void reset (
) const;
inline bool current_element_valid (
) const;
inline const map_pair<domain,range>& element (
) const;
inline map_pair<domain,range>& element (
);
inline bool move_next (
) const;
private:
bst_base bst;
// restricted functions
map_kernel_1(map_kernel_1&);
map_kernel_1& operator= ( map_kernel_1&);
};
template <
typename domain,
typename range,
typename bst_base,
typename mem_manager
>
inline void swap (
map_kernel_1<domain,range,bst_base,mem_manager>& a,
map_kernel_1<domain,range,bst_base,mem_manager>& b
) { a.swap(b); }
template <
typename domain,
typename range,
typename bst_base,
typename mem_manager
>
void deserialize (
map_kernel_1<domain,range,bst_base,mem_manager>& item,
std::istream& in
)
{
try
{
item.clear();
unsigned long size;
deserialize(size,in);
domain d;
range r;
for (unsigned long i = 0; i < size; ++i)
{
deserialize(d,in);
deserialize(r,in);
item.add(d,r);
}
}
catch (serialization_error e)
{
item.clear();
throw serialization_error(e.info + "\n while deserializing object of type map_kernel_1");
}
}
// ----------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
// member function definitions
// ----------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
template <
typename domain,
typename range,
typename bst_base,
typename mem_manager
>
void map_kernel_1<domain,range,bst_base,mem_manager>::
clear (
)
{
bst.clear();
}
// ----------------------------------------------------------------------------------------
template <
typename domain,
typename range,
typename bst_base,
typename mem_manager
>
void map_kernel_1<domain,range,bst_base,mem_manager>::
add(
domain& d,
range& r
)
{
// try to add pair to bst_base
bst.add(d,r);
}
// ----------------------------------------------------------------------------------------
template <
typename domain,
typename range,
typename bst_base,
typename mem_manager
>
bool map_kernel_1<domain,range,bst_base,mem_manager>::
is_in_domain(
const domain& d
) const
{
return (bst[d] != 0);
}
// ----------------------------------------------------------------------------------------
template <
typename domain,
typename range,
typename bst_base,
typename mem_manager
>
void map_kernel_1<domain,range,bst_base,mem_manager>::
remove_any(
domain& d,
range& r
)
{
bst.remove_any(d,r);
}
// ----------------------------------------------------------------------------------------
template <
typename domain,
typename range,
typename bst_base,
typename mem_manager
>
void map_kernel_1<domain,range,bst_base,mem_manager>::
remove (
const domain& d,
domain& d_copy,
range& r
)
{
bst.remove(d,d_copy,r);
}
// ----------------------------------------------------------------------------------------
template <
typename domain,
typename range,
typename bst_base,
typename mem_manager
>
void map_kernel_1<domain,range,bst_base,mem_manager>::
destroy (
const domain& d
)
{
bst.destroy(d);
}
// ----------------------------------------------------------------------------------------
template <
typename domain,
typename range,
typename bst_base,
typename mem_manager
>
range& map_kernel_1<domain,range,bst_base,mem_manager>::
operator[](
const domain& d
)
{
return *bst[d];
}
// ----------------------------------------------------------------------------------------
template <
typename domain,
typename range,
typename bst_base,
typename mem_manager
>
const range& map_kernel_1<domain,range,bst_base,mem_manager>::
operator[](
const domain& d
) const
{
return *bst[d];
}
// ----------------------------------------------------------------------------------------
template <
typename domain,
typename range,
typename bst_base,
typename mem_manager
>
unsigned long map_kernel_1<domain,range,bst_base,mem_manager>::
size (
) const
{
return bst.size();
}
// ----------------------------------------------------------------------------------------
template <
typename domain,
typename range,
typename bst_base,
typename mem_manager
>
void map_kernel_1<domain,range,bst_base,mem_manager>::
swap (
map_kernel_1<domain,range,bst_base,mem_manager>& item
)
{
bst.swap(item.bst);
}
// ----------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
// enumerable function definitions
// ----------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
template <
typename domain,
typename range,
typename bst_base,
typename mem_manager
>
bool map_kernel_1<domain,range,bst_base,mem_manager>::
at_start (
) const
{
return bst.at_start();
}
// ----------------------------------------------------------------------------------------
template <
typename domain,
typename range,
typename bst_base,
typename mem_manager
>
void map_kernel_1<domain,range,bst_base,mem_manager>::
reset (
) const
{
bst.reset();
}
// ----------------------------------------------------------------------------------------
template <
typename domain,
typename range,
typename bst_base,
typename mem_manager
>
bool map_kernel_1<domain,range,bst_base,mem_manager>::
current_element_valid (
) const
{
return bst.current_element_valid();
}
// ----------------------------------------------------------------------------------------
template <
typename domain,
typename range,
typename bst_base,
typename mem_manager
>
const map_pair<domain,range>& map_kernel_1<domain,range,bst_base,mem_manager>::
element (
) const
{
return bst.element();
}
// ----------------------------------------------------------------------------------------
template <
typename domain,
typename range,
typename bst_base,
typename mem_manager
>
map_pair<domain,range>& map_kernel_1<domain,range,bst_base,mem_manager>::
element (
)
{
return bst.element();
}
// ----------------------------------------------------------------------------------------
template <
typename domain,
typename range,
typename bst_base,
typename mem_manager
>
bool map_kernel_1<domain,range,bst_base,mem_manager>::
move_next (
) const
{
return bst.move_next();
}
// ----------------------------------------------------------------------------------------
}
#endif // DLIB_MAP_KERNEl_1_