int main() {
int data1,data2,data3,data4,data5;
int nonData = 6;
int * pFind = NULL;
List test = NULL;
initList(&test);
data1 = 10;data2 = 20;data3 = 30;data4 = 40;data5 = 50;
addToList(test, (void*)&data1);
addToList(test, (void*)&data2);
addToList(test, (void*)&data3);
addToList(test, (void*)&data4);
addToList(test, (void*)&data5);
displayList(test);
printf("%s","Searching for 30");
pFind = (int*)findInList(test, (void*)&data3, intGreater);
if (pFind)
{
printf("%s%d","\nFound data value: ", *pFind);
}
else {
printf("%s","\nData not found");
}
printf("%s","\nSearching for 99 (shouldn't be in list)");
pFind = (int*)findInList(test, (void*)&nonData, intGreater);
if (pFind)
{
printf("%s%d","\nFound data value: ", *pFind);
}
else {
printf("%s","\nData not found");
}
printf("%s","\nremoving one item then displaying\n");
removeFirst(test);
displayList(test);
printf("%s","removing all items then displaying\n");
deleteList(test);
displayList(test);
printf("%s","Attempting to remove from an empty list\n");
removeFirst(test);
displayList(test);
cleanupList(&test);
printf("%s","All tests complete\n");
return 0;
}
void List::removeByIndex(uint index)
{
if (index == 0)
{
removeFirst();
}
else if (index == _count - 1)
{
pop();
}
else
{
Node* element = elementByIndex(index);
if (element != NULL)
{
_count--;
//// у i-го берем і-1 ставим следующий і+1
//Node* temp = element->getPrev();
//temp->setNext(element->getNext());
//// у i-го берем і+1 ставим предыдущий і-1
//temp = element->getNext();
//temp->setPrev(element->getPrev());
//
//// бахаем і-й
//delete element;
// in short form
element->getPrevious()->setNext(element->getNext());
element->getNext()->setPrevious(element->getPrevious());
delete element;
}
}
}
TYPE Sequence<TYPE>::remove(int pos)
{
Node *aux = &list;
Node *aux7 = &list;
while (aux->next != NULL)
{
if(pos <= 0)
return removeFirst();
else
{
if(pos == 0)
{
if(aux->next != NULL)
{
Node *toBeDeleted = aux->next;
aux->next = aux->next->next;
delete toBeDeleted;
return true;
}
else
break;
}
}
pos--;
aux = aux->next;
}
if(aux7->next != NULL)
removeLast();
return false;
}
/* Adds a command to the history list, deleting the first if the
* size of the list is too large */
void addCommandToHistory(char* command_line)
{
history_item* theItem = (history_item*)malloc(sizeof(history_item));
if(history_list == NULL)
{
initHistory();
}
if(length(history_list) == 0)
{
theItem->command_number = 1;
}
else
{
theItem->command_number =
1 + ((history_item*)(history_list->tail->data))->command_number;
}
theItem->command_line = command_line;
addLast(history_list, theItem);
if(length(history_list) > HISTORY_LENGTH)
{
free(((history_item*)(history_list->head->data))->command_line);
free(history_list->head->data);
removeFirst(history_list);
}
}
Sequence<TYPE>::~Sequence()
{
while(!isEmpty())
{
removeFirst();
};
}
Grantlee::Node *FilterNodeFactory::getNode(const QString &tagContent,
Grantlee::Parser *p) const
{
auto expr = tagContent.split(QLatin1Char(' '), QString::SkipEmptyParts);
expr.removeFirst();
auto expression = expr.join(QChar::fromLatin1(' '));
FilterExpression fe(QStringLiteral("var|%1").arg(expression), p);
auto filters = fe.filters();
if (filters.contains(QStringLiteral("safe"))
|| filters.contains(QStringLiteral("escape"))) {
throw Grantlee::Exception(
TagSyntaxError, QStringLiteral("Use the \"autoescape\" tag instead."));
}
auto n = new FilterNode(fe, p);
auto filterNodes = p->parse(n, QStringLiteral("endfilter"));
p->removeNextToken();
n->setNodeList(filterNodes);
return n;
}
// removes last element of list
void*CList::removeLast(bool freeData)
{
if(first == last) {
return removeFirst(freeData);
}
CListItem *tmp = last;
CListItem *iter = first;
while(iter->next != last)
{
iter = iter->next;
}
// iter->next == last
iter->next = NULL;
last = iter;
void*result;
#ifdef DOFREE
if(freeData) {
free(tmp->data);
tmp->data = NULL;
}
#endif
result = tmp->data;
free(tmp);
length--;
if(length <= 0) {
length = 0;
}
return result;
}
//---------------------------------------
void FRDialog::updateItemforTable(QStringList &booklist, QStringList &chapterlist)
{
QStringList booklib, chapterlib;
for (int i = 0; i < booklist.size(); i++)
{
QString name = getFileNameAbs(QString(booklist.at(i)));
QString namebook = QString(name)
.remove("book_")
.remove("chapter_");
QString namechapter = namebook;
QStringList list;
list = namebook.split("_");
namebook = list.first();
namechapter = QString(namechapter)
.remove("_");
namechapter = removeFirst(namechapter, namebook);
QString filenamebook = Config::configuration()->CurPrjDir()
+ "/" + "book_" + namebook + ".htm";
namechapter = tr("Chapter ") + namechapter;
namebook = getParamBook(filenamebook, "FullName");
booklib << namebook;
chapterlib << namechapter;
}
booklist = booklib;
chapterlist = chapterlib;
// qDebug() << "\nlist1 = " << booklist
// << "\n\n list2 = " << chapterlist;
}
void Liste::remove(int index){
if(index < 0){
index = _len + index;
}
if(index < 0 || index >= _len){
//TODO TROW ERR
cout << "ERROR remove index out of range" << endl;
return;
}
if(index == 0){
removeFirst();
} else if(index == _len-1) {
removeLast();
} else {
ListeItem *r = _getItem(index);
ListeItem *b = r->_back;
ListeItem *f = r->_front;
b->_front = f;
f->_back = b;
delete r;
_len--;
}
}
/**
* Remove any element e for which predicate(e) returns true.
*/
int removeAll(std::function<bool (const T&)> predicate)
{
const std::vector<T> &matches = items(predicate);
for(const auto &elt : matches) {
removeFirst(elt);
}
return matches.size();
}
bool DLList::removeAll (int target) {
bool valueDeleted = false;
for (unsigned int i = 0; i < count; i++) {
if (removeFirst(target) == true) {
valueDeleted = true;
}
}
return valueDeleted;
}
void TagManager::removeEntity(const EntityInfo& e)
{
std::string tag = _tagsByEntity[e.getId()];
std::vector<Entity>& entities = _entityArraysByTag[tag];
removeFirst(entities, (Entity)e);
_tagsByEntity[e.getId()] = "";
}
struct number * parseNum(char* number){
struct number *num;
num = (struct number *)malloc(sizeof(struct number));
long dec;
if(number[0]== '-'){
num->negative = true;
char type = number[1];
number = removeFirst(number);
number = removeFirst(number);
if(type == 'b'){
num->binary = number;
dec = conBinToDec(number);
}else if(type == 'o'){
num->oct = number;
dec = conOctToDec(number);
}else if(type == 'x'){
num->hex = number;
dec = conHexToDec(number);
}else{
dec = atol(number);
}
printf("%s\n", number);
num->decimal = dec;
}else{
num->negative = false;
char type = number[0];
number = removeFirst(number);
if(type == 'b'){
num->binary = number;
dec = conBinToDec(number);
}else if(type == 'o'){
num->oct = number;
dec = conOctToDec(number);
}else if(type == 'x'){
num->hex = number;
dec = conHexToDec(number);
}else{
dec = atol(number);
}
printf("%s\n", number);
num->decimal = dec;
}
return num;
}
T deque<T>::removeLast()
{
if (head.get() == tail)
return removeFirst();
T elt = tail->first;
tail = tail->prev;
tail->rest = nullptr;
return elt;
}
bool DLList::removeAll(int target) {
bool targetFound = false;
if (head == NULL)
return targetFound;
for (unsigned int i = 0; i < size; i++) {
removeFirst(target);
targetFound = true;
}
return targetFound;
}
void freeList(LinkedList *lL)
{
LinkedListNode *tempPtr;
tempPtr = lL->head;
//free each element
while (tempPtr != NULL)
{
removeFirst(lL);
tempPtr= lL->head;
}
free(lL); //free list
}
T deque<T>::remove(loc lnk)
{
if (tail == lnk)
return removeLast();
else if (head.get() == lnk)
return removeFirst();
// no special cases, so we can just update the links
lnk->rest->prev = lnk->prev;
lnk->prev->rest = move(lnk->rest);
return lnk->first;
}
int main(int argc, char* argv[]){
Point p1;
p1.x = 1; p1.y = 2;
Point p2;
p2.x = 3; p2.y = 4;
List list = initList(sizeof(Point));
insertFirst(list, &p1);
insertFirst(list, &p2);
Point* test[2];
test[0] = (Point*) removeFirst(list);
test[1] = (Point*) removeFirst(list);
/*
printf("p2.x: %d, p2.y: %d\n", test[0]->x, test[0]->y);
printf("p1.x: %d, p1.y: %d\n", test[1]->x, test[1]->y);
*/
liberer(list);
return !(test[0]->x==3 && test[0]->y==4 && test[1]->x==1 && test[1]->y==2);
}
static void buildMaze(int y, int x)
{
int numOffsets, offset, offsets[4];
while (1) {
numOffsets = 0;
maze[y][x].visited = true;
if (y > 0 && !maze[y - 1][x].visited)
offsets[numOffsets ++] = -width;
if (y < height - 1 && !maze[y + 1][x].visited)
offsets[numOffsets ++] = width;
if (x > 0 && !maze[y][x - 1].visited)
offsets[numOffsets ++] = -1;
if (x < width - 1 && !maze[y][x + 1].visited)
offsets[numOffsets ++] = 1;
if (numOffsets > 0) {
offset = offsets[rand() % numOffsets];
addFirst(dp, offset(x, y));
if (offset == -width) {
maze[y - 1][x].bottom = false;
buildMaze(y - 1, x);
} else if (offset == width) {
maze[y][x].bottom = false;
buildMaze(y + 1, x);
} else if (offset == -1) {
maze[y][x - 1].right = false;
buildMaze(y, x - 1);
} else if (offset == 1) {
maze[y][x].right = false;
buildMaze(y, x + 1);
} else
abort();
} else if (numItems(dp) > 0) {
offset = removeFirst(dp);
x = xcoord(offset);
y = ycoord(offset);
} else
break;
}
maze[height - 1][width - 1].right = false;
}
/// \details
/// This routine is called from the timer interrupt service routine
/// to count ticks and to wake-up the sleeping threads when their
/// associated counters reach zero.
///
/// Due to the way ticks are stored relatively to the previous element,
/// only the top counter needs to be decremented. When zero is
/// reached, the thread related to the current element and the threads
/// related to all following elements with ticks=0 will be waked-up.
void
TimerBase::interruptServiceRoutine(void)
{
#if defined(DEBUG) && defined(OS_DEBUG_TIMERBASE_INTERRUPTTICK)
os::diag::trace.putChar('[');
#endif // defined(DEBUG) && defined(OS_DEBUG_TIMERBASE_INTERRUPTTICK)
// Increment the perpetual ticks counter. Will obviously overflow
// and start from 0.
m_ticks++;
// Decrement timer and eventually wake-up thread
if (m_count > 0) // is there anything in the list?
{
#if defined(DEBUG) && defined(OS_DEBUG_TIMERBASE_INTERRUPTTICK)
os::diag::trace.putChar('*');
#endif // defined(DEBUG) && defined(OS_DEBUG_TIMERBASE_INTERRUPTTICK)
volatile timer::Element* p;
p = m_pArray;
// Decrement the counter associated with the first element
if (--(p->ticks) == 0)
{
do
{
#if defined(DEBUG) && defined(OS_DEBUG_TIMERBASE_INTERRUPTTICK)
os::diag::trace.putString(" tw(");
os::diag::trace.putString(p->pThread->getName());
os::diag::trace.putString(",");
os::diag::trace.putDec(m_count);
os::diag::trace.putString(") ");
#endif // defined(DEBUG) && defined(OS_DEBUG_TIMERBASE_INTERRUPTTICK)
// Sleep period completed, wake-up the thread
p->pThread->wakeupNoInterrupts();
// Remove the top element from the array
// MANDATORY, otherwise this routine hangs with
// an infinite loop!
removeFirst();
}
while ((p->ticks == 0) && (m_count > 0));
}
}
#if defined(DEBUG) && defined(OS_DEBUG_TIMERBASE_INTERRUPTTICK)
os::diag::trace.putChar(']');
#endif // defined(DEBUG) && defined(OS_DEBUG_TIMERBASE_INTERRUPTTICK)
}
void trimList()
{
if(HISTCOUNT > HISTFILECOUNT)
{
HISTMAX = HISTCOUNT;
}
else
{
HISTMAX = HISTFILECOUNT;
}
while((*HISTORY).size >= HISTMAX)
{
removeFirst(HISTORY, cleanHistory);
}
}
void PacketBuffer::put(const Packet &packet)
{
lock();
while (pos > backwardPackets)
{
const Packet &tmpPacket = first();
backward_duration -= tmpPacket.duration;
backward_bytes -= tmpPacket.size();
removeFirst();
--pos;
}
append(packet);
remaining_bytes += packet.size();
remaining_duration += packet.duration;
unlock();
}
// assignment operator
DoublyLinkedList& DoublyLinkedList::operator=(const DoublyLinkedList& dll) //O(n)
{
while (!isEmpty()){
removeFirst();
}
header.next = &trailer; trailer.prev = &header;
DListNode *current = dll.getFirst();
while(current != dll.getAfterLast())
{
insertFirst(current->getElem());
current=current->getNext();
}
return *this;
}
/*This Func Del an Existing User By Key*/
Item delRecByKey(List *ptrList,Item *ptritem)
{
Node *tmpitem,*deleteNode;
Item tmp={"No Item"};
if(!ptrList)
{
NO_LIST;
return tmp;
}
if(ListIsEmpty(ptrList))
{
Item tmp={"No Item"};
LIST_IS_EMPTY;
return tmp;
}
tmpitem=ptrList->start;
if(COMPARE(*ptritem,tmpitem->data))
{/*in case that the 1st is to delete*/
tmp=removeFirst(ptrList);
return tmp;
}
while(tmpitem->next)
{
if(COMPARE(tmpitem->next->data,*ptritem))
{
if (tmpitem->next == ptrList->end)
ptrList->end = tmpitem;
tmp=tmpitem->next->data;
deleteNode=tmpitem->next;
tmpitem->next=tmpitem->next->next;
free(deleteNode);
ptrList->num--;
return tmp;
}
tmpitem=tmpitem->next;
}
return tmp;
}
void TagManager::setTag(const EntityInfo& e, std::string tag)
{
_tagsByEntity.resize(e.getId()+1);
// Get old tag
std::string oldTag = _tagsByEntity[e.getId()];
std::vector<Entity>& oldTagEntities = _entityArraysByTag[oldTag];
std::vector<Entity>& newTagEntities = _entityArraysByTag[tag];
// Set entity's tag
_tagsByEntity[e.getId()] = tag;
// Remove entity from old tag collection
removeFirst(oldTagEntities, (Entity)e);
// Add entity to new tag collection
newTagEntities.push_back(e);
}
int main( int argc, char *argv[] ){
QCoreApplication a( argc, argv );
Overmix::ImageContainer images;
Overmix::CommandParser parser( images );
try{
//Parse command-line arguments
auto args = a.arguments();
args.removeFirst();
parser.parse( args );
return 0;
}
catch( std::exception& e ){
std::cout << "Some error occurred:" << std::endl;
std::cout << e.what();
return -1;
}
}
void ReachableList::calculateNewList()
{
// qDebug( "ReachableList::calculateNewList() is called" );
// calculateNewList is also called from calculator, so on check has to be
// executed
if ( !isOn() )
{
return;
}
// QTime t; // timer for performance measurement
// t.start();
setInitValues();
clearLists(); // clear all lists
// Now add items of different type to the list
addItemsToList(MapContents::AirfieldList);
addItemsToList(MapContents::GliderfieldList);
addItemsToList(MapContents::OutLandingList);
addItemsToList(MapContents::WaypointList);
modeAltitude = false;
//qDebug("Number of potential reachable sites: %d", count() );
// sort list according to distances
qSort(begin(), end() );
removeDoubles();
// qDebug("Number of potential reachable sites (after pruning): %d", count() );
// Remove all elements over the maximum. That are the far away elements.
int nr = getMaxNrOfSites();
while ( nr < size() )
{
removeFirst();
}
// qDebug("Limited Number of potential reachable sites: %d", count() );
calculateDataInList();
//qDebug("Time for full calculation: %d msec", t.restart() );
}
/**
Parses a string in the format `a = 1,b=2, c = "1,2,3,4", d = 5.0, e='a,b,c'`
into a map of key/value pairs
@param qstr The input string
@throws std::runtime_error on an invalid input string
@returns : a map of key/value pairs as QStrings
*/
std::map<QString, QString> parseKeyValueQString(const QString &qstr) {
/*
This is a bad example of using a tokenizer, and
Mantid::Kernel::StringTokenizer should
ideally be used for this (see LoadProcessedNexus, Fit1D or others for
examples)
The reason we must use boost::tokenizer here is that passing a list of
separators is not
yet possible with Mantid::Kernel::StringTokenizer.
*/
auto str = qstr.toStdString();
boost::tokenizer<boost::escaped_list_separator<char>> tok(
str, boost::escaped_list_separator<char>("\\", ",", "\"'"));
std::map<QString, QString> kvp;
for (const auto &it : tok) {
auto keyValueString = QString::fromStdString(it);
auto valVec = keyValueString.split("=");
if (valVec.size() > 1) {
// We split on all '='s. The first delimits the key, the rest are assumed
// to be part of the value
auto key = valVec[0].trimmed();
// Drop the key from the values vector
valVec.removeFirst();
// Join the remaining sections
auto value = valVec.join("=").trimmed();
if (key.isEmpty() || value.isEmpty())
throw std::runtime_error("Invalid key value pair, '" + it + "'");
kvp[key] = value;
} else {
throw std::runtime_error("Invalid key value pair, '" + it + "'");
}
}
return kvp;
}
/*Tar bort noden innehållande value (går självklart även att
göra på position)
Pre - listan är inte tom och det finns en nod innehållande
value i listan
Post - noden innehållande value är borttagen*/
void removeNode(List *myList, int pos)
{
if (pos == 1)
{
removeFirst(myList);
}
else if (pos == myList->numberOfNodes)
{
removeLast(myList);
}
else if (pos > 1 && pos < myList->numberOfNodes)
{
Node* remove = myList->head;
Node* next;
Node* prev;
for (int i = 1; i < pos; i++)
{
remove = remove->next;
}
printf("\n%d\n", remove->data);
next = remove->next;
prev = remove->prev;
next->prev = prev;
prev->next = next;
myList->numberOfNodes--;
free(remove);
}
else
{
printf("error!\n");
system("pause");
}
}
void WorkerThread::run( const Event* stopSignal )
{
try
{
while ( WAIT_TIMEOUT == stopSignal->wait(10) )
{
if ( 0 == queueSize() )
continue;
WorkerThreadTask* t = getFirst();
bool keepWorking = t->execute();
removeFirst();
delete t;
if ( ! keepWorking )
{
break;
}
}
}
catch( ... )
{
}
}
