void DDSEntityManager::deleteFilteredTopic()
{
status = participant->delete_contentfilteredtopic(filteredTopic);
checkStatus(status, "DDS.DomainParticipant.delete_topic");
}
bool load(CFURLRef url) {
OSStatus status;
memset(&aqData,0,sizeof(aqData));
timeBase = 0;
status = AudioFileOpenURL(url,kAudioFileReadPermission,0,&aqData.mAudioFile);
checkStatus(status);
if( status != noErr ) return false;
UInt32 dataFormatSize = sizeof (aqData.mDataFormat); // 1
status = AudioFileGetProperty ( // 2
aqData.mAudioFile, // 3
kAudioFilePropertyDataFormat, // 4
&dataFormatSize, // 5
&aqData.mDataFormat // 6
);
checkStatus(status);
status = AudioQueueNewOutput ( // 1
&aqData.mDataFormat, // 2
HandleOutputBuffer, // 3
&aqData, // 4
CFRunLoopGetCurrent (), // 5
kCFRunLoopCommonModes, // 6
0, // 7
&aqData.mQueue // 8
);
checkStatus(status);
UInt32 maxPacketSize;
UInt32 propertySize = sizeof (maxPacketSize);
status = AudioFileGetProperty ( // 1
aqData.mAudioFile, // 2
kAudioFilePropertyPacketSizeUpperBound, // 3
&propertySize, // 4
&maxPacketSize // 5
);
checkStatus(status);
deriveBufferSize ( // 6
aqData.mDataFormat, // 7
maxPacketSize, // 8
0.5, // 9
&aqData.bufferByteSize, // 10
&aqData.mNumPacketsToRead // 11
);
bool isFormatVBR = ( // 1
aqData.mDataFormat.mBytesPerPacket == 0 ||
aqData.mDataFormat.mFramesPerPacket == 0
);
if (isFormatVBR) { // 2
aqData.mPacketDescs =
(AudioStreamPacketDescription*) malloc (
aqData.mNumPacketsToRead * sizeof (AudioStreamPacketDescription)
);
} else { // 3
aqData.mPacketDescs = NULL;
}
UInt32 cookieSize = sizeof (UInt32); // 1
OSStatus couldNotGetProperty = // 2
AudioFileGetPropertyInfo ( // 3
aqData.mAudioFile, // 4
kAudioFilePropertyMagicCookieData, // 5
&cookieSize, // 6
NULL // 7
);
// checkStatus(couldNotGetProperty);
if (!couldNotGetProperty && cookieSize) { // 8
char* magicCookie =
(char *) malloc (cookieSize);
status = AudioFileGetProperty ( // 9
aqData.mAudioFile, // 10
kAudioFilePropertyMagicCookieData, // 11
&cookieSize, // 12
magicCookie // 13
);
checkStatus(status);
status = AudioQueueSetProperty ( // 14
aqData.mQueue, // 15
kAudioQueueProperty_MagicCookie, // 16
magicCookie, // 17
cookieSize // 18
);
checkStatus(status);
free (magicCookie); // 19
}
return true;
}
bool WebGLFramebuffer::onAccess(GraphicsContext3D* context3d, const char** reason)
{
if (checkStatus(reason) != GraphicsContext3D::FRAMEBUFFER_COMPLETE)
return false;
return true;
}
void IteratorImpl::seek(const LevelDBSlice& target)
{
m_iterator->Seek(makeSlice(target));
checkStatus();
}
void IteratorImpl::prev()
{
ASSERT(isValid());
m_iterator->Prev();
checkStatus();
}
void DDSEntityManager::deleteReader(DDS::DataReader_ptr dataReader)
{
status = subscriber->delete_datareader(dataReader);
checkStatus(status, "DDS::Subscriber::delete_datareader ");
}
void DDSEntityManager::deleteTopic()
{
status = participant->delete_topic(topic);
checkStatus(status, "DDS.DomainParticipant.delete_topic");
}
void deleteContainedEntities()
{
// Recursively delete all entities in the DomainParticipant.
g_status = DDS_DomainParticipant_delete_contained_entities(g_domainParticipant);
checkStatus(g_status, "DDS_DomainParticipant_delete_contained_entities");
}
void deleteParticipant()
{
g_status = DDS_DomainParticipantFactory_delete_participant(g_domainParticipantFactory, g_domainParticipant);
checkStatus(g_status, "DDS_DomainParticipantFactory_delete_participant");
}
void deleteSubscriber(DDS_Subscriber subscriber)
{
g_status = DDS_DomainParticipant_delete_subscriber(g_domainParticipant, subscriber);
checkStatus(g_status, "DDS_DomainParticipant_delete_subscriber");
}
void deleteDataReader(DDS_Subscriber subscriber, DDS_DataReader dataReader)
{
g_status = DDS_Subscriber_delete_datareader(subscriber, dataReader);
checkStatus(g_status, "DDS_Subscriber_delete_datareader");
}
void ofFbo::setup(Settings _settings) {
checkGLSupport();
destroy();
if(_settings.width == 0) _settings.width = ofGetWidth();
if(_settings.height == 0) _settings.height = ofGetHeight();
settings = _settings;
// create main fbo
// this is the main one we bind for drawing into
// all the renderbuffers are attached to this (whether MSAA is enabled or not)
glGenFramebuffers(1, &fbo);
retainFB(fbo);
bind();
// If we want both a depth AND a stencil buffer tehn combine them into a single buffer
#ifndef TARGET_OPENGLES
if( settings.useDepth && settings.useStencil )
{
stencilBuffer = depthBuffer = createAndAttachRenderbuffer(GL_DEPTH_STENCIL, GL_DEPTH_STENCIL_ATTACHMENT);
retainRB(depthBuffer);
retainRB(stencilBuffer);
}else
#endif
{
// if we want a depth buffer, create it, and attach to our main fbo
if(settings.useDepth){
depthBuffer = createAndAttachRenderbuffer(GL_DEPTH_COMPONENT, GL_DEPTH_ATTACHMENT);
retainRB(depthBuffer);
}
// if we want a stencil buffer, create it, and attach to our main fbo
if(settings.useStencil){
stencilBuffer = createAndAttachRenderbuffer(GL_STENCIL_INDEX, GL_STENCIL_ATTACHMENT);
retainRB(stencilBuffer);
}
}
// if we want MSAA, create a new fbo for textures
#ifndef TARGET_OPENGLES
if(settings.numSamples){
glGenFramebuffers(1, &fboTextures);
retainFB(fboTextures);
}else{
fboTextures = fbo;
}
#else
fboTextures = fbo;
if(settings.numSamples){
ofLog(OF_LOG_WARNING,"ofFbo: multisampling not supported in opengles");
}
#endif
// now create all textures and color buffers
for(int i=0; i<settings.numColorbuffers; i++) createAndAttachTexture(i);
// if textures are attached to a different fbo (e.g. if using MSAA) check it's status
if(fbo != fboTextures) {
glBindFramebuffer(GL_FRAMEBUFFER, fboTextures);
}
// check everything is ok with this fbo
checkStatus();
// unbind it
unbind();
}
int OSPL_MAIN (int argc, char *argv[])
{
DDS_Subscriber QueryConditionDataSubscriber;
DDS_DataReader QueryConditionDataDataReader;
StockMarket_Stock* QueryConditionDataSample;
DDS_sequence_StockMarket_Stock* msgList = DDS_sequence_StockMarket_Stock__alloc();
DDS_SampleInfoSeq* infoSeq = DDS_SampleInfoSeq__alloc();
c_bool isClosed = FALSE;
unsigned long j;
DDS_char* QueryConditionDataToSubscribe;
DDS_char *query_string = "ticker=%0";
DDS_QueryCondition queryCondition;
os_time delay_200ms = { 0, 200000000 };
int count = 0;
// usage : QueryConditionSubscriber <topic's content filtering string>
if( argc < 2 )
{
usage();
}
printf("\n\n Starting QueryConditionSubscriber...");
printf("\n\n Parameter is \"%s\"", argv[1]);
QueryConditionDataToSubscribe = argv[1];
createParticipant("QueryCondition example");
// Register Stock Topic's type in the DDS Domain.
g_StockTypeSupport = (DDS_TypeSupport) StockMarket_StockTypeSupport__alloc();
checkHandle(g_StockTypeSupport, "StockMarket_StockTypeSupport__alloc");
registerStockType(g_StockTypeSupport);
// Create Stock Topic in the DDS Domain.
g_StockTypeName = StockMarket_StockTypeSupport_get_type_name(g_StockTypeSupport);
g_StockTopic = createTopic("StockTrackerExclusive", g_StockTypeName);
DDS_free(g_StockTypeName);
DDS_free(g_StockTypeSupport);
// Create the Subscriber's in the DDS Domain.
QueryConditionDataSubscriber = createSubscriber();
// Request a Reader from the the Subscriber.
QueryConditionDataDataReader = createDataReader(QueryConditionDataSubscriber, g_StockTopic);
// Create QueryCondition
printf( "\n=== [QueryConditionSubscriber] Query : ticker = %s\n", QueryConditionDataToSubscribe );
queryCondition = createQueryCondition(QueryConditionDataDataReader, query_string, (DDS_char*) QueryConditionDataToSubscribe);
printf( "\n=== [QueryConditionSubscriber] Ready..." );
do
{
g_status = StockMarket_StockDataReader_take_w_condition(QueryConditionDataDataReader,
msgList,
infoSeq,
DDS_LENGTH_UNLIMITED,
queryCondition);
checkStatus(g_status, "StockMarket_StockDataReaderView_take");
if( msgList->_length > 0 )
{
j = 0;
do
{
QueryConditionDataSample = &msgList->_buffer[j];
// When is this supposed to happen?
// Needs comment...
if( infoSeq->_buffer[j].valid_data )
{
printf("\n\n %s: %f", QueryConditionDataSample->ticker, QueryConditionDataSample->price);
if( QueryConditionDataSample->price == (DDS_float) -1.0f )
{
printf("\n ===[QueryConditionSubscriber] QueryConditionDataSample->price == -1.0f ");
isClosed = TRUE;
}
}
}
while( ++j < msgList->_length );
g_status = StockMarket_StockDataReader_return_loan(QueryConditionDataDataReader, msgList, infoSeq);
checkStatus(g_status, "StockMarket_StockDataReaderView_return_loan");
}
os_nanoSleep(delay_200ms);
++count;
}
while( isClosed == FALSE && count < 1500 );
printf("\n\n=== [QueryConditionSubscriber] Market Closed");
// Cleanup DDS from the created Entities.
deleteQueryCondition(QueryConditionDataDataReader, queryCondition);
deleteDataReader(QueryConditionDataSubscriber, QueryConditionDataDataReader);
deleteSubscriber(QueryConditionDataSubscriber);
deleteTopic(g_StockTopic);
deleteParticipant();
// Cleanup C allocations,
// recursively freeing the allocated structures and sequences using the OpenSplice API.
DDS_free(msgList);
DDS_free(infoSeq);
// Print out an empty line, just to let behind a clean new line for the shell..
printf("\n\r");
return 0;
}
void DDSEntityManager::deletePublisher()
{
status = participant->delete_publisher(publisher);
checkStatus(status, "DDS::DomainParticipant::delete_publisher");
}
void ofFbo::allocate(Settings _settings) {
if(!checkGLSupport()) return;
destroy();
if(_settings.width == 0) _settings.width = ofGetWidth();
if(_settings.height == 0) _settings.height = ofGetHeight();
if(_settings.numSamples > maxSamples()) {
ofLogWarning() << "clamping numSamples (" << _settings.numSamples << ") to maxSamples (" << maxSamples() << ")";
_settings.numSamples = maxSamples();
}
settings = _settings;
// create main fbo
// this is the main one we bind for drawing into
// all the renderbuffers are attached to this (whether MSAA is enabled or not)
glGenFramebuffers(1, &fbo);
retainFB(fbo);
bind();
if(settings.depthStencilAsTexture && settings.numSamples){
ofLogWarning() << "multisampling not supported with depth as texture, setting 0 samples";
settings.numSamples = 0;
}
//currently depth only works if stencil is enabled.
// http://forum.openframeworks.cc/index.php/topic,6837.0.html
#ifdef TARGET_OPENGLES
if(settings.useDepth){
settings.useStencil = true;
}
if( settings.depthStencilAsTexture ){
settings.depthStencilAsTexture = false;
ofLogWarning() << "ofFbo::Settings depthStencilAsTexture is not available for iOS" << endl;
}
#endif
GLenum depthAttachment;
GLint depthPixelType;
GLint depthFormat;
if( settings.useDepth && settings.useStencil ){
depthFormat = GL_DEPTH_STENCIL;
settings.depthStencilInternalFormat = GL_DEPTH_STENCIL;
depthPixelType = GL_UNSIGNED_INT_24_8;
#ifdef TARGET_OPENGLES
depthAttachment = GL_DEPTH_ATTACHMENT;
#else
depthAttachment = GL_DEPTH_STENCIL_ATTACHMENT;
#endif
}else if(settings.useDepth){
depthPixelType = GL_UNSIGNED_SHORT;
if(settings.depthStencilInternalFormat==GL_DEPTH_COMPONENT16){
depthPixelType = GL_UNSIGNED_SHORT;
}else if(settings.depthStencilInternalFormat==GL_DEPTH_COMPONENT24){
depthPixelType = GL_UNSIGNED_INT;
}
#ifdef GL_DEPTH_COMPONENT32
else if(settings.depthStencilInternalFormat==GL_DEPTH_COMPONENT32){
depthPixelType = GL_UNSIGNED_INT;
}
#endif
depthAttachment = GL_DEPTH_ATTACHMENT;
depthFormat = GL_DEPTH_COMPONENT;
}else if(settings.useStencil){
depthAttachment = GL_STENCIL_ATTACHMENT;
settings.depthStencilInternalFormat = GL_STENCIL_INDEX;
depthFormat = GL_STENCIL_INDEX;
depthPixelType = GL_UNSIGNED_BYTE;
}
//- USE REGULAR RENDER BUFFER
if(!settings.depthStencilAsTexture){
if(settings.useDepth && settings.useStencil){
stencilBuffer = depthBuffer = createAndAttachRenderbuffer(settings.depthStencilInternalFormat, depthAttachment);
retainRB(stencilBuffer);
retainRB(depthBuffer);
}else if(settings.useDepth){
depthBuffer = createAndAttachRenderbuffer(settings.depthStencilInternalFormat, depthAttachment);
retainRB(depthBuffer);
}else if(settings.useStencil){
stencilBuffer = createAndAttachRenderbuffer(settings.depthStencilInternalFormat, depthAttachment);
retainRB(stencilBuffer);
}
//- INSTEAD USE TEXTURE
}else{
if(settings.useDepth || settings.useStencil){
createAndAttachDepthStencilTexture(settings.textureTarget,settings.depthStencilInternalFormat,depthFormat,depthPixelType,depthAttachment);
#ifdef TARGET_OPENGLES
// if there's depth and stencil the texture should be attached as
// depth and stencil attachments
// http://www.khronos.org/registry/gles/extensions/OES/OES_packed_depth_stencil.txt
if(settings.useDepth && settings.useStencil){
glFramebufferTexture2D(GL_FRAMEBUFFER,
GL_STENCIL_ATTACHMENT,
GL_TEXTURE_2D, depthBufferTex.texData.textureID, 0);
}
#endif
}
}
// if we want MSAA, create a new fbo for textures
#ifndef TARGET_OPENGLES
if(settings.numSamples){
glGenFramebuffers(1, &fboTextures);
retainFB(fboTextures);
}else{
fboTextures = fbo;
}
#else
fboTextures = fbo;
if(settings.numSamples){
ofLog(OF_LOG_WARNING,"ofFbo: multisampling not supported in opengles");
}
#endif
// now create all textures and color buffers
for(int i=0; i<settings.numColorbuffers; i++) createAndAttachTexture(i);
// if textures are attached to a different fbo (e.g. if using MSAA) check it's status
if(fbo != fboTextures) {
glBindFramebuffer(GL_FRAMEBUFFER, fboTextures);
}
// check everything is ok with this fbo
checkStatus();
// unbind it
unbind();
bIsAllocated = true;
}
void deleteTopic(DDS_Topic topic)
{
g_status = DDS_DomainParticipant_delete_topic(g_domainParticipant, topic);
checkStatus(g_status, "DDS_DomainParticipant_delete_topic");
}
void DDSEntityManager::deleteWriter(DDS::DataWriter_ptr dataWriter)
{
status = publisher->delete_datawriter(dataWriter);
checkStatus(status, "DDS::Publisher::delete_datawriter ");
}
int main(int argc, char *argv[])
{
DDS_sequence_HelloWorldData_Msg* message_seq = DDS_sequence_HelloWorldData_Msg__alloc();
DDS_SampleInfoSeq* message_infoSeq = DDS_SampleInfoSeq__alloc();
DDS_Subscriber message_Subscriber;
DDS_DataReader message_DataReader;
c_bool isClosed = FALSE;
int count = 0;
os_time os_delay200 = { 0, 200000000 };
// Create DDS DomainParticipant
createParticipant("HelloWorld example");
// Register the Topic's type in the DDS Domain.
g_MessageTypeSupport = HelloWorldData_MsgTypeSupport__alloc();
checkHandle(g_MessageTypeSupport, "HelloWorldData_MsgTypeSupport__alloc");
registerMessageType(g_MessageTypeSupport);
// Create the Topic's in the DDS Domain.
g_MessageTypeName = (char*) HelloWorldData_MsgTypeSupport_get_type_name(g_MessageTypeSupport);
g_MessageTopic = createTopic("HelloWorldData_Msg", g_MessageTypeName);
DDS_free(g_MessageTypeName);
DDS_free(g_MessageTypeSupport);
// Create the Subscriber's in the DDS Domain.
message_Subscriber = createSubscriber("HelloWorld");
// Request a Reader from the the Subscriber.
message_DataReader = createDataReader(message_Subscriber, g_MessageTopic);
printf("\n=== [Subscriber] Ready ...");
do
{
g_status = HelloWorldData_MsgDataReader_take(
message_DataReader,
message_seq,
message_infoSeq,
1,
DDS_ANY_SAMPLE_STATE,
DDS_ANY_VIEW_STATE,
DDS_ANY_INSTANCE_STATE );
checkStatus(g_status, "HelloWorldData_MsgDataReader_take");
if( message_seq->_length > 0 && message_infoSeq->_buffer[0].valid_data )
{
isClosed = TRUE;
printf("\n=== [Subscriber] message received :" );
printf( "\n userID : %d", message_seq->_buffer[0].userID );
printf( "\n Message : \"%s\"\n", message_seq->_buffer[0].message );
HelloWorldData_MsgDataReader_return_loan (message_DataReader, message_seq, message_infoSeq);
}
if(isClosed == FALSE)
{
os_nanoSleep(os_delay200);
++count;
}
}
while( isClosed == FALSE && count < 1500 );
os_nanoSleep(os_delay200);
// Cleanup DDS from the created Entities.
deleteDataReader(message_Subscriber, message_DataReader);
deleteSubscriber(message_Subscriber);
deleteTopic(g_MessageTopic);
deleteParticipant();
// Cleanup C allocations
// Recursively free the instances sequence using the OpenSplice API.
DDS_free(message_seq);
DDS_free(message_infoSeq);
return 0;
}
void DDSEntityManager::registerType(TypeSupport *ts)
{
typeName = ts->get_type_name();
status = ts->register_type(participant.in(), typeName);
checkStatus(status, "register_type");
}
//--------------------------------------------------------------
void ofFbo::allocate(Settings _settings) {
if(!checkGLSupport()) return;
clear();
auto renderer = _settings.renderer.lock();
if(renderer){
settings.renderer = renderer;
}else{
settings.renderer = ofGetGLRenderer();
}
// check that passed values are correct
if(_settings.width <= 0 || _settings.height <= 0){
ofLogError("ofFbo") << "width and height have to be more than 0";
}
if(_settings.numSamples > maxSamples() && maxSamples() > -1) {
ofLogWarning("ofFbo") << "allocate(): clamping numSamples " << _settings.numSamples << " to maxSamples " << maxSamples() << " for frame buffer object" << fbo;
_settings.numSamples = maxSamples();
}
if(_settings.depthStencilAsTexture && _settings.numSamples){
ofLogWarning("ofFbo") << "allocate(): multisampling not supported with depthStencilAsTexture, setting 0 samples for frame buffer object " << fbo;
_settings.numSamples = 0;
}
//currently depth only works if stencil is enabled.
// http://forum.openframeworks.cc/index.php/topic,6837.0.html
#ifdef TARGET_OPENGLES
if(_settings.useDepth){
_settings.useStencil = true;
}
if( _settings.depthStencilAsTexture ){
_settings.depthStencilAsTexture = false;
ofLogWarning("ofFbo") << "allocate(): depthStencilAsTexture is not available for iOS";
}
#endif
GLenum depthAttachment = GL_DEPTH_ATTACHMENT;
if( _settings.useDepth && _settings.useStencil ){
_settings.depthStencilInternalFormat = GL_DEPTH_STENCIL;
#ifdef TARGET_OPENGLES
depthAttachment = GL_DEPTH_ATTACHMENT;
#else
depthAttachment = GL_DEPTH_STENCIL_ATTACHMENT;
#endif
}else if(_settings.useDepth){
depthAttachment = GL_DEPTH_ATTACHMENT;
}else if(_settings.useStencil){
depthAttachment = GL_STENCIL_ATTACHMENT;
_settings.depthStencilInternalFormat = GL_STENCIL_INDEX;
}
// set needed values for allocation on instance settings
// the rest will be set by the corresponding methods during allocation
settings.width = _settings.width;
settings.height = _settings.height;
settings.numSamples = _settings.numSamples;
// create main fbo
// this is the main one we bind for drawing into
// all the renderbuffers are attached to this (whether MSAA is enabled or not)
glGenFramebuffers(1, &fbo);
retainFB(fbo);
GLint previousFboId = 0;
// note that we are using a glGetInteger method here, which may stall the pipeline.
// in the allocate() method, this is not that tragic since this will not be called
// within the draw() loop. Here, we need not optimise for performance, but for
// simplicity and readability .
glGetIntegerv(GL_FRAMEBUFFER_BINDING, &previousFboId);
glBindFramebuffer(GL_FRAMEBUFFER, fbo);
//- USE REGULAR RENDER BUFFER
if(!_settings.depthStencilAsTexture){
if(_settings.useDepth && _settings.useStencil){
stencilBuffer = depthBuffer = createAndAttachRenderbuffer(_settings.depthStencilInternalFormat, depthAttachment);
retainRB(stencilBuffer);
retainRB(depthBuffer);
}else if(_settings.useDepth){
depthBuffer = createAndAttachRenderbuffer(_settings.depthStencilInternalFormat, depthAttachment);
retainRB(depthBuffer);
}else if(_settings.useStencil){
stencilBuffer = createAndAttachRenderbuffer(_settings.depthStencilInternalFormat, depthAttachment);
retainRB(stencilBuffer);
}
//- INSTEAD USE TEXTURE
}else{
if(_settings.useDepth || _settings.useStencil){
createAndAttachDepthStencilTexture(_settings.textureTarget,_settings.depthStencilInternalFormat,depthAttachment);
#ifdef TARGET_OPENGLES
// if there's depth and stencil the texture should be attached as
// depth and stencil attachments
// http://www.khronos.org/registry/gles/extensions/OES/OES_packed_depth_stencil.txt
if(_settings.useDepth && _settings.useStencil){
glFramebufferTexture2D(GL_FRAMEBUFFER,
GL_STENCIL_ATTACHMENT,
GL_TEXTURE_2D, depthBufferTex.texData.textureID, 0);
}
#endif
}
}
settings.useDepth = _settings.useDepth;
settings.useStencil = _settings.useStencil;
settings.depthStencilInternalFormat = _settings.depthStencilInternalFormat;
settings.depthStencilAsTexture = _settings.depthStencilAsTexture;
settings.textureTarget = _settings.textureTarget;
settings.wrapModeHorizontal = _settings.wrapModeHorizontal;
settings.wrapModeVertical = _settings.wrapModeVertical;
settings.maxFilter = _settings.maxFilter;
settings.minFilter = _settings.minFilter;
// if we want MSAA, create a new fbo for textures
#ifndef TARGET_OPENGLES
if(_settings.numSamples){
glGenFramebuffers(1, &fboTextures);
retainFB(fboTextures);
}else{
fboTextures = fbo;
}
#else
fboTextures = fbo;
if(_settings.numSamples){
ofLogWarning("ofFbo") << "allocate(): multisampling not supported in OpenGL ES";
}
#endif
// now create all textures and color buffers
if(_settings.colorFormats.size() > 0) {
for(int i=0; i<(int)_settings.colorFormats.size(); i++) createAndAttachTexture(_settings.colorFormats[i], i);
} else if(_settings.numColorbuffers > 0) {
for(int i=0; i<_settings.numColorbuffers; i++) createAndAttachTexture(_settings.internalformat, i);
_settings.colorFormats = settings.colorFormats;
} else {
ofLogWarning("ofFbo") << "allocate(): no color buffers specified for frame buffer object " << fbo;
}
settings.internalformat = _settings.internalformat;
dirty.resize(_settings.colorFormats.size(), true); // we start with all color buffers dirty.
// if textures are attached to a different fbo (e.g. if using MSAA) check it's status
if(fbo != fboTextures) {
glBindFramebuffer(GL_FRAMEBUFFER, fboTextures);
}
// check everything is ok with this fbo
bIsAllocated = checkStatus();
// restore previous framebuffer id
glBindFramebuffer(GL_FRAMEBUFFER, previousFboId);
/* UNCOMMENT OUTSIDE OF DOING RELEASES
// this should never happen
if(settings != _settings) ofLogWarning("ofFbo") << "allocation not complete, passed settings not equal to created ones, this is an internal OF bug";
*/
#ifdef TARGET_ANDROID
ofAddListener(ofxAndroidEvents().reloadGL,this,&ofFbo::reloadFbo);
#endif
}
void IteratorImpl::seekToLast()
{
m_iterator->SeekToLast();
checkStatus();
}
// 'Pings' the FlashThread to keep the LEDs flashing.
static int PluginMessageEventHook(WPARAM hContact, LPARAM lParam)
{
HANDLE hEvent = (HANDLE)lParam;
//get DBEVENTINFO without pBlob
DBEVENTINFO einfo = { sizeof(einfo) };
if (!db_event_get(hEvent, &einfo) && !(einfo.flags & DBEF_SENT))
if ((einfo.eventType == EVENTTYPE_MESSAGE && bFlashOnMsg && checkOpenWindow(hContact) && checkMsgTimestamp(hContact, hEvent, einfo.timestamp)) ||
(einfo.eventType == EVENTTYPE_URL && bFlashOnURL) ||
(einfo.eventType == EVENTTYPE_FILE && bFlashOnFile) ||
(einfo.eventType != EVENTTYPE_MESSAGE && einfo.eventType != EVENTTYPE_URL && einfo.eventType != EVENTTYPE_FILE && bFlashOnOther)) {
if (contactCheckProtocol(einfo.szModule, hContact, einfo.eventType) && checkNotifyOptions() && checkStatus(einfo.szModule) && checkXstatus(einfo.szModule))
SetEvent(hFlashEvent);
}
return 0;
}
void IteratorImpl::next()
{
ASSERT(isValid());
m_iterator->Next();
checkStatus();
}
static VOID CALLBACK ReminderTimer(HWND hwnd, UINT message, UINT_PTR idEvent, DWORD dwTime)
{
int nIndex;
CLISTEVENT *pCLEvent;
if (!bReminderDisabled && nExternCount && bFlashOnOther) {
SetEvent(hFlashEvent);
return;
}
for (nIndex = 0; !bReminderDisabled && (pCLEvent = (CLISTEVENT*)CallService(MS_CLIST_GETEVENT, -1, nIndex)); nIndex++) {
DBEVENTINFO einfo = readEventInfo(pCLEvent->hDbEvent, pCLEvent->hContact);
if ((einfo.eventType == EVENTTYPE_MESSAGE && bFlashOnMsg) ||
(einfo.eventType == EVENTTYPE_URL && bFlashOnURL) ||
(einfo.eventType == EVENTTYPE_FILE && bFlashOnFile) ||
(einfo.eventType != EVENTTYPE_MESSAGE && einfo.eventType != EVENTTYPE_URL && einfo.eventType != EVENTTYPE_FILE && bFlashOnOther))
if (metaCheckProtocol(einfo.szModule, pCLEvent->hContact, einfo.eventType) && checkNotifyOptions() && checkStatus(einfo.szModule) && checkXstatus(einfo.szModule)) {
SetEvent(hFlashEvent);
return;
}
}
}
main(int argc, const char *argv[])
{
os_time os_delay_500ms = { 0, 500000000 };
os_time os_delay_200ms = { 0, 200000000 };
os_time os_delay_2ms = { 0, 2000000 };
int x, i;
DDS_boolean autodispose_unregistered_instances = FALSE;
DDS_Publisher writerStatePublisher;
DDS_DataWriter writerStateWriter;
DDS_Publisher msgPublisher;
DDS_DataWriter msgWriter;
DDS_DataWriter msgWriter_stopper;
int messageLength;
LifecycleData_Msg *sample_Msg;
// Force the output to be unbuffered.
setbuf(stdout, (char *) 0);
printf("\n\n Starting LifecyclePublisher...");
if( argc < 3 )
{
usage();
}
if ((strcmp(argv[1], "false") != 0) &&
(strcmp(argv[1], "true") != 0) &&
(strcmp(argv[2], "dispose") != 0) &&
(strcmp(argv[2], "unregister") != 0) &&
(strcmp(argv[2], "stoppub") != 0))
{
usage();
}
autodispose_unregistered_instances = (strcmp(argv[1], "true") == 0);
// First initialize the Topics and their DDS Entities
// Create DDS DomainParticipant
createParticipant("Lifecycle example");
//------------------ Msg topic --------------------//
// Register Msg Topic's type in the DDS Domain.
g_msgTypeSupport = LifecycleData_MsgTypeSupport__alloc();
checkHandle(g_msgTypeSupport, "LifecycleData_MsgTypeSupport__alloc");
registerMsgType(g_msgTypeSupport);
// Create Msg Topic in the DDS Domain.
g_msgTypeName = (char*) LifecycleData_MsgTypeSupport_get_type_name(g_msgTypeSupport);
g_msgTopic = createTopic("Lifecycle_Msg", g_msgTypeName);
DDS_free(g_msgTypeName);
DDS_free(g_msgTypeSupport);
// Create the Publisher's in the DDS Domain.
msgPublisher = createPublisher();
// Request a Writer from the the Publisher.
msgWriter = createDataWriter(msgPublisher, g_msgTopic, autodispose_unregistered_instances);
msgWriter_stopper = createDataWriter(msgPublisher, g_msgTopic, autodispose_unregistered_instances);
//End initialization.
os_nanoSleep(os_delay_200ms);
// Start publishing...
printf("\n=== [Publisher] Ready...");
if (strcmp(argv[2], "dispose") == 0)
{
// Publish a Msg Sample and dispose the instance
LifecycleData_Msg *sample_Msg = LifecycleData_Msg__alloc();
sample_Msg->userID = 1;
messageLength = strlen("Lifecycle_1");
sample_Msg->message = DDS_string_alloc(messageLength);
snprintf(sample_Msg->message, messageLength + 1, "%s", "Lifecycle_1");
messageLength = strlen("SAMPLE_SENT -> INSTANCE_DISPOSED -> DATAWRITER_DELETED");
sample_Msg->writerStates = DDS_string_alloc(messageLength);
snprintf(sample_Msg->writerStates, messageLength + 1, "%s", "SAMPLE_SENT -> INSTANCE_DISPOSED -> DATAWRITER_DELETED");
printf("\n=== [Publisher] :");
printf("\n userID : %d", sample_Msg->userID);
printf("\n Message : %s", sample_Msg->message);
printf("\n writerStates : %s", sample_Msg->writerStates);
g_status = LifecycleData_MsgDataWriter_write(msgWriter, sample_Msg, 0);
checkStatus(g_status, "MsgDataWriter_write");
os_nanoSleep(os_delay_500ms);
printf("\n=== [Publisher] : SAMPLE_SENT");
// Dispose instance
g_status = LifecycleData_MsgDataWriter_dispose(msgWriter, sample_Msg, 0);
checkStatus(g_status, "LifecycleData_MsgDataWriter_dispose");
printf("\n=== [Publisher] : INSTANCE_DISPOSED");
// OpenSplice will recursively free the content of the sample,
// provided it has all been allocated through the DDS_xxxx_alloc API...
DDS_free(sample_Msg);
}
else if (strcmp(argv[2], "unregister") == 0)
{
// Publish a Msg Sample and unregister the instance
LifecycleData_Msg *sample_Msg = LifecycleData_Msg__alloc();
sample_Msg->userID = 1;
messageLength = strlen("Lifecycle_2");
sample_Msg->message = DDS_string_alloc(messageLength);
snprintf(sample_Msg->message, messageLength + 1, "%s", "Lifecycle_2");
messageLength = strlen("SAMPLE_SENT -> INSTANCE_UNREGISTERED -> DATAWRITER_DELETED");
sample_Msg->writerStates = DDS_string_alloc(messageLength);
snprintf(sample_Msg->writerStates, messageLength + 1, "%s", "SAMPLE_SENT -> INSTANCE_UNREGISTERED -> DATAWRITER_DELETED");
printf("\n=== [Publisher] :");
printf("\n userID : %d", sample_Msg->userID);
printf("\n Message : %s", sample_Msg->message);
printf("\n writerStates : %s", sample_Msg->writerStates);
g_status = LifecycleData_MsgDataWriter_write(msgWriter, sample_Msg, 0);
checkStatus(g_status, "MsgDataWriter_write");
os_nanoSleep(os_delay_500ms);
printf("\n=== [Publisher] : SAMPLE_SENT");
// Unregister instance : the auto_dispose_unregistered_instances flag
// is currently ignored and the instance is never disposed automatically
g_status = LifecycleData_MsgDataWriter_unregister_instance(msgWriter, sample_Msg, 0);
checkStatus(g_status, "LifecycleData_MsgDataWriter_unregister_instance");
printf("\n=== [Publisher] : INSTANCE_UNREGISTERED");
// OpenSplice will recursively free the content of the sample,
// provided it has all been allocated through the DDS_xxxx_alloc API...
DDS_free(sample_Msg);
}
else if (strcmp(argv[2], "stoppub") == 0)
{
// Publish a Msg Sample
LifecycleData_Msg *sample_Msg = LifecycleData_Msg__alloc();
sample_Msg->userID = 1;
messageLength = strlen("Lifecycle_3");
sample_Msg->message = DDS_string_alloc(messageLength);
snprintf(sample_Msg->message, messageLength + 1, "%s", "Lifecycle_3");
messageLength = strlen("SAMPLE_SENT -> DATAWRITER_DELETED");
sample_Msg->writerStates = DDS_string_alloc(messageLength);
snprintf(sample_Msg->writerStates, messageLength + 1, "%s", "SAMPLE_SENT -> DATAWRITER_DELETED");
printf("\n=== [Publisher] :");
printf("\n userID : %d", sample_Msg->userID);
printf("\n Message : %s", sample_Msg->message);
printf("\n writerStates : %s", sample_Msg->writerStates);
g_status = LifecycleData_MsgDataWriter_write(msgWriter, sample_Msg, 0);
checkStatus(g_status, "MsgDataWriter_write");
os_nanoSleep(os_delay_500ms);
printf("\n=== [Publisher] : SAMPLE_SENT");
// OpenSplice will recursively free the content of the sample,
// provided it has all been allocated through the DDS_xxxx_alloc API...
DDS_free(sample_Msg);
}
// let the subscriber treat the previous writer state !!!!
printf("\n=== [Publisher] waiting 500ms to let the subscriber treat the previous write state ...");
os_nanoSleep(os_delay_500ms);
/* Remove the DataWriters */
deleteDataWriter(msgPublisher, &msgWriter);
printf("\n=== [Publisher] : DATAWRITER_DELETED");
os_nanoSleep(os_delay_500ms);
printf("\n=== [Publisher] : Sending a message to stop the subscriber");
/* send a Msg sample to stop the subscriber */
sample_Msg = LifecycleData_Msg__alloc();
sample_Msg->userID = 1;
messageLength = strlen("Lifecycle_4");
sample_Msg->message = DDS_string_alloc(messageLength);
snprintf(sample_Msg->message, messageLength + 1, "%s", "Lifecycle_4");
messageLength = strlen("STOPPING_SUBSCRIBER");
sample_Msg->writerStates = DDS_string_alloc(messageLength);
snprintf(sample_Msg->writerStates, messageLength + 1, "%s", "STOPPING_SUBSCRIBER");
printf("\n=== [Publisher] :");
printf("\n userID : %d", sample_Msg->userID);
printf("\n Message : %s", sample_Msg->message);
printf("\n writerStates : %s\n", sample_Msg->writerStates);
g_status = LifecycleData_MsgDataWriter_write(msgWriter_stopper, sample_Msg, 0);
checkStatus(g_status, "MsgDataWriter_write");
os_nanoSleep(os_delay_500ms);
// OpenSplice will recursively free the content of the sample,
// provided it has all been allocated through the DDS_xxxx_alloc API...
DDS_free(sample_Msg);
/* Remove the DataWriter */
deleteDataWriter(msgPublisher, &msgWriter_stopper);
// Cleanup DDS from the created Entities.
deletePublisher(&msgPublisher);
deleteTopic(g_msgTopic);
deleteParticipant();
return 0;
}
void BlrFromMessage::buildBlr(IMessageMetadata* metadata)
{
if (!metadata)
return;
LocalStatus st;
expectedMessageLength = metadata->getMessageLength(&st);
checkStatus(&st);
getBlrData().clear();
const unsigned count = metadata->getCount(&st);
fb_assert(count < MAX_USHORT / 2);
if (count == 0)
return; // If there isn't an SQLDA, don't bother with anything else.
appendVersion();
appendUChar(blr_begin);
appendUChar(blr_message);
appendUChar(0);
appendUShort(count * 2);
unsigned msgLen = 0;
for (unsigned i = 0; i < count; ++i)
{
unsigned dtype = metadata->getType(&st, i) & ~1;
checkStatus(&st);
unsigned len = metadata->getLength(&st, i);
checkStatus(&st);
unsigned scale = metadata->getScale(&st, i);
checkStatus(&st);
unsigned charSet = metadata->getCharSet(&st, i);
checkStatus(&st);
switch (dtype)
{
case SQL_VARYING:
appendUChar(blr_varying2);
appendUShort(charSet);
appendUShort(len);
dtype = dtype_varying;
len += sizeof(USHORT);
break;
case SQL_TEXT:
appendUChar(blr_text2);
appendUShort(charSet);
appendUShort(len);
dtype = dtype_text;
break;
case SQL_DOUBLE:
appendUChar(blr_double);
dtype = dtype_double;
break;
case SQL_FLOAT:
appendUChar(blr_float);
dtype = dtype_real;
break;
case SQL_D_FLOAT:
appendUChar(blr_d_float);
dtype = dtype_d_float;
break;
case SQL_TYPE_DATE:
appendUChar(blr_sql_date);
dtype = dtype_sql_date;
break;
case SQL_TYPE_TIME:
appendUChar(blr_sql_time);
dtype = dtype_sql_time;
break;
case SQL_TIMESTAMP:
appendUChar(blr_timestamp);
dtype = dtype_timestamp;
break;
case SQL_BLOB:
appendUChar(blr_blob2);
appendUShort(metadata->getSubType(&st, i));
appendUShort(charSet);
dtype = dtype_blob;
break;
case SQL_ARRAY:
appendUChar(blr_quad);
appendUChar(0);
dtype = dtype_array;
break;
case SQL_LONG:
appendUChar(blr_long);
appendUChar(scale);
dtype = dtype_long;
break;
case SQL_SHORT:
appendUChar(blr_short);
appendUChar(scale);
dtype = dtype_short;
break;
case SQL_INT64:
appendUChar(blr_int64);
appendUChar(scale);
dtype = dtype_int64;
break;
case SQL_QUAD:
appendUChar(blr_quad);
appendUChar(scale);
dtype = dtype_quad;
break;
case SQL_BOOLEAN:
appendUChar(blr_bool);
dtype = dtype_boolean;
break;
case SQL_NULL:
appendUChar(blr_text);
appendUShort(len);
dtype = dtype_text;
break;
default:
Arg::Gds(isc_dsql_sqlda_value_err).raise();
break;
}
appendUChar(blr_short);
appendUChar(0);
unsigned align = type_alignments[dtype];
if (align)
msgLen = FB_ALIGN(msgLen, align);
msgLen += len;
align = type_alignments[dtype_short];
if (align)
msgLen = FB_ALIGN(msgLen, align);
msgLen += sizeof(SSHORT);
}
appendUChar(blr_end);
appendUChar(blr_eoc);
if (expectedMessageLength && msgLen && (expectedMessageLength != msgLen))
{
Arg::Gds(isc_wrong_message_length).raise();
}
}
DDS::Topic_ptr
DDS::ExtDomainParticipantImpl::create_simulated_multitopic (
const char *,
const char * type_name,
const char *,
const DDS::StringSeq & expression_parameters)
{
/* Type-specific DDS entities */
Chat::ChatMessageDataReader_ptr chatMessageDR;
Chat::NameServiceDataReader_ptr nameServiceDR;
Chat::NamedMessageDataWriter_ptr namedMessageDW;
/* Query related stuff */
DDS::QueryCondition_ptr nameFinder;
/* QosPolicy holders */
DDS::TopicQos namedMessageQos;
DDS::SubscriberQos sub_qos;
DDS::PublisherQos pub_qos;
/* Others */
DDS::DataReader_ptr parentReader;
DDS::DataWriter_ptr parentWriter;
char *nameFinderExpr;
const char *partitionName = "ChatRoom";
DDS::ReturnCode_t status;
/* Lookup both components that constitute the multi-topic. */
chatMessageTopic = realParticipant->find_topic("Chat_ChatMessage", DDS::DURATION_INFINITE);
checkHandle(chatMessageTopic.in(), "DDS::DomainParticipant::find_topic (Chat_ChatMessage)");
nameServiceTopic = realParticipant->find_topic("Chat_NameService", DDS::DURATION_INFINITE);
checkHandle(nameServiceTopic.in(), "DDS::DomainParticipant::find_topic (Chat_NameService)");
/* Create a ContentFilteredTopic to filter out our own ChatMessages. */
filteredMessageTopic = realParticipant->create_contentfilteredtopic(
"Chat_FilteredMessage",
chatMessageTopic.in(),
"userID <> %0",
expression_parameters);
checkHandle(filteredMessageTopic.in(), "DDS::DomainParticipant::create_contentfilteredtopic");
/* Adapt the default SubscriberQos to read from the "ChatRoom" Partition. */
status = realParticipant->get_default_subscriber_qos (sub_qos);
checkStatus(status, "DDS::DomainParticipant::get_default_subscriber_qos");
sub_qos.partition.name.length(1);
sub_qos.partition.name[0] = partitionName;
/* Create a private Subscriber for the multitopic simulator. */
multiSub = realParticipant->create_subscriber(sub_qos, NULL, DDS::STATUS_MASK_NONE);
checkHandle(multiSub.in(), "DDS::DomainParticipant::create_subscriber (for multitopic)");
/* Create a DataReader for the FilteredMessage Topic (using the appropriate QoS). */
parentReader = multiSub->create_datareader(
filteredMessageTopic.in(),
DATAREADER_QOS_USE_TOPIC_QOS,
NULL,
DDS::STATUS_MASK_NONE);
checkHandle(parentReader, "DDS::Subscriber::create_datareader (ChatMessage)");
/* Narrow the abstract parent into its typed representative. */
chatMessageDR = Chat::ChatMessageDataReader::_narrow(parentReader);
checkHandle(chatMessageDR, "Chat::ChatMessageDataReader::_narrow");
/* Allocate the DataReaderListener Implementation. */
msgListener = new DDS::DataReaderListenerImpl();
checkHandle(msgListener, "new DDS::DataReaderListenerImpl");
/* Attach the DataReaderListener to the DataReader, only enabling the data_available event. */
status = chatMessageDR->set_listener(msgListener, DDS::DATA_AVAILABLE_STATUS);
checkStatus(status, "DDS::DataReader_set_listener");
/* Create a DataReader for the nameService Topic (using the appropriate QoS). */
parentReader = multiSub->create_datareader(
nameServiceTopic.in(),
DATAREADER_QOS_USE_TOPIC_QOS,
NULL,
DDS::STATUS_MASK_NONE);
checkHandle(parentReader, "DDS::Subscriber::create_datareader (NameService)");
/* Narrow the abstract parent into its typed representative. */
nameServiceDR = Chat::NameServiceDataReader::_narrow(parentReader);
checkHandle(nameServiceDR, "Chat::NameServiceDataReader::_narrow");
/* Define the SQL expression (using a parameterized value). */
nameFinderExpr = "userID = %0";
/* Create a QueryCondition to only read corresponding nameService information by key-value. */
nameFinder = nameServiceDR->create_querycondition(
DDS::ANY_SAMPLE_STATE,
DDS::ANY_VIEW_STATE,
DDS::ANY_INSTANCE_STATE,
nameFinderExpr,
expression_parameters);
checkHandle(nameFinder, "DDS::DataReader::create_querycondition (nameFinder)");
/* Create the Topic that simulates the multi-topic (use Qos from chatMessage).*/
status = chatMessageTopic->get_qos(namedMessageQos);
checkStatus(status, "DDS::Topic::get_qos");
/* Create the NamedMessage Topic whose samples simulate the MultiTopic */
namedMessageTopic = realParticipant->create_topic(
"Chat_NamedMessage",
type_name,
namedMessageQos,
NULL,
DDS::STATUS_MASK_NONE);
checkHandle(namedMessageTopic.in(), "DDS::DomainParticipant::create_topic (NamedMessage)");
/* Adapt the default PublisherQos to write into the "ChatRoom" Partition. */
status = realParticipant->get_default_publisher_qos(pub_qos);
checkStatus(status, "DDS::DomainParticipant::get_default_publisher_qos");
pub_qos.partition.name.length(1);
pub_qos.partition.name[0] = partitionName;
/* Create a private Publisher for the multitopic simulator. */
multiPub = realParticipant->create_publisher(pub_qos, NULL, DDS::STATUS_MASK_NONE);
checkHandle(multiPub.in(), "DDS::DomainParticipant::create_publisher (for multitopic)");
/* Create a DataWriter for the multitopic. */
parentWriter = multiPub->create_datawriter(
namedMessageTopic.in(),
DATAWRITER_QOS_USE_TOPIC_QOS,
NULL,
DDS::STATUS_MASK_NONE);
checkHandle(parentWriter, "DDS::Publisher::create_datawriter (NamedMessage)");
/* Narrow the abstract parent into its typed representative. */
namedMessageDW = Chat::NamedMessageDataWriter::_narrow(parentWriter);
checkHandle(namedMessageDW, "Chat::NamedMessageDataWriter::_narrow");
/* Store the relevant Entities in our Listener. */
msgListener->chatMessageDR = chatMessageDR;
msgListener->nameServiceDR = nameServiceDR;
msgListener->namedMessageDW = namedMessageDW;
msgListener->nameFinder = nameFinder;
/* Return the simulated Multitopic. */
return DDS::Topic::_duplicate( namedMessageTopic.in() );
}
bool Framebuffer::complete(const ContextState &state)
{
return (checkStatus(state) == GL_FRAMEBUFFER_COMPLETE);
}
int main(int argc, char *argv[])
{
c_bool isTransient, isPersistent;
c_bool isClosed = FALSE;
unsigned long i, j;
os_time os_delay2000 = { 2, 0 };
DDS_sequence_DurabilityData_Msg* DurabilityData_Msg_Seq = DDS_sequence_DurabilityData_Msg__alloc();
DDS_SampleInfoSeq* DurabilityData_infoSeq = DDS_SampleInfoSeq__alloc();
if( argc < 2 )
{
usage();
}
isTransient = (strcmp(argv[1], "transient") == 0) ? TRUE : FALSE;
isPersistent = (strcmp(argv[1], "persistent") == 0) ? TRUE : FALSE;
if( ! (isTransient || isPersistent) )
{
usage();
}
g_durability_kind = (char*) argv[1];
// Create DDS DomainParticipant
createParticipant("Durability example");
// Register the Topic's type in the DDS Domain.
g_MsgTypeSupport = DurabilityData_MsgTypeSupport__alloc();
checkHandle(g_MsgTypeSupport, "DurabilityData_MsgTypeSupport__alloc");
registerType(g_MsgTypeSupport);
// Create the Topic's in the DDS Domain.
g_MsgTypeName = (char*) DurabilityData_MsgTypeSupport_get_type_name(g_MsgTypeSupport);
createTopic("DurabilityData_Msg", g_MsgTypeName);
DDS_free(g_MsgTypeName);
DDS_free(g_MsgTypeSupport);
// Create the Subscriber's in the DDS Domain.
createSubscriber();
// Request a Reader from the the Subscriber.
createReader();
printf("=== [Subscriber] Ready ...");
// Added a max iteration threshold in order to avoid looping infinitely.
// This is in the case of "persistent" + auto_dispose == TRUE,
// if the user tries to use persistence feature, it won't succeed:
// with this setting value, the Instance is still deleted upon the delete of the Writer,
// even though the persistent setting has been passed on both processes.
i = 0;
do
{
g_status = DurabilityData_MsgDataReader_take(
g_DataReader,
DurabilityData_Msg_Seq,
DurabilityData_infoSeq,
DDS_LENGTH_UNLIMITED,
DDS_ANY_SAMPLE_STATE,
DDS_ANY_VIEW_STATE,
DDS_ANY_INSTANCE_STATE );
checkStatus(g_status, "DurabilityData_MsgDataReader_take");
if( DurabilityData_Msg_Seq->_length > 0 )
{
j = 0;
do
{
if( DurabilityData_infoSeq->_buffer[j].valid_data )
{
printf("\n%s", DurabilityData_Msg_Seq->_buffer[j].content);
if( strcmp(DurabilityData_Msg_Seq->_buffer[j].content, "9") == 0 )
{
isClosed = TRUE;
}
}
}
while( ++j < DurabilityData_Msg_Seq->_length );
DurabilityData_MsgDataReader_return_loan (g_DataReader, DurabilityData_Msg_Seq, DurabilityData_infoSeq);
}
os_nanoSleep(os_delay2000);
}
while( isClosed == FALSE && i++ < 5);
// Cleanup DDS from the created Entities.
deleteDataReader();
deleteSubscriber();
deleteTopic();
deleteParticipant();
// Cleanup C allocations, recursively freeing the allocated structures and sequences using the OpenSplice API.
DDS_free(DurabilityData_Msg_Seq);
DDS_free(DurabilityData_infoSeq);
// Print out an empty line, just to let behind a clean new line for the shell..
printf("\n");
return 0;
}
void DDSEntityManager::deleteParticipant()
{
status = dpf->delete_participant(participant.in());
checkStatus(status, "DDS::DomainParticipant::delete_participant");
}