dlib C++ Library - set_kernel_1.h

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