dlib C++ Library - sequence_kernel_c.h

// Copyright (C) 2003 Davis E. King (davis@dlib.net)
// License: Boost Software License See LICENSE.txt for the full license.
#ifndef DLIB_SEQUENCE_KERNEl_C_
#define DLIB_SEQUENCE_KERNEl_C_
#include "sequence_kernel_abstract.h"
#include "../algs.h"
#include "../assert.h"
namespace dlib
{
 template <
 typename seq_base
 >
 class sequence_kernel_c : public seq_base
 {
 typedef typename seq_base::type T;
 public:
 void add (
 unsigned long pos,
 T& item
 );
 void remove (
 unsigned long pos,
 T& item
 );
 const T& operator[] (
 unsigned long pos
 ) const;
 T& operator[] (
 unsigned long pos
 );
 void cat (
 sequence_kernel_c& item
 );
 const T& element (
 ) const;
 T& element (
 );
 void remove_any (
 T& item
 );
 };
 template <
 typename seq_base
 >
 inline void swap (
 sequence_kernel_c<seq_base>& a, 
 sequence_kernel_c<seq_base>& b 
 ) { a.swap(b); } 
// ----------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
// member function definitions
// ----------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
 template <
 typename seq_base
 >
 void sequence_kernel_c<seq_base>::
 add(
 unsigned long pos,
 T& item
 )
 {
 // make sure requires clause is not broken
 DLIB_CASSERT(( pos <= this->size() ), 
 "\tvoid sequence::add"
 << "\n\tpos must be >= 0 and <= size()" 
 << "\n\tpos: " << pos 
 << "\n\tsize(): " << this->size()
 << "\n\tthis: " << this
 );
 // call the real function
 seq_base::add(pos,item);
 }
// ----------------------------------------------------------------------------------------
 template <
 typename seq_base
 >
 void sequence_kernel_c<seq_base>::
 cat (
 sequence_kernel_c<seq_base>& item
 )
 {
 // make sure requires clause is not broken
 DLIB_CASSERT(&item != this, 
 "\tvoid sequence::cat"
 << "\n\tyou can't concatenate a sequence onto itself" 
 << "\n\t&item: " << &item
 << "\n\tthis: " << this
 );
 // call the real function
 seq_base::cat(item);
 }
// ----------------------------------------------------------------------------------------
 template <
 typename seq_base
 >
 void sequence_kernel_c<seq_base>::
 remove (
 unsigned long pos,
 T& item
 )
 {
 // make sure requires clause is not broken
 DLIB_CASSERT(( pos < this->size() ), 
 "\tvoid sequence::remove"
 << "\n\tpos must be >= 0 and < size()" 
 << "\n\tpos: " << pos 
 << "\n\tsize(): " << this->size()
 << "\n\tthis: " << this
 );
 // call the real function
 seq_base::remove(pos,item);
 }
// ----------------------------------------------------------------------------------------
 template <
 typename seq_base
 >
 const typename seq_base::type& sequence_kernel_c<seq_base>::
 operator[] (
 unsigned long pos
 ) const
 {
 // make sure requires clause is not broken
 DLIB_CASSERT(( pos < this->size() ), 
 "\tconst T& sequence::operator[]"
 << "\n\tpos must be >= 0 and < size()" 
 << "\n\tpos: " << pos 
 << "\n\tsize(): " << this->size()
 << "\n\tthis: " << this
 );
 // call the real function
 return seq_base::operator[](pos);
 }
// ----------------------------------------------------------------------------------------
 template <
 typename seq_base
 >
 typename seq_base::type& sequence_kernel_c<seq_base>::
 operator[] (
 unsigned long pos
 )
 {
 // make sure requires clause is not broken
 DLIB_CASSERT(( pos < this->size() ), 
 "\tT& sequence::operator[]"
 << "\n\tpos must be >= 0 and < size()" 
 << "\n\tpos: " << pos 
 << "\n\tsize(): " << this->size()
 << "\n\tthis: " << this
 );
 // call the real function
 return seq_base::operator[](pos);
 }
// ----------------------------------------------------------------------------------------
 template <
 typename seq_base
 >
 const typename seq_base::type& sequence_kernel_c<seq_base>::
 element (
 ) const
 {
 DLIB_CASSERT(this->current_element_valid() == true,
 "\tconst T& sequence::element() const"
 << "\n\tyou can't access the current element if it doesn't exist"
 << "\n\tthis: " << this
 );
 return seq_base::element();
 }
// ----------------------------------------------------------------------------------------
 template <
 typename seq_base
 >
 typename seq_base::type& sequence_kernel_c<seq_base>::
 element (
 ) 
 {
 DLIB_CASSERT(this->current_element_valid() == true,
 "\tT& sequence::element()"
 << "\n\tyou can't access the current element if it doesn't exist"
 << "\n\tthis: " << this
 );
 return seq_base::element();
 }
// ----------------------------------------------------------------------------------------
 template <
 typename seq_base
 >
 void sequence_kernel_c<seq_base>::
 remove_any (
 T& item
 ) 
 {
 // make sure requires clause is not broken
 DLIB_CASSERT( (this->size() > 0),
 "\tvoid sequence::remove_any"
 << "\n\tsize() must be greater than zero if something is going to be removed"
 << "\n\tsize(): " << this->size() 
 << "\n\tthis: " << this
 );
 // call the real function
 seq_base::remove_any(item);
 }
// ----------------------------------------------------------------------------------------
}
#endif // DLIB_SEQUENCE_KERNEl_C_