/*
Quicksort algorithm
is used by the public void sort( int (*Comparator)(T, T)) methode
*/
void Sort(unsigned int left, unsigned int right, int (*Comparator)(T, T) )
{
int i = left, j = right;
T tmp;
T pivot = _data[(i + j) / 2];
/* partition */
while (i <= j)
{
while (Comparator(_data[i], pivot) < 0)
i++;
while (Comparator(_data[i], pivot) > 0)
j--;
if (i <= j)
{
tmp = _data[i];
_data[i] = _data[j];
_data[j] = tmp;
i++;
j--;
}
}
/* recursion */
if (left < j)
sort(left, j, Comparator);
if (i < right)
sort(i, right, Comparator);
}
/**
* @brief Compare two list view items.
* @param lParam1 - 1st item index.
* @param lParam2 - 2nd item index.
* @param lParamSort - sort argument.
* @return comparison result.
*/
int CALLBACK ListViewCompareFunc(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)
{
LISTVIEW_SORT_PARAMS* pLVSortParams = (LISTVIEW_SORT_PARAMS*)lParamSort;
TCHAR szItem1Text[256];
ListView_GetItemText(pLVSortParams->hwndList, lParam1, pLVSortParams->iColumnNumber, szItem1Text, countof(szItem1Text));
TCHAR szItem2Text[256];
ListView_GetItemText(pLVSortParams->hwndList, lParam2, pLVSortParams->iColumnNumber, szItem2Text, countof(szItem2Text));
int iResult;
switch (pLVSortParams->eCompareType)
{
case LISTVIEW_SORT_PARAMS::ICT_STRING:
iResult = _tcscmp(szItem1Text, szItem2Text);
break;
case LISTVIEW_SORT_PARAMS::ICT_INTEGER:
{
int iItemValue1 = _ttoi(szItem1Text);
int iItemValue2 = _ttoi(szItem2Text);
iResult = Comparator(iItemValue1, iItemValue2);
}
break;
case LISTVIEW_SORT_PARAMS::ICT_HEXADECIMAL:
{
unsigned uItemValue1 = _tcstoul(szItem1Text, NULL, 16);
unsigned uItemValue2 = _tcstoul(szItem2Text, NULL, 16);
iResult = Comparator(uItemValue1, uItemValue2);
}
break;
default:
iResult = 0;
break;
}
return (pLVSortParams->bAscending ? iResult : -iResult);
}
int _sstdata_binaryinsert(sst_data_t* sstdata, data_t* data)
{
int left, right, middle;
int i,j;
if (sstdata->key_num == 0)
{
sstdata->keys[0] = data;
return 1;
}
left = 0, right = sstdata->key_num - 1;
while (left <= right)
{
middle = (left + right) / 2;
if (Comparator(*sstdata->keys[middle], *data) == 1)
{
right = middle - 1;
}
else if (Comparator(*sstdata->keys[middle], *data) == -1)
{
left = middle + 1;
}
else if (Comparator(*sstdata->keys[middle], *data) == 0)
{
xfree(sstdata->keys[middle]); //if the key is exist,replace
sstdata->keys[middle] = data;
return 0;
}
}
i = middle;
if (Comparator(*sstdata->keys[middle], *data) > 0)
{
i = middle;
}
else
{
i = middle + 1;
}
j = sstdata->key_num - 1;
for (; j>=i; j--)
{
sstdata->keys[j+1] = sstdata->keys[j];
}
sstdata->keys[i] = data;
return 1;
}
static PropPtr
insert(char *key, PropPtr * avl)
{
PropPtr ret;
register PropPtr p = *avl;
register int cmp;
static short balancep;
if (p) {
cmp = Comparator(key, PropName(p));
if (cmp > 0) {
ret = insert(key, &(AVL_RT(p)));
} else if (cmp < 0) {
ret = insert(key, &(AVL_LF(p)));
} else {
balancep = 0;
return (p);
}
if (balancep) {
*avl = balance_node(p);
}
return ret;
} else {
p = *avl = alloc_propnode(key);
balancep = 1;
return (p);
}
}
void DocumentSourceSort::loadDocument(const Document& doc) {
invariant(!populated);
if (!_sorter) {
_sorter.reset(MySorter::make(makeSortOptions(), Comparator(*this)));
}
_sorter->add(extractKey(doc), doc);
}
PropPtr
next_node(PropPtr ptr, char *name)
{
PropPtr from;
int cmpval;
if (!ptr)
return NULL;
if (!name || !*name)
return (PropPtr) NULL;
cmpval = Comparator(name, PropName(ptr));
if (cmpval < 0) {
from = next_node(AVL_LF(ptr), name);
if (from)
return from;
return ptr;
} else if (cmpval > 0) {
return next_node(AVL_RT(ptr), name);
} else if (AVL_RT(ptr)) {
from = AVL_RT(ptr);
while (AVL_LF(from))
from = AVL_LF(from);
return from;
} else {
return NULL;
}
}
static PropPtr
remove_propnode(char *key, PropPtr * root)
{
PropPtr save;
PropPtr tmp;
PropPtr avl = *root;
int cmpval;
save = avl;
if (avl) {
cmpval = Comparator(key, PropName(avl));
if (cmpval < 0) {
save = remove_propnode(key, &AVL_LF(avl));
} else if (cmpval > 0) {
save = remove_propnode(key, &AVL_RT(avl));
} else if (!(AVL_LF(avl))) {
avl = AVL_RT(avl);
} else if (!(AVL_RT(avl))) {
avl = AVL_LF(avl);
} else {
tmp = remove_propnode(PropName(getmax(AVL_LF(avl))), &AVL_LF(avl));
if (!tmp)
abort(); /* this shouldn't be possible. */
AVL_LF(tmp) = AVL_LF(avl);
AVL_RT(tmp) = AVL_RT(avl);
avl = tmp;
}
if (save) {
AVL_LF(save) = NULL;
AVL_RT(save) = NULL;
}
*root = balance_node(avl);
}
return save;
}
int main()
{
std::list<Person*> mylist;
mylist.push_back(new Person(1));
mylist.push_back(new Person(2));
mylist.sort(Comparator());
}
void RestDispatcher::sink(HTTP::Connection* conn)
{
HTTP::setShouldConnectionBeClosed(conn->request(), conn->response());
if (BOOST_UNLIKELY(table_.empty()))
{
throw std::logic_error("Dispatch table is empty");
}
const auto& path = conn->request().uri;
auto it = std::lower_bound(table_.begin(), table_.end(), path, Comparator());
for (auto end = table_.end(); it != end && it->first == path; ++it)
{
if (it->second.handle(conn))
{
return; // Properly handled
}
}
conn->response()
.setCode(HTTP::HttpCode::NotFound)
.setBody("Unroutable request");
conn->sendResponse();
}
void DocumentSourceSort::populateFromCursors(const vector<DBClientCursor*>& cursors) {
vector<boost::shared_ptr<MySorter::Iterator> > iterators;
for (size_t i = 0; i < cursors.size(); i++) {
iterators.push_back(boost::make_shared<IteratorFromCursor>(this, cursors[i]));
}
_output.reset(MySorter::Iterator::merge(iterators, makeSortOptions(), Comparator(*this)));
}
auto make_stable_multiway_merge_tree(
ReaderIterator seqs_begin, ReaderIterator seqs_end,
const Comparator& comp = Comparator()) {
assert(seqs_end - seqs_begin >= 1);
return MultiwayMergeTree<ValueType, ReaderIterator, Comparator, true>(
seqs_begin, seqs_end, comp);
}
void put(T *t) {
std::lock_guard<Lock> l(_lock);
_data.push_back(t);
std::sort(_data.begin(), _data.end(), Comparator());
assert(sem_post(&_count) == 0);
}
void quick_sort(T *in_place_list, int size) {
auto qsort_comparator = [](const void *void_a, const void *void_b) -> int {
T *a = (T *)void_a;
T *b = (T *)void_b;
return Comparator(*a, *b);
};
qsort(in_place_list, size, sizeof(T), qsort_comparator);
}
/**
* @brief Compare two list view items.
* @param lParam1 - 1st item index.
* @param lParam2 - 2nd item index.
* @param lParamSort - sort argument.
* @return comparison result.
*/
static int CALLBACK FileSizeCompareFunc(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)
{
LISTVIEW_SORT_PARAMS* pLVSortParams = (LISTVIEW_SORT_PARAMS*)lParamSort;
FILE_ITEM_INFO* pFileItem1Info = (FILE_ITEM_INFO*)lParam1;
FILE_ITEM_INFO* pFileItem2Info = (FILE_ITEM_INFO*)lParam2;
int iResult = Comparator(pFileItem1Info->dwFileSize, pFileItem2Info->dwFileSize);
return (pLVSortParams->bAscending ? iResult : -iResult);
}
void DocumentSourceSort::populateFromBsonArrays(const vector<BSONArray>& arrays) {
vector<boost::shared_ptr<MySorter::Iterator> > iterators;
for (size_t i = 0; i < arrays.size(); i++) {
iterators.push_back(boost::make_shared<IteratorFromBsonArray>(this, arrays[i]));
}
_output.reset(MySorter::Iterator::merge(iterators, makeSortOptions(), Comparator(*this)));
}
void DocumentSourceSort::loadingDone() {
if (!_sorter) {
_sorter.reset(MySorter::make(makeSortOptions(), Comparator(*this)));
}
_output.reset(_sorter->done());
_sorter.reset();
populated = true;
}
Heap(size_t fixed_size)
:
m_data(new T[fixed_size]),
m_capacity(fixed_size),
m_size(0),
m_comp(Comparator()),
m_node_to_heap()
{
}
PacSolver::Result PacSolver::process()
{
std::deque<PacBoard *>::iterator itr = this_generation.begin();
std::vector<Position> next_pos;
if (this_generation.empty()) {
std::cout << "all generation extinct." << std::endl;
return PacSolver::Failed;
}
if (this_generation[0]->rest_time_counter == 0) {
std::cout << "all generation timed up." << std::endl;
return PacSolver::Failed;
}
while (itr != this_generation.end()) {
next_pos = trunc_next_pos(*itr, next_move(*itr));
if (next_pos.empty()) {
PacBoard *branch_top = (*itr)->find_and_cut_last_branch();
delete branch_top;
}
std::vector<Position>::iterator pi = next_pos.begin();
while (pi != next_pos.end()) {
PacBoard *child = (*itr)->create_and_register_child(*pi);
if (child->dots == 0) {
end_board = child;
return PacSolver::Solved;
}
if (child->dots < remaining_dots) {
remaining_dots = child->dots;
delete highest_score_now;
highest_score_now = new PacBoard(*child);
}
next_generation.push_back(child);
pi ++;
}
itr ++;
}
if (next_generation.size() > threshold_leaves) {
std::sort(next_generation.begin(), next_generation.end(), Comparator());
for (int i = trunc_leaves_to; i < next_generation.size(); i ++) {
PacBoard *b = next_generation[i]->find_and_cut_last_branch();
delete b;
}
next_generation.resize(trunc_leaves_to);
}
this_generation = next_generation;
next_generation.clear();
return PacSolver::Solving;
}
//--------------------------------------------------------------
void ofxMtlMapping2DControls::refreshShapesListForMappingMode(ofxMtlMapping2DMode mappingMode)
{
clearShapesList();
// Re populate the UI List
ofxMtlMapping2DShapes::pmShapes.sort(Comparator());
list<ofxMtlMapping2DShape*>::reverse_iterator it;
for (it=ofxMtlMapping2DShapes::pmShapes.rbegin(); it!=ofxMtlMapping2DShapes::pmShapes.rend(); it++) {
ofxMtlMapping2DShape* shape = *it;
if (mappingMode == MAPPING_MODE_OUTPUT || (mappingMode == MAPPING_MODE_INPUT && shape->shapeType != MAPPING_2D_SHAPE_MASK)) {
ofxMtlMapping2DControls::mapping2DControls()->addShapeToList(shape->shapeId, shape->shapeType);
}
}
}
static PropPtr
find(char *key, PropPtr avl)
{
int cmpval;
while (avl) {
cmpval = Comparator(key, PropName(avl));
if (cmpval > 0) {
avl = AVL_RT(avl);
} else if (cmpval < 0) {
avl = AVL_LF(avl);
} else {
break;
}
}
return avl;
}
static inline void sort(T * in_place_list, int size) {
// insertion sort, cuz whatever.
for (int top = 1; top < size; top++) {
T where_do_i_go = in_place_list[top];
for (int falling_index = top - 1; falling_index >= 0; falling_index--){
T do_you_want_my_spot = in_place_list[falling_index];
if (Comparator(do_you_want_my_spot, where_do_i_go) <= 0) {
// no one out of order here, officer
break;
}
// these two are in the wrong order.
// switch spots
in_place_list[falling_index + 1] = do_you_want_my_spot;
in_place_list[falling_index] = where_do_i_go;
}
}
}
void _sstdata_sort(sst_data_t* sstdata)
{
int i;
int j;
data_t* index;
for (i=1; i<sstdata->key_num; i++)
{
j = i;
index = sstdata->keys[i];
while (j>0 && Comparator(*index,*sstdata->keys[j-1]) == -1)
{
sstdata->keys[j] = sstdata->keys[j-1];
j--;
}
sstdata->keys[j] = index;
}
}
NetworkLinkCollection::NetworkLinkCollection() :
DirectoryOption(ZLCategoryKey::NETWORK, "Options", "DownloadDirectory", "") {
shared_ptr<ZLDir> dir = ZLFile(NetworkLink::NetworkDataDirectory()).directory();
if (!dir.isNull()) {
std::vector<std::string> names;
dir->collectFiles(names, false);
for (std::vector<std::string>::iterator it = names.begin(); it != names.end(); ++it) {
shared_ptr<NetworkLink> link = OPDSLink::read(dir->itemPath(*it));
if (!link.isNull()) {
myLinks.push_back(link);
}
}
}
std::sort(myLinks.begin(), myLinks.end(), Comparator());
}
void DocumentSourceSort::populate() {
/* make sure we've got a sort key */
verify(vSortKey.size());
SortOptions opts;
if (limitSrc)
opts.limit = limitSrc->getLimit();
opts.maxMemoryUsageBytes = 100*1024*1024;
opts.extSortAllowed = pExpCtx->extSortAllowed && !pExpCtx->inRouter;
scoped_ptr<MySorter> sorter (MySorter::make(opts, Comparator(*this)));
while (boost::optional<Document> next = pSource->getNext()) {
sorter->add(extractKey(*next), *next);
}
_output.reset(sorter->done());
populated = true;
}
void DocumentSourceSort::populate() {
if (_mergingPresorted) {
typedef DocumentSourceMergeCursors DSCursors;
typedef DocumentSourceCommandShards DSCommands;
if (DSCursors* castedSource = dynamic_cast<DSCursors*>(pSource)) {
populateFromCursors(castedSource->getCursors());
} else if (DSCommands* castedSource = dynamic_cast<DSCommands*>(pSource)) {
populateFromBsonArrays(castedSource->getArrays());
} else {
msgasserted(17196, "can only mergePresorted from MergeCursors and CommandShards");
}
} else {
scoped_ptr<MySorter> sorter (MySorter::make(makeSortOptions(), Comparator(*this)));
while (boost::optional<Document> next = pSource->getNext()) {
sorter->add(extractKey(*next), *next);
}
_output.reset(sorter->done());
}
populated = true;
}
/**
* Naplni pole ID a ukazatelu daty 'count' patchu s nejvetsi energii
*/
void ModelContainer::getHighestRadiosityPatchesId(unsigned int count, Patch** p_emitters, unsigned int* p_emitters_ids) {
if (needRefresh == true)
updateData();
list<unsigned int> tops;
Comparator c = Comparator();
c.patches = patches;
for (unsigned int pi = 0; pi < patchesCount; pi++) {
if (
tops.empty() ||
(patches[pi]->radiosity.f_Length2() > 0 && patches[tops.back()]->radiosity.f_Length2() <= patches[pi]->radiosity.f_Length2())
) {
tops.push_back(pi);
tops.sort(c);
tops.reverse(); // seradit od nejvyssiho k nejmensimu
if (tops.size() > count) {
list<unsigned int>::iterator it = tops.begin();
for (unsigned int i = 0; i < count; i++)
it++;
tops.erase(it, tops.end());
}
}
}
// zkopirovat data na vystup
list<unsigned int>::iterator it = tops.begin();
for (unsigned int i = 0; i < count; i++) {
if (it == tops.end()) {
p_emitters_ids[i] = 0;
p_emitters[i] = NULL;
continue;
}
p_emitters_ids[i] = (*it);
p_emitters[i] = patches[ p_emitters_ids[i] ];
it++;
}
}
//--------------------------------------------------------------
void ofxMtlMapping2D::saveShapesList()
{
list<ofxMtlMapping2DShape*> pmShapesCopy;
pmShapesCopy.resize (ofxMtlMapping2DShapes::pmShapes.size());
copy (ofxMtlMapping2DShapes::pmShapes.begin(), ofxMtlMapping2DShapes::pmShapes.end(), pmShapesCopy.begin());
pmShapesCopy.sort(Comparator());
ofxXmlSettings newShapesListXML;
int shapeCounter = 0;
newShapesListXML.addTag("root");
newShapesListXML.pushTag("root", 0);
//Create/Update XML
list<ofxMtlMapping2DShape*>::reverse_iterator it;
for (it=pmShapesCopy.rbegin(); it!=pmShapesCopy.rend(); it++) {
ofxMtlMapping2DShape* shape = *it;
int tagNum = newShapesListXML.addTag("shape");
newShapesListXML.addAttribute("shape", "id", shape->shapeId, tagNum);
newShapesListXML.pushTag("shape", tagNum);
//Shape settings
map<string,string>::iterator itShape;
for ( itShape=shape->shapeSettings.begin() ; itShape != shape->shapeSettings.end(); itShape++ ) {
int tagNum = newShapesListXML.addTag("setting");
newShapesListXML.addAttribute("setting", "key", (*itShape).first, tagNum);
newShapesListXML.setValue("setting", (*itShape).second, tagNum);
}
//Output Vertex/Vertices
tagNum = newShapesListXML.addTag("outputVertices");
newShapesListXML.pushTag("outputVertices", tagNum);
list<ofxMtlMapping2DVertex*>::iterator itVertex;
for (itVertex=shape->vertices.begin(); itVertex!=shape->vertices.end(); itVertex++) {
ofxMtlMapping2DVertex* vertex = *itVertex;
int tagNum = newShapesListXML.addTag("vertex");
newShapesListXML.addAttribute("vertex", "x", (int)vertex->center.x, tagNum);
newShapesListXML.addAttribute("vertex", "y", (int)vertex->center.y, tagNum);
}
newShapesListXML.popTag();
if(shape->shapeType != MAPPING_2D_SHAPE_MASK) {
//Input Quads
tagNum = newShapesListXML.addTag("inputPolygon");
newShapesListXML.pushTag("inputPolygon", tagNum);
//Vertices
for (itVertex=shape->inputPolygon->vertices.begin(); itVertex!=shape->inputPolygon->vertices.end(); itVertex++) {
ofxMtlMapping2DVertex* vertex = *itVertex;
int tagNum = newShapesListXML.addTag("vertex");
newShapesListXML.addAttribute("vertex", "x", (int)vertex->center.x, tagNum);
newShapesListXML.addAttribute("vertex", "y", (int)vertex->center.y, tagNum);
}
newShapesListXML.popTag();
}
newShapesListXML.popTag();
shapeCounter++;
}
//Save to file
newShapesListXML.saveFile(_mappingXmlFilePath);
ofLog(OF_LOG_NOTICE, "Status > settings saved to xml!");
}
inline bool operator==(const Value& lhs, const Value& rhs)
{
return boost::apply_visitor(Comparator(lhs), rhs);
}
namespace utils {
template <typename T, typename Comparator = std::less<T> >
bool addToOrderedVector(const T &value, std::vector<T> &list, Comparator comparator = Comparator());
template <typename T, typename Comparator = std::less<T> >
typename std::vector<T>::const_iterator findInOrderedVector(const T &value, const std::vector<T> &list, Comparator comparator = Comparator());
template <class T>
void eraseValue(std::vector<T> &, const T&);
template <class T>
std::vector<T> intersectionVector(const std::vector<T>&, const std::vector<T>&);
#ifndef __BITPIT_UTILS_SRC__
extern template bool addToOrderedVector<>(const long&, std::vector<long>&, std::less<long>);
extern template bool addToOrderedVector<>(const unsigned long&, std::vector<unsigned long>&, std::less<unsigned long>);
extern template std::vector<long>::const_iterator findInOrderedVector<>(const long&, const std::vector<long>&, std::less<long>);
extern template std::vector<unsigned long>::const_iterator findInOrderedVector<>(const unsigned long&, const std::vector<unsigned long>&, std::less<unsigned long>);
#endif
void extractWithoutReplacement( // Extract integers without replacement
int , // (input) number of integers to be extracted
int , // (input) upper bound of extraction interval
std::vector<int> & // (input/output) list of extracted value
);
// Trimming operators --------------------------------------------------------------- //
inline std::string <rim( // STRING LEFT TRIMMING
std::string & // (input) std::string to be trimmed
);
inline std::string &rtrim( // STRING RIGHT TRIMMING
std::string & // (input) std::string to be trimmed
);
inline std::string &trim( // STRING TRIMMING
std::string & // (input) std::string to be trimmed
);
// Padding operators ---------------------------------------------------------------- //
inline std::string lfill( // Left filler for input string
const int &, // (input) Final string length
std::string &, // (input) input string
char // (input) char used as filler
);
inline std::string rfill( // Right filler for input string
const int &, // (input) Final string length
std::string &, // (input) input string
char // (input) char used as filler
);
inline std::string zeroPadNumber( // PERFORMS CONVERSION OF INTEGER INTO STRING
int , // (input) number of char in std::string
int // (input) integer to be padded
);
// Input stream operator ------------------------------------------------------------ //
bool getAfterKeyword( // EXTRACT FIELD AFTER SPECIFIC KEYWORD
std::string , // (input) std::string
std::string , // (input) keyword
char , // (input) field delimiter
std::string & // (input/output) field found
);
// returns true if key_ is present in line ------------------------------------------ //
inline bool keywordInString( // SEARCH KEYWORD IN STRING
std::string , // (input) input string
std::string // (input) keyword
) ;
// converts a string to fundamental data types and vectors or arrays of them -------- //
template <class T>
void convertString( // EXTRACT SCALAR FROM STRING
std::string , // (input) input string
T & // (input/output) scalar
);
template <class T>
void convertString( // EXTRACT DATA FROM STRING AND STORE THEM INTO VECTOR
std::string , // (input) string
std::vector<T> & // (input/output) vector used to store string
);
template <class T, size_t n>
void convertString( // EXTRACT DATA FROM STRING AND STORE THEM INTO ARRAY
std::string , // (input) string
std::array<T,n> & // (input/output) array used to store data
);
}
explicit Heap(int max_num, Comparator comparator = Comparator()):
heap_(1),
point_to_id_(1),
id_to_point_(max_num),
comparator(comparator)
{}
