Example #1
0
gapi_returnCode_t
gapi_publisher_delete_contained_entities (
    gapi_publisher _this)
{
    _Publisher publisher;
    _DataWriter dataWriter;
    gapi_dataWriter handle;
    gapi_returnCode_t result = GAPI_RETCODE_OK;
    c_iter writers;
    u_writer w;
    void *userData;

    publisher  = gapi_publisherClaim(_this, &result);

    if ( publisher != NULL ) {
        /* delete all datawriters in the datawriterSet */
        writers = u_publisherLookupWriters(U_PUBLISHER_GET(publisher),NULL);

        w = c_iterTakeFirst(writers);
        while (w) {
            handle = u_entityGetUserData(u_entity(w));
            dataWriter = gapi_dataWriterClaimNB(handle,&result);
            if (dataWriter) {
                userData = _ObjectGetUserData(_Object(dataWriter));
                _DataWriterFree(dataWriter);
            }
            w = c_iterTakeFirst(writers);
        }
        c_iterFree(writers);
        _EntityRelease(publisher);
    } else {
        result = GAPI_RETCODE_BAD_PARAMETER;
    }
    return result;
}
/*     DomainParticipant
 *     get_participant();
 */
gapi_domainParticipant
gapi_topicDescription_get_participant (
    gapi_topicDescription _this)
{
    _TopicDescription topicDescription;
    _Topic topic;
    _DomainParticipant participant = NULL;
    
    topicDescription = gapi_topicDescriptionClaim(_this, NULL);   

    if ( topicDescription != NULL ) {
        /* all entities except for content filtered topics have a reference
         * to a user layer entity. So except for content filtered topics
         * entities get their participant from the user layer entity.
         * Content filters instead do this via the related topic.
         */
        if (_ObjectGetKind(_Object(topicDescription)) == OBJECT_KIND_CONTENTFILTEREDTOPIC) {
            topic = _ContentFilteredTopicGetRelatedTopic(_ContentFilteredTopic(topicDescription));
            participant = _EntityParticipant(_Entity(topic));
        } else {
            participant = _EntityParticipant(_Entity(topicDescription));
        }
    }

    _EntityRelease(topicDescription);
     
    return (gapi_domainParticipant)_EntityHandle(participant);
}
Example #3
0
const char *
_BuiltinFindTopicName (
    _Entity entity)
{
    const char *name = NULL;

    switch (_ObjectGetKind(_Object(entity))) {
    case OBJECT_KIND_DOMAINPARTICIPANT:
        name = builtinTopicTypeInfo[_BUILTIN_PARTICIPANT_INFO].topicName;
    break;
    case OBJECT_KIND_TOPIC:
        name = builtinTopicTypeInfo[_BUILTIN_TOPIC_INFO].topicName;
    break;
    case OBJECT_KIND_DATAWRITER:
        name = builtinTopicTypeInfo[_BUILTIN_PUBLICATION_INFO].topicName;
    break;
    case OBJECT_KIND_DATAREADER:
        name = builtinTopicTypeInfo[_BUILTIN_SUBSCRIPTION_INFO].topicName;
    break;
    default:
    break;
    }

    return name;
}
/*     ReadCondition
 *     create_readcondition(
 *         in SampleStateMask sample_states,
 *         in ViewStateMask view_states,
 *         in InstanceStateMask instance_states);
 */
gapi_readCondition
gapi_dataReaderView_create_readcondition (
    gapi_dataReaderView _this,
    const gapi_sampleStateMask sample_states,
    const gapi_viewStateMask view_states,
    const gapi_instanceStateMask instance_states)
{
    _DataReaderView datareaderview;
    _ReadCondition readCondition = NULL;

    datareaderview = gapi_dataReaderViewClaim(_this, NULL);

    if ( datareaderview && _EntityEnabled(datareaderview) && 
         gapi_stateMasksValid(sample_states, view_states, instance_states) ) {

        _DataReader datareader;

        datareader = _DataReaderViewDataReader(datareaderview);
        readCondition = _ReadConditionNew ( sample_states,
                                            view_states,
                                            instance_states, 
                                            datareader,
                                            datareaderview);
        _EntityRelease(datareader);
        if ( readCondition != NULL ) {
            gapi_deleteEntityAction deleteAction;
            void *actionArg;
            
            if ( _ObjectGetDeleteAction(_Object(readCondition),
                                        &deleteAction, &actionArg) ) {
                _ObjectSetDeleteAction(_Object(readCondition),
                                       deleteAction,
                                       actionArg);
            }
            
            _ENTITY_REGISTER_OBJECT(_Entity(datareaderview),
                                    (_Object)readCondition);
        }
    }

    _EntityRelease(datareaderview);

    return (gapi_readCondition)_EntityRelease(readCondition);
}
/*     ReturnCode_t
 *     delete_contained_entities();
 */
gapi_returnCode_t
gapi_dataReaderView_delete_contained_entities (
    gapi_dataReaderView _this)
{
    gapi_returnCode_t result = GAPI_RETCODE_OK;
    _DataReaderView datareaderview;
    gapi_context context;
    _Condition condition = NULL;
    c_iter entities;
    u_entity e;
    u_result ur;

    GAPI_CONTEXT_SET(context, _this, GAPI_METHOD_DELETE_CONTAINED_ENTITIES);

    if ( _this != NULL ) {
        datareaderview = gapi_dataReaderViewClaim(_this, &result);
        if ( datareaderview != NULL ) {
            if (!gapi_loanRegistry_is_empty(datareaderview->loanRegistry)) {
                result = GAPI_RETCODE_PRECONDITION_NOT_MET;
            } else {
                entities = u_readerLookupQueries(U_READER_GET(datareaderview));
                e = c_iterTakeFirst(entities);
                while (e) {
                    condition = u_entityGetUserData(e);
                    if (condition) {
                        _ObjectReadClaimNotBusy(_Object(condition));
                        _ConditionFree(condition);
                    } else {
                        if (e == u_entity(datareaderview->uQuery)) {
                            datareaderview->uQuery = NULL;
                            ur = u_queryFree(u_query(e));
                            if (ur == U_RESULT_OK) {
                                result = GAPI_RETCODE_OK;
                            } else {
                                result = GAPI_RETCODE_BAD_PARAMETER;
                            }
                        } else {
                            assert(condition);
                            result = GAPI_RETCODE_BAD_PARAMETER;
                        }
                    }
                    e = c_iterTakeFirst(entities);
                }
                c_iterFree(entities);
            }
            _EntityRelease(datareaderview);
        } else {
            result = GAPI_RETCODE_ALREADY_DELETED;
        }
    } else {
        result = GAPI_RETCODE_BAD_PARAMETER;
    }

    return result;
}
Example #6
0
/**
 * @fn Class *URLSessionTask::_URLSessionTask(void)
 * @memberof URLSessionTask
 */
Class *_URLSessionTask(void) {
	static Class *clazz;
	static Once once;

	do_once(&once, {
		clazz = _initialize(&(const ClassDef) {
			.name = "URLSessionTask",
			.superclass = _Object(),
			.instanceSize = sizeof(URLSessionTask),
			.interfaceOffset = offsetof(URLSessionTask, interface),
			.interfaceSize = sizeof(URLSessionTaskInterface),
			.initialize = initialize,
		});
	});
Example #7
0
/**
 * @fn Class *TableColumn::_TableColumn(void)
 * @memberof TableColumn
 */
Class *_TableColumn(void) {
	static Class *clazz;
	static Once once;

	do_once(&once, {
		clazz = _initialize(&(const ClassDef) {
			.name = "TableColumn",
			.superclass = _Object(),
			.instanceSize = sizeof(TableColumn),
			.interfaceOffset = offsetof(TableColumn, interface),
			.interfaceSize = sizeof(TableColumnInterface),
			.initialize = initialize,
		});
	});
Example #8
0
gapi_returnCode_t
_ReadConditionFree(
    _ReadCondition readcondition)
{
    gapi_returnCode_t result = GAPI_RETCODE_OK;

    if (_ObjectGetKind(_Object(readcondition)) == OBJECT_KIND_QUERYCONDITION ) {
        _QueryConditionFree((_QueryCondition)readcondition);
    } else {
        _ReadConditionDispose(readcondition);
    }

    return result;
}
Example #9
0
/**
 * @fn Class *Resource::_Resource(void)
 * @memberof Resource
 */
Class *_Resource(void) {
	static Class *clazz;
	static Once once;

	do_once(&once, {
		clazz = _initialize(&(const ClassDef) {
			.name = "Resource",
			.superclass = _Object(),
			.instanceSize = sizeof(Resource),
			.interfaceOffset = offsetof(Resource, interface),
			.interfaceSize = sizeof(ResourceInterface),
			.initialize = initialize,
			.destroy = destroy,
		});
	});
Example #10
0
void
_ConditionDispose(
    _Condition _this)
{
    gapi_waitSet waitset;

    waitset = c_iterTakeFirst(_this->waitsets);
    while (waitset) {
        gapi_condition handle = _EntityRelease(_this);
        gapi_waitSet_detach_condition(waitset, handle);
        _this = gapi_conditionClaim(handle, NULL);
        waitset = c_iterTakeFirst(_this->waitsets);
    }
    c_iterFree(_this->waitsets);
    if (_ObjectGetKind(_Object(_this)) != OBJECT_KIND_GUARDCONDITION) {
        _EntityDelete(_this);
    }
}
Example #11
0
void
_ConditionFree(
    _Condition _this)
{
    switch (_ObjectGetKind(_Object(_this))) {
    case OBJECT_KIND_QUERYCONDITION:
        _QueryConditionFree((_QueryCondition)_this);
    break;
    case OBJECT_KIND_READCONDITION:
        _ReadConditionFree((_ReadCondition)_this);
    break;
    case OBJECT_KIND_STATUSCONDITION:
        _StatusConditionFree((_StatusCondition)_this);
    break;
    case OBJECT_KIND_GUARDCONDITION:
        _GuardConditionFree(_this);
    break;
    default:
        assert(0);
    break;
    }
}
Example #12
0
gapi_returnCode_t
gapi_dataReader_delete_contained_entities (
    gapi_dataReader _this)
{
    gapi_object handle;
    gapi_returnCode_t result = GAPI_RETCODE_OK;
    _DataReader datareader;
    gapi_context context;
    _Condition condition = NULL;
    _DataReaderView view = NULL;
    c_iter entities;
    u_entity e;
    u_result ur;

    GAPI_CONTEXT_SET(context, _this, GAPI_METHOD_DELETE_CONTAINED_ENTITIES);

    datareader = gapi_dataReaderClaim(_this, &result);

    if ( datareader != NULL ) {
        if (!gapi_loanRegistry_is_empty(datareader->loanRegistry)) {
            result = GAPI_RETCODE_PRECONDITION_NOT_MET;
        } else {
            entities = u_readerLookupQueries(U_READER_GET(datareader));
            e = c_iterTakeFirst(entities);
            while (e) {
                condition = u_entityGetUserData(e);
                if (condition) {
                    _ObjectReadClaimNotBusy(_Object(condition));
                    _ConditionFree(condition);
                } else {
                    assert(condition);
                    result = GAPI_RETCODE_BAD_PARAMETER;
                }
                e = c_iterTakeFirst(entities);
            }
            c_iterFree(entities);

            entities = u_dataReaderLookupViews(U_DATAREADER_GET(datareader));
            e = c_iterTakeFirst(entities);
            while (e) {
                handle = u_entityGetUserData(e);
                view = _DataReaderView(gapi_conditionClaimNB(handle,&result));
                if (view) {
                    _DataReaderViewFree(view);
                } else {
                    ur = u_dataViewFree(u_dataView(e));
                    if (ur == U_RESULT_OK) {
                        result = GAPI_RETCODE_OK;
                    } else {
                        result = GAPI_RETCODE_BAD_PARAMETER;
                    }
                }
                e = c_iterTakeFirst(entities);
            }
            c_iterFree(entities);
        }
        _EntityRelease(datareader);
    } else {
        result = GAPI_RETCODE_BAD_PARAMETER;
    }
    return result;
}
Example #13
0
_DataReader
_DataReaderNew (
    const _TopicDescription topicDescription,
    const _TypeSupport typesupport,
    const gapi_dataReaderQos *qos,
    const struct gapi_dataReaderListener *a_listener,
    const gapi_statusMask mask,
    const _Subscriber subscriber)
{
    _DataReader _this;
    v_readerQos readerQos;
    u_dataReader uReader;
    gapi_string topicName;
    char dataReaderId[256];
    c_bool noError = TRUE;

    readerQos = u_readerQosNew(NULL);
    if ( readerQos != NULL ) {
        if ( gapi_kernelReaderQosCopyIn(qos, readerQos) ) {
            q_expr expr;
            c_value *params;

            topicName = _TopicDescriptionGetName (topicDescription);
            if (topicName) {
                snprintf (dataReaderId,
                          sizeof(dataReaderId),
                          "%sReader", topicName);
                gapi_free (topicName);
            } else {
                snprintf (dataReaderId,
                          sizeof(dataReaderId),
                          "dataReader");
            }
            expr = _TopicDescriptionGetExpr(topicDescription);
            if (_ObjectGetKind(_Object(topicDescription)) ==
                OBJECT_KIND_CONTENTFILTEREDTOPIC) {
                params = _ContentFilteredTopicParameters(
                             (_ContentFilteredTopic)topicDescription);
            } else {
                params = NULL;
            }
            uReader = u_dataReaderNew(_SubscriberUsubscriber(subscriber),
                                      dataReaderId,
                                      expr,
                                      params,
                                      readerQos,
                                      FALSE);
            q_dispose(expr);
            os_free(params);
            noError = (uReader != NULL);
            if (noError) {
                _this = _DataReaderAlloc();

                if ( _this != NULL ) {
                    noError = _DataReaderInit(_this,
                                              subscriber,
                                              topicDescription,
                                              typesupport,
                                              a_listener,
                                              mask,
                                              uReader);
                    if (!noError) {
                        _EntityDispose(_Entity(_this));
                    }
                }
                if (!noError) {
                    u_dataReaderFree(uReader);
                }
            }
        } else {
            noError = FALSE;
        }
        u_readerQosFree(readerQos);
    } else {
        noError = FALSE;
    }

    if (!noError) {
        _this = NULL;
    }

    return _this;
}
Example #14
0
gapi_dataReader
gapi_subscriber_create_datareader (
    gapi_subscriber _this,
    const gapi_topicDescription a_topic,
    const gapi_dataReaderQos *qos,
    const struct gapi_dataReaderListener *a_listener,
    const gapi_statusMask mask)
{
    _Subscriber         subscriber;
    _DataReader         datareader       = NULL;
    gapi_dataReader     result           = NULL;
    _TopicDescription   topicDescription = NULL;
    gapi_dataReaderQos *readerQos;
    gapi_context        context;
    gapi_topicQos* topicQos;

    GAPI_CONTEXT_SET(context, _this, GAPI_METHOD_CREATE_DATAREADER);

    subscriber = gapi_subscriberClaim(_this, NULL);

    if ( subscriber ) {
        if ( !subscriber->builtin ) {
            topicDescription = _TopicDescriptionFromHandle(a_topic);
        }
    }

    if ( topicDescription ) {
        if ( qos == GAPI_DATAREADER_QOS_DEFAULT ) {
            readerQos = &subscriber->_defDataReaderQos;
        } else if ( qos == GAPI_DATAREADER_QOS_USE_TOPIC_QOS ) {
            _Topic topic = NULL;
            switch(_ObjectGetKind(_Object(topicDescription))) {
            case OBJECT_KIND_TOPIC:
                topic = _Topic(topicDescription);
            break;
            case OBJECT_KIND_CONTENTFILTEREDTOPIC:
                topic = _ContentFilteredTopicGetRelatedTopic(_ContentFilteredTopic(topicDescription));
            break;
            default:
                topic = NULL;
            break;
            }
            if ( topic ) {
                topicQos = gapi_topicQos__alloc();
                readerQos = gapi_dataReaderQos__alloc();
                gapi_dataReaderQosCopy(&subscriber->_defDataReaderQos, readerQos);
                _TopicGetQos(topic, topicQos);
                gapi_mergeTopicQosWithDataReaderQos(topicQos,readerQos);
                gapi_free(topicQos);
            } else {
                readerQos = (gapi_dataReaderQos *)qos;
            }
        } else {
            readerQos = (gapi_dataReaderQos *)qos;
        }

        if (  gapi_dataReaderQosIsConsistent(readerQos, &context) == GAPI_RETCODE_OK ) {
            gapi_char *typeName;
            gapi_char *topicName;
            _DomainParticipant participant;
            _TypeSupport typeSupport;

            /* find topic with the participant for consistency */
            typeName  = _TopicDescriptionGetTypeName(topicDescription);
            topicName = _TopicDescriptionGetName(topicDescription);
            participant = _EntityParticipant(_Entity(subscriber));


            /* find type support for the data type to find
             * data reader create function.
             */
            typeSupport = _DomainParticipantFindType(participant, typeName);
            if(typeSupport)
            {          
                /* if create function is NULL, take default from data reader */
                datareader = _DataReaderNew(topicDescription,
                                            typeSupport,
                                            readerQos,
                                            a_listener,
                                            mask,
                                            subscriber);
                if ( datareader ) {
                    _ENTITY_REGISTER_OBJECT(_Entity(subscriber),
                                            (_Object)datareader);
                }
            }else{
                OS_REPORT_1(OS_WARNING,
                            "gapi_subscriber_create_datareader", 0,
                            "TypeSupport %s not found !",
                            typeName);
            }
            
            gapi_free(typeName);
            gapi_free(topicName);
        }

        if (qos == GAPI_DATAREADER_QOS_USE_TOPIC_QOS) {
            gapi_free(readerQos);
        }
    }

    _EntityRelease(subscriber);

    if ( datareader ) {
        gapi_object statusHandle;
        statusHandle = _EntityHandle(_Entity(datareader)->status);
        result = (gapi_dataReader)_EntityRelease(datareader);
    }

    return result;
}