コード例 #1
0
ファイル: Notifier.cpp プロジェクト: anidev/frc-simulator
/**
 * ProcessQueue is called whenever there is a timer interrupt.
 * We need to wake up and process the current top item in the timer queue as long
 * as its scheduled time is after the current time. Then the item is removed or 
 * rescheduled (repetitive events) in the queue.
 */
void Notifier::ProcessQueue(uint32_t mask, void *params)
{
	Notifier *current;
	while (true)				// keep processing past events until no more
	{
		{
			Synchronized sync(queueSemaphore);
			double currentTime = GetClock();
			current = timerQueueHead;
			if (current == NULL || current->m_expirationTime > currentTime)
			{
				break;		// no more timer events to process
			}
			// need to process this entry
			timerQueueHead = current->m_nextEvent;
			if (current->m_periodic)
			{
				// if periodic, requeue the event
				// compute when to put into queue
				current->InsertInQueue(true);
			}
			else
			{
				// not periodic; removed from queue
				current->m_queued = false;
			}
			// Take handler semaphore while holding queue semaphore to make sure
			//  the handler will execute to completion in case we are being deleted.
			semTake(current->m_handlerSemaphore, WAIT_FOREVER);
		}

		current->m_handler(current->m_param);	// call the event handler
		semGive(current->m_handlerSemaphore);
	}
	// reschedule the first item in the queue
	Synchronized sync(queueSemaphore);
	UpdateAlarm();
}
コード例 #2
0
ファイル: MasterAdapter.cpp プロジェクト: DSIHarman/DSI
void MasterAdapter::removePending(Notifier& notifier)
{
   /*
    * removing all jobs from the queue and returning an error.
    * error handling is don in the servicebroker thread
    */
   Job* job = mQueue.pop();
   while( job )
   {
      job->status = EIO;
      notifier.jobFinished(*job);
      job = mQueue.pop();
   }
}
コード例 #3
0
TEST( Notifier, TestOfNotificationChangesStack )
{
	Notifier notifier;
	TestClazz testClazz;

	notifier.addNotification( getNotificationTest1(),
							  Utils::makeCallback( &testClazz, &TestClazz::onDeliverNotification ) );
	notifier.addNotification( getNotificationTest2(),
							  Utils::makeCallback( &testClazz, &TestClazz::onDeliverNotification ) );

	EXPECT_EQ( 0, testClazz.deliveredCount );
	notifier.notify( getNotificationTest1() );
	EXPECT_EQ( 1, testClazz.deliveredCount );

	notifier.removeAllForObject( &testClazz );
	notifier.removeAllForObject( &testClazz );
	notifier.notify( getNotificationTest3(), 0x01 );
}
コード例 #4
0
TEST( Notifier, TestOfNotification )
{
	Notifier notifier;
	TestClazz testClazz;

	notifier.addNotification( getNotificationTest1(),
							  Utils::makeCallback( &testClazz, &TestClazz::onDeliverNotification ) );

	EXPECT_EQ( 0, testClazz.deliveredCount );

	notifier.notify( getNotificationTest1() );

	EXPECT_EQ( 1, testClazz.deliveredCount );

	notifier.notify( getNotificationTest1() );
	notifier.notify( getNotificationTest1() );
	EXPECT_EQ( 3, testClazz.deliveredCount );

	notifier.removeAllForObject( &testClazz );
	notifier.notify( getNotificationTest1() );
	EXPECT_EQ( 3, testClazz.deliveredCount );

	notifier.addNotification( getNotificationTest1(),
							  Utils::makeCallback( &testClazz, &TestClazz::onDeliverNotification ) );
	EXPECT_EQ( 3, testClazz.deliveredCount );

	notifier.notify( getNotificationTest1() );
	EXPECT_EQ( 4, testClazz.deliveredCount );

	notifier.removeNotification( &testClazz, getNotificationTest1() );
	notifier.notify( getNotificationTest1() );
	EXPECT_EQ( 4, testClazz.deliveredCount );


	//////////////////////////////////////////////////////////////////////////////////////

	notifier.addNotification( getNotificationTest1(),
							  Utils::makeCallback( &testClazz, &TestClazz::onDeliverNotification ) );
	notifier.addNotification( getNotificationTest2(),
							  Utils::makeCallback( &testClazz, &TestClazz::onDeliverNotification ) );

	notifier.notify( getNotificationTest1() );

	EXPECT_EQ( 5, testClazz.deliveredCount );

	notifier.notify( getNotificationTest2() );
	EXPECT_EQ( 6, testClazz.deliveredCount );

	notifier.removeNotification( &testClazz, getNotificationTest1() );
	notifier.notify( getNotificationTest1() );
	EXPECT_EQ( 6, testClazz.deliveredCount );

	notifier.notify( getNotificationTest2() );
	EXPECT_EQ( 7, testClazz.deliveredCount );

	notifier.addNotification( getNotificationTest1(),
							  Utils::makeCallback( &testClazz, &TestClazz::onDeliverNotification ) );
	notifier.notify( getNotificationTest1() );

	EXPECT_EQ( 8, testClazz.deliveredCount );

	notifier.removeAllForObject( &testClazz );

	notifier.notify( getNotificationTest1() );
	EXPECT_EQ( 8, testClazz.deliveredCount );
}
コード例 #5
0
	TestClazzReleased( Notifier& notifier ) :
		m_pNotifier( notifier )
	{
		notifier.addNotification( getNotificationTestUseAfterRelease(), Utils::makeCallback( this,
								  &TestClazzReleased::onCall ) );
	}
コード例 #6
0
TEST( Notifier, DISABLED_TestOfNotificationChangesStackDoubleCommands )
{
	Notifier notifier;
	TestClazz testClazz;

	notifier.addNotification( getNotificationTest1(),
							  Utils::makeCallback( &testClazz, &TestClazz::onDeliverNotification ) );
	notifier.addNotification( getNotificationTest2(),
							  Utils::makeCallback( &testClazz, &TestClazz::onDeliverNotification ) );

	EXPECT_EQ( 0, testClazz.deliveredCount );
	notifier.notify( getNotificationTest1() );
	EXPECT_EQ( 1, testClazz.deliveredCount );

	notifier.removeAllForObject( &testClazz );
	notifier.removeAllForObject( &testClazz );

	notifier.addNotification( getNotificationTest1(),
							  Utils::makeCallback( &testClazz, &TestClazz::onDeliverNotification ) );
	notifier.addNotification( getNotificationTest2(),
							  Utils::makeCallback( &testClazz, &TestClazz::onDeliverNotification ) );

	notifier.notify( getNotificationTest3(), 0x01 );

	EXPECT_EQ( 1, testClazz.deliveredCount );
	notifier.notify( getNotificationTest1() );
	EXPECT_EQ( 2, testClazz.deliveredCount );

	notifier.addNotification( getNotificationTest1(),
							  Utils::makeCallback( &testClazz, &TestClazz::onDeliverNotification ) );
	//Now we have double notification
	notifier.notify( getNotificationTest1() );
	EXPECT_EQ( 4, testClazz.deliveredCount );

	notifier.removeNotification( &testClazz, getNotificationTest1() );
	notifier.notify( getNotificationTest1() );
	EXPECT_EQ( 4, testClazz.deliveredCount );
}
コード例 #7
0
ファイル: SelectPoll.cpp プロジェクト: jimmy486/kuma
void SelectPoll::notify()
{
    notifier_.notify();
}
コード例 #8
0
ファイル: test_units.cpp プロジェクト: UIKit0/GLV
int main(){

//	{
//		const std::string mAlign = "xxx,<><,--x";
//		const int mRepeatRow = 1;
//
//		int row = 0;
//		int ibeg=0, iend=0;
//		for(int i=0; i<mAlign.size(); ++i){
//			if(mAlign[i] == ','){
//				++row;
//				
//			}
//		}
//	}

	#define SET4(x, a,b,c,d) x[0]=a; x[1]=b; x[2]=c; x[3]=d
	#define EQ4(x, a,b,c,d) (x[0]==a && x[1]==b && x[2]==c && x[3]==d)

	// Multidimensional data array
	{
	
		// basics
		{
			const int s1=5, s2=4, s3=3, s4=2;
			Data d(Data::INT, s1,s2,s3,s4);

			assert(d.hasData());
			assert(d.type() == Data::INT);
			assert(d.sizeType() == sizeof(int));
			assert(d.isNumerical());
			assert(d.offset() == 0);
			assert(d.order() == 4);
			assert(d.stride() == 1);

			assert(d.size(0) == s1);
			assert(d.size(1) == s2);
			assert(d.size(2) == s3);
			assert(d.size(3) == s4);
			assert(d.size(0,1) == s1*s2);
			assert(d.size(0,1,2) == s1*s2*s3);
			assert(d.size(0,1,2,3) == d.size());
		
			assert(d.indexFlat(0,0,0,0) ==          0);
			assert(d.indexFlat(1,0,0,0) ==          1);
			assert(d.indexFlat(0,1,0,0) ==       s1*1);
			assert(d.indexFlat(0,2,0,0) ==       s1*2);
			assert(d.indexFlat(0,0,1,0) ==    s2*s1*1);
			assert(d.indexFlat(0,0,2,0) ==    s2*s1*2);
			assert(d.indexFlat(0,0,0,1) == s3*s2*s1*1);
			assert(d.indexFlat(0,0,0,2) == s3*s2*s1*2);
			
			for(int i=0; i<d.size(); ++i){
				int i1,i2,i3,i4;
				d.indexDim(i1,i2,i3,i4, i);
				assert(d.inBounds(i1,i2,i3,i4));
				assert(d.indexFlat(i1,i2,i3,i4) == i);
			}
			
			for(int i=0; i<d.size(); ++i) d.assign(i, i);
			for(int i=0; i<d.size(); ++i) assert(d.elem<int>(i) == i);
			
			// resizing
			{
				Data e(Data::INT, 8);
				int N; // resize change, in bytes

				for(int i=0; i<e.size(); ++i) e.assign(i,i);
				
				N=e.resize(16);			assert(e.sizeType()*8==N);
				
				// old elements should be copied over; extras should be zero
				for(int i=0; i<8 ; ++i) assert(e.at<int>(i) == i);
				for(int i=8; i<16; ++i) assert(e.at<int>(i) == 0);

				N=e.resize(0);			assert(e.sizeType()*-16==N);
				N=e.resize(8);			assert(e.sizeType()*  8==N);
				for(int i=0; i<e.size(); ++i) assert(e.at<int>(i) == 0);
			}
			
			// cloning data
			{
				Data e = d;
				assert(e == d);
				
				e.clone();
				assert(d.elems<int>() != e.elems<int>());
				assert(e == d);
			}
			
			// reversed slice
			{				
				Data e = d.reversed();
				for(int i=0; i<e.size(); ++i)
					assert(d.elem<int>(d.size()-1-i) == e.elem<int>(i));

				e.clone();
				for(int i=0; i<e.size(); ++i)
					assert(d.elem<int>(d.size()-1-i) == e.elem<int>(i));
				
				e += d;
				for(int i=0; i<e.size(); ++i)
					assert(e.elem<int>(i) == e.size()-1);
			}
		}


		// reference counting
		{
			Data d1(Data::INT, 4,4);
			assert(Data::references(d1.elems<int>()) == 1);

			{
				Data d2 = d1;
				assert(d1.elems<int>() == d2.elems<int>());
				assert(Data::references(d1.elems<int>()) == 2);
			}
			assert(Data::references(d1.elems<int>()) == 1);

			{
				Data d2 = d1.slice(1);
				Data d3 = d2.slice(1);
				assert(Data::references(d1.elems<int>()) == 3);
			}
			assert(Data::references(d1.elems<int>()) == 1);
		}
		
	
		const float cf = 10;
		float f = 10;
		std::string s = "hello";
		
		Data d(cf);

		assert(d.hasData());
		assert(d.size() == 1);
		assert(d.type() == Data::FLOAT);
		assert(d.at<float>(0) == cf);
		assert(d.toString() == "10");
		assert(d.at<std::string>(0) == "10");
		
//		d.put(std::string("8"));
//		assert(d.at<float>(0) == 8);

		// Getting/setting values
		d.assign(11.f);
		assert(d.at<float>(0) == 11.f);
		
		d.clone();
		assert(d.hasData());
		assert(d.size() == 1);
		assert(d.type() == Data::FLOAT);

		d.assign(11.f);
		assert(d.at<float>(0) == 11.f);

		d.assign(100);
		assert(d.at<float>(0) == 100);
		
		d.set(f);
		assert(d.elems<float>() == &f);
		assert(d.at<float>(0) == f);
		
		d.set(s);
		assert(d.type() == Data::STRING);
		assert(d.size() == 1);
		assert(d.elems<std::string>() == &s);
		assert(d.at<std::string>(0) == s);
		
		d.clone();
		assert(d.elems<std::string>() != &s);
		assert(d.at<std::string>(0) == s);

		d.set("hello");
		assert(d.type() == Data::STRING);
		assert(d.at<std::string>(0) == "hello");

		{
			std::string s = "d2";
			Data d2(s);
			
			d.set("d");
			d2.assign(d);
			assert(d2.at<std::string>(0) == d.at<std::string>(0));
		}
		
		{
			Data a(Data::FLOAT, 3);
			a.assign(10,0);
			a.assign(20,1);
			a.assign(30,2);
			float b[3];
			a.copyTo(b);
			for(int i=0;i<3;++i) assert(b[i] == a.at<float>(i));
		}
		
		// checking elements
		{
			Data::Type types[] = {Data::BOOL, Data::INT, Data::FLOAT, Data::DOUBLE};
			for(int i=0;i<4;++i){
				Data a(types[i], 8);
				a.assignAll(0);
				assert(a.isZero());
				a.assign(1, 1);
				assert(!a.isZero());
				a.assign(1, 3);
				a.assign(1, 5);
				a.assign(1, 7);
				assert(a.slice(0,4,2).isZero());
			}
		}
		
		// searching
		{
			Data e(Data::STRING, 3);
			std::string s1 = "test1", s2 = "test2", s3 = "test3";
			e.assign(s1, 0);
			e.assign(s2, 1);
			e.assign(s3, 2);
			
			assert(e.indexOf(s1) == 0);
			assert(e.indexOf(s2) == 1);
			assert(e.indexOf(s3) == 2);
			assert(e.indexOf(std::string("invalid")) == Data::npos);
		}
		
		// multiple element assignment
		{
			#define ASSERT_EQUALS(a,b,c,d,e)\
				assert(d1.at<int>(0) == a);\
				assert(d1.at<int>(1) == b);\
				assert(d1.at<int>(2) == c);\
				assert(d1.at<int>(3) == d);\
				assert(d1.at<int>(4) == e)

			Data d1(Data::INT, 5);
			d1.assignAll(-1);
			ASSERT_EQUALS(-1,-1,-1,-1,-1);
			
			d1.assignAll(0);
			ASSERT_EQUALS(0,0,0,0,0);
			
			{
				float t[] = {1,2,3,4,5};
				d1.assignFromArray(t,2);
				ASSERT_EQUALS(1,2,0,0,0);
				
				d1.assignFromArray(t+2,2,1,2);
				ASSERT_EQUALS(1,2,3,4,0);
				
				d1.assignAll(0);
				d1.assignFromArray(t,3, 2);
				ASSERT_EQUALS(1,3,5,0,0);
				
				d1.assignFromArray(t+1,2, 2,3);
				ASSERT_EQUALS(1,3,5,2,4);
			}
			#undef ASSERT_EQUALS
		}
	}


	// stringification
	{	//for(int i=0;i<4;++i) printf("%g\n", f4[i]);
		//printf("%s\n", s1.c_str());
		bool b1;
		float f1;
		double d1;
		std::string s1;
		
		bool b4[4];
		float f4[4];
		double d4[4];
		std::string s4[4];
		
		int N;	// number of elements converted

		N=fromToken(f1, "1e-2");		assert(1==N && f1 == float(1e-2));
		N=fromToken(f1, "1000");		assert(1==N && f1 == float(1000));
		N=fromToken(d1, "1e-2");		assert(1==N && d1 == double(1e-2));
		N=fromToken(d1, "1000");		assert(1==N && d1 == double(1000));
		N=fromToken(b1, "0");			assert(1==N && b1 == 0);
		N=fromToken(b1, "1");			assert(1==N && b1 == 1);
		N=fromToken(s1, "\"test\"");	assert(1==N && s1 == "test");
		
		N=fromToken(b4,4,1, "{1,0,1,1}");				assert(4==N && EQ4(b4, 1,0,1,1));
		N=fromToken(b4,4,1, "{0,  1, 0,0}");			assert(4==N && EQ4(b4, 0,1,0,0));
		N=fromToken(f4,4,1, "{1, -1.2, 1e10, +.1}");	assert(4==N && EQ4(f4, 1.f,-1.2f,1e10f,+.1f));
		N=fromToken(d4,4,1, "{1, -1.2, 1e10, +.1}");	assert(4==N && EQ4(d4, 1,-1.2,1e10,+.1));
		N=fromToken(s4,4,1, "{\"one\", \"two\", \"three\", \"four\"}");
														assert(4==N && EQ4(s4, "one","two","three","four"));

		N=toToken(s1, 1000.f);			assert(1==N && s1 == "1000");
		N=toToken(s1, 2000.0);			assert(1==N && s1 == "2000");
		N=toToken(s1, true);			assert(1==N && s1 == "1");
		N=toToken(s1, false);			assert(1==N && s1 == "0");
		N=toToken(s1, "test");			assert(1==N && s1 == "\"test\"");
		N=toToken(s1, std::string("test"));
										assert(1==N && s1 == "\"test\"");		

		SET4(b4, 1,0,1,1);		N=toToken(s1, b4,4,1);	assert(4==N && s1 == "{1, 0, 1, 1}");
		SET4(f4,-1,0.1,3,1e10);	N=toToken(s1, f4,4,1);	assert(4==N && s1 == "{-1, 0.1, 3, 1e+10}");
		SET4(d4,-1,0.1,3,1e10);	N=toToken(s1, d4,4,1);	assert(4==N && s1 == "{-1, 0.1, 3, 1e+10}");
		SET4(s4,"one","two","three","four"); N=toToken(s1,s4,4,1);
														assert(4==N && s1 == "{\"one\", \"two\", \"three\", \"four\"}");
	}


	// test View linked list implementation
	{
		View n00, n10, n11, n20;

		n00.add(n10);
		n00.add(n11);
		n10.add(n20);
		
		// check all of our links
		assert( n00.child == &n10);
		assert(!n00.parent);
		assert(!n00.sibling);
		assert( n10.parent == &n00);
		assert( n10.sibling == &n11);
		assert( n10.child == &n20);
		assert( n11.parent == &n00);
		assert(!n11.child);
		assert(!n11.sibling);
		assert( n20.parent == &n10);
		assert(!n20.child);
		assert(!n20.sibling);
		
		n10.makeLastSibling();
		assert(!n10.sibling);
		assert(n11.sibling == &n10);
		n11.makeLastSibling();

		n10.remove();
		assert(!n10.parent);
		assert(!n10.sibling);
		assert(!n00.child->sibling);
		
		n11.remove();
		assert(!n00.child);

		assert(n10.child == &n20);
	}

	
	// test View memory management
	{
		View * v0d = new View;
		View v1s;
		View * v1d = new View;
		
		assert(v0d->dynamicAlloc());
		assert(!v1s.dynamicAlloc());

		*v0d << v1s << v1d;
		
		delete v0d;
	}



	// Notifications	
	{
		bool bv1=false, bv2=false, bf=false;
		Notifier n;
	
		assert(n.numObservers(Update::Value) == 0);

		n.attach(ntSetBool1, Update::Value, &bv1);
		n.attach(ntSetBool2, Update::Value, &bv2);
		n.attach(ntSetBool1, Update::Focus, &bf);

		assert(n.numObservers(Update::Value) == 2);
		assert(n.numObservers(Update::Focus) == 1);

		n.notify(Update::Value);
		assert(bv1);
		assert(bv2);
		assert(!bf);

		n.notify(Update::Focus);
		assert(bf);
		
		bv1=bv2=false;
		n.detach(ntSetBool1, Update::Value, &bv1);
		n.notify(Update::Value);
		assert(!bv1);
		assert(bv2);

		bv1=bv2=false;
		n.detach(ntSetBool2, Update::Value, &bv2);
		n.notify(Update::Value);
		assert(!bv1);
		assert(!bv2);
	}
	
	{
		bool b=false;
		Button w;
		w.attach(ntValue, Update::Value, &b);
		w.setValue(true);
		assert(b);
		assert(w.getValue() == true);

// Setting to current value should NOT send notification to avoid infinite loops
		b=false;
		w.setValue(w.getValue());
		assert(!b);

// Boolean model variable
		bool v = false;
		w.attachVariable(v);
		w.setValue(true);		assert(v == true);
		w.setValue(false);		assert(v == false);
		
		v = true;
		w.onDataModelSync();		assert(w.getValue() == true);

		w.setValue(true);

		assert(w.data().toToken() == "1");
		w.setValue(false);
		assert(w.data().toToken() == "0");
		w.setDataFromString("0");	assert(w.getValue() == false);
		w.setDataFromString("1");	assert(w.getValue() == true);

		assert(!w.setDataFromString("invalid"));
	}

	{
		Buttons w;
		bool b=false;
		w.attach(ntValue, Update::Value, &b);
		w.setValue(true, 0);
		assert(b);
		assert(w.getValue(0) == true);
		
		w.data().resize(2,2);
		w.data().assignAll(0);

		bool v1 = false;
		bool v2 = false;
		w.attachVariable(v1, 0);
		w.attachVariable(v2, 2);

		w.setValue(true, 0);		assert(v1 == true);
		w.setValue(true, 2);		assert(v2 == true);
		w.setValue(false, 0);		assert(v1 == false);
		w.setValue(false, 2);		assert(v2 == false);

		w.setValue(false, 0);
		w.setValue(false, 1);
		w.setValue(false, 2);
		w.setValue(false, 3);
		assert(w.data().toToken() == "{0, 0, 0, 0}");
		
		v1 = v2 = false;
		w.setDataFromString("{1,1,1,1}");
		assert(w.getValue(0) && w.getValue(1) && w.getValue(2) && w.getValue(3));
		assert(v1 && v2);
	}

	{
		bool b=false;
		Slider w;
		w.attach(ntValue, Update::Value, &b);
		w.setValue(0.99f);
		assert(b);
		assert(w.getValue() == 0.99f);

// Setting to current value should NOT send notification to avoid infinite loops
		b=false;
		w.setValue(w.getValue());
		assert(!b);

		float v;
		w.attachVariable(v);
		w.setValue(0.99);
		assert(v == 0.99f);
		
		v = 0;
		w.onDataModelSync();
		assert(w.getValue() == 0);

		std::string s;
		w.setValue(0.25);
		assert(w.data().toToken() == "0.25");
		w.setDataFromString("0.5");	assert(w.getValue() == 0.5);
									assert(v == 0.5);

		assert(!w.setDataFromString("invalid"));
		assert(w.getValue() == 0.5);
	}

	{
		bool b=false;
		Sliders w(Rect(1), 2,2);
		w.attach(ntValue, Update::Value, &b);
		w.setValue(0.99f, 3);
		assert(b);
		assert(w.getValue(3) == 0.99f);

		float v1, v2;
		w.attachVariable(v1, 0);
		w.attachVariable(v2, 1);

		w.setValue(0.1f, 0); assert(v1 == 0.1f);
		w.setValue(0.2f, 0); assert(v1 == 0.2f);
		
		v1 = 0.8f; v2 = 0.9f;
		w.onDataModelSync();
		assert(w.getValue(0) == 0.8f);
		assert(w.getValue(1) == 0.9f);

		w.setValue(0.1f, 0);
		w.setValue(0.2f, 1);
		w.setValue(0.3f, 2);
		w.setValue(0.4f, 3);
		assert(w.data().toToken() == "{0.1, 0.2, 0.3, 0.4}");
		
		v1=v2=0;
		w.setDataFromString("{0.4,0.3,0.2,0.1}");
		assert(w.getValue(0) == 0.4);
		assert(w.getValue(1) == 0.3);
		assert(w.getValue(2) == 0.2);
		assert(w.getValue(3) == 0.1);
		assert(v1 == (float)w.getValue(0) && v2 == (float)w.getValue(1));
		
//		double vs[4] = {0.11, 0.22, 0.33, 0.44};
//		w.attachVariable(vs,4);
//		w.onDataModelSync();
//		for(int i=0; i<4; ++i) printf("%f\n", w.values()[i]);
//		
//		w.getValue(0.44, 0);
//		w.getValue(0.33, 0);
//		w.getValue(0.22, 0);
//		w.getValue(0.11, 0);
//		for(int i=0; i<4; ++i) printf("%f\n", vs[i]);
	}

	{
		bool b=false;
		Slider2D w;
		w.attach(ntSetBool1, Update::Value, &b);
		w.setValue(0.01f, 0);
		assert(b);
		assert(w.getValue(0) == 0.01f);

// Setting to current value should NOT send notification to avoid infinite loops
		b=false;
		w.setValue(0.01f, 0);
		assert(!b);
		
		b=false;
		w.setValue(0.00f, 0);
		w.setValue(0.01f, 1);
		assert(b);
		assert(w.getValue(1) == 0.01f);
		
		b=false;
		w.setValueMax();
		assert(b);
		assert(w.getValue(0) == 1.f);
		assert(w.getValue(1) == 1.f);
		
		float v1, v2;
		w.attachVariable(v1, 0);
		w.attachVariable(v2, 1);
		
		w.setValue(0.5f, 0);	assert(v1 == 0.5f);
		w.setValue(0.6f, 1);	assert(v2 == 0.6f);
		
		v1 = 0.1;
		v2 = 0.2;
		
		w.onDataModelSync();
		assert(w.getValue(0) == v1);
		assert(w.getValue(1) == v2);
	
		w.setValue(0.2, 0);
		w.setValue(0.3, 1);
		assert(w.data().toToken() == "{0.2, 0.3}");
		
		v1 = v2 = 0;
		w.setDataFromString("{0.7, 0.8}");
		assert(w.getValue(0)==0.7 && w.getValue(1)==0.8);
		assert(v1==(float)w.getValue(0) && v2==(float)w.getValue(1));
	}

	{
		bool b=false;
		SliderGrid<4> w;
		w.attach(ntValue, Update::Value, &b);
		w.setValue(0.01f, 0);
		assert(b);
		assert(w.getValue(0) == 0.01f);

		float v1, v2;
		w.attachVariable(v1, 0);
		w.attachVariable(v2, 1);

		w.setValue(0.1f, 0); assert(v1 == 0.1f);
		w.setValue(0.2f, 0); assert(v1 == 0.2f);
		
		v1 = 0.8f; v2 = 0.9f;
		w.onDataModelSync();
		assert(w.getValue(0) == 0.8f);
		assert(w.getValue(1) == 0.9f);

		w.setValue(0.1f, 0);
		w.setValue(0.2f, 1);
		w.setValue(0.3f, 2);
		w.setValue(0.4f, 3);
		assert(w.data().toToken() == "{0.1, 0.2, 0.3, 0.4}");
		
		v1=v2=0;
		w.setDataFromString("{0.4,0.3,0.2,0.1}");
		assert(w.getValue(0) == 0.4);
		assert(w.getValue(1) == 0.3);
		assert(w.getValue(2) == 0.2);
		assert(w.getValue(3) == 0.1);
		assert(v1 == (float)w.getValue(0) && v2 == (float)w.getValue(1));
	}
	
	{
		bool b=false;
		SliderRange w;
		w.attach(ntValue, Update::Value, &b);
		w.setValue(0.01f, 0);
		w.setValue(0.02f, 1);
		assert(b);
		assert(w.getValue(0) == 0.01f);
		assert(w.getValue(1) == 0.02f);
		assert(w.center() == 0.015f);
		assert(w.range() == 0.01f);
		
		w.endpoints(0,1);
		assert(w.getValue(0) == 0);
		assert(w.getValue(1) == 1);
		
		w.centerRange(0.5, 0.25);
		assert(w.getValue(0) == (0.5-0.25/2));
		assert(w.getValue(1) == (0.5+0.25/2));

		float v1,v2;
		w.attachVariable(v1, 0);
		w.attachVariable(v2, 1);

		w.setValue(0.2, 0);
		w.setValue(0.3, 1);
		assert(w.data().toToken() == "{0.2, 0.3}");
		
		v1 = v2 = 0;
		w.setDataFromString("{0.7, 0.8}");
		assert(w.getValue(0)==0.7 && w.getValue(1)==0.8);
		assert(v1==(float)w.getValue(0) && v2==(float)w.getValue(1));
	}

	{
		bool b=false;
		Label w;

		w.attach(ntValue, Update::Value, &b);
		w.setValue("test");
		assert(b);
		assert(w.getValue() == "test");
		
		assert(w.data().toToken() == "\"test\"");
		
		w.setValue("");
		w.setDataFromString("\"test\"");	assert(w.getValue() == "test");
	}

	{

//		{
//			double val = 1e14;
//			double inc = 1;
//			printf("%f\n", val + inc*1);
//			printf("%f\n", val + inc*2);
//			printf("%f\n", val + inc*3);
//			printf("%f\n", val + inc*4);
//		}

		bool b=false;
		NumberDialer w(1,2,1,0);
		w.attach(ntValue, Update::Value, &b);
		w.setValue(0.75);
		assert(b);
		assert(w.getValue() == 0.75);

// Setting to current value should NOT send notification to avoid infinite loops
		b=false;
		w.setValue(w.getValue());
		assert(!b);

		double v=0;
		w.attachVariable(v);
		w.setValue(0.5);	assert(v == 0.5);
		
		v = 0.25;
		w.onDataModelSync();
		assert(w.getValue() == v);

		w.setValue(0.2);
		assert(w.data().toToken() == "0.2");
		
		v = 0;
		w.setDataFromString("0.8");
		assert(w.getValue()==0.8 && w.getValue()==v);
	}

	{
		bool b=false;
		TextView w;
		w.attach(ntValue, Update::Value, &b);
		w.setValue("hello");
		assert(b);
		assert(w.getValue() == "hello");
		
		assert(w.data().toToken() == "\"hello\"");

		std::string v = "test";
		w.attachVariable(v);
		
		w.onDataModelSync();
		assert(w.getValue() == "test");

		w.setDataFromString("\"world\"");
		assert(w.getValue() == "world");
		assert(v == "world");
	}



	// model to string conversion
	{
		Label l;
		TextView tv;
		Button b;
		Buttons bs(Rect(), 2, 2);
		Slider s;
		Sliders ss(Rect(), 1, 4);
		Slider2D s2D;
		NumberDialer nd(1,4,1,-1);
		std::string strings[] = {"test1", "test2", "test3"};
	
		l.setValue("Hello Label!").name("l");
		tv.setValue("Hello TextView!").name("tv");
		b.setValue(true).name("b");
		bs.setValue(true, 0,1).name("bs");
		s.setValue(0.5).name("s");
		ss.setValue(0.4, 1).name("ss");
		s2D.setValue(0.5, 0).setValue(0.1, 1).name("s2D");
		nd.setValue(-0.54941).name("nd");

		const View * views[] = {&l, &tv, &b, &bs, &s, &ss, &s2D, &nd};
		for(unsigned i=0; i<sizeof(views)/sizeof(View *); ++i){
			//const Data& d = views[i]->data();
			//printf("%p: %s\n", &d, d.toString().c_str());
			//views[i]->model().print(); printf("\n");
		}

		View top;
		top << l << tv << b << bs << s << ss << s2D << nd;
	
		std::string str1, str2;
//		top.modelToString(str1, "test model");		
//		printf("%s\n", str1.c_str());
//
//		l.setValue("changed...");
//		top.modelFromString(str1);
//		top.modelToString(str2);
//		printf("%s\n", str2.c_str());
//		assert(str1 == str2);

		ModelManager mm;
		
		mm.add("l", l);
		mm.add("tv", tv);
		mm.add("b", b);
		mm.add("bs", bs);
		mm.add("s" , s);
		mm.add("ss", ss);
		mm.add("s2D",s2D);
		mm.add("nd", nd);
		
		Data dat(strings, 3);
		//Data dat(10);
		//dat.print();
		//mm.add("strings", dat);
		//mm.add("strings", *new Data(strings, 3));
		
//		mm.toToken(str1, "test");
//		printf("%s\n", str1.c_str());
//		
//		mm.fromToken(str1);
//		mm.toToken(str2, "test");
//		printf("%s\n", str2.c_str());

		std::string snapshotString1 =
"[\"test 1\"] = {\n\
	l = \"Label 1\",\n\
	tv = \"TextView 1\",\n\
	b = 0,\n\
	bs = {0,0,0,0},\n\
}";

		std::string snapshotString2 =
"[\"test 2\"] = {\n\
	l = \"Label 2\",\n\
	tv = \"TextView 2\",\n\
	b = 1,\n\
	bs = {1,1,1,1},\n\
	s = 1,\n\
	ss = {1,1,1,1},\n\
	s2D = {1,1},\n\
	nd = 1,\n\
}";
		
		mm.snapshotsFromString("{" + snapshotString1 + ",\r\n" + snapshotString2 + "}");

//		mm.snapshots()["test 1"]["l"].print();
//		mm.snapshots()["test 1"]["b"].print();
//		mm.snapshots()["test 1"]["bs"].print();
//		mm.snapshots()["test 1"]["s"].print();
//		mm.snapshots()["test 1"]["ss"].print();
//		mm.snapshots()["test 1"]["s2D"].print();
//		mm.snapshots()["test 1"]["nd"].print();
//		mm.snapshots()["test 2"]["l"].print();
//		mm.snapshots()["test 2"]["b"].print();
//		mm.snapshots()["test 2"]["bs"].print();
//		mm.snapshots()["test 2"]["s"].print();
//		mm.snapshots()["test 2"]["ss"].print();
//		mm.snapshots()["test 2"]["s2D"].print();
//		mm.snapshots()["test 2"]["nd"].print();
//
//		mm.snapshotsToFile("snapshots.txt");
//		
//		mm.clearSnapshots();
//		mm.snapshotsFromFile("snapshots.txt");
//
//		str1.clear();
//		mm.snapshotsToString(str1);
//		printf("%s\n", str1.c_str());
	}

//	{
//		std::string str( "a bc ab ca ab" );
//		std::string searchString("ab"); 
//		std::string replaceString("hello");
//
//		std::string::size_type pos = 0;
//		while((pos = str.find(searchString, pos)) != std::string::npos){
//			str.replace(pos++, searchString.size(), replaceString);
//		}
//		printf("%s\n", str.c_str());
//	}

//	printf("sizeof(Notifier): %d\n", sizeof(Notifier));
//	printf("sizeof(View): %d\n", sizeof(View));
//	printf("sizeof(Data): %d\n", sizeof(Data));
//	printf("sizeof(Model): %d\n", sizeof(Model));
//	printf("sizeof(ModelManager): %d\n", sizeof(ModelManager));

	return 0;
}
コード例 #9
0
ファイル: MasterAdapter.cpp プロジェクト: DSIHarman/DSI
bool MasterAdapter::execute(Job& job, Notifier& notifier)
{
   bool rc = mConnector->execute(job);
   notifier.jobFinished(job);
   return rc;
}
コード例 #10
0
ファイル: bdtlearner.cpp プロジェクト: mamday/pybdt-tools
boost::shared_ptr<Model>
BDTLearner::train_given_everything (
    const vector<Event>& all_sig_events, const vector<Event>& all_bg_events,
    const vector<double>& init_sig_weights,
    const vector<double>& init_bg_weights) const
{
    typedef vector<Event> vecev;
    typedef vector<double> vecd;
    typedef vecev::const_iterator vecev_citer;
    typedef vecd::const_iterator vecd_citer;
    typedef vecd::iterator vecd_iter;
    using namespace np;

    int n_sig (all_sig_events.size ());
    int n_bg (all_bg_events.size ());
    int N_f (all_sig_events[0].size ());
    vector<double> all_sig_weights (
        div (init_sig_weights, sum (init_sig_weights)));
    vector<double> all_bg_weights (
        div (init_bg_weights, sum (init_bg_weights)));

    // Warning: technically, this usage of dtl.min_split is not threadsafe
    DTLearner& dtl (*m_dtlearner);
//TODO: Add to Booster Class

    RegLearner& rdtl (static_cast<RegLearner&>(*m_dtlearner));
    rdtl.separation_type("sum_squared");
    std::cout<<rdtl.separation_type()<<std::endl;
    int save_min_split (m_dtlearner->m_min_split);
    dtl.min_split (max (
        dtl.min_split (),
        static_cast<int> (1.0 * (n_sig + n_bg) / N_f / N_f / 20)));

    vector<boost::shared_ptr<DTModel> > dtmodels;
    vector<double> errs;
    vector<double> alphas;
//TODO: Overload function to take map
    std::map<const DTNode*,double> alpha_j;
    Notifier<int> notifier ("training decision trees", m_num_trees);
    if (not m_quiet) {
        notifier.update (0);
    }

//Get median of classifier value. TODO:Add to booster class
    double f_mmone = -9999;
    double quant_val = 0.7;
    std::map<const DTNode*,double> f_x;

//    if(n_sig>n_bg){
//      f_mmone = 1;
//    }
//    else if(n_bg>n_sig){
//      f_mmone = -1;
//    }
//    else{
//      f_mmone = 0;
//    }
    Booster gradBoost(true,n_sig,n_bg);
    //gradBoost.InitFX(n_sig,n_bg);
//Iterate over requested number of trees
    for (int m = 0; m < m_num_trees; ++m) {
        const int n_sig_used = static_cast<int>((m_frac_random_events * n_sig));
        const int n_bg_used = static_cast<int> ((m_frac_random_events * n_bg));
        const int n_sig_unused = (n_sig - n_sig_used);
        const int n_bg_unused = (n_bg - n_bg_used);
        // storage for picked events, if not using all events
        vector<Event> picked_sig_events;
        vector<double> picked_sig_weights;
        vector<Event> picked_bg_events;
        vector<double> picked_bg_weights;
        const vector<Event>* sig_events;
        const vector<double>* sig_weights;
        const vector<Event>* bg_events;
        const vector<double>* bg_weights;
        // if desired, pick events
        if (n_sig_unused > 0 or n_bg_unused > 0) {
            const vector<int> sig_indices (
                dtl.m_random_sampler.sample_range<int> (
                    n_sig_used, 0, n_sig, true));
            picked_sig_events =
                np::subscript (all_sig_events, sig_indices);
            picked_sig_weights =
                np::subscript (all_sig_weights, sig_indices);
            const vector<int> bg_indices (
                dtl.m_random_sampler.sample_range<int> (
                    n_bg_used, 0, n_bg, true));
            picked_bg_events =
                np::subscript (all_bg_events, bg_indices);
            picked_bg_weights =
                np::subscript (all_bg_weights, bg_indices);
            sig_events = &picked_sig_events;
            sig_weights = &picked_sig_weights;
            bg_events = &picked_bg_events;
            bg_weights = &picked_bg_weights;
        }
        else {
            sig_events = &all_sig_events;
            sig_weights = &all_sig_weights;
            bg_events = &all_bg_events;
            bg_weights = &all_bg_weights;
        }

        boost::shared_ptr<Model> model (
            dtl.train_given_everything (
                *sig_events, *bg_events, *sig_weights, *bg_weights));
        boost::shared_ptr<DTModel> dtmodel (
            dynamic_pointer_cast<DTModel> (model));
        dtmodels.push_back (dtmodel);
        // TODO: if there are unused events, set purity from unused?

        std::cout<<" Melanie was here "<<std::endl;
//Iterate over nodes and get coefficient for each
        boost::shared_ptr<DTNode> dtNode = dtmodel->root(); 
        dtnresmap resMap;
        vecd_iter my_w;
        vecev_citer my_ev;
        vecpdd resPairs;
//Get residuals for delta TODO: Make this a function
        for(my_ev = sig_events->begin(),
            my_w = all_sig_weights.begin();
            my_ev != sig_events->end(); ++my_ev, ++my_w) {
          const DTNode& eLeaf (dtNode->trace(make_scoreable(*my_ev)));
          const DTNode* pLeaf = &eLeaf;
          double leaf_res = 1;
          double f_xi;
          f_x.find(pLeaf)!=f_x.end() ? f_xi = f_x[pLeaf] : f_xi = gradBoost.f_mmone;
          std::cout<<"First f_x: "<<f_xi<<" "<<gradBoost.f_mmone<<" "<<pLeaf<<std::endl;
          resPairs.push_back(make_pair(leaf_res-f_xi,*my_w)); 
        }
        for(my_ev = bg_events->begin(),
            my_w = all_bg_weights.begin();
            my_ev != bg_events->end(); ++my_ev, ++my_w) {
          const DTNode& eLeaf (dtNode->trace(make_scoreable(*my_ev)));
          const DTNode* pLeaf = &eLeaf;
          double leaf_res = -1;
          double f_xi;
          f_x.find(pLeaf)!=f_x.end() ? f_xi = f_x[pLeaf] : f_xi = gradBoost.f_mmone;
          std::cout<<"First f_x: "<<f_xi<<" "<<gradBoost.f_mmone<<" "<<pLeaf<<std::endl;
          resPairs.push_back(make_pair(leaf_res-f_xi,*my_w)); 
        }
//Update delta
        double delta = GetQuantile(resPairs,quant_val,true,2);
//Get residuals for signal TODO:Make this a function
        for(my_ev = sig_events->begin(),
            my_w = all_sig_weights.begin();
            my_ev != sig_events->end(); ++my_ev, ++my_w) {
          const DTNode& eLeaf (dtNode->trace(make_scoreable(*my_ev)));
          const DTNode* pLeaf = &eLeaf;
          double leaf_res = 1;
          double sign_leaf_res = boost::math::sign(leaf_res);
          resMap[pLeaf].weightSum+=*my_w;
          resMap[pLeaf].resPair.push_back(make_pair(sign_leaf_res*min(fabs(leaf_res-delta),delta),*my_w));
        }
//Get residuals for background TODO:Make this a function 
        for(my_ev = bg_events->begin(),
            my_w = all_bg_weights.begin();
            my_ev != bg_events->end(); ++my_ev, ++my_w) {
          const DTNode& eLeaf (dtNode->trace(make_scoreable(*my_ev)));
          const DTNode* pLeaf = &eLeaf;
          double leaf_res = -1;
          double sign_leaf_res = boost::math::sign(leaf_res);
          resMap[pLeaf].weightSum+=*my_w;
          resMap[pLeaf].resPair.push_back(make_pair(sign_leaf_res*min(fabs(leaf_res-delta),delta),*my_w));
        }
//TODO: Make this a function
        for(dtnresmap_citer n_map = resMap.begin();
            n_map != resMap.end(); ++n_map){
//TODO: Add this to Booster Class
//Residual and Weight pair
          vecpdd nPair = n_map->second.resPair; 
          double r_bar = GetQuantile(nPair,0.5,true,n_map->second.weightSum);
          double tot_gamma = 0;
          double gamma_j = 0;
//Calculate gammas for each node TODO: Make this a function
          for(vecpdd_iter pair_i = nPair.begin();
              pair_i != nPair.end(); pair_i++){
//Node residual variables
            double res_i = pair_i->first; 
            double meddiff_i = res_i-r_bar;
            double sign_meddiff_i = boost::math::sign(meddiff_i); 
            double min_i = std::min(delta,meddiff_i);
            double gsum_i = sign_meddiff_i*min_i;
            gamma_j += gsum_i;
//       std::cout<<(1/(sig_size+bg_size))<<" "<<((sig_size*sig_gamma)+(bg_size*bg_gamma))<<" "<<delta<<" "<<sig_res<<" "<<r_bar<<" "<<sig_meddiff<<" "<<sig_sign_meddiff<<" "<<sig_min<<" "<<sig_gamma<<" "<<bg_gamma<<" "<<tot_gamma<<std::endl;
          }//End vecpdd loop
//Get map of node weights
          alpha_j[n_map->first] = r_bar + (1/nPair.size())*gamma_j;
          f_x[n_map->first] += alpha_j[n_map->first];
          std::cout<<"Delta: "<<delta<<" F(x): "<<f_x[n_map->first]<<" Point: "<<n_map->first<<std::endl;
        }//End dtnresmap loop 

        // before pruners get to prune before boosting
        for (vector<boost::shared_ptr<Pruner> >::const_iterator i_pruner
             = m_before_pruners.begin (); i_pruner != m_before_pruners.end ();
             ++i_pruner) {
            (*i_pruner)->prune (dtmodel);
        }

        // get scores for boosting
        const vector<double> all_sig_result (
            dtmodel->score (all_sig_events, false, true));
        const vector<double> all_bg_result (
            dtmodel->score (all_bg_events, false, true));

        // AdaBoost: find sum of weights for misclass'd events
        vecev_citer i_ev;
        vecd_iter i_weight;
        vecd_citer i_result;
        double sum_sig_weights (0);
        double sum_wrong_sig_weights (0);
        for (i_weight = all_sig_weights.begin (),
             i_result = all_sig_result.begin();
             i_weight != all_sig_weights.end (); ++i_weight, ++i_result) {
            sum_sig_weights += *i_weight;
            if (*i_result < 0) {
                sum_wrong_sig_weights += *i_weight;
            }
        }
        double sum_bg_weights (0);
        double sum_wrong_bg_weights (0);
        for (i_weight = all_bg_weights.begin (),
             i_result = all_bg_result.begin();
             i_weight != all_bg_weights.end (); ++i_weight, ++i_result) {
            sum_bg_weights += *i_weight;
            if (*i_result > 0) {
                sum_wrong_bg_weights += *i_weight;
            }
        }
        // AdaBoost: boost weights of misclass'd events
        const double err_m ((sum_wrong_sig_weights + sum_wrong_bg_weights)
                            / (sum_sig_weights + sum_bg_weights));
        const double boost_factor = pow ((1-err_m)/err_m, m_beta);
        const double alpha_m = m_beta ? log (boost_factor) : 1;
        for (i_weight = all_sig_weights.begin (),
             i_result = all_sig_result.begin(),
             i_ev = all_sig_events.begin ();
             i_weight != all_sig_weights.end ();
             ++i_weight, ++i_result, ++i_ev) {
            if (*i_result < 0) {
                *i_weight *= boost_factor;
            }
        }
        for (i_weight = all_bg_weights.begin (),
             i_result = all_bg_result.begin(),
             i_ev = all_bg_events.begin ();
             i_weight != all_bg_weights.end ();
             ++i_weight, ++i_result, ++i_ev) {
            if (*i_result > 0) {
                *i_weight *= boost_factor;
            }
        }
        errs.push_back (err_m);
        alphas.push_back (alpha_m);
        // Renormalize weights
        const double new_total_weight (
            sum (all_sig_weights) + sum (all_bg_weights));
        all_sig_weights = div (all_sig_weights, new_total_weight);
        all_bg_weights = div (all_bg_weights, new_total_weight);

        // after pruners get to prune after boosting
        for (vector<boost::shared_ptr<Pruner> >::const_iterator i_pruner
             = m_after_pruners.begin (); i_pruner != m_after_pruners.end ();
             ++i_pruner) {
            (*i_pruner)->prune (dtmodel);
        }
        if (not m_quiet) {
            notifier.update (m + 1);
        }
    }
    if (not m_quiet) {
        notifier.finish ();
    }
    dtl.min_split (save_min_split);
    return boost::make_shared<BDTModel> (m_feature_names, dtmodels, alphas);
}
コード例 #11
0
ファイル: EPoll.cpp プロジェクト: zhaowolong/kuma
void EPoll::notify()
{
    notifier_.notify();
}
コード例 #12
0
ファイル: coolfluid-solver.cpp プロジェクト: Peita/coolfluid3
int main(int argc, char ** argv)
{
  LogForwarder * forwarder;
  Notifier * notifier;
  Communicator parent_comm;
  int rank;

  // initiate the CF core and MPI environment
  Core::instance().initiate(argc, argv);
  Comm::instance().init(argc, argv);

  parent_comm = Comm::instance().get_parent();
  rank = Comm::instance().rank();

  if( parent_comm == MPI_COMM_NULL )
  {
    CFerror << "This solver cannot run without a manager. Exiting..." << CFendl;
    return 1;
  }

  setup_tree();

  // create the PE manager
  Handle< Manager > mgr = Core::instance().root().get_child("Tools")->
      create_component<Manager>("PEManager");

  Core::instance().root().create_component<CWorker>("Worker");

  // Make sure the python ScriptEngine gets created, if it exists
  try
  {
    build_component("cf3.python.ScriptEngine", "DummyScriptEngine");
  }
  catch(...)
  {
  }

  mgr->mark_basic();

  notifier = new Notifier( mgr );

  notifier->listen_to_event("tree_updated", true);

  // set the forwarder, if needed
  //  if( forward == "all" || (forward == "rank0" && Comm::instance().rank() == 0) )
    {
      forwarder = new LogForwarder();
      Logger::instance().getStream(INFO).addStringForwarder(forwarder);
    }

  bool rank0 = CFinfo.getFilterRankZero(LogStream::SCREEN);

  CFinfo.setFilterRankZero(LogStream::SCREEN, false);

  CFinfo << "Worker[" << rank << "] -> Syncing with the parent..." << CFendl;
  Comm::instance().barrier();
  MPI_Barrier( parent_comm );
  CFinfo << "Worker[" << rank << "] -> Synced with the parent!" << CFendl;

  CFinfo.setFilterRankZero(LogStream::SCREEN, rank0);

  mgr->listening_thread()->join();

  CFinfo << "Worker[" << rank << "] -> " << "C U..." << CFendl;

  // synchronize with the parent before we finalize the MPI environment
  MPI_Barrier( parent_comm );

  // terminate the CF core and MPI environment
  Comm::instance().finalize();
  Core::instance().terminate();

  delete forwarder;
  delete notifier;

  return 0;
}
コード例 #13
0
ファイル: mango.cpp プロジェクト: tritania/Mango
void MangoListener::onFrame(const Controller& controller) {
  const Frame frame = controller.frame();
    HandList hands = frame.hands();
    int extendedFingers = 0;
    for (HandList::const_iterator hl = hands.begin(); hl != hands.end(); ++hl) {
        const Hand hand = *hl;
        for (int i = 0; i < hand.fingers().count(); i++)
        {
            Finger finger = hand.fingers()[i];
            if(finger.isExtended()) extendedFingers++;
        }

        if (!onGesture && !frame.hands().isEmpty() && frame.hands().count() == 1 && extendedFingers == 0)
        {
            preGestureCounter++;
            std::cout << preGestureCounter << std::endl;
            if (preGestureCounter > MAX_PREGESTURE && frameCount == 0)
            {
                onGesture = true;
                preGestureCounter = 0;
                frameCount++;
                note.show();
            }
        }
        else if (preGestureCounter > 0)
        {
            preGestureCounter--;
        }
    }
        if (onGesture && frameCount < MAX_FRAMECOUNT) {

            switch (extendedFingers)
            {
                case 1:
                {
                    std::string command = commands.getCommand("FING3");
                    std::cout << command << std::endl;
                    break;
                }
                case 2:
                {
                    break;
                }
                case 3:
                {
                    break;
                }
                default:
                {
                    break;
                }
            }

            frameCount++;
            const GestureList gestures = frame.gestures();
            for (int g = 0; g < gestures.count(); ++g) {
                Gesture gesture = gestures[g]; //need to move finger detection in here too
                switch (gesture.type()) {
                    case Gesture::TYPE_CIRCLE:
                    {
                        CircleGesture circle = gesture;
                        std::string clockwiseness; //probably simplfy to a bool

                        if (circle.pointable().direction().angleTo(circle.normal()) <= PI/4)
                        {
                          clockwiseness = "clockwise";
                          std::cout << "CIRCLE CLOCKWISE" << std::endl;
                        }
                        else
                        {
                          clockwiseness = "counterclockwise";
                          std::cout << "CIRCLE COUNTERCLOCKWISE" << std::endl;
                        }
                        break;
                    }
                    case Gesture::TYPE_SWIPE:
                    {
                        SwipeGesture swipe = gesture;
                        std::cout << "SWIPE" << std::endl;
                        break;
                    }
                    case Gesture::TYPE_KEY_TAP:
                    {
                        KeyTapGesture tap = gesture;
                        std::cout << "KEY TAP" << std::endl;
                        break;
                    }
                    case Gesture::TYPE_SCREEN_TAP:
                    {
                        ScreenTapGesture screentap = gesture;
                        std::cout << "SCREEN TAP" << std::endl;
                        break;
                    }
                    default:
                    {
                        std::cout << std::string(2, ' ')  << "Unknown gesture type." << std::endl;
                        break;
                    }
                }
                float seconds = gesture.durationSeconds();
                std::cout << seconds << std::endl;
            }
        }
        else if (onGesture == true && frameCount > MAX_FRAMECOUNT)
        {
            note.hide();
            onGesture = false;
            frameCount = 0;
        }
        else if (onGesture)
        {
            frameCount++;
        }
}