void DisruptorFixture::ensureTwoEventsProcessedAccordingToDependencies(const std::shared_ptr< CountdownEvent >& countDownLatch,
const std::initializer_list< std::shared_ptr< DelayedEventHandler > >& dependencies)
{
publishEvent();
publishEvent();
for (auto&& dependency : dependencies)
{
assertThatCountDownLatchEquals(countDownLatch, 2L);
dependency->processEvent();
dependency->processEvent();
}
assertThatCountDownLatchIsZero(countDownLatch);
}
bool LoginPanel::init()
{
if(!Layer::init())return false;
CHILD_CLICK_CALLBACK
{
IF_CHILD_TOUCH_ENDED
{
if(ref == loginBtn)
{
if(isRemeberPassword)
{
LOCAL_SAVE->setStringForKey(PLAYER_NAME, nameTf->getStringValue());
LOCAL_SAVE->setStringForKey(PLAYER_PASSWORD, passwordTf->getStringValue());
CCLOG("save name is %s",nameTf->getStringValue().c_str());
CCLOG("save password is %s",passwordTf->getStringValue().c_str());
}
publishEvent(LOGIN_GAME);
}
}
};
//this->setAnchorPoint(cocos2d::Point(0.0f,0.0f));
new LoginMediator(this);
//loading::PreLoader::getInstance()->loadLoginPanel([this](){initPanel();});
initPanel();
return true;
}
void* trafficLightDetectedEvent(void* args)
{
char* detectedString;
void* eventValue;
msg_t* event = _createDefaultEventMsg();
event->id = EVENT_TRAFFICLIGHT_DETECTION;
event->numOfParm = 1;
switch(*(int*)args)
{
case TRAFFICLIGHT_GREEN:
detectedString = "GREEN";
break;
case TRAFFICLIGHT_RED:
detectedString = "RED";
break;
case TRAFFICLIGHT_NONE:
detectedString = "NONE";
break;
default:
detectedString = "ERROR";
break;
}
eventValue = malloc(strlen(detectedString) + 1);
memcpy(eventValue, detectedString, strlen(detectedString) + 1);
event->values = eventValue;
publishEvent(event);
return NULL;
}
int main(int argc, char *argv[])
{
int useCerts = 0;
if ( argc < 6 ){
printf("Sample expects minimum of 5 args.\n");
usage();
}
else{
useCerts = argv[5][0] - '0';
if ( useCerts && argc != 9){
printf("Sample expects extactly 9 args when useCerts = %d.\n",useCerts);
usage();
}
else
{
int rc = -1;
//catch interrupt signal
signal(SIGINT, sigHandler);
signal(SIGTERM, sigHandler);
iotfclient client;
if(!useCerts)
rc = initialize(&client,argv[1],"internetofthings.ibmcloud.com",argv[2],
argv[3],"token",argv[4],NULL,useCerts,NULL,NULL,NULL,0);
else
rc = initialize(&client,argv[1],"internetofthings.ibmcloud.com",argv[2],
argv[3],"token",argv[4],NULL,useCerts,argv[6],argv[7],argv[8],0);
if(rc != SUCCESS){
printf("Initialize returned rc = %d.\n Quitting..\n", rc);
return 0;
}
rc = connectiotf(&client);
if(rc != SUCCESS){
printf("Connection returned rc = %d.\n Quitting..\n", rc);
return 0;
}
printf("Connection Successful. Press Ctrl+C to quit\n");
char *data = "{\"d\" : {\"x\" : 26 }}";
while(!interrupt)
{
printf("Publishing the event stat with rc ");
rc= publishEvent(&client,"status","json", data , QOS0);
printf(" %d\n", rc);
sleep(2);
}
printf("Quitting!!\n");
disconnect(&client);
return 0;
}
}
}
void* driveFinishedEvent(void* args)
{
msg_t* event = _createDefaultEventMsg();
event->id = EVENT_DRIVE_FINISHED;
publishEvent(event);
return NULL;
}
void* liftGotoEvent(void* args)
{
void* eventValue;
msg_t* event = _createDefaultEventMsg();
event->id = EVENT_LIFT_GOTO;
event->numOfParm = 1;
eventValue = malloc(strlen((char*)args) + 1);
memcpy(eventValue, args, strlen((char*)args) + 1);
event->values = eventValue;
publishEvent(event);
return NULL;
}
void* tagReadEvent(void* args)
{
void* eventValue;
msg_t* event = _createDefaultEventMsg();
event->id = EVENT_TAG_DETECTION;
event->numOfParm = 1;
eventValue = malloc(strlen((char*)args) + 1);
memcpy(eventValue, args, strlen((char*)args) + 1);
event->values = eventValue;
publishEvent(event);
return NULL;
}
void* getDriveDistance(void* args)
{
void* eventValue;
msg_t* event = _createDefaultEventMsg();
int wheelL, wheelR;
int wheelAverage;
wheelAverage = getWheelPosition(&wheelL, &wheelR);
event->id = EVENT_TRAVEL_DISTANCE;
event->numOfParm = 1;
eventValue = malloc(sizeof(int));
memcpy(eventValue, (void*)&wheelAverage, sizeof(int));
event->values = eventValue;
publishEvent(event);
return NULL;
}
//-----------------------------------------------------------------------------
void
RTSupplier::disconnect()
{
ACS_TRACE("RTSupplier::~RTSupplier");
//Delete the thread manager
if(threadManager_mp != 0)
{
threadManager_mp->stop("worker");
delete threadManager_mp;
threadManager_mp=0;
}
//Now we rush through and publish any events still left in the queue
//must use a mutex for any STL write operation
eventQueueMutex_m.acquire();
while(unpublishedEvents_m.empty() != true)
{
try
{
//publish the event.
publishEvent(unpublishedEvents_m.front().event);
//remove the last event
unpublishedEvents_m.pop();
}
catch(...)
{
ACS_SHORT_LOG((LM_ERROR,
"RTSupplier::disconnect() %s channel - problem publishing a saved event!",
channelName_mp));
}
}
//do NOT release mutex to ensure events can no longer be published
//eventQueueMutex_m.release();
//just call superclass disconnect
Supplier::disconnect();
}
void* getLiftHeight(void* args)
{
void* eventValue;
msg_t* event;
float liftHeight;
if(LiftGetHeight(&liftHeight) == 0)
{
event = _createDefaultEventMsg();
event->id = EVENT_LIFT_HEIGHT;
event->numOfParm = 1;
eventValue = malloc(sizeof(float));
memcpy(eventValue, (void*)&liftHeight, sizeof(float));
event->values = eventValue;
publishEvent(event);
}
return NULL;
}
int publishEvent_dm(char *eventType, char *eventFormat, unsigned char* data, enum QoS qos)
{
int rc = -1;
rc = publishEvent(&dmClient.deviceClient, eventType, eventFormat, data, qos);
return rc;
}
void set_state(simpleState s){
state = s;
publishEvent(TestEvent());
}
//-----------------------------------------------------------------------------
void
Supplier::publishEvent(const CORBA::Any &eventData)
{
populateHeader(eventData);
publishEvent(event_m);
}
