GraphNodePtrNN makeNewTree2(void)
{
GraphNodePtrNN node1=makeNewNode();
return makeNewNode( node1,
makeNewNode(
makeNewNode( makeNewLeaf(), node1 ), node1 ) );
}
struct ListNode* addTwoNumbers(struct ListNode* l1,struct ListNode* l2)
{
listNode* t1 = l1;
listNode* t2 = l2;
listNode* result = makeNewNode();
listNode* p = 0;
int c = 0;
while (t1 != NULL || t2 != NULL || c != 0)
{
if (p == 0) {
p = result;
}
else {
p->next = (listNode*)malloc(sizeof(listNode));
p->next->val = 0;
p = p->next;
}
int a = t1 != NULL ? t1->val : NULL;
int b = t2 != NULL ? t2->val : NULL;
int s = (a + b + c) % 10;
c = (a + b + c) / 10;
p->val = s;
p->next = 0;
t1 = t1->next == NULL ? NULL : t1->next;
t2 = t2->next == NULL ? NULL : t2->next;
}
return result;
};
void testObj::test<4>(void)
{
GraphNodePtrNN node=makeNewNode( makeNewLeaf( makeNewAlert(), 10u ), makeNewLeaf( makeNewAlert(), 20u ), 666u );
vector<path> files;
files.push_back("idmef_10.xml");
files.push_back("idmef_20.xml");
ensureValid(node, files);
}
void testObj::test<2>(void)
{
Strategy s(InstanceName("myfiletrigger"), cfg_);
Strategy::ChangedNodes nc;
const time_t start=time(NULL);
s.process( makeNewNode(), nc );
const time_t stop =time(NULL);
testFileInRange(".", start, stop);
}
void testObj::test<4>(void)
{
// this test main part has to fit in <1[s] window - retru 5 times
// if it does not happen
for(int i=0; i<5; ++i)
{
Strategy s(InstanceName("myfiletrigger"), cfg_);
Strategy::ChangedNodes nc;
// wait until seconds just changed - to make event as probable as possible
// (yes - this is busy loop...)
{
time_t start=time(NULL);
while( start==time(NULL) )
{
}
}
// no make double write
const time_t start=time(NULL);
s.process( makeNewNode(), nc );
s.process( makeNewNode(), nc );
const time_t stop =time(NULL);
// if second elapsed there is nothing that can be done
if(start!=stop)
continue;
// check for output files
ensure("first output file does not exist", testFile(".", start, 0)==0 );
ensure("second output file does not exist", testFile(".", start, 1)==0 );
// ok - if we're here, test succeeded.
return;
}
// 5 fails means FAIL...
fail("this test's main part has to fit in <1[s] time window and failed "
"to do so 5 times. looks like your machine is to slow to perform "
"this test - aborting");
}
void testObj::test<3>(void)
{
const char *out="TEST_OUT_DIR";
if( mkdir(out, 0755)!=0 )
ensure("unable to create output dir", errno==EEXIST);
const Config cfg(out, cfg_.getThresholdConfig() );
Strategy s(InstanceName("myfiletrigger"), cfg);
Strategy::ChangedNodes nc;
const time_t start=time(NULL);
s.process( makeNewNode(), nc );
const time_t stop =time(NULL);
testFileInRange(out, start, stop);
}
//adds new nodes to new list
void makeSets(linkedList oldList, linkedList newList, int minFrequ)
{
Node<T>* temp1;
Node<T>* temp2;
Node<T>* newListTemp = newList.mHead;
temp2 = oldList.mHead;
while(temp2->mNext != NULL)
{
temp1 = temp2;
temp2 = temp2->mNext;
if(isSame(temp1, temp2))
if(newList.mHead == NULL)
newList.mHead = makeNewNode(temp1, temp2);
else
{
newListTemp = newListTemp->mNext;
newListTemp = makeNewNode(temp1, temp2);
}
}
}
// Adds a new empty node following the given node and returns a pointer to it
NODE* appendNewNode(NODE *node) {
NODE *new_node = makeNewNode();
if (node == NULL) {
// We're starting a new cycle, make this node self-referential
new_node->previous = new_node;
new_node->next = new_node;
} else {
// Add the new node into the given cycle
new_node->previous = node;
new_node->next = node->next;
node->next->previous = new_node;
node->next = new_node;
}
return new_node;
}
void BMEsplitEdge(meTree *T, meNode *v, meEdge *e, double **A)
{
meEdge *newPendantEdge;
meEdge *newInternalEdge;
meNode *newNode;
char nodeLabel[NODE_LABEL_LENGTH];
char edgeLabel1[EDGE_LABEL_LENGTH];
char edgeLabel2[EDGE_LABEL_LENGTH];
sprintf(nodeLabel,"I%d",T->size+1);
sprintf(edgeLabel1,"E%d",T->size);
sprintf(edgeLabel2,"E%d",T->size+1);
/*make the new meNode and edges*/
newNode = makeNewNode(nodeLabel,T->size+1);
newPendantEdge = makeEdge(edgeLabel1,newNode,v,0.0);
newInternalEdge = makeEdge(edgeLabel2,newNode,e->head,0.0);
/*update the matrix of average distances*/
BMEupdateAveragesMatrix(A,e,v,newNode);
/*put them in the correct topology*/
newNode->parentEdge = e;
e->head->parentEdge = newInternalEdge;
v->parentEdge = newPendantEdge;
e->head = newNode;
T->size = T->size + 2;
if (e->tail->leftEdge == e)
/*actually this is totally arbitrary and probably unnecessary*/
{
newNode->leftEdge = newInternalEdge;
newNode->rightEdge = newPendantEdge;
}
else
{
newNode->leftEdge = newInternalEdge;
newNode->rightEdge = newPendantEdge;
}
}
void appendLocation (List l, LocationID location) {
assert(l != NULL); // Ensure list is valid
// Make a new node with the location
NodePointer newNode = makeNewNode(location);
if (l->first == NULL) {
// List is empty
// make first and last the new node
l->first = newNode;
l->last = newNode;
} else {
// List is not empty
// update last, after adding new node
l->last->next = newNode;
l->last = l->last->next;
}
// Increment number of elements in list
l->numElements++;
}
int main(void)
{
listNode* l13 = makeNewNode(3, NULL);
listNode* l12 = makeNewNode(4, l13);
listNode* l1 = makeNewNode(2, l12);
listNode* l23 = makeNewNode(4, NULL);
listNode* l22 = makeNewNode(6, l23);
listNode* l2 = makeNewNode(5, l22);
listNode* output = addTwoNumbers(l1, l2);
listNode* p = output;
while (p->next != 0)
{
printf("%d->", p->val);
p = p->next;
}
printf("%d\n",p->val);
while (output->next != 0)
{
p = output;
output = output->next;
free(p);
}
return 0;
}
//--------------------------------------------------------------
void camApp::update(){
updateAppInfo();
if( title.state == NODE_ACTIVE && title.introAllDone() ){
title.setState(NODE_DEACTIVATING);
state = CAM_APP_NORMAL;
durationSameDirection = 0.0;
}
if( title.state != NODE_INACTIVE ){
titleUpdate();
}
if( howTo.state != NODE_INACTIVE ){
if( howTo.timeActive < 1.0 ){
magRotZStartHowTo = mag.angleZ;
}
howTo.update();
if( fabs( ofAngleDifferenceDegrees(magRotZStartHowTo, mag.angleZ) ) > 120 ){
howTo.playMovie();
}
}
if( state == CAM_APP_TITLE && title.holdPerson() ){
//camMan.setTargetPosX(currentNode->pos.x);
camMan.setTargetPosY(title.pos.y);
}else{
riseFallUpdate();
camShiftAmntY = ofLerp(camShiftAmntY, ofMap(riseFallPct, 0, 1, -(float)ofGetHeight() * 0.175, (float)ofGetHeight() * 0.175, true), 0.03);
if( state == CAM_APP_NORMAL ){
float endGraphicOffset = 210.0;
percentOver = ofMap( fabs(myPerson.pos.y - (endGraphic.pos.y+endGraphicOffset) ), 1000, endGraphicOffset*0.5, 0.0, 1.0, true);
if( percentOver >= 0.7 ){
float pct = ofMap(percentOver, 0.7, 1.0, 0.0, 1.0, true);
float ipct = 1.0-pct;
myPerson.vel *= 0.7 + 0.3*ipct;
myPerson.pos.x = ofLerp(myPerson.pos.x, endGraphic.pos.x, 0.01 + pct * 0.02);
myPerson.pos.y = ofLerp(myPerson.pos.y, endGraphic.pos.y+endGraphicOffset, 0.01 + pct * 0.02);
camMan.setTargetPosY(endGraphic.pos.y * pct + (myPerson.pos.y+camShiftAmntY) * ipct);
}else{
camMan.setTargetPosY(myPerson.pos.y+camShiftAmntY);
}
}
if( howTo.pct > 0.2 ){
camMan.setTargetPosY(howToStorePos.y);
}
if( makeNewNode( ofGetHeight() ) ){
if( state == CAM_APP_NORMAL && howTo.state == NODE_INACTIVE && ofGetElapsedTimef() - nodeCreatedTime > 1.2 ){
if( myPerson.vel.y > 0.2 ){
nextNode(true);
}else if( myPerson.vel.y < -0.2 ){
nextNode(false);
}
nodeCreatedTime = ofGetElapsedTimef();
}
}
if( state == CAM_APP_NORMAL && nodes.size() > 0 ){
nodes.erase(nodes.begin(), partition(nodes.begin(), nodes.end(), killNodesAndDelete));
}
}
if( state == CAM_APP_HOWTO ){
limitPersonMovement(howToStorePos, -ofGetWidth()/2, ofGetWidth()/2, -(float)ofGetHeight()*0.4, (float)ofGetHeight()*0.4);
}
soundMan.update(riseFallPct);
handleRiseFall();
camMan.update(0.1, 0.04);
world.camPos = camMan.getPosition();
world.camRot = camMan.getRotation();
camPos = world.camPos;
if( state != CAM_APP_TITLE && !( state == CAM_APP_HOWTO && howTo.state == NODE_ACTIVE ) ){
for(int i = 0; i < nodes.size(); i++){
nodes[i]->update();
}
}
sceneGraph.clearElements();
sceneGraph.addElement(&myPerson);
sceneGraph.addElement(&weather);
if( title.state != NODE_INACTIVE ){
sceneGraph.addElement(&title);
}
for(int i = 0; i < nodes.size(); i++){
sceneGraph.addElement(nodes[i]);
}
//MANUAL NODEs
weather.update();
hand.update();
}
GraphNodePtrNN makeNewTree1(void)
{
return makeNewNode( makeNewNode(),
makeNewNode(
makeNewNode(), makeNewLeaf() ) );
}
