https://github.com/cran/tgp
Tip revision: 5a6ad419c0e9305d1a98e7750122700b3dabdf3f authored by Robert B. Gramacy on 17 June 2007, 00:00:00 UTC
version 1.2-6
version 1.2-6
Tip revision: 5a6ad41
list.cc
/********************************************************************************
*
* Bayesian Regression and Adaptive Sampling with Gaussian Process Trees
* Copyright (C) 2005, University of California
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
* Questions? Contact Robert B. Gramacy (rbgramacy@ams.ucsc.edu)
*
********************************************************************************/
extern "C"
{
#include "rhelp.h"
}
#include "list.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <assert.h>
/*
* the usual constructor function
* for NODE
*/
LNode::LNode(void* entry)
{
this->entry = entry;
prev = next = NULL;
list = NULL;
}
/*
* the usual destructor function
* for NODE
*/
LNode::~LNode(void)
{
}
/*
* return the next node in the list
*/
LNode* LNode::Next(void)
{
return next;
}
/*
* return the previous node in the list
*/
LNode* LNode::Prev(void)
{
return prev;
}
/*
* return the data entry for the node
*/
void* LNode::Entry(void)
{
return entry;
}
/*
************************
* BEGIN List FUNCTIONS *
************************
*/
/*
* the usual constructor function
* for LIST
*/
List::List(void)
{
first = last = curr = NULL;
len = 0;
}
/*
* the usual destructor function
* for LIST
*/
List::~List(void)
{
curr = first;
if(curr) warning("nonempty list deleted");
while(curr) {
LNode* temp = curr;
curr = curr->next;
delete temp;
}
}
/*
* insert a new node at the beginning
* of the list
*/
LNode* List::EnQueue(void* entry)
{
if(first == NULL) {
assert(last == NULL);
assert(len == 0);
first = new LNode(entry);
last = first;
} else {
assert(last != NULL);
assert(len > 0);
LNode* newnode = new LNode(entry);
newnode->next = first;
assert(first->prev == NULL);
first->prev = newnode;
first = newnode;
}
len++;
first->list = this;
return first;
}
/*
* remove a node from the end
* of the list
*/
void * List::DeQueue(void)
{
if(last == NULL) {
assert(first == NULL);
assert(len == 0);
return NULL;
} else {
LNode* temp = last;
if(first == last) {
first = NULL;
} else {
assert(last->prev != NULL);
last->prev->next = NULL;
}
last = last->prev;
len--;
assert(len >= 0);
void* entry = temp->Entry();
temp->list = NULL;
delete temp;
return entry;
}
}
/*
* check if the list is empty
*/
bool List::isEmpty(void)
{
if(first == NULL) {
assert(last == NULL);
assert(len == 0);
return true;
} else {
assert(last != NULL);
assert(len > 0);
return false;
}
}
/*
* return the length of the list
*/
unsigned int List::Len(void)
{
return len;
}
/*
* detach and delete the node from the list
*/
void* List::detach_and_delete(LNode* node)
{
assert(node);
if(node->list == NULL) {
void* entry = node->Entry();
delete node;
return entry;
}
assert(node->list == this);
if(node == first) {
assert(node->prev == NULL);
if(node == last) { /* first and last (one node list) */
assert(node->next == NULL);
first = last = NULL;
} else { /* first but not last */
assert(node->next != NULL);
first = node->next;
node->next = NULL;
first->prev = NULL;
}
} else if(node == last) { /* last but not first */
assert(node->next == NULL);
assert(node->prev != NULL);
last = node->prev;
node->prev = NULL;
last->next = NULL;
} else { /* not last or first */
node->prev->next = node->next;
node->next->prev = node->prev;
node->next = NULL;
node->prev = NULL;
}
void* entry = node->Entry();
node->list = NULL;
delete node;
node = NULL;
len--;
assert(len >= 0);
return entry;
}
/*
* return the first node in the list
*/
LNode* List::First(void)
{
return first;
}