mirror of
https://gitcode.com/gh_mirrors/ope/OpenFace.git
synced 2026-08-07 10:47:46 +00:00
Master commit of OpenFace.
This commit is contained in:
unknown
102
lib/3rdParty/dlib/include/dlib/sequence/sequence_compare_1.h
vendored
Normal file
102
lib/3rdParty/dlib/include/dlib/sequence/sequence_compare_1.h
vendored
Normal file
@@ -0,0 +1,102 @@
|
||||
// Copyright (C) 2003 Davis E. King (davis@dlib.net)
|
||||
// License: Boost Software License See LICENSE.txt for the full license.
|
||||
#ifndef DLIB_SEQUENCE_COMPARe_1_
|
||||
#define DLIB_SEQUENCE_COMPARe_1_
|
||||
|
||||
#include "sequence_compare_abstract.h"
|
||||
|
||||
#include "../algs.h"
|
||||
|
||||
|
||||
namespace dlib
|
||||
{
|
||||
|
||||
template <
|
||||
typename seq_base
|
||||
>
|
||||
class sequence_compare_1 : public seq_base
|
||||
{
|
||||
typedef typename seq_base::type T;
|
||||
|
||||
public:
|
||||
|
||||
bool operator< (
|
||||
const sequence_compare_1& rhs
|
||||
) const;
|
||||
|
||||
bool operator== (
|
||||
const sequence_compare_1& rhs
|
||||
) const;
|
||||
|
||||
};
|
||||
|
||||
|
||||
template <
|
||||
typename seq_base
|
||||
>
|
||||
inline void swap (
|
||||
sequence_compare_1<seq_base>& a,
|
||||
sequence_compare_1<seq_base>& b
|
||||
) { a.swap(b); }
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// member function definitions
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <
|
||||
typename seq_base
|
||||
>
|
||||
bool sequence_compare_1<seq_base>::
|
||||
operator< (
|
||||
const sequence_compare_1<seq_base>& rhs
|
||||
) const
|
||||
{
|
||||
unsigned int length;
|
||||
if (this->size() < rhs.size())
|
||||
length = this->size();
|
||||
else
|
||||
length = rhs.size();
|
||||
|
||||
for (unsigned long i = 0; i < length; ++i)
|
||||
{
|
||||
if ((*this)[i] < rhs[i])
|
||||
return true;
|
||||
else if ( !((*this)[i] == rhs[i]) )
|
||||
return false;
|
||||
}
|
||||
// they are equal so far
|
||||
if (this->size() < rhs.size())
|
||||
return true;
|
||||
else
|
||||
return false;
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <
|
||||
typename seq_base
|
||||
>
|
||||
bool sequence_compare_1<seq_base>::
|
||||
operator== (
|
||||
const sequence_compare_1<seq_base>& rhs
|
||||
) const
|
||||
{
|
||||
if (this->size() != rhs.size())
|
||||
return false;
|
||||
|
||||
for (unsigned long i = 0; i < this->size(); ++i)
|
||||
{
|
||||
if (!((*this)[i] == rhs[i]))
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
}
|
||||
|
||||
#endif // DLIB_SEQUENCE_COMPARe_1_
|
||||
|
||||
75
lib/3rdParty/dlib/include/dlib/sequence/sequence_compare_abstract.h
vendored
Normal file
75
lib/3rdParty/dlib/include/dlib/sequence/sequence_compare_abstract.h
vendored
Normal file
@@ -0,0 +1,75 @@
|
||||
// Copyright (C) 2003 Davis E. King (davis@dlib.net)
|
||||
// License: Boost Software License See LICENSE.txt for the full license.
|
||||
#undef DLIB_SEQUENCE_COMPARe_ABSTRACT_
|
||||
#ifdef DLIB_SEQUENCE_COMPARe_ABSTRACT_
|
||||
|
||||
#include "sequence_kernel_abstract.h"
|
||||
|
||||
#include "../algs.h"
|
||||
|
||||
|
||||
namespace dlib
|
||||
{
|
||||
|
||||
template <
|
||||
typename seq_base
|
||||
>
|
||||
class sequence_compare : public seq_base
|
||||
{
|
||||
|
||||
/*!
|
||||
REQUIREMENTS ON T
|
||||
T must implement operator< for its type and
|
||||
T must implement operator== for its type
|
||||
|
||||
REQUIREMENTS ON SEQUENCE_BASE
|
||||
must be an implementation of sequence/sequence_kernel_abstract.h
|
||||
|
||||
|
||||
POINTERS AND REFERENCES TO INTERNAL DATA
|
||||
operator== and operator< do not invalidate pointers or references to
|
||||
data members
|
||||
|
||||
WHAT THIS EXTENSION DOES FOR sequence
|
||||
This gives a sequence the ability to compare itself to other
|
||||
sequences using the < and == operators.
|
||||
!*/
|
||||
|
||||
public:
|
||||
|
||||
bool operator< (
|
||||
const sequence_compare& rhs
|
||||
) const;
|
||||
/*!
|
||||
ensures
|
||||
- returns true if there exists an integer j such that 0 <= j < size()
|
||||
and for all integers i such that 0 <= i < j where it is true that
|
||||
(*this)[i] <= rhs[i] and (*this)[j] < rhs[j]
|
||||
- returns false if there is no j that will satisfy the above conditions
|
||||
!*/
|
||||
|
||||
bool operator== (
|
||||
const sequence_compare& rhs
|
||||
) const;
|
||||
/*!
|
||||
ensures
|
||||
- returns true if for all i: (*this)[i] == rhs[i] else returns false
|
||||
!*/
|
||||
|
||||
};
|
||||
|
||||
template <
|
||||
typename seq_base
|
||||
>
|
||||
inline void swap (
|
||||
sequence_compare<seq_base>& a,
|
||||
sequence_compare<seq_base>& b
|
||||
) { a.swap(b); }
|
||||
/*!
|
||||
provides a global swap function
|
||||
!*/
|
||||
|
||||
}
|
||||
|
||||
#endif // DLIB_SEQUENCE_COMPARe_ABSTRACT_
|
||||
|
||||
1340
lib/3rdParty/dlib/include/dlib/sequence/sequence_kernel_1.h
vendored
Normal file
1340
lib/3rdParty/dlib/include/dlib/sequence/sequence_kernel_1.h
vendored
Normal file
File diff suppressed because it is too large
Load Diff
682
lib/3rdParty/dlib/include/dlib/sequence/sequence_kernel_2.h
vendored
Normal file
682
lib/3rdParty/dlib/include/dlib/sequence/sequence_kernel_2.h
vendored
Normal file
@@ -0,0 +1,682 @@
|
||||
// Copyright (C) 2003 Davis E. King (davis@dlib.net)
|
||||
// License: Boost Software License See LICENSE.txt for the full license.
|
||||
#ifndef DLIB_SEQUENCE_KERNEl_2_
|
||||
#define DLIB_SEQUENCE_KERNEl_2_
|
||||
|
||||
#include "sequence_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 sequence_kernel_2 : public enumerable<T>,
|
||||
public remover<T>
|
||||
{
|
||||
/*!
|
||||
INITIAL VALUE
|
||||
sequence_size == 0
|
||||
at_start_ == true
|
||||
current_enumeration_node == 0
|
||||
|
||||
CONVENTION
|
||||
sequence_size == the number of elements in the sequence
|
||||
|
||||
at_start_ == at_start()
|
||||
(current_enumeration_node!=0) == current_element_valid()
|
||||
if (current_enumeration_node!=0) then
|
||||
current_enumeration_node->item == element()
|
||||
current_enumeration_pos == the position of the node pointed to by
|
||||
current_enumeration_node
|
||||
|
||||
if ( sequence_size > 0 )
|
||||
{
|
||||
current_node == pointer to a node in the linked list and
|
||||
current_node->right->right->... eventually == current_node and
|
||||
current_node->left->left->... eventually == current_node and
|
||||
current_pos == the position in the sequence of
|
||||
current_node->item
|
||||
}
|
||||
|
||||
!*/
|
||||
|
||||
struct node {
|
||||
T item;
|
||||
node* right;
|
||||
node* left;
|
||||
};
|
||||
|
||||
public:
|
||||
|
||||
typedef T type;
|
||||
typedef mem_manager mem_manager_type;
|
||||
|
||||
sequence_kernel_2 (
|
||||
) :
|
||||
sequence_size(0),
|
||||
at_start_(true),
|
||||
current_enumeration_node(0)
|
||||
{}
|
||||
|
||||
virtual ~sequence_kernel_2 (
|
||||
);
|
||||
|
||||
inline void clear (
|
||||
);
|
||||
|
||||
void add (
|
||||
unsigned long pos,
|
||||
T& item
|
||||
);
|
||||
|
||||
void remove (
|
||||
unsigned long pos,
|
||||
T& item
|
||||
);
|
||||
|
||||
void cat (
|
||||
sequence_kernel_2& item
|
||||
);
|
||||
|
||||
const T& operator[] (
|
||||
unsigned long pos
|
||||
) const;
|
||||
|
||||
T& operator[] (
|
||||
unsigned long pos
|
||||
);
|
||||
|
||||
void swap (
|
||||
sequence_kernel_2& item
|
||||
);
|
||||
|
||||
// functions from the remover interface
|
||||
inline void remove_any (
|
||||
T& item
|
||||
);
|
||||
|
||||
// functions from the enumerable interface
|
||||
inline unsigned long size (
|
||||
) const;
|
||||
|
||||
bool at_start (
|
||||
) const;
|
||||
|
||||
inline void reset (
|
||||
) const;
|
||||
|
||||
bool current_element_valid (
|
||||
) const;
|
||||
|
||||
const T& element (
|
||||
) const;
|
||||
|
||||
T& element (
|
||||
);
|
||||
|
||||
bool move_next (
|
||||
) const;
|
||||
|
||||
private:
|
||||
|
||||
void delete_nodes (
|
||||
node* current_node,
|
||||
unsigned long sequence_size
|
||||
);
|
||||
/*!
|
||||
requires
|
||||
CONVENTION IS CORRECT
|
||||
ensures
|
||||
all memory associated with the ring of nodes has been freed
|
||||
!*/
|
||||
|
||||
void move_to_pos (
|
||||
node*& current_node,
|
||||
unsigned long& current_pos,
|
||||
unsigned long pos,
|
||||
unsigned long size
|
||||
) const;
|
||||
/*!
|
||||
requires
|
||||
everything in the CONVENTION is correct and
|
||||
there is a node corresponding to pos in the CONVENTION and
|
||||
0 <= pos < size
|
||||
ensures
|
||||
current_pos == pos and
|
||||
current_node->item is the item in the sequence associated with
|
||||
position pos
|
||||
!*/
|
||||
|
||||
// data members
|
||||
unsigned long sequence_size;
|
||||
mutable node* current_node;
|
||||
mutable unsigned long current_pos;
|
||||
mutable bool at_start_;
|
||||
mutable node* current_enumeration_node;
|
||||
mutable unsigned long current_enumeration_pos;
|
||||
|
||||
// restricted functions
|
||||
sequence_kernel_2(sequence_kernel_2&); // copy constructor
|
||||
sequence_kernel_2& operator=(sequence_kernel_2&); // assignment operator
|
||||
|
||||
};
|
||||
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename mem_manager
|
||||
>
|
||||
inline void swap (
|
||||
sequence_kernel_2<T,mem_manager>& a,
|
||||
sequence_kernel_2<T,mem_manager>& b
|
||||
) { a.swap(b); }
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename mem_manager
|
||||
>
|
||||
void deserialize (
|
||||
sequence_kernel_2<T,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(i,temp);
|
||||
}
|
||||
}
|
||||
catch (serialization_error e)
|
||||
{
|
||||
item.clear();
|
||||
throw serialization_error(e.info + "\n while deserializing object of type sequence_kernel_2");
|
||||
}
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// member function definitions
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename mem_manager
|
||||
>
|
||||
sequence_kernel_2<T,mem_manager>::
|
||||
~sequence_kernel_2 (
|
||||
)
|
||||
{
|
||||
delete_nodes(current_node,sequence_size);
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename mem_manager
|
||||
>
|
||||
void sequence_kernel_2<T,mem_manager>::
|
||||
clear (
|
||||
)
|
||||
{
|
||||
if (sequence_size != 0)
|
||||
{
|
||||
delete_nodes(current_node,sequence_size);
|
||||
sequence_size = 0;
|
||||
}
|
||||
// reset the enumerator
|
||||
reset();
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename mem_manager
|
||||
>
|
||||
void sequence_kernel_2<T,mem_manager>::
|
||||
add (
|
||||
unsigned long pos,
|
||||
T& item
|
||||
)
|
||||
{
|
||||
// make new node and swap item into it
|
||||
node* new_node = new node;
|
||||
exchange(item,new_node->item);
|
||||
|
||||
if (sequence_size > 0)
|
||||
{
|
||||
if (pos == sequence_size)
|
||||
{
|
||||
move_to_pos(current_node,current_pos,pos-1,sequence_size);
|
||||
|
||||
node& n_node = *new_node;
|
||||
node& c_node = *current_node;
|
||||
|
||||
// make new node point to the nodes to its left and right
|
||||
n_node.right = c_node.right;
|
||||
n_node.left = current_node;
|
||||
|
||||
// make the left node point back to new_node
|
||||
c_node.right->left = new_node;
|
||||
|
||||
// make the right node point back to new_node
|
||||
c_node.right = new_node;
|
||||
current_pos = pos;
|
||||
|
||||
}
|
||||
else
|
||||
{
|
||||
move_to_pos(current_node,current_pos,pos,sequence_size);
|
||||
|
||||
node& n_node = *new_node;
|
||||
node& c_node = *current_node;
|
||||
|
||||
// make new node point to the nodes to its left and right
|
||||
n_node.right = current_node;
|
||||
n_node.left = c_node.left;
|
||||
|
||||
// make the left node point back to new_node
|
||||
c_node.left->right = new_node;
|
||||
|
||||
// make the right node point back to new_node
|
||||
c_node.left = new_node;
|
||||
}
|
||||
|
||||
}
|
||||
else
|
||||
{
|
||||
current_pos = 0;
|
||||
new_node->left = new_node;
|
||||
new_node->right = new_node;
|
||||
}
|
||||
|
||||
// make the new node the current node
|
||||
current_node = new_node;
|
||||
|
||||
++sequence_size;
|
||||
// reset the enumerator
|
||||
reset();
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename mem_manager
|
||||
>
|
||||
void sequence_kernel_2<T,mem_manager>::
|
||||
remove (
|
||||
unsigned long pos,
|
||||
T& item
|
||||
)
|
||||
{
|
||||
move_to_pos(current_node,current_pos,pos,sequence_size);
|
||||
node& c_node = *current_node;
|
||||
exchange(c_node.item,item);
|
||||
|
||||
node* temp = current_node;
|
||||
|
||||
// close up gap left by remove
|
||||
c_node.left->right = c_node.right;
|
||||
c_node.right->left = c_node.left;
|
||||
|
||||
current_node = c_node.right;
|
||||
|
||||
--sequence_size;
|
||||
|
||||
delete temp;
|
||||
// reset the enumerator
|
||||
reset();
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename mem_manager
|
||||
>
|
||||
const T& sequence_kernel_2<T,mem_manager>::
|
||||
operator[] (
|
||||
unsigned long pos
|
||||
) const
|
||||
{
|
||||
move_to_pos(current_node,current_pos,pos,sequence_size);
|
||||
return current_node->item;
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename mem_manager
|
||||
>
|
||||
void sequence_kernel_2<T,mem_manager>::
|
||||
cat (
|
||||
sequence_kernel_2<T,mem_manager>& item
|
||||
)
|
||||
{
|
||||
if (item.sequence_size > 0)
|
||||
{
|
||||
if (sequence_size > 0)
|
||||
{
|
||||
// move both sequences to a convenient location
|
||||
move_to_pos(current_node,current_pos,0,sequence_size);
|
||||
item.move_to_pos (
|
||||
item.current_node,
|
||||
item.current_pos,
|
||||
item.sequence_size-1,
|
||||
item.sequence_size
|
||||
);
|
||||
|
||||
// make copies of poitners
|
||||
node& item_right = *item.current_node->right;
|
||||
node& left = *current_node->left;
|
||||
|
||||
|
||||
item.current_node->right = current_node;
|
||||
current_node->left = item.current_node;
|
||||
|
||||
left.right = &item_right;
|
||||
item_right.left = &left;
|
||||
|
||||
// set sizes
|
||||
sequence_size += item.sequence_size;
|
||||
item.sequence_size = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
// *this is empty so just swap
|
||||
item.swap(*this);
|
||||
}
|
||||
}
|
||||
item.clear();
|
||||
// reset the enumerator
|
||||
reset();
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename mem_manager
|
||||
>
|
||||
T& sequence_kernel_2<T,mem_manager>::
|
||||
operator[] (
|
||||
unsigned long pos
|
||||
)
|
||||
{
|
||||
move_to_pos(current_node,current_pos,pos,sequence_size);
|
||||
return current_node->item;
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename mem_manager
|
||||
>
|
||||
unsigned long sequence_kernel_2<T,mem_manager>::
|
||||
size (
|
||||
) const
|
||||
{
|
||||
return sequence_size;
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename mem_manager
|
||||
>
|
||||
void sequence_kernel_2<T,mem_manager>::
|
||||
swap (
|
||||
sequence_kernel_2<T,mem_manager>& item
|
||||
)
|
||||
{
|
||||
unsigned long sequence_size_temp = item.sequence_size;
|
||||
node* current_node_temp = item.current_node;
|
||||
unsigned long current_pos_temp = item.current_pos;
|
||||
bool at_start_temp = item.at_start_;
|
||||
node* current_enumeration_node_temp = item.current_enumeration_node;
|
||||
unsigned long current_enumeration_pos_temp = item.current_enumeration_pos;
|
||||
|
||||
item.sequence_size = sequence_size;
|
||||
item.current_node = current_node;
|
||||
item.current_pos = current_pos;
|
||||
item.at_start_ = at_start_;
|
||||
item.current_enumeration_node = current_enumeration_node;
|
||||
item.current_enumeration_pos = current_enumeration_pos;
|
||||
|
||||
sequence_size = sequence_size_temp;
|
||||
current_node = current_node_temp;
|
||||
current_pos = current_pos_temp;
|
||||
at_start_ = at_start_temp;
|
||||
current_enumeration_node = current_enumeration_node_temp;
|
||||
current_enumeration_pos = current_enumeration_pos_temp;
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// enumerable function definitions
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename mem_manager
|
||||
>
|
||||
bool sequence_kernel_2<T,mem_manager>::
|
||||
at_start (
|
||||
) const
|
||||
{
|
||||
return at_start_;
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename mem_manager
|
||||
>
|
||||
void sequence_kernel_2<T,mem_manager>::
|
||||
reset (
|
||||
) const
|
||||
{
|
||||
at_start_ = true;
|
||||
current_enumeration_node = 0;
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename mem_manager
|
||||
>
|
||||
bool sequence_kernel_2<T,mem_manager>::
|
||||
current_element_valid (
|
||||
) const
|
||||
{
|
||||
return (current_enumeration_node!=0);
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename mem_manager
|
||||
>
|
||||
const T& sequence_kernel_2<T,mem_manager>::
|
||||
element (
|
||||
) const
|
||||
{
|
||||
return current_enumeration_node->item;
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename mem_manager
|
||||
>
|
||||
T& sequence_kernel_2<T,mem_manager>::
|
||||
element (
|
||||
)
|
||||
{
|
||||
return current_enumeration_node->item;
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename mem_manager
|
||||
>
|
||||
bool sequence_kernel_2<T,mem_manager>::
|
||||
move_next (
|
||||
) const
|
||||
{
|
||||
if (at_start_ && sequence_size>0)
|
||||
{
|
||||
move_to_pos(current_node,current_pos,0,sequence_size);
|
||||
current_enumeration_node = current_node;
|
||||
current_enumeration_pos = 0;
|
||||
}
|
||||
else if (current_enumeration_node!=0)
|
||||
{
|
||||
++current_enumeration_pos;
|
||||
if (current_enumeration_pos<sequence_size)
|
||||
{
|
||||
current_enumeration_node = current_enumeration_node->right;
|
||||
}
|
||||
else
|
||||
{
|
||||
// we have reached the end of the sequence
|
||||
current_enumeration_node = 0;
|
||||
}
|
||||
}
|
||||
|
||||
at_start_ = false;
|
||||
return (current_enumeration_node!=0);
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// remover function definitions
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename mem_manager
|
||||
>
|
||||
void sequence_kernel_2<T,mem_manager>::
|
||||
remove_any (
|
||||
T& item
|
||||
)
|
||||
{
|
||||
remove(0,item);
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// private member function definitions
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename mem_manager
|
||||
>
|
||||
void sequence_kernel_2<T,mem_manager>::
|
||||
delete_nodes (
|
||||
node* current_node,
|
||||
unsigned long sequence_size
|
||||
)
|
||||
{
|
||||
node* temp;
|
||||
while (sequence_size)
|
||||
{
|
||||
temp = current_node->right;
|
||||
delete current_node;
|
||||
current_node = temp;
|
||||
--sequence_size;
|
||||
}
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename mem_manager
|
||||
>
|
||||
void sequence_kernel_2<T,mem_manager>::
|
||||
move_to_pos (
|
||||
node*& current_node,
|
||||
unsigned long& current_pos,
|
||||
unsigned long pos,
|
||||
unsigned long size
|
||||
) const
|
||||
{
|
||||
if ( current_pos > pos)
|
||||
{
|
||||
// number of hops in each direction needed to reach pos
|
||||
unsigned long right = size + pos - current_pos;
|
||||
unsigned long left = current_pos - pos;
|
||||
current_pos = pos;
|
||||
|
||||
if (left < right)
|
||||
{
|
||||
// move left to position pos
|
||||
for (; left > 0; --left)
|
||||
current_node = current_node->left;
|
||||
}
|
||||
else
|
||||
{
|
||||
// move left to position pos
|
||||
for (; right > 0; --right)
|
||||
current_node = current_node->right;
|
||||
}
|
||||
}
|
||||
else if (current_pos != pos)
|
||||
{
|
||||
// number of hops in each direction needed to reach pos
|
||||
unsigned long right = pos - current_pos;
|
||||
unsigned long left = size - pos + current_pos;
|
||||
current_pos = pos;
|
||||
|
||||
if (left < right)
|
||||
{
|
||||
// move left to position pos
|
||||
for (; left > 0; --left)
|
||||
current_node = current_node->left;
|
||||
}
|
||||
else
|
||||
{
|
||||
// move left to position pos
|
||||
for (; right > 0; --right)
|
||||
current_node = current_node->right;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
}
|
||||
|
||||
#endif // DLIB_SEQUENCE_KERNEl_2_
|
||||
|
||||
199
lib/3rdParty/dlib/include/dlib/sequence/sequence_kernel_abstract.h
vendored
Normal file
199
lib/3rdParty/dlib/include/dlib/sequence/sequence_kernel_abstract.h
vendored
Normal file
@@ -0,0 +1,199 @@
|
||||
// Copyright (C) 2003 Davis E. King (davis@dlib.net)
|
||||
// License: Boost Software License See LICENSE.txt for the full license.
|
||||
#undef DLIB_SEQUENCE_KERNEl_ABSTRACT_
|
||||
#ifdef DLIB_SEQUENCE_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 sequence : 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 operator[] functions do not invalidate pointers or
|
||||
references to internal data.
|
||||
All other functions have no such guarantees.
|
||||
|
||||
ENUMERATION ORDER
|
||||
The enumerator will iterate over the elements in the sequence from
|
||||
the 0th element to the (size()-1)th element.
|
||||
|
||||
INITIAL VALUE
|
||||
size() == 0
|
||||
|
||||
WHAT THIS OBJECT REPRESENTS
|
||||
sequence contains items of type T
|
||||
|
||||
This object represents an ordered sequence of items, each item is
|
||||
associated with an integer value.
|
||||
The items are numbered from 0 to size()-1
|
||||
|
||||
Also note that unless specified otherwise, no member functions
|
||||
of this object throw exceptions.
|
||||
!*/
|
||||
|
||||
public:
|
||||
|
||||
typedef T type;
|
||||
typedef mem_manager mem_manager_type;
|
||||
|
||||
sequence (
|
||||
);
|
||||
/*!
|
||||
ensures
|
||||
- #*this is properly initialized
|
||||
throws
|
||||
- std::bad_alloc or any exception thrown by T's constructor
|
||||
!*/
|
||||
|
||||
virtual ~sequence (
|
||||
);
|
||||
/*!
|
||||
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 add (
|
||||
unsigned long pos,
|
||||
T& item
|
||||
);
|
||||
/*!
|
||||
requires
|
||||
- pos <= size()
|
||||
ensures
|
||||
- #size() == size() + 1
|
||||
- #item has an initial value for its type
|
||||
- #operator[](pos) == item
|
||||
i.e. item has been inserted into *this between the elements which
|
||||
were previously at position pos-1 and pos
|
||||
- #at_start() == true
|
||||
throws
|
||||
- std::bad_alloc or any exception thrown by T's constructor
|
||||
if add() throws then it has no effect
|
||||
!*/
|
||||
|
||||
void remove (
|
||||
unsigned long pos,
|
||||
T& item
|
||||
);
|
||||
/*!
|
||||
requires
|
||||
- pos < size()
|
||||
ensures
|
||||
- #size() == size() - 1
|
||||
- the element at the position pos in *this has been removed and
|
||||
swapped into #item
|
||||
- #at_start() == true
|
||||
!*/
|
||||
|
||||
void cat (
|
||||
sequence& item
|
||||
);
|
||||
/*!
|
||||
requires
|
||||
- &item != this (i.e. you can't concatenate a sequence onto itself)
|
||||
ensures
|
||||
- item has been concatenated onto the end of *this
|
||||
i.e. item[0] becomes (#*this)[size()], item[1]
|
||||
becomes (#*this)[size()+1], etc.
|
||||
- #size() == size() + item.size()
|
||||
- #item has its initial value
|
||||
- #at_start() == true
|
||||
!*/
|
||||
|
||||
const T& operator[] (
|
||||
unsigned long pos
|
||||
) const;
|
||||
/*!
|
||||
requires
|
||||
- pos < size()
|
||||
ensures
|
||||
- returns a const reference to the element at position pos
|
||||
!*/
|
||||
|
||||
T& operator[] (
|
||||
unsigned long pos
|
||||
);
|
||||
/*!
|
||||
requires
|
||||
- pos < size()
|
||||
ensures
|
||||
- returns a non-const reference to the element at position pos
|
||||
!*/
|
||||
|
||||
void swap (
|
||||
sequence& item
|
||||
);
|
||||
/*!
|
||||
ensures
|
||||
- swaps *this and item
|
||||
!*/
|
||||
|
||||
|
||||
private:
|
||||
|
||||
// restricted functions
|
||||
sequence(sequence&); // copy constructor
|
||||
sequence& operator=(sequence&); // assignment operator
|
||||
|
||||
};
|
||||
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename mem_manager
|
||||
>
|
||||
inline void swap (
|
||||
sequence<T,mem_manager>& a,
|
||||
sequence<T,mem_manager>& b
|
||||
) { a.swap(b); }
|
||||
/*!
|
||||
provides a global swap function
|
||||
!*/
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename mem_manager
|
||||
>
|
||||
void deserialize (
|
||||
sequence<T,mem_manager>& item,
|
||||
std::istream& in
|
||||
);
|
||||
/*!
|
||||
provides deserialization support
|
||||
!*/
|
||||
}
|
||||
|
||||
#endif // DLIB_SEQUENCE_KERNEl_ABSTRACT_
|
||||
|
||||
253
lib/3rdParty/dlib/include/dlib/sequence/sequence_kernel_c.h
vendored
Normal file
253
lib/3rdParty/dlib/include/dlib/sequence/sequence_kernel_c.h
vendored
Normal file
@@ -0,0 +1,253 @@
|
||||
// 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_
|
||||
|
||||
182
lib/3rdParty/dlib/include/dlib/sequence/sequence_sort_1.h
vendored
Normal file
182
lib/3rdParty/dlib/include/dlib/sequence/sequence_sort_1.h
vendored
Normal file
@@ -0,0 +1,182 @@
|
||||
// Copyright (C) 2003 Davis E. King (davis@dlib.net)
|
||||
// License: Boost Software License See LICENSE.txt for the full license.
|
||||
#ifndef DLIB_SEQUENCE_SORt_1_
|
||||
#define DLIB_SEQUENCE_SORt_1_
|
||||
|
||||
#include "sequence_sort_abstract.h"
|
||||
#include "../algs.h"
|
||||
|
||||
namespace dlib
|
||||
{
|
||||
|
||||
template <
|
||||
typename seq_base
|
||||
>
|
||||
class sequence_sort_1 : public seq_base
|
||||
{
|
||||
typedef typename seq_base::type T;
|
||||
|
||||
public:
|
||||
|
||||
/*!
|
||||
this is a median of three version of the QuickSort algorithm and
|
||||
it sorts sequences of less than 30 elements with a selection sort
|
||||
!*/
|
||||
|
||||
void sort (
|
||||
);
|
||||
|
||||
private:
|
||||
|
||||
void sort_this_sequence (
|
||||
seq_base& sequence
|
||||
);
|
||||
/*!
|
||||
ensures
|
||||
- each element in the sequence is < the element behind it
|
||||
!*/
|
||||
|
||||
void selection_sort (
|
||||
seq_base& sequence
|
||||
);
|
||||
/*!
|
||||
ensures
|
||||
- sequence is sorted with a selection_sort
|
||||
!*/
|
||||
|
||||
|
||||
};
|
||||
|
||||
|
||||
template <
|
||||
typename seq_base
|
||||
>
|
||||
inline void swap (
|
||||
sequence_sort_1<seq_base>& a,
|
||||
sequence_sort_1<seq_base>& b
|
||||
) { a.swap(b); }
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// member function definitions
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <
|
||||
typename seq_base
|
||||
>
|
||||
void sequence_sort_1<seq_base>::
|
||||
sort (
|
||||
)
|
||||
{
|
||||
if (this->size() > 1)
|
||||
{
|
||||
sort_this_sequence(*this);
|
||||
}
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// private member function definitions
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <
|
||||
typename seq_base
|
||||
>
|
||||
void sequence_sort_1<seq_base>::
|
||||
sort_this_sequence (
|
||||
seq_base& sequence
|
||||
)
|
||||
{
|
||||
if (sequence.size() < 30)
|
||||
{
|
||||
selection_sort(sequence);
|
||||
}
|
||||
else
|
||||
{
|
||||
seq_base left, right;
|
||||
T partition_element;
|
||||
|
||||
sequence.remove(0,partition_element);
|
||||
|
||||
dlib::median (
|
||||
partition_element,
|
||||
sequence[sequence.size()-1],
|
||||
sequence[(sequence.size()-1)/2]
|
||||
);
|
||||
|
||||
// partition sequence into left and right
|
||||
T temp;
|
||||
while (sequence.size() > 0)
|
||||
{
|
||||
sequence.remove(0,temp);
|
||||
if (temp < partition_element)
|
||||
{
|
||||
left.add(0,temp);
|
||||
}
|
||||
else
|
||||
{
|
||||
right.add(0,temp);
|
||||
}
|
||||
}
|
||||
|
||||
sort_this_sequence(left);
|
||||
sort_this_sequence(right);
|
||||
|
||||
// combine left and right into sequence
|
||||
left.swap(sequence);
|
||||
sequence.add(sequence.size(),partition_element);
|
||||
sequence.cat(right);
|
||||
}
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <
|
||||
typename seq_base
|
||||
>
|
||||
void sequence_sort_1<seq_base>::
|
||||
selection_sort (
|
||||
seq_base& sequence
|
||||
)
|
||||
{
|
||||
if (sequence.size() > 2)
|
||||
{
|
||||
T temp[29];
|
||||
unsigned long ssize = sequence.size();
|
||||
|
||||
for (unsigned long i = 0; i < ssize; ++i)
|
||||
sequence.remove(0,temp[i]);
|
||||
|
||||
unsigned long smallest;
|
||||
for (unsigned long i = 0; i < ssize - 1; ++i)
|
||||
{
|
||||
// find smallest element and swap into i
|
||||
smallest = i;
|
||||
for (unsigned long j = i+1; j < ssize; ++j)
|
||||
{
|
||||
if (temp[j] < temp[smallest])
|
||||
smallest = j;
|
||||
}
|
||||
exchange(temp[smallest],temp[i]);
|
||||
}
|
||||
|
||||
for (unsigned long i = 0; i < ssize; ++i)
|
||||
sequence.add(i,temp[i]);
|
||||
}
|
||||
else if (sequence.size() == 2)
|
||||
{
|
||||
if (sequence[1] < sequence[0])
|
||||
{
|
||||
exchange(sequence[0],sequence[1]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
}
|
||||
|
||||
#endif // DLIB_SEQUENCE_SORt_1_
|
||||
|
||||
65
lib/3rdParty/dlib/include/dlib/sequence/sequence_sort_2.h
vendored
Normal file
65
lib/3rdParty/dlib/include/dlib/sequence/sequence_sort_2.h
vendored
Normal file
@@ -0,0 +1,65 @@
|
||||
// Copyright (C) 2003 Davis E. King (davis@dlib.net)
|
||||
// License: Boost Software License See LICENSE.txt for the full license.
|
||||
#ifndef DLIB_SEQUENCE_SORt_2_
|
||||
#define DLIB_SEQUENCE_SORt_2_
|
||||
|
||||
#include "sequence_sort_abstract.h"
|
||||
#include "../algs.h"
|
||||
#include "../sort.h"
|
||||
|
||||
namespace dlib
|
||||
{
|
||||
|
||||
template <
|
||||
typename seq_base
|
||||
>
|
||||
class sequence_sort_2 : public seq_base
|
||||
{
|
||||
typedef typename seq_base::type T;
|
||||
|
||||
public:
|
||||
|
||||
/*!
|
||||
this is a version of the QuickSort algorithm
|
||||
this uses the dlib::qsort_array function
|
||||
!*/
|
||||
|
||||
void sort (
|
||||
);
|
||||
|
||||
|
||||
};
|
||||
|
||||
template <
|
||||
typename seq_base
|
||||
>
|
||||
inline void swap (
|
||||
sequence_sort_2<seq_base>& a,
|
||||
sequence_sort_2<seq_base>& b
|
||||
) { a.swap(b); }
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// member function definitions
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
template <
|
||||
typename seq_base
|
||||
>
|
||||
void sequence_sort_2<seq_base>::
|
||||
sort (
|
||||
)
|
||||
{
|
||||
if (this->size() > 1)
|
||||
{
|
||||
dlib::qsort_array(*this,0,this->size()-1);
|
||||
}
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
|
||||
}
|
||||
|
||||
#endif // DLIB_SEQUENCE_SORt_2_
|
||||
|
||||
65
lib/3rdParty/dlib/include/dlib/sequence/sequence_sort_abstract.h
vendored
Normal file
65
lib/3rdParty/dlib/include/dlib/sequence/sequence_sort_abstract.h
vendored
Normal file
@@ -0,0 +1,65 @@
|
||||
// Copyright (C) 2003 Davis E. King (davis@dlib.net)
|
||||
// License: Boost Software License See LICENSE.txt for the full license.
|
||||
#undef DLIB_SEQUENCE_SORt_ABSTRACT_
|
||||
#ifdef DLIB_SEQUENCE_SORt_ABSTRACT_
|
||||
|
||||
#include "sequence_kernel_abstract.h"
|
||||
|
||||
namespace dlib
|
||||
{
|
||||
|
||||
template <
|
||||
typename seq_base
|
||||
>
|
||||
class sequence_sort : public seq_base
|
||||
{
|
||||
|
||||
/*!
|
||||
REQUIREMENTS ON T
|
||||
T must implement operator< for its type
|
||||
|
||||
REQUIREMENTS ON seq_base
|
||||
must be an implementation of sequence/sequence_kernel_abstract.h
|
||||
|
||||
|
||||
|
||||
POINTERS AND REFERENCES TO INTERNAL DATA
|
||||
sort() may invalidate pointers and references to data members.
|
||||
|
||||
WHAT THIS EXTENSION DOES FOR sequence
|
||||
this gives a sequence the ability to sort its contents by calling sort()
|
||||
!*/
|
||||
|
||||
|
||||
public:
|
||||
|
||||
void sort (
|
||||
);
|
||||
/*!
|
||||
ensures
|
||||
- for all elements in #*this the ith element is <= the i+1 element
|
||||
- #at_start() == true
|
||||
throws
|
||||
- std::bad_alloc or any exception thrown by T's constructor
|
||||
data may be lost if sort() throws
|
||||
!*/
|
||||
|
||||
|
||||
};
|
||||
|
||||
|
||||
template <
|
||||
typename seq_base
|
||||
>
|
||||
inline void swap (
|
||||
sequence_sort<seq_base>& a,
|
||||
sequence_sort<seq_base>& b
|
||||
) { a.swap(b); }
|
||||
/*!
|
||||
provides a global swap function
|
||||
!*/
|
||||
|
||||
}
|
||||
|
||||
#endif // DLIB_SEQUENCE_SORt_ABSTRACT_
|
||||
|
||||
Reference in New Issue
Block a user