Lesson 35 - Get Compute Auth Token Working
This commit is contained in:
Norman Lansing
@@ -0,0 +1,504 @@
|
||||
// Copyright (C) 2003 Davis E. King (davis@dlib.net)
|
||||
// License: Boost Software License See LICENSE.txt for the full license.
|
||||
#ifndef DLIB_STACK_KERNEl_1_
|
||||
#define DLIB_STACK_KERNEl_1_
|
||||
|
||||
#include "stack_kernel_abstract.h"
|
||||
#include "../algs.h"
|
||||
#include "../interfaces/enumerable.h"
|
||||
#include "../interfaces/remover.h"
|
||||
#include "../serialize.h"
|
||||
|
||||
namespace dlib
|
||||
{
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename mem_manager = default_memory_manager
|
||||
>
|
||||
class stack_kernel_1 : public enumerable<T>,
|
||||
public remover<T>
|
||||
{
|
||||
|
||||
/*!
|
||||
INITIAL VALUE
|
||||
stack_size == 0
|
||||
top == 0
|
||||
current_element == 0
|
||||
_at_start == true
|
||||
|
||||
|
||||
CONVENTION
|
||||
at_start() == _at_start
|
||||
current_element_valid() == (current_element != 0)
|
||||
if (current_element != 0) then
|
||||
element() == current_element->item
|
||||
|
||||
stack_size == the number of elements in the stack.
|
||||
Each node points to the next node to be poped off the stack.
|
||||
The last node in the list has its next pointer is set to 0.
|
||||
|
||||
if (size == 0)
|
||||
{
|
||||
top == 0
|
||||
}
|
||||
else
|
||||
{
|
||||
top == pointer to the last element added to the stack
|
||||
}
|
||||
!*/
|
||||
|
||||
struct node
|
||||
{
|
||||
node* next;
|
||||
T item;
|
||||
};
|
||||
|
||||
public:
|
||||
|
||||
typedef T type;
|
||||
typedef mem_manager mem_manager_type;
|
||||
|
||||
stack_kernel_1(
|
||||
):
|
||||
top(0),
|
||||
stack_size(0),
|
||||
current_element(0),
|
||||
_at_start(true)
|
||||
{}
|
||||
|
||||
virtual ~stack_kernel_1(
|
||||
);
|
||||
|
||||
inline void clear(
|
||||
);
|
||||
|
||||
inline void push(
|
||||
T& item
|
||||
);
|
||||
|
||||
void pop(
|
||||
T& item
|
||||
);
|
||||
|
||||
T& current(
|
||||
);
|
||||
|
||||
const T& current(
|
||||
) const;
|
||||
|
||||
inline void swap (
|
||||
stack_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;
|
||||
|
||||
bool current_element_valid (
|
||||
) const;
|
||||
|
||||
inline const T& element (
|
||||
) const;
|
||||
|
||||
inline T& element (
|
||||
);
|
||||
|
||||
bool move_next (
|
||||
) const;
|
||||
|
||||
private:
|
||||
|
||||
void delete_elements_in_stack(
|
||||
node*& top
|
||||
);
|
||||
/*!
|
||||
requires
|
||||
- top points to the top of the stack
|
||||
ensures
|
||||
- all memory has been freed
|
||||
- #top = 0
|
||||
!*/
|
||||
|
||||
|
||||
// data members
|
||||
typename mem_manager::template rebind<node>::other pool;
|
||||
node* top;
|
||||
unsigned long stack_size;
|
||||
mutable node* current_element;
|
||||
mutable bool _at_start;
|
||||
|
||||
|
||||
// restricted functions
|
||||
stack_kernel_1(stack_kernel_1&); // copy constructor
|
||||
stack_kernel_1& operator=(stack_kernel_1&); // assignment operator
|
||||
|
||||
};
|
||||
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename mem_manager
|
||||
>
|
||||
inline void swap (
|
||||
stack_kernel_1<T,mem_manager>& a,
|
||||
stack_kernel_1<T,mem_manager>& b
|
||||
) { a.swap(b); }
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename mem_manager
|
||||
>
|
||||
void deserialize (
|
||||
stack_kernel_1<T,mem_manager>& item,
|
||||
std::istream& in
|
||||
)
|
||||
{
|
||||
try
|
||||
{
|
||||
item.clear();
|
||||
unsigned long size;
|
||||
deserialize(size,in);
|
||||
T temp = T();
|
||||
stack_kernel_1<T> temp_stack;
|
||||
for (unsigned long i = 0; i < size; ++i)
|
||||
{
|
||||
deserialize(temp,in);
|
||||
temp_stack.push(temp);
|
||||
}
|
||||
while (temp_stack.size() > 0)
|
||||
{
|
||||
temp_stack.pop(temp);
|
||||
item.push(temp);
|
||||
}
|
||||
}
|
||||
catch (serialization_error& e)
|
||||
{
|
||||
item.clear();
|
||||
throw serialization_error(e.info + "\n while deserializing object of type stack_kernel_1");
|
||||
}
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// member function definitions
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename mem_manager
|
||||
>
|
||||
stack_kernel_1<T,mem_manager>::
|
||||
~stack_kernel_1(
|
||||
)
|
||||
{
|
||||
delete_elements_in_stack(top);
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename mem_manager
|
||||
>
|
||||
void stack_kernel_1<T,mem_manager>::
|
||||
clear(
|
||||
)
|
||||
{
|
||||
if (stack_size != 0)
|
||||
{
|
||||
delete_elements_in_stack(top);
|
||||
stack_size = 0;
|
||||
}
|
||||
reset();
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename mem_manager
|
||||
>
|
||||
T& stack_kernel_1<T,mem_manager>::
|
||||
current(
|
||||
)
|
||||
{
|
||||
return top->item;
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename mem_manager
|
||||
>
|
||||
const T& stack_kernel_1<T,mem_manager>::
|
||||
current(
|
||||
) const
|
||||
{
|
||||
return top->item;
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename mem_manager
|
||||
>
|
||||
void stack_kernel_1<T,mem_manager>::
|
||||
swap(
|
||||
stack_kernel_1<T,mem_manager>& item
|
||||
)
|
||||
{
|
||||
pool.swap(item.pool);
|
||||
|
||||
// declare temp variables
|
||||
node* top_temp;
|
||||
unsigned long stack_size_temp;
|
||||
|
||||
// swap stack_size variables
|
||||
stack_size_temp = item.stack_size;
|
||||
item.stack_size = stack_size;
|
||||
stack_size = stack_size_temp;
|
||||
|
||||
// swap top pointers
|
||||
top_temp = item.top;
|
||||
item.top = top;
|
||||
top = top_temp;
|
||||
|
||||
exchange(current_element,item.current_element);
|
||||
exchange(_at_start,item._at_start);
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename mem_manager
|
||||
>
|
||||
void stack_kernel_1<T,mem_manager>::
|
||||
push(
|
||||
T& item
|
||||
)
|
||||
{
|
||||
// allocate memory for new node
|
||||
node* new_node = pool.allocate();
|
||||
|
||||
// swap item into new_node
|
||||
exchange(new_node->item,item);
|
||||
|
||||
// put new_node into stack
|
||||
new_node->next = top;
|
||||
top = new_node;
|
||||
++stack_size;
|
||||
|
||||
reset();
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename mem_manager
|
||||
>
|
||||
void stack_kernel_1<T,mem_manager>::
|
||||
pop(
|
||||
T& item
|
||||
)
|
||||
{
|
||||
node* old_node = top;
|
||||
top = top->next;
|
||||
|
||||
// swap the item from the stack into item
|
||||
exchange(old_node->item,item);
|
||||
|
||||
// free the memory
|
||||
pool.deallocate(old_node);
|
||||
--stack_size;
|
||||
|
||||
reset();
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// private member function definitions
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename mem_manager
|
||||
>
|
||||
void stack_kernel_1<T,mem_manager>::
|
||||
delete_elements_in_stack(
|
||||
node*& top
|
||||
)
|
||||
{
|
||||
node* temp;
|
||||
while (top != 0)
|
||||
{
|
||||
temp = top->next;
|
||||
pool.deallocate(top);
|
||||
top = temp;
|
||||
}
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// enumerable function definitions
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename mem_manager
|
||||
>
|
||||
size_t stack_kernel_1<T,mem_manager>::
|
||||
size (
|
||||
) const
|
||||
{
|
||||
return stack_size;
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename mem_manager
|
||||
>
|
||||
bool stack_kernel_1<T,mem_manager>::
|
||||
at_start (
|
||||
) const
|
||||
{
|
||||
return _at_start;
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename mem_manager
|
||||
>
|
||||
void stack_kernel_1<T,mem_manager>::
|
||||
reset (
|
||||
) const
|
||||
{
|
||||
_at_start = true;
|
||||
current_element = 0;
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename mem_manager
|
||||
>
|
||||
bool stack_kernel_1<T,mem_manager>::
|
||||
current_element_valid (
|
||||
) const
|
||||
{
|
||||
return current_element != 0;
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename mem_manager
|
||||
>
|
||||
const T& stack_kernel_1<T,mem_manager>::
|
||||
element (
|
||||
) const
|
||||
{
|
||||
return current_element->item;
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename mem_manager
|
||||
>
|
||||
T& stack_kernel_1<T,mem_manager>::
|
||||
element (
|
||||
)
|
||||
{
|
||||
return current_element->item;
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename mem_manager
|
||||
>
|
||||
bool stack_kernel_1<T,mem_manager>::
|
||||
move_next (
|
||||
) const
|
||||
{
|
||||
if (!_at_start)
|
||||
{
|
||||
if (current_element)
|
||||
{
|
||||
current_element = current_element->next;
|
||||
if (current_element)
|
||||
return true;
|
||||
else
|
||||
return false;
|
||||
}
|
||||
else
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
_at_start = false;
|
||||
if (stack_size)
|
||||
{
|
||||
current_element = top;
|
||||
return true;
|
||||
}
|
||||
else
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// remover function definitions
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename mem_manager
|
||||
>
|
||||
void stack_kernel_1<T,mem_manager>::
|
||||
remove_any (
|
||||
T& item
|
||||
)
|
||||
{
|
||||
pop(item);
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
}
|
||||
|
||||
#endif // DLIB_STACK_KERNEl_1_
|
||||
|
||||
@@ -0,0 +1,180 @@
|
||||
// Copyright (C) 2003 Davis E. King (davis@dlib.net)
|
||||
// License: Boost Software License See LICENSE.txt for the full license.
|
||||
#undef DLIB_STACK_KERNEl_ABSTRACT_
|
||||
#ifdef DLIB_STACK_KERNEl_ABSTRACT_
|
||||
|
||||
#include "../interfaces/enumerable.h"
|
||||
#include "../interfaces/remover.h"
|
||||
#include "../serialize.h"
|
||||
#include "../algs.h"
|
||||
|
||||
namespace dlib
|
||||
{
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename mem_manager = default_memory_manager
|
||||
>
|
||||
class stack : public enumerable<T>,
|
||||
public remover<T>
|
||||
{
|
||||
|
||||
/*!
|
||||
REQUIREMENTS ON T
|
||||
T must be swappable by a global swap() and
|
||||
T must have a default constructor
|
||||
|
||||
REQUIREMENTS ON mem_manager
|
||||
must be an implementation of memory_manager/memory_manager_kernel_abstract.h or
|
||||
must be an implementation of memory_manager_global/memory_manager_global_kernel_abstract.h or
|
||||
must be an implementation of memory_manager_stateless/memory_manager_stateless_kernel_abstract.h
|
||||
mem_manager::type can be set to anything.
|
||||
|
||||
POINTERS AND REFERENCES TO INTERNAL DATA
|
||||
swap() and current() functions do not invalidate pointers
|
||||
or references to internal data.
|
||||
All other functions have no such guarantee.
|
||||
|
||||
INITIAL VALUE
|
||||
size() == 0
|
||||
|
||||
ENUMERATION ORDER
|
||||
The enumerator will iterate over the elements in the stack in the
|
||||
same order they would be removed in by repeated calls to pop().
|
||||
(e.g. current() would be the first element enumerated)
|
||||
|
||||
WHAT THIS OBJECT REPRESENTS
|
||||
This is a last in first out stack containing items of type T.
|
||||
|
||||
e.g. if the stack is {b,c,d,e} then a is put in
|
||||
the stack becomes {a,b,c,d,e} and then pop takes a back out
|
||||
returning the stack to {b,c,d,e}
|
||||
|
||||
Also note that unless specified otherwise, no member functions
|
||||
of this object throw exceptions.
|
||||
!*/
|
||||
|
||||
public:
|
||||
|
||||
typedef T type;
|
||||
typedef mem_manager mem_manager_type;
|
||||
|
||||
stack (
|
||||
);
|
||||
/*!
|
||||
ensures
|
||||
- #*this is properly initialized
|
||||
throws
|
||||
- std::bad_alloc or any exception thrown by T's constructor
|
||||
!*/
|
||||
|
||||
virtual ~stack (
|
||||
);
|
||||
/*!
|
||||
ensures
|
||||
- all memory associated with *this has been released
|
||||
!*/
|
||||
|
||||
void clear(
|
||||
);
|
||||
/*!
|
||||
ensures
|
||||
- #*this has its initial value
|
||||
throws
|
||||
- std::bad_alloc or any exception thrown by T's constructor
|
||||
if this exception is thrown then *this is unusable
|
||||
until clear() is called and succeeds
|
||||
!*/
|
||||
|
||||
void push (
|
||||
T& item
|
||||
);
|
||||
/*!
|
||||
ensures
|
||||
- item has been swapped onto the top of the stack
|
||||
- #current() == item
|
||||
- #item has an initial value for its type
|
||||
- #size() == size() + 1
|
||||
- #at_start() == true
|
||||
throws
|
||||
- std::bad_alloc or any exception thrown by T's constructor
|
||||
if push() throws then it has no effect
|
||||
!*/
|
||||
|
||||
void pop (
|
||||
T& item
|
||||
);
|
||||
/*!
|
||||
requires
|
||||
- size() != 0
|
||||
ensures
|
||||
- #size() == size() - 1
|
||||
- #item == current()
|
||||
i.e. the top element of *this has been removed and swapped
|
||||
into #item
|
||||
- #at_start() == true
|
||||
!*/
|
||||
|
||||
T& current (
|
||||
);
|
||||
/*!
|
||||
requires
|
||||
- size() != 0
|
||||
ensures
|
||||
- returns a const reference to the element at the top of *this
|
||||
!*/
|
||||
|
||||
const T& current (
|
||||
) const;
|
||||
/*!
|
||||
requires
|
||||
- size() != 0
|
||||
ensures
|
||||
- returns a non-const reference to the element at the top of *this
|
||||
!*/
|
||||
|
||||
void swap (
|
||||
stack& item
|
||||
);
|
||||
/*!
|
||||
ensures
|
||||
- swaps *this and item
|
||||
!*/
|
||||
|
||||
|
||||
private:
|
||||
|
||||
// restricted functions
|
||||
stack(stack&); // copy constructor
|
||||
stack& operator=(stack&); // assignment operator
|
||||
|
||||
};
|
||||
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename mem_manager
|
||||
>
|
||||
inline void swap (
|
||||
stack<T,mem_manager>& a,
|
||||
stack<T,mem_manager>& b
|
||||
) { a.swap(b); }
|
||||
/*!
|
||||
provides a global swap function
|
||||
!*/
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename mem_manager
|
||||
>
|
||||
void deserialize (
|
||||
stack<T,mem_manager>& item,
|
||||
std::istream& in
|
||||
);
|
||||
/*!
|
||||
provides deserialization support
|
||||
!*/
|
||||
}
|
||||
|
||||
#endif // DLIB_STACK_KERNEl_ABSTRACT_
|
||||
|
||||
@@ -0,0 +1,189 @@
|
||||
// Copyright (C) 2003 Davis E. King (davis@dlib.net)
|
||||
// License: Boost Software License See LICENSE.txt for the full license.
|
||||
#ifndef DLIB_STACK_KERNEl_C_
|
||||
#define DLIB_STACK_KERNEl_C_
|
||||
|
||||
#include "stack_kernel_abstract.h"
|
||||
#include "../algs.h"
|
||||
#include "../assert.h"
|
||||
|
||||
namespace dlib
|
||||
{
|
||||
|
||||
template <
|
||||
typename stack_base
|
||||
>
|
||||
class stack_kernel_c : public stack_base
|
||||
{
|
||||
typedef typename stack_base::type T;
|
||||
public:
|
||||
void pop(
|
||||
T& item
|
||||
);
|
||||
|
||||
T& current(
|
||||
);
|
||||
|
||||
const T& current(
|
||||
) const;
|
||||
|
||||
const T& element(
|
||||
) const;
|
||||
|
||||
T& element(
|
||||
);
|
||||
|
||||
void remove_any (
|
||||
T& item
|
||||
);
|
||||
|
||||
};
|
||||
|
||||
|
||||
template <
|
||||
typename stack_base
|
||||
>
|
||||
inline void swap (
|
||||
stack_kernel_c<stack_base>& a,
|
||||
stack_kernel_c<stack_base>& b
|
||||
) { a.swap(b); }
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// member function definitions
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <
|
||||
typename stack_base
|
||||
>
|
||||
void stack_kernel_c<stack_base>::
|
||||
pop(
|
||||
T& item
|
||||
)
|
||||
{
|
||||
|
||||
// make sure requires clause is not broken
|
||||
DLIB_CASSERT(this->size() != 0,
|
||||
"\tvoid stack::pop"
|
||||
<< "\n\tsize of stack should not be zero"
|
||||
<< "\n\tthis: " << this
|
||||
);
|
||||
|
||||
// call the real function
|
||||
stack_base::pop(item);
|
||||
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <
|
||||
typename stack_base
|
||||
>
|
||||
const typename stack_base::type& stack_kernel_c<stack_base>::
|
||||
current(
|
||||
) const
|
||||
{
|
||||
// make sure requires clause is not broken
|
||||
DLIB_CASSERT(this->size() != 0,
|
||||
"\tconst T& stack::current"
|
||||
<< "\n\tsize of stack should not be zero"
|
||||
<< "\n\tthis: " << this
|
||||
);
|
||||
|
||||
// call the real function
|
||||
return stack_base::current();
|
||||
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <
|
||||
typename stack_base
|
||||
>
|
||||
typename stack_base::type& stack_kernel_c<stack_base>::
|
||||
current(
|
||||
)
|
||||
{
|
||||
// make sure requires clause is not broken
|
||||
DLIB_CASSERT(this->size() != 0,
|
||||
"\tT& stack::current"
|
||||
<< "\n\tsize of stack should not be zero"
|
||||
<< "\n\tthis: " << this
|
||||
);
|
||||
|
||||
// call the real function
|
||||
return stack_base::current();
|
||||
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <
|
||||
typename stack_base
|
||||
>
|
||||
typename stack_base::type& stack_kernel_c<stack_base>::
|
||||
element(
|
||||
)
|
||||
{
|
||||
// make sure requires clause is not broken
|
||||
DLIB_CASSERT(this->current_element_valid(),
|
||||
"\tT& stack::element"
|
||||
<< "\n\tThe current element must be valid if you are to access it."
|
||||
<< "\n\tthis: " << this
|
||||
);
|
||||
|
||||
// call the real function
|
||||
return stack_base::element();
|
||||
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <
|
||||
typename stack_base
|
||||
>
|
||||
const typename stack_base::type& stack_kernel_c<stack_base>::
|
||||
element(
|
||||
) const
|
||||
{
|
||||
// make sure requires clause is not broken
|
||||
DLIB_CASSERT(this->current_element_valid(),
|
||||
"\tconst T& stack::element"
|
||||
<< "\n\tThe current element must be valid if you are to access it."
|
||||
<< "\n\tthis: " << this
|
||||
);
|
||||
|
||||
// call the real function
|
||||
return stack_base::element();
|
||||
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <
|
||||
typename stack_base
|
||||
>
|
||||
void stack_kernel_c<stack_base>::
|
||||
remove_any (
|
||||
T& item
|
||||
)
|
||||
{
|
||||
// make sure requires clause is not broken
|
||||
DLIB_CASSERT( (this->size() > 0),
|
||||
"\tvoid stack::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
|
||||
stack_base::remove_any(item);
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
}
|
||||
|
||||
#endif // DLIB_STACK_KERNEl_C_
|
||||
|
||||
Reference in New Issue
Block a user