Return-Path: X-Original-To: apmail-incubator-celix-commits-archive@minotaur.apache.org Delivered-To: apmail-incubator-celix-commits-archive@minotaur.apache.org Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by minotaur.apache.org (Postfix) with SMTP id 621DA10E65 for ; Wed, 12 Jun 2013 19:11:38 +0000 (UTC) Received: (qmail 46764 invoked by uid 500); 12 Jun 2013 19:11:38 -0000 Delivered-To: apmail-incubator-celix-commits-archive@incubator.apache.org Received: (qmail 46741 invoked by uid 500); 12 Jun 2013 19:11:38 -0000 Mailing-List: contact celix-commits-help@incubator.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: celix-dev@incubator.apache.org Delivered-To: mailing list celix-commits@incubator.apache.org Received: (qmail 46734 invoked by uid 99); 12 Jun 2013 19:11:38 -0000 Received: from nike.apache.org (HELO nike.apache.org) (192.87.106.230) by apache.org (qpsmtpd/0.29) with ESMTP; Wed, 12 Jun 2013 19:11:38 +0000 X-ASF-Spam-Status: No, hits=-2000.0 required=5.0 tests=ALL_TRUSTED X-Spam-Check-By: apache.org Received: from [140.211.11.4] (HELO eris.apache.org) (140.211.11.4) by apache.org (qpsmtpd/0.29) with ESMTP; Wed, 12 Jun 2013 19:09:37 +0000 Received: from eris.apache.org (localhost [127.0.0.1]) by eris.apache.org (Postfix) with ESMTP id 1F7212388A6E; Wed, 12 Jun 2013 19:09:15 +0000 (UTC) Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Subject: svn commit: r1492377 [5/12] - in /incubator/celix/trunk: dependency_manager/private/src/ dependency_manager/public/include/ deployment_admin/private/include/ deployment_admin/private/src/ deployment_admin/public/include/ device_access/device_access/pri... Date: Wed, 12 Jun 2013 19:08:55 -0000 To: celix-commits@incubator.apache.org From: pnoltes@apache.org X-Mailer: svnmailer-1.0.8-patched Message-Id: <20130612190915.1F7212388A6E@eris.apache.org> X-Virus-Checked: Checked by ClamAV on apache.org Modified: incubator/celix/trunk/framework/private/src/bundle_context.c URL: http://svn.apache.org/viewvc/incubator/celix/trunk/framework/private/src/bundle_context.c?rev=1492377&r1=1492376&r2=1492377&view=diff ============================================================================== --- incubator/celix/trunk/framework/private/src/bundle_context.c (original) +++ incubator/celix/trunk/framework/private/src/bundle_context.c Wed Jun 12 19:08:50 2013 @@ -37,9 +37,9 @@ struct bundleContext { apr_pool_t *pool; }; -celix_status_t bundleContext_create(framework_t framework, bundle_t bundle, bundle_context_t *bundle_context) { +celix_status_t bundleContext_create(framework_pt framework, bundle_pt bundle, bundle_context_pt *bundle_context) { celix_status_t status = CELIX_SUCCESS; - bundle_context_t context = NULL; + bundle_context_pt context = NULL; if (*bundle_context != NULL && framework == NULL && bundle == NULL) { status = CELIX_ILLEGAL_ARGUMENT; @@ -70,7 +70,7 @@ celix_status_t bundleContext_create(fram return status; } -celix_status_t bundleContext_destroy(bundle_context_t context) { +celix_status_t bundleContext_destroy(bundle_context_pt context) { celix_status_t status = CELIX_SUCCESS; if (context != NULL) { @@ -84,7 +84,7 @@ celix_status_t bundleContext_destroy(bun return status; } -celix_status_t bundleContext_getBundle(bundle_context_t context, bundle_t *bundle) { +celix_status_t bundleContext_getBundle(bundle_context_pt context, bundle_pt *bundle) { celix_status_t status = CELIX_SUCCESS; if (context == NULL) { @@ -96,7 +96,7 @@ celix_status_t bundleContext_getBundle(b return status; } -celix_status_t bundleContext_getFramework(bundle_context_t context, framework_t *framework) { +celix_status_t bundleContext_getFramework(bundle_context_pt context, framework_pt *framework) { celix_status_t status = CELIX_SUCCESS; if (context == NULL) { @@ -108,7 +108,7 @@ celix_status_t bundleContext_getFramewor return status; } -celix_status_t bundleContext_getMemoryPool(bundle_context_t context, apr_pool_t **memory_pool) { +celix_status_t bundleContext_getMemoryPool(bundle_context_pt context, apr_pool_t **memory_pool) { celix_status_t status = CELIX_SUCCESS; if (context == NULL) { @@ -120,13 +120,13 @@ celix_status_t bundleContext_getMemoryPo return status; } -celix_status_t bundleContext_installBundle(bundle_context_t context, char * location, bundle_t *bundle) { +celix_status_t bundleContext_installBundle(bundle_context_pt context, char * location, bundle_pt *bundle) { return bundleContext_installBundle2(context, location, NULL, bundle); } -celix_status_t bundleContext_installBundle2(bundle_context_t context, char * location, char *inputFile, bundle_t *bundle) { +celix_status_t bundleContext_installBundle2(bundle_context_pt context, char * location, char *inputFile, bundle_pt *bundle) { celix_status_t status = CELIX_SUCCESS; - bundle_t b = NULL; + bundle_pt b = NULL; if (context != NULL && *bundle == NULL) { if (fw_installBundle(context->framework, &b, location, inputFile) != CELIX_SUCCESS) { @@ -141,9 +141,9 @@ celix_status_t bundleContext_installBund return status; } -celix_status_t bundleContext_registerService(bundle_context_t context, char * serviceName, void * svcObj, - properties_t properties, service_registration_t *service_registration) { - service_registration_t registration = NULL; +celix_status_t bundleContext_registerService(bundle_context_pt context, char * serviceName, void * svcObj, + properties_pt properties, service_registration_pt *service_registration) { + service_registration_pt registration = NULL; celix_status_t status = CELIX_SUCCESS; if (context != NULL && *service_registration == NULL) { @@ -156,9 +156,9 @@ celix_status_t bundleContext_registerSer return status; } -celix_status_t bundleContext_registerServiceFactory(bundle_context_t context, char * serviceName, service_factory_t factory, - properties_t properties, service_registration_t *service_registration) { - service_registration_t registration = NULL; +celix_status_t bundleContext_registerServiceFactory(bundle_context_pt context, char * serviceName, service_factory_pt factory, + properties_pt properties, service_registration_pt *service_registration) { + service_registration_pt registration = NULL; celix_status_t status = CELIX_SUCCESS; if (context != NULL && *service_registration == NULL) { @@ -171,7 +171,7 @@ celix_status_t bundleContext_registerSer return status; } -celix_status_t bundleContext_getServiceReferences(bundle_context_t context, const char * serviceName, char * filter, array_list_t *service_references) { +celix_status_t bundleContext_getServiceReferences(bundle_context_pt context, const char * serviceName, char * filter, array_list_pt *service_references) { celix_status_t status = CELIX_SUCCESS; if (context != NULL && *service_references == NULL) { @@ -183,9 +183,9 @@ celix_status_t bundleContext_getServiceR return status; } -celix_status_t bundleContext_getServiceReference(bundle_context_t context, char * serviceName, service_reference_t *service_reference) { - service_reference_t reference = NULL; - array_list_t services = NULL; +celix_status_t bundleContext_getServiceReference(bundle_context_pt context, char * serviceName, service_reference_pt *service_reference) { + service_reference_pt reference = NULL; + array_list_pt services = NULL; celix_status_t status = CELIX_SUCCESS; if (serviceName != NULL) { @@ -203,7 +203,7 @@ celix_status_t bundleContext_getServiceR return status; } -celix_status_t bundleContext_getService(bundle_context_t context, service_reference_t reference, void **service_instance) { +celix_status_t bundleContext_getService(bundle_context_pt context, service_reference_pt reference, void **service_instance) { celix_status_t status = CELIX_SUCCESS; if (context != NULL && reference != NULL && *service_instance == NULL) { @@ -215,7 +215,7 @@ celix_status_t bundleContext_getService( return status; } -celix_status_t bundleContext_ungetService(bundle_context_t context, service_reference_t reference, bool *result) { +celix_status_t bundleContext_ungetService(bundle_context_pt context, service_reference_pt reference, bool *result) { celix_status_t status = CELIX_SUCCESS; if (context != NULL && reference != NULL) { @@ -227,7 +227,7 @@ celix_status_t bundleContext_ungetServic return status; } -celix_status_t bundleContext_getBundles(bundle_context_t context, array_list_t *bundles) { +celix_status_t bundleContext_getBundles(bundle_context_pt context, array_list_pt *bundles) { celix_status_t status = CELIX_SUCCESS; if (context == NULL || *bundles != NULL) { @@ -239,7 +239,7 @@ celix_status_t bundleContext_getBundles( return status; } -celix_status_t bundleContext_getBundleById(bundle_context_t context, long id, bundle_t *bundle) { +celix_status_t bundleContext_getBundleById(bundle_context_pt context, long id, bundle_pt *bundle) { celix_status_t status = CELIX_SUCCESS; if (context == NULL || *bundle != NULL) { @@ -251,7 +251,7 @@ celix_status_t bundleContext_getBundleBy return status; } -celix_status_t bundleContext_addServiceListener(bundle_context_t context, service_listener_t listener, char * filter) { +celix_status_t bundleContext_addServiceListener(bundle_context_pt context, service_listener_pt listener, char * filter) { celix_status_t status = CELIX_SUCCESS; if (context != NULL && listener != NULL) { @@ -263,7 +263,7 @@ celix_status_t bundleContext_addServiceL return status; } -celix_status_t bundleContext_removeServiceListener(bundle_context_t context, service_listener_t listener) { +celix_status_t bundleContext_removeServiceListener(bundle_context_pt context, service_listener_pt listener) { celix_status_t status = CELIX_SUCCESS; if (context != NULL && listener != NULL) { @@ -275,7 +275,7 @@ celix_status_t bundleContext_removeServi return status; } -celix_status_t bundleContext_addBundleListener(bundle_context_t context, bundle_listener_t listener) { +celix_status_t bundleContext_addBundleListener(bundle_context_pt context, bundle_listener_pt listener) { celix_status_t status = CELIX_SUCCESS; if (context != NULL && listener != NULL) { @@ -287,7 +287,7 @@ celix_status_t bundleContext_addBundleLi return status; } -celix_status_t bundleContext_removeBundleListener(bundle_context_t context, bundle_listener_t listener) { +celix_status_t bundleContext_removeBundleListener(bundle_context_pt context, bundle_listener_pt listener) { celix_status_t status = CELIX_SUCCESS; if (context != NULL && listener != NULL) { @@ -299,7 +299,7 @@ celix_status_t bundleContext_removeBundl return status; } -celix_status_t bundleContext_getProperty(bundle_context_t context, const char *name, char **value) { +celix_status_t bundleContext_getProperty(bundle_context_pt context, const char *name, char **value) { celix_status_t status = CELIX_SUCCESS; if (context == NULL || name == NULL || *value != NULL) { Modified: incubator/celix/trunk/framework/private/src/bundle_revision.c URL: http://svn.apache.org/viewvc/incubator/celix/trunk/framework/private/src/bundle_revision.c?rev=1492377&r1=1492376&r2=1492377&view=diff ============================================================================== --- incubator/celix/trunk/framework/private/src/bundle_revision.c (original) +++ incubator/celix/trunk/framework/private/src/bundle_revision.c Wed Jun 12 19:08:50 2013 @@ -40,11 +40,11 @@ struct bundleRevision { static apr_status_t bundleRevision_destroy(void *revisionP); -celix_status_t bundleRevision_create(apr_pool_t *pool, char *root, char *location, long revisionNr, char *inputFile, bundle_revision_t *bundle_revision) { +celix_status_t bundleRevision_create(apr_pool_t *pool, char *root, char *location, long revisionNr, char *inputFile, bundle_revision_pt *bundle_revision) { celix_status_t status = CELIX_SUCCESS; - bundle_revision_t revision = NULL; + bundle_revision_pt revision = NULL; - revision = (bundle_revision_t) apr_pcalloc(pool, sizeof(*revision)); + revision = (bundle_revision_pt) apr_pcalloc(pool, sizeof(*revision)); if (!revision) { status = CELIX_ENOMEM; } else { @@ -76,11 +76,11 @@ celix_status_t bundleRevision_create(apr } apr_status_t bundleRevision_destroy(void *revisionP) { - bundle_revision_t revision = revisionP; + bundle_revision_pt revision = revisionP; return CELIX_SUCCESS; } -celix_status_t bundleRevision_getNumber(bundle_revision_t revision, long *revisionNr) { +celix_status_t bundleRevision_getNumber(bundle_revision_pt revision, long *revisionNr) { celix_status_t status = CELIX_SUCCESS; if (revision == NULL) { status = CELIX_ILLEGAL_ARGUMENT; @@ -90,7 +90,7 @@ celix_status_t bundleRevision_getNumber( return status; } -celix_status_t bundleRevision_getLocation(bundle_revision_t revision, char **location) { +celix_status_t bundleRevision_getLocation(bundle_revision_pt revision, char **location) { celix_status_t status = CELIX_SUCCESS; if (revision == NULL) { status = CELIX_ILLEGAL_ARGUMENT; @@ -100,7 +100,7 @@ celix_status_t bundleRevision_getLocatio return status; } -celix_status_t bundleRevision_getRoot(bundle_revision_t revision, char **root) { +celix_status_t bundleRevision_getRoot(bundle_revision_pt revision, char **root) { celix_status_t status = CELIX_SUCCESS; if (revision == NULL) { status = CELIX_ILLEGAL_ARGUMENT; Modified: incubator/celix/trunk/framework/private/src/capability.c URL: http://svn.apache.org/viewvc/incubator/celix/trunk/framework/private/src/capability.c?rev=1492377&r1=1492376&r2=1492377&view=diff ============================================================================== --- incubator/celix/trunk/framework/private/src/capability.c (original) +++ incubator/celix/trunk/framework/private/src/capability.c Wed Jun 12 19:08:50 2013 @@ -30,17 +30,17 @@ struct capability { char * serviceName; - module_t module; - version_t version; - hash_map_t attributes; - hash_map_t directives; + module_pt module; + version_pt version; + hash_map_pt attributes; + hash_map_pt directives; }; apr_status_t capability_destroy(void *capabilityP); -celix_status_t capability_create(apr_pool_t *pool, module_t module, hash_map_t directives, hash_map_t attributes, capability_t *capability) { +celix_status_t capability_create(apr_pool_t *pool, module_pt module, hash_map_pt directives, hash_map_pt attributes, capability_pt *capability) { celix_status_t status = CELIX_SUCCESS; - *capability = (capability_t) apr_palloc(pool, sizeof(**capability)); + *capability = (capability_pt) apr_palloc(pool, sizeof(**capability)); if (!*capability) { status = CELIX_ENOMEM; } else { @@ -53,11 +53,11 @@ celix_status_t capability_create(apr_poo (*capability)->version = NULL; status = version_createEmptyVersion(pool, &(*capability)->version); if (status == CELIX_SUCCESS) { - attribute_t versionAttribute = NULL; - attribute_t serviceAttribute = (attribute_t) hashMap_get(attributes, "service"); + attribute_pt versionAttribute = NULL; + attribute_pt serviceAttribute = (attribute_pt) hashMap_get(attributes, "service"); status = attribute_getValue(serviceAttribute, &(*capability)->serviceName); if (status == CELIX_SUCCESS) { - versionAttribute = (attribute_t) hashMap_get(attributes, "version"); + versionAttribute = (attribute_pt) hashMap_get(attributes, "version"); if (versionAttribute != NULL) { char *versionStr = NULL; attribute_getValue(versionAttribute, &versionStr); @@ -72,11 +72,11 @@ celix_status_t capability_create(apr_poo } apr_status_t capability_destroy(void *capabilityP) { - capability_t capability = capabilityP; + capability_pt capability = capabilityP; - hash_map_iterator_t attrIter = hashMapIterator_create(capability->attributes); + hash_map_iterator_pt attrIter = hashMapIterator_create(capability->attributes); while (hashMapIterator_hasNext(attrIter)) { - attribute_t attr = hashMapIterator_nextValue(attrIter); + attribute_pt attr = hashMapIterator_nextValue(attrIter); hashMapIterator_remove(attrIter); } hashMapIterator_destroy(attrIter); @@ -91,17 +91,17 @@ apr_status_t capability_destroy(void *ca return APR_SUCCESS; } -celix_status_t capability_getServiceName(capability_t capability, char **serviceName) { +celix_status_t capability_getServiceName(capability_pt capability, char **serviceName) { *serviceName = capability->serviceName; return CELIX_SUCCESS; } -celix_status_t capability_getVersion(capability_t capability, version_t *version) { +celix_status_t capability_getVersion(capability_pt capability, version_pt *version) { *version = capability->version; return CELIX_SUCCESS; } -celix_status_t capability_getModule(capability_t capability, module_t *module) { +celix_status_t capability_getModule(capability_pt capability, module_pt *module) { *module = capability->module; return CELIX_SUCCESS; } Modified: incubator/celix/trunk/framework/private/src/filter.c URL: http://svn.apache.org/viewvc/incubator/celix/trunk/framework/private/src/filter.c?rev=1492377&r1=1492376&r2=1492377&view=diff ============================================================================== --- incubator/celix/trunk/framework/private/src/filter.c (original) +++ incubator/celix/trunk/framework/private/src/filter.c Wed Jun 12 19:08:50 2013 @@ -53,15 +53,15 @@ struct filter { }; void filter_skipWhiteSpace(char * filterString, int * pos); -filter_t filter_parseFilter(char * filterString, int * pos, apr_pool_t *pool); -filter_t filter_parseFilterComp(char * filterString, int * pos, apr_pool_t *pool); -filter_t filter_parseAnd(char * filterString, int * pos, apr_pool_t *pool); -filter_t filter_parseOr(char * filterString, int * pos, apr_pool_t *pool); -filter_t filter_parseNot(char * filterString, int * pos, apr_pool_t *pool); -filter_t filter_parseItem(char * filterString, int * pos, apr_pool_t *pool); +filter_pt filter_parseFilter(char * filterString, int * pos, apr_pool_t *pool); +filter_pt filter_parseFilterComp(char * filterString, int * pos, apr_pool_t *pool); +filter_pt filter_parseAnd(char * filterString, int * pos, apr_pool_t *pool); +filter_pt filter_parseOr(char * filterString, int * pos, apr_pool_t *pool); +filter_pt filter_parseNot(char * filterString, int * pos, apr_pool_t *pool); +filter_pt filter_parseItem(char * filterString, int * pos, apr_pool_t *pool); char * filter_parseAttr(char * filterString, int * pos); char * filter_parseValue(char * filterString, int * pos); -array_list_t filter_parseSubstring(char * filterString, int * pos, apr_pool_t *pool); +array_list_pt filter_parseSubstring(char * filterString, int * pos, apr_pool_t *pool); celix_status_t filter_compare(OPERAND operand, char * string, void * value2, bool *result); celix_status_t filter_compareString(OPERAND operand, char * string, void * value2, bool *result); @@ -73,8 +73,8 @@ void filter_skipWhiteSpace(char * filter } } -filter_t filter_create(char * filterString, apr_pool_t *pool) { - filter_t filter = NULL; +filter_pt filter_create(char * filterString, apr_pool_t *pool) { + filter_pt filter = NULL; int pos = 0; filter = filter_parseFilter(filterString, &pos, pool); if (pos != strlen(filterString)) { @@ -85,7 +85,7 @@ filter_t filter_create(char * filterStri return filter; } -void filter_destroy(filter_t filter) { +void filter_destroy(filter_pt filter) { if (filter != NULL) { if (filter->operand == SUBSTRING) { arrayList_clear(filter->value); @@ -95,7 +95,7 @@ void filter_destroy(filter_t filter) { int size = arrayList_size(filter->value); int i = 0; for (i = 0; i < size; i++) { - filter_t f = arrayList_get(filter->value, i); + filter_pt f = arrayList_get(filter->value, i); filter_destroy(f); } arrayList_destroy(filter->value); @@ -111,8 +111,8 @@ void filter_destroy(filter_t filter) { } } -filter_t filter_parseFilter(char * filterString, int * pos, apr_pool_t *pool) { - filter_t filter; +filter_pt filter_parseFilter(char * filterString, int * pos, apr_pool_t *pool) { + filter_pt filter; filter_skipWhiteSpace(filterString, pos); if (filterString[*pos] != '(') { printf("Error: Missing '('\n"); @@ -134,7 +134,7 @@ filter_t filter_parseFilter(char * filte return filter; } -filter_t filter_parseFilterComp(char * filterString, int * pos, apr_pool_t *pool) { +filter_pt filter_parseFilterComp(char * filterString, int * pos, apr_pool_t *pool) { char c; filter_skipWhiteSpace(filterString, pos); @@ -157,9 +157,9 @@ filter_t filter_parseFilterComp(char * f return filter_parseItem(filterString, pos, pool); } -filter_t filter_parseAnd(char * filterString, int * pos, apr_pool_t *pool) { - filter_t filter = (filter_t) malloc(sizeof(*filter)); - array_list_t operands = NULL; +filter_pt filter_parseAnd(char * filterString, int * pos, apr_pool_t *pool) { + filter_pt filter = (filter_pt) malloc(sizeof(*filter)); + array_list_pt operands = NULL; arrayList_create(pool, &operands); filter_skipWhiteSpace(filterString, pos); @@ -169,7 +169,7 @@ filter_t filter_parseAnd(char * filterSt } while(filterString[*pos] == '(') { - filter_t child = filter_parseFilter(filterString, pos, pool); + filter_pt child = filter_parseFilter(filterString, pos, pool); arrayList_add(operands, child); } @@ -180,9 +180,9 @@ filter_t filter_parseAnd(char * filterSt return filter; } -filter_t filter_parseOr(char * filterString, int * pos, apr_pool_t *pool) { - filter_t filter = (filter_t) malloc(sizeof(*filter)); - array_list_t operands = NULL; +filter_pt filter_parseOr(char * filterString, int * pos, apr_pool_t *pool) { + filter_pt filter = (filter_pt) malloc(sizeof(*filter)); + array_list_pt operands = NULL; arrayList_create(pool, &operands); filter_skipWhiteSpace(filterString, pos); @@ -192,7 +192,7 @@ filter_t filter_parseOr(char * filterStr } while(filterString[*pos] == '(') { - filter_t child = filter_parseFilter(filterString, pos, pool); + filter_pt child = filter_parseFilter(filterString, pos, pool); arrayList_add(operands, child); } @@ -203,9 +203,9 @@ filter_t filter_parseOr(char * filterStr return filter; } -filter_t filter_parseNot(char * filterString, int * pos, apr_pool_t *pool) { - filter_t child = NULL; - filter_t filter = (filter_t) malloc(sizeof(*filter)); +filter_pt filter_parseNot(char * filterString, int * pos, apr_pool_t *pool) { + filter_pt child = NULL; + filter_pt filter = (filter_pt) malloc(sizeof(*filter)); filter_skipWhiteSpace(filterString, pos); if (filterString[*pos] != '(') { @@ -222,13 +222,13 @@ filter_t filter_parseNot(char * filterSt return filter; } -filter_t filter_parseItem(char * filterString, int * pos, apr_pool_t *pool) { +filter_pt filter_parseItem(char * filterString, int * pos, apr_pool_t *pool) { char * attr = filter_parseAttr(filterString, pos); filter_skipWhiteSpace(filterString, pos); switch(filterString[*pos]) { case '~': { if (filterString[*pos + 1] == '=') { - filter_t filter = (filter_t) malloc(sizeof(*filter)); + filter_pt filter = (filter_pt) malloc(sizeof(*filter)); *pos += 2; filter->operand = APPROX; filter->attribute = attr; @@ -239,7 +239,7 @@ filter_t filter_parseItem(char * filterS } case '>': { if (filterString[*pos + 1] == '=') { - filter_t filter = (filter_t) malloc(sizeof(*filter)); + filter_pt filter = (filter_pt) malloc(sizeof(*filter)); *pos += 2; filter->operand = GREATER; filter->attribute = attr; @@ -250,7 +250,7 @@ filter_t filter_parseItem(char * filterS } case '<': { if (filterString[*pos + 1] == '=') { - filter_t filter = (filter_t) malloc(sizeof(*filter)); + filter_pt filter = (filter_pt) malloc(sizeof(*filter)); *pos += 2; filter->operand = LESS; filter->attribute = attr; @@ -260,14 +260,14 @@ filter_t filter_parseItem(char * filterS break; } case '=': { - filter_t filter = NULL; - array_list_t subs; + filter_pt filter = NULL; + array_list_pt subs; if (filterString[*pos + 1] == '*') { int oldPos = *pos; *pos += 2; filter_skipWhiteSpace(filterString, pos); if (filterString[*pos] == ')') { - filter_t filter = (filter_t) malloc(sizeof(*filter)); + filter_pt filter = (filter_pt) malloc(sizeof(*filter)); filter->operand = PRESENT; filter->attribute = attr; filter->value = NULL; @@ -275,7 +275,7 @@ filter_t filter_parseItem(char * filterS } *pos = oldPos; } - filter = (filter_t) malloc(sizeof(*filter)); + filter = (filter_pt) malloc(sizeof(*filter)); (*pos)++; subs = filter_parseSubstring(filterString, pos, pool); if (arrayList_size(subs) == 1) { @@ -372,9 +372,9 @@ char * filter_parseValue(char * filterSt return value; } -array_list_t filter_parseSubstring(char * filterString, int * pos, apr_pool_t *pool) { +array_list_pt filter_parseSubstring(char * filterString, int * pos, apr_pool_t *pool) { char * sub = (char *) malloc(strlen(filterString)); - array_list_t operands = NULL; + array_list_pt operands = NULL; int keepRunning = 1; int size; @@ -431,13 +431,13 @@ array_list_t filter_parseSubstring(char return operands; } -celix_status_t filter_match(filter_t filter, properties_t properties, bool *result) { +celix_status_t filter_match(filter_pt filter, properties_pt properties, bool *result) { switch (filter->operand) { case AND: { - array_list_t filters = (array_list_t) filter->value; + array_list_pt filters = (array_list_pt) filter->value; unsigned int i; for (i = 0; i < arrayList_size(filters); i++) { - filter_t sfilter = (filter_t) arrayList_get(filters, i); + filter_pt sfilter = (filter_pt) arrayList_get(filters, i); bool mresult; filter_match(sfilter, properties, &mresult); if (!mresult) { @@ -449,10 +449,10 @@ celix_status_t filter_match(filter_t fil return CELIX_SUCCESS; } case OR: { - array_list_t filters = (array_list_t) filter->value; + array_list_pt filters = (array_list_pt) filter->value; unsigned int i; for (i = 0; i < arrayList_size(filters); i++) { - filter_t sfilter = (filter_t) arrayList_get(filters, i); + filter_pt sfilter = (filter_pt) arrayList_get(filters, i); bool mresult; filter_match(sfilter, properties, &mresult); if (mresult) { @@ -464,7 +464,7 @@ celix_status_t filter_match(filter_t fil return CELIX_SUCCESS; } case NOT: { - filter_t sfilter = (filter_t) filter->value; + filter_pt sfilter = (filter_pt) filter->value; bool mresult; filter_match(sfilter, properties, &mresult); *result = !mresult; @@ -501,7 +501,7 @@ celix_status_t filter_compare(OPERAND op celix_status_t filter_compareString(OPERAND operand, char * string, void * value2, bool *result) { switch (operand) { case SUBSTRING: { - array_list_t subs = (array_list_t) value2; + array_list_pt subs = (array_list_pt) value2; int pos = 0; int i; int size = arrayList_size(subs); @@ -580,7 +580,7 @@ celix_status_t filter_compareString(OPER return CELIX_SUCCESS; } -celix_status_t filter_getString(filter_t filter, char **filterStr) { +celix_status_t filter_getString(filter_pt filter, char **filterStr) { if (filter != NULL) { *filterStr = filter->filterStr; } Modified: incubator/celix/trunk/framework/private/src/framework.c URL: http://svn.apache.org/viewvc/incubator/celix/trunk/framework/private/src/framework.c?rev=1492377&r1=1492376&r2=1492377&view=diff ============================================================================== --- incubator/celix/trunk/framework/private/src/framework.c (original) +++ incubator/celix/trunk/framework/private/src/framework.c Wed Jun 12 19:08:50 2013 @@ -65,14 +65,14 @@ struct framework { struct bundle * bundle; - hash_map_t installedBundleMap; - hash_map_t installRequestMap; - array_list_t serviceListeners; - array_list_t bundleListeners; + hash_map_pt installedBundleMap; + hash_map_pt installRequestMap; + array_list_pt serviceListeners; + array_list_pt bundleListeners; long nextBundleId; struct serviceRegistry * registry; -bundle_cache_t cache; +bundle_cache_pt cache; apr_thread_cond_t *shutdownGate; apr_thread_cond_t *condition; @@ -82,7 +82,7 @@ bundle_cache_t cache; apr_thread_mutex_t *bundleLock; apr_os_thread_t globalLockThread; - array_list_t globalLockWaitersList; + array_list_pt globalLockWaitersList; int globalLockCount; bool interrupted; @@ -90,9 +90,9 @@ bundle_cache_t cache; apr_pool_t *mp; - properties_t configurationMap; + properties_pt configurationMap; - array_list_t requests; + array_list_pt requests; apr_thread_cond_t *dispatcher; apr_thread_mutex_t *dispatcherLock; apr_thread_t *dispatcherThread; @@ -100,39 +100,39 @@ bundle_cache_t cache; struct activator { void * userData; - void (*start)(void * userData, bundle_context_t context); - void (*stop)(void * userData, bundle_context_t context); - void (*destroy)(void * userData, bundle_context_t context); + void (*start)(void * userData, bundle_context_pt context); + void (*stop)(void * userData, bundle_context_pt context); + void (*destroy)(void * userData, bundle_context_pt context); }; -celix_status_t framework_setBundleStateAndNotify(framework_t framework, bundle_t bundle, int state); -celix_status_t framework_markBundleResolved(framework_t framework, module_t module); +celix_status_t framework_setBundleStateAndNotify(framework_pt framework, bundle_pt bundle, int state); +celix_status_t framework_markBundleResolved(framework_pt framework, module_pt module); -celix_status_t framework_acquireBundleLock(framework_t framework, bundle_t bundle, int desiredStates); -bool framework_releaseBundleLock(framework_t framework, bundle_t bundle); +celix_status_t framework_acquireBundleLock(framework_pt framework, bundle_pt bundle, int desiredStates); +bool framework_releaseBundleLock(framework_pt framework, bundle_pt bundle); -bool framework_acquireGlobalLock(framework_t framework); -celix_status_t framework_releaseGlobalLock(framework_t framework); +bool framework_acquireGlobalLock(framework_pt framework); +celix_status_t framework_releaseGlobalLock(framework_pt framework); -celix_status_t framework_acquireInstallLock(framework_t framework, char * location); -celix_status_t framework_releaseInstallLock(framework_t framework, char * location); +celix_status_t framework_acquireInstallLock(framework_pt framework, char * location); +celix_status_t framework_releaseInstallLock(framework_pt framework, char * location); -long framework_getNextBundleId(framework_t framework); +long framework_getNextBundleId(framework_pt framework); -celix_status_t fw_installBundle2(framework_t framework, bundle_t * bundle, long id, char * location, char *inputFile, bundle_archive_t archive); +celix_status_t fw_installBundle2(framework_pt framework, bundle_pt * bundle, long id, char * location, char *inputFile, bundle_archive_pt archive); -celix_status_t fw_refreshBundles(framework_t framework, bundle_t bundles[], int size); -celix_status_t fw_refreshBundle(framework_t framework, bundle_t bundle); +celix_status_t fw_refreshBundles(framework_pt framework, bundle_pt bundles[], int size); +celix_status_t fw_refreshBundle(framework_pt framework, bundle_pt bundle); -celix_status_t fw_populateDependentGraph(framework_t framework, bundle_t exporter, hash_map_t *map); +celix_status_t fw_populateDependentGraph(framework_pt framework, bundle_pt exporter, hash_map_pt *map); -celix_status_t fw_fireBundleEvent(framework_t framework, bundle_event_type_e, bundle_t bundle); +celix_status_t fw_fireBundleEvent(framework_pt framework, bundle_event_type_e, bundle_pt bundle); static void *APR_THREAD_FUNC fw_eventDispatcher(apr_thread_t *thd, void *fw); -celix_status_t fw_invokeBundleListener(framework_t framework, bundle_listener_t listener, bundle_event_t event, bundle_t bundle); +celix_status_t fw_invokeBundleListener(framework_pt framework, bundle_listener_pt listener, bundle_event_pt event, bundle_pt bundle); struct fw_refreshHelper { - framework_t framework; - bundle_t bundle; + framework_pt framework; + bundle_pt bundle; bundle_state_e oldState; }; @@ -141,20 +141,20 @@ celix_status_t fw_refreshHelper_restart( celix_status_t fw_refreshHelper_stop(struct fw_refreshHelper * refreshHelper); struct fw_serviceListener { - bundle_t bundle; - service_listener_t listener; - filter_t filter; + bundle_pt bundle; + service_listener_pt listener; + filter_pt filter; }; -typedef struct fw_serviceListener * fw_service_listener_t; +typedef struct fw_serviceListener * fw_service_listener_pt; struct fw_bundleListener { apr_pool_t *pool; - bundle_t bundle; - bundle_listener_t listener; + bundle_pt bundle; + bundle_listener_pt listener; }; -typedef struct fw_bundleListener * fw_bundle_listener_t; +typedef struct fw_bundleListener * fw_bundle_listener_pt; enum event_type { FRAMEWORK_EVENT_TYPE, @@ -166,20 +166,20 @@ typedef enum event_type event_type_e; struct request { event_type_e type; - array_list_t listeners; + array_list_pt listeners; int eventType; - bundle_t bundle; + bundle_pt bundle; char *filter; }; -typedef struct request *request_t; +typedef struct request *request_pt; -celix_status_t framework_create(framework_t *framework, apr_pool_t *memoryPool, properties_t config) { +celix_status_t framework_create(framework_pt *framework, apr_pool_t *memoryPool, properties_pt config) { celix_status_t status = CELIX_SUCCESS; - *framework = (framework_t) apr_palloc(memoryPool, sizeof(**framework)); + *framework = (framework_pt) apr_palloc(memoryPool, sizeof(**framework)); if (*framework == NULL) { status = CELIX_ENOMEM; } else { @@ -187,7 +187,7 @@ celix_status_t framework_create(framewor if (apr_status != APR_SUCCESS) { status = CELIX_FRAMEWORK_EXCEPTION; } else { - bundle_t bundle = NULL; + bundle_pt bundle = NULL; apr_pool_t *bundlePool; apr_status_t apr_status = apr_pool_create(&bundlePool, (*framework)->mp); if (apr_status != APR_SUCCESS) { @@ -258,25 +258,25 @@ celix_status_t framework_create(framewor return status; } -celix_status_t framework_destroy(framework_t framework) { +celix_status_t framework_destroy(framework_pt framework) { celix_status_t status = CELIX_SUCCESS; - hash_map_iterator_t iterator = hashMapIterator_create(framework->installedBundleMap); + hash_map_iterator_pt iterator = hashMapIterator_create(framework->installedBundleMap); while (hashMapIterator_hasNext(iterator)) { - linked_list_t wires; - hash_map_entry_t entry = hashMapIterator_nextEntry(iterator); - bundle_t bundle = (bundle_t) hashMapEntry_getValue(entry); + linked_list_pt wires; + hash_map_entry_pt entry = hashMapIterator_nextEntry(iterator); + bundle_pt bundle = (bundle_pt) hashMapEntry_getValue(entry); char *location = (char *) hashMapEntry_getKey(entry); - bundle_archive_t archive = NULL; + bundle_archive_pt archive = NULL; // for each installed bundle, clean up memory - module_t mod = NULL; + module_pt mod = NULL; bundle_getCurrentModule(bundle, &mod); wires = module_getWires(mod); if (wires != NULL) { - linked_list_iterator_t iter = linkedListIterator_create(wires, 0); + linked_list_iterator_pt iter = linkedListIterator_create(wires, 0); while (linkedListIterator_hasNext(iter)) { - wire_t wire = (wire_t) linkedListIterator_next(iter); + wire_pt wire = (wire_pt) linkedListIterator_next(iter); linkedListIterator_remove(iter); } linkedListIterator_destroy(iter); @@ -306,10 +306,10 @@ celix_status_t framework_destroy(framewo return status; } -typedef void *(*create_function_t)(bundle_context_t context, void **userData); -typedef void (*start_function_t)(void * handle, bundle_context_t context); -typedef void (*stop_function_t)(void * handle, bundle_context_t context); -typedef void (*destroy_function_t)(void * handle, bundle_context_t context); +typedef void *(*create_function_pt)(bundle_context_pt context, void **userData); +typedef void (*start_function_pt)(void * handle, bundle_context_pt context); +typedef void (*stop_function_pt)(void * handle, bundle_context_pt context); +typedef void (*destroy_function_pt)(void * handle, bundle_context_pt context); #ifdef _WIN32 HMODULE fw_getCurrentModule() { @@ -319,14 +319,14 @@ HMODULE fw_getCurrentModule() { } #endif -celix_status_t fw_init(framework_t framework) { +celix_status_t fw_init(framework_pt framework) { celix_status_t status = framework_acquireBundleLock(framework, framework->bundle, BUNDLE_INSTALLED|BUNDLE_RESOLVED|BUNDLE_STARTING|BUNDLE_ACTIVE); bundle_state_e state; char *location; - module_t module = NULL; - hash_map_t wires; - array_list_t archives; - bundle_archive_t archive = NULL; + module_pt module = NULL; + hash_map_pt wires; + array_list_pt archives; + bundle_archive_pt archive = NULL; if (status != CELIX_SUCCESS) { framework_releaseBundleLock(framework, framework->bundle); @@ -341,7 +341,7 @@ celix_status_t fw_init(framework_t frame bundle_getState(framework->bundle, &state); if ((state == BUNDLE_INSTALLED) || (state == BUNDLE_RESOLVED)) { - properties_t props = properties_create(); + properties_pt props = properties_create(); properties_set(props, (char *) FRAMEWORK_STORAGE, ".cache"); status = bundleCache_create(props, framework->mp, &framework->cache); if (status == CELIX_SUCCESS) { @@ -387,11 +387,11 @@ celix_status_t fw_init(framework_t frame void * handle = NULL; #endif unsigned int arcIdx; - bundle_context_t context = NULL; - ACTIVATOR activator; + bundle_context_pt context = NULL; + activator_pt activator; for (arcIdx = 0; arcIdx < arrayList_size(archives); arcIdx++) { - bundle_archive_t archive1 = (bundle_archive_t) arrayList_get(archives, arcIdx); + bundle_archive_pt archive1 = (bundle_archive_pt) arrayList_get(archives, arcIdx); long id; bundle_state_e bundleState; bundleArchive_getId(archive1, &id); @@ -401,7 +401,7 @@ celix_status_t fw_init(framework_t frame if (bundleState == BUNDLE_UNINSTALLED) { bundleArchive_closeAndDelete(archive1); } else { - bundle_t bundle = NULL; + bundle_pt bundle = NULL; char *location1 = NULL; status = bundleArchive_getLocation(archive1, &location1); fw_installBundle2(framework, &bundle, id, location1, NULL, archive1); @@ -436,22 +436,22 @@ celix_status_t fw_init(framework_t frame bundle_setHandle(framework->bundle, handle); - activator = (ACTIVATOR) apr_palloc(framework->mp, (sizeof(*activator))); + activator = (activator_pt) apr_palloc(framework->mp, (sizeof(*activator))); if (activator == NULL) { status = CELIX_ENOMEM; } else { - bundle_context_t context = NULL; + bundle_context_pt context = NULL; void * userData = NULL; #ifdef _WIN32 - create_function_t create = (create_function_t) GetProcAddress((HMODULE) bundle_getHandle(framework->bundle), BUNDLE_ACTIVATOR_CREATE); - start_function_t start = (start_function_t) GetProcAddress((HMODULE) bundle_getHandle(framework->bundle), BUNDLE_ACTIVATOR_START); - stop_function_t stop = (stop_function_t) GetProcAddress((HMODULE) bundle_getHandle(framework->bundle), BUNDLE_ACTIVATOR_STOP); - destroy_function_t destroy = (destroy_function_t) GetProcAddress((HMODULE) bundle_getHandle(framework->bundle), BUNDLE_ACTIVATOR_DESTROY); + create_function_pt create = (create_function_pt) GetProcAddress((HMODULE) bundle_getHandle(framework->bundle), BUNDLE_ACTIVATOR_CREATE); + start_function_pt start = (start_function_pt) GetProcAddress((HMODULE) bundle_getHandle(framework->bundle), BUNDLE_ACTIVATOR_START); + stop_function_pt stop = (stop_function_pt) GetProcAddress((HMODULE) bundle_getHandle(framework->bundle), BUNDLE_ACTIVATOR_STOP); + destroy_function_pt destroy = (destroy_function_pt) GetProcAddress((HMODULE) bundle_getHandle(framework->bundle), BUNDLE_ACTIVATOR_DESTROY); #else - create_function_t create = dlsym(bundle_getHandle(framework->bundle), BUNDLE_ACTIVATOR_CREATE); - start_function_t start = dlsym(bundle_getHandle(framework->bundle), BUNDLE_ACTIVATOR_START); - stop_function_t stop = dlsym(bundle_getHandle(framework->bundle), BUNDLE_ACTIVATOR_STOP); - destroy_function_t destroy = dlsym(bundle_getHandle(framework->bundle), BUNDLE_ACTIVATOR_DESTROY); + create_function_pt create = dlsym(bundle_getHandle(framework->bundle), BUNDLE_ACTIVATOR_CREATE); + start_function_pt start = dlsym(bundle_getHandle(framework->bundle), BUNDLE_ACTIVATOR_START); + stop_function_pt stop = dlsym(bundle_getHandle(framework->bundle), BUNDLE_ACTIVATOR_STOP); + destroy_function_pt destroy = dlsym(bundle_getHandle(framework->bundle), BUNDLE_ACTIVATOR_DESTROY); #endif activator->start = start; activator->stop = stop; @@ -484,7 +484,7 @@ celix_status_t fw_init(framework_t frame return status; } -celix_status_t framework_start(framework_t framework) { +celix_status_t framework_start(framework_pt framework) { celix_status_t lock = framework_acquireBundleLock(framework, framework->bundle, BUNDLE_INSTALLED|BUNDLE_RESOLVED|BUNDLE_STARTING|BUNDLE_ACTIVE); bundle_state_e state; @@ -511,11 +511,11 @@ celix_status_t framework_start(framework return CELIX_SUCCESS; } -void framework_stop(framework_t framework) { +void framework_stop(framework_pt framework) { fw_stopBundle(framework, framework->bundle, true); } -celix_status_t fw_getProperty(framework_t framework, const char *name, char **value) { +celix_status_t fw_getProperty(framework_pt framework, const char *name, char **value) { celix_status_t status = CELIX_SUCCESS; if (framework == NULL || name == NULL || *value != NULL) { @@ -532,12 +532,12 @@ celix_status_t fw_getProperty(framework_ return status; } -celix_status_t fw_installBundle(framework_t framework, bundle_t * bundle, char * location, char *inputFile) { +celix_status_t fw_installBundle(framework_pt framework, bundle_pt * bundle, char * location, char *inputFile) { return fw_installBundle2(framework, bundle, -1, location, inputFile, NULL); } -celix_status_t fw_installBundle2(framework_t framework, bundle_t * bundle, long id, char * location, char *inputFile, bundle_archive_t archive) { - bundle_archive_t bundle_archive = NULL; +celix_status_t fw_installBundle2(framework_pt framework, bundle_pt * bundle, long id, char * location, char *inputFile, bundle_archive_pt archive) { + bundle_archive_pt bundle_archive = NULL; bundle_state_e state; apr_pool_t *bundlePool; bool locked; @@ -597,11 +597,11 @@ celix_status_t fw_installBundle2(framewo return status; } -celix_status_t framework_getBundleEntry(framework_t framework, bundle_t bundle, char *name, apr_pool_t *pool, char **entry) { +celix_status_t framework_getBundleEntry(framework_pt framework, bundle_pt bundle, char *name, apr_pool_t *pool, char **entry) { celix_status_t status = CELIX_SUCCESS; - bundle_revision_t revision; - bundle_archive_t archive = NULL; + bundle_revision_pt revision; + bundle_archive_pt archive = NULL; status = bundle_getArchive(bundle, &archive); if (status == CELIX_SUCCESS) { @@ -632,15 +632,15 @@ celix_status_t framework_getBundleEntry( return status; } -celix_status_t fw_startBundle(framework_t framework, bundle_t bundle, int options) { +celix_status_t fw_startBundle(framework_pt framework, bundle_pt bundle, int options) { celix_status_t lock = framework_acquireBundleLock(framework, bundle, BUNDLE_INSTALLED|BUNDLE_RESOLVED|BUNDLE_STARTING|BUNDLE_ACTIVE); - hash_map_t wires = NULL; + hash_map_pt wires = NULL; void * handle; - bundle_context_t context = NULL; + bundle_context_pt context = NULL; bundle_state_e state; - module_t module = NULL; - MANIFEST manifest = NULL; + module_pt module = NULL; + manifest_pt manifest = NULL; char *library; #ifdef __linux__ char * library_prefix = "lib"; @@ -657,8 +657,8 @@ celix_status_t fw_startBundle(framework_ long refreshCount; char *archiveRoot; long revisionNumber; - ACTIVATOR activator; - bundle_archive_t archive = NULL; + activator_pt activator; + bundle_archive_pt archive = NULL; apr_pool_t *bundlePool = NULL; if (lock != CELIX_SUCCESS) { @@ -747,23 +747,23 @@ celix_status_t fw_startBundle(framework_ bundle_setHandle(bundle, handle); - activator = (ACTIVATOR) apr_palloc(bundlePool, (sizeof(*activator))); + activator = (activator_pt) apr_palloc(bundlePool, (sizeof(*activator))); if (activator == NULL) { return CELIX_ENOMEM; } else { void * userData = NULL; - bundle_context_t context; + bundle_context_pt context; #ifdef _WIN32 - create_function_t create = (create_function_t) GetProcAddress((HMODULE) bundle_getHandle(bundle), BUNDLE_ACTIVATOR_CREATE); - start_function_t start = (start_function_t) GetProcAddress((HMODULE) bundle_getHandle(bundle), BUNDLE_ACTIVATOR_START); - stop_function_t stop = (stop_function_t) GetProcAddress((HMODULE) bundle_getHandle(bundle), BUNDLE_ACTIVATOR_STOP); - destroy_function_t destroy = (destroy_function_t) GetProcAddress((HMODULE) bundle_getHandle(bundle), BUNDLE_ACTIVATOR_DESTROY); + create_function_pt create = (create_function_pt) GetProcAddress((HMODULE) bundle_getHandle(bundle), BUNDLE_ACTIVATOR_CREATE); + start_function_pt start = (start_function_pt) GetProcAddress((HMODULE) bundle_getHandle(bundle), BUNDLE_ACTIVATOR_START); + stop_function_pt stop = (stop_function_pt) GetProcAddress((HMODULE) bundle_getHandle(bundle), BUNDLE_ACTIVATOR_STOP); + destroy_function_pt destroy = (destroy_function_pt) GetProcAddress((HMODULE) bundle_getHandle(bundle), BUNDLE_ACTIVATOR_DESTROY); #else - create_function_t create = dlsym(bundle_getHandle(bundle), BUNDLE_ACTIVATOR_CREATE); - start_function_t start = dlsym(bundle_getHandle(bundle), BUNDLE_ACTIVATOR_START); - stop_function_t stop = dlsym(bundle_getHandle(bundle), BUNDLE_ACTIVATOR_STOP); - destroy_function_t destroy = dlsym(bundle_getHandle(bundle), BUNDLE_ACTIVATOR_DESTROY); + create_function_pt create = dlsym(bundle_getHandle(bundle), BUNDLE_ACTIVATOR_CREATE); + start_function_pt start = dlsym(bundle_getHandle(bundle), BUNDLE_ACTIVATOR_START); + stop_function_pt stop = dlsym(bundle_getHandle(bundle), BUNDLE_ACTIVATOR_STOP); + destroy_function_pt destroy = dlsym(bundle_getHandle(bundle), BUNDLE_ACTIVATOR_DESTROY); #endif activator->start = start; @@ -798,13 +798,13 @@ celix_status_t fw_startBundle(framework_ return CELIX_SUCCESS; } -celix_status_t framework_updateBundle(framework_t framework, bundle_t bundle, char *inputFile) { +celix_status_t framework_updateBundle(framework_pt framework, bundle_pt bundle, char *inputFile) { celix_status_t status; celix_status_t lock = framework_acquireBundleLock(framework, bundle, BUNDLE_INSTALLED|BUNDLE_RESOLVED|BUNDLE_ACTIVE); bundle_state_e oldState; char *location; bool locked; - bundle_archive_t archive = NULL; + bundle_archive_pt archive = NULL; if (lock != CELIX_SUCCESS) { printf("Cannot update bundle, in wrong state"); @@ -844,7 +844,7 @@ celix_status_t framework_updateBundle(fr return CELIX_SUCCESS; } -celix_status_t fw_stopBundle(framework_t framework, bundle_t bundle, bool record) { +celix_status_t fw_stopBundle(framework_pt framework, bundle_pt bundle, bool record) { celix_status_t status = CELIX_SUCCESS; status = framework_acquireBundleLock(framework, bundle, BUNDLE_INSTALLED|BUNDLE_RESOLVED|BUNDLE_STARTING|BUNDLE_ACTIVE); @@ -853,10 +853,10 @@ celix_status_t fw_stopBundle(framework_t framework_releaseBundleLock(framework, bundle); } else { bundle_state_e state; - ACTIVATOR activator; - bundle_context_t context; - module_t module = NULL; - MANIFEST manifest = NULL; + activator_pt activator; + bundle_context_pt context; + module_pt module = NULL; + manifest_pt manifest = NULL; if (record) { bundle_setPersistentStateInactive(bundle); } @@ -928,7 +928,7 @@ celix_status_t fw_stopBundle(framework_t return status; } -celix_status_t fw_uninstallBundle(framework_t framework, bundle_t bundle) { +celix_status_t fw_uninstallBundle(framework_pt framework, bundle_pt bundle) { celix_status_t status = CELIX_SUCCESS; bundle_state_e state; @@ -953,13 +953,13 @@ celix_status_t fw_uninstallBundle(framew framework_releaseGlobalLock(framework); status = CELIX_ILLEGAL_STATE; } else { - bundle_archive_t archive = NULL; + bundle_archive_pt archive = NULL; char * location; - bundle_t target; + bundle_pt target; status = bundle_getArchive(bundle, &archive); status = bundleArchive_getLocation(archive, &location); // TODO sync issues? - target = (bundle_t) hashMap_remove(framework->installedBundleMap, location); + target = (bundle_pt) hashMap_remove(framework->installedBundleMap, location); if (target != NULL) { bundle_setPersistentStateUninstalled(target); @@ -984,7 +984,7 @@ celix_status_t fw_uninstallBundle(framew locked = framework_acquireGlobalLock(framework); if (locked) { - bundle_t bundles[] = { bundle }; + bundle_pt bundles[] = { bundle }; celix_status_t refreshStatus = fw_refreshBundles(framework, bundles, 1); if (refreshStatus != CELIX_SUCCESS) { printf("Could not refresh bundle"); @@ -999,7 +999,7 @@ celix_status_t fw_uninstallBundle(framew return status; } -celix_status_t fw_refreshBundles(framework_t framework, bundle_t bundles[], int size) { +celix_status_t fw_refreshBundles(framework_pt framework, bundle_pt bundles[], int size) { celix_status_t status = CELIX_SUCCESS; bool locked = framework_acquireGlobalLock(framework); @@ -1008,14 +1008,14 @@ celix_status_t fw_refreshBundles(framewo framework_releaseGlobalLock(framework); status = CELIX_ILLEGAL_STATE; } else { - hash_map_values_t values; - bundle_t *newTargets; + hash_map_values_pt values; + bundle_pt *newTargets; unsigned int nrofvalues; bool restart = false; - hash_map_t map = hashMap_create(NULL, NULL, NULL, NULL); + hash_map_pt map = hashMap_create(NULL, NULL, NULL, NULL); int targetIdx = 0; for (targetIdx = 0; targetIdx < size; targetIdx++) { - bundle_t bundle = bundles[targetIdx]; + bundle_pt bundle = bundles[targetIdx]; hashMap_put(map, bundle, bundle); fw_populateDependentGraph(framework, bundle, &map); } @@ -1029,7 +1029,7 @@ celix_status_t fw_refreshBundles(framewo int i = 0; struct fw_refreshHelper * helpers; for (i = 0; i < nrofvalues && !restart; i++) { - bundle_t bundle = (bundle_t) newTargets[i]; + bundle_pt bundle = (bundle_pt) newTargets[i]; if (framework->bundle == bundle) { restart = true; } @@ -1037,7 +1037,7 @@ celix_status_t fw_refreshBundles(framewo helpers = (struct fw_refreshHelper * )malloc(nrofvalues * sizeof(struct fw_refreshHelper)); for (i = 0; i < nrofvalues && !restart; i++) { - bundle_t bundle = (bundle_t) newTargets[i]; + bundle_pt bundle = (bundle_pt) newTargets[i]; helpers[i].framework = framework; helpers[i].bundle = bundle; helpers[i].oldState = BUNDLE_INSTALLED; @@ -1067,7 +1067,7 @@ celix_status_t fw_refreshBundles(framewo return status; } -celix_status_t fw_refreshBundle(framework_t framework, bundle_t bundle) { +celix_status_t fw_refreshBundle(framework_pt framework, bundle_pt bundle) { celix_status_t status = CELIX_SUCCESS; bundle_state_e state; @@ -1120,11 +1120,11 @@ celix_status_t fw_refreshHelper_restart( return CELIX_SUCCESS; } -celix_status_t fw_getDependentBundles(framework_t framework, bundle_t exporter, array_list_t *list) { +celix_status_t fw_getDependentBundles(framework_pt framework, bundle_pt exporter, array_list_pt *list) { celix_status_t status = CELIX_SUCCESS; if (*list == NULL && exporter != NULL && framework != NULL) { - array_list_t modules; + array_list_pt modules; unsigned int modIdx = 0; apr_pool_t *pool = NULL; bundle_getMemoryPool(exporter, &pool); @@ -1132,11 +1132,11 @@ celix_status_t fw_getDependentBundles(fr modules = bundle_getModules(exporter); for (modIdx = 0; modIdx < arrayList_size(modules); modIdx++) { - module_t module = (module_t) arrayList_get(modules, modIdx); - array_list_t dependents = module_getDependents(module); + module_pt module = (module_pt) arrayList_get(modules, modIdx); + array_list_pt dependents = module_getDependents(module); unsigned int depIdx = 0; for (depIdx = 0; (dependents != NULL) && (depIdx < arrayList_size(dependents)); depIdx++) { - module_t dependent = (module_t) arrayList_get(dependents, depIdx); + module_pt dependent = (module_pt) arrayList_get(dependents, depIdx); arrayList_add(*list, module_getBundle(dependent)); } arrayList_destroy(dependents); @@ -1148,17 +1148,17 @@ celix_status_t fw_getDependentBundles(fr return status; } -celix_status_t fw_populateDependentGraph(framework_t framework, bundle_t exporter, hash_map_t *map) { +celix_status_t fw_populateDependentGraph(framework_pt framework, bundle_pt exporter, hash_map_pt *map) { celix_status_t status = CELIX_SUCCESS; if (exporter != NULL && framework != NULL) { - array_list_t dependents = NULL; + array_list_pt dependents = NULL; if ((status = fw_getDependentBundles(framework, exporter, &dependents)) == CELIX_SUCCESS) { unsigned int depIdx = 0; for (depIdx = 0; (dependents != NULL) && (depIdx < arrayList_size(dependents)); depIdx++) { if (!hashMap_containsKey(*map, arrayList_get(dependents, depIdx))) { hashMap_put(*map, arrayList_get(dependents, depIdx), arrayList_get(dependents, depIdx)); - fw_populateDependentGraph(framework, (bundle_t) arrayList_get(dependents, depIdx), map); + fw_populateDependentGraph(framework, (bundle_pt) arrayList_get(dependents, depIdx), map); } } arrayList_destroy(dependents); @@ -1170,7 +1170,7 @@ celix_status_t fw_populateDependentGraph return status; } -celix_status_t fw_registerService(framework_t framework, service_registration_t *registration, bundle_t bundle, char * serviceName, void * svcObj, properties_t properties) { +celix_status_t fw_registerService(framework_pt framework, service_registration_pt *registration, bundle_pt bundle, char * serviceName, void * svcObj, properties_pt properties) { celix_status_t lock; if (serviceName == NULL) { printf("Service name cannot be null"); @@ -1192,26 +1192,26 @@ celix_status_t fw_registerService(framew // If this is a listener hook, invoke the callback with all current listeners if (strcmp(serviceName, listener_hook_service_name) == 0) { unsigned int i; - array_list_t infos = NULL; + array_list_pt infos = NULL; apr_pool_t *subpool; - service_reference_t ref = NULL; - listener_hook_service_t hook; + service_reference_pt ref = NULL; + listener_hook_service_pt hook; apr_pool_t *pool = NULL; bundle_getMemoryPool(bundle, &pool); arrayList_create(pool, &infos); for (i = 0; i < arrayList_size(framework->serviceListeners); i++) { - fw_service_listener_t listener =(fw_service_listener_t) arrayList_get(framework->serviceListeners, i); + fw_service_listener_pt listener =(fw_service_listener_pt) arrayList_get(framework->serviceListeners, i); apr_pool_t *pool; - bundle_context_t context; - listener_hook_info_t info; - bundle_context_t lContext = NULL; + bundle_context_pt context; + listener_hook_info_pt info; + bundle_context_pt lContext = NULL; bundle_getContext(bundle, &context); bundleContext_getMemoryPool(context, &pool); - info = (listener_hook_info_t) apr_palloc(pool, sizeof(*info)); + info = (listener_hook_info_pt) apr_palloc(pool, sizeof(*info)); bundle_getContext(listener->bundle, &lContext); info->context = lContext; @@ -1224,7 +1224,7 @@ celix_status_t fw_registerService(framew apr_pool_create(&subpool, pool); serviceRegistry_createServiceReference(framework->registry, subpool, *registration, &ref); - hook = (listener_hook_service_t) fw_getService(framework,framework->bundle, ref); + hook = (listener_hook_service_pt) fw_getService(framework,framework->bundle, ref); hook->added(hook->handle, infos); serviceRegistry_ungetService(framework->registry, framework->bundle, ref); @@ -1234,7 +1234,7 @@ celix_status_t fw_registerService(framew return CELIX_SUCCESS; } -celix_status_t fw_registerServiceFactory(framework_t framework, service_registration_t *registration, bundle_t bundle, char * serviceName, service_factory_t factory, properties_t properties) { +celix_status_t fw_registerServiceFactory(framework_pt framework, service_registration_pt *registration, bundle_pt bundle, char * serviceName, service_factory_pt factory, properties_pt properties) { celix_status_t lock; if (serviceName == NULL) { printf("Service name cannot be null"); @@ -1256,8 +1256,8 @@ celix_status_t fw_registerServiceFactory return CELIX_SUCCESS; } -celix_status_t fw_getServiceReferences(framework_t framework, array_list_t *references, bundle_t bundle, const char * serviceName, char * sfilter) { - filter_t filter = NULL; +celix_status_t fw_getServiceReferences(framework_pt framework, array_list_pt *references, bundle_pt bundle, const char * serviceName, char * sfilter) { + filter_pt filter = NULL; unsigned int refIdx = 0; apr_pool_t *pool = NULL; @@ -1274,10 +1274,10 @@ celix_status_t fw_getServiceReferences(f } for (refIdx = 0; (*references != NULL) && refIdx < arrayList_size(*references); refIdx++) { - service_reference_t ref = (service_reference_t) arrayList_get(*references, refIdx); - service_registration_t reg = NULL; + service_reference_pt ref = (service_reference_pt) arrayList_get(*references, refIdx); + service_registration_pt reg = NULL; char * serviceName; - properties_t props = NULL; + properties_pt props = NULL; serviceReference_getServiceRegistration(ref, ®); serviceRegistration_getProperties(reg, &props); serviceName = properties_get(props, (char *) OBJECTCLASS); @@ -1290,46 +1290,46 @@ celix_status_t fw_getServiceReferences(f return CELIX_SUCCESS; } -void * fw_getService(framework_t framework, bundle_t bundle, service_reference_t reference) { +void * fw_getService(framework_pt framework, bundle_pt bundle, service_reference_pt reference) { return serviceRegistry_getService(framework->registry, bundle, reference); } -celix_status_t fw_getBundleRegisteredServices(framework_t framework, apr_pool_t *pool, bundle_t bundle, array_list_t *services) { +celix_status_t fw_getBundleRegisteredServices(framework_pt framework, apr_pool_t *pool, bundle_pt bundle, array_list_pt *services) { return serviceRegistry_getRegisteredServices(framework->registry, pool, bundle, services); } -celix_status_t fw_getBundleServicesInUse(framework_t framework, bundle_t bundle, array_list_t *services) { +celix_status_t fw_getBundleServicesInUse(framework_pt framework, bundle_pt bundle, array_list_pt *services) { celix_status_t status = CELIX_SUCCESS; *services = serviceRegistry_getServicesInUse(framework->registry, bundle); return status; } -bool framework_ungetService(framework_t framework, bundle_t bundle, service_reference_t reference) { +bool framework_ungetService(framework_pt framework, bundle_pt bundle, service_reference_pt reference) { return serviceRegistry_ungetService(framework->registry, bundle, reference); } -void fw_addServiceListener(framework_t framework, bundle_t bundle, service_listener_t listener, char * sfilter) { +void fw_addServiceListener(framework_pt framework, bundle_pt bundle, service_listener_pt listener, char * sfilter) { // apr_pool_t *pool; // apr_pool_t *bpool; -// bundle_context_t context; +// bundle_context_pt context; // bundle_getContext(bundle, &context); // bundleContext_getMemoryPool(context, &bpool); // apr_pool_create(&pool, bpool); - array_list_t listenerHooks = NULL; + array_list_pt listenerHooks = NULL; apr_pool_t *subpool; - listener_hook_info_t info; + listener_hook_info_pt info; unsigned int i; - fw_service_listener_t fwListener = (fw_service_listener_t) malloc(sizeof(*fwListener)); + fw_service_listener_pt fwListener = (fw_service_listener_pt) malloc(sizeof(*fwListener)); apr_pool_t *pool = NULL; - bundle_context_t context = NULL; + bundle_context_pt context = NULL; bundle_getMemoryPool(bundle, &pool); fwListener->bundle = bundle; if (sfilter != NULL) { - filter_t filter = filter_create(sfilter, pool); + filter_pt filter = filter_create(sfilter, pool); fwListener->filter = filter; } else { fwListener->filter = NULL; @@ -1340,7 +1340,7 @@ void fw_addServiceListener(framework_t f apr_pool_create(&subpool, listener->pool); serviceRegistry_getListenerHooks(framework->registry, subpool, &listenerHooks); - info = (listener_hook_info_t) apr_palloc(subpool, sizeof(*info)); + info = (listener_hook_info_pt) apr_palloc(subpool, sizeof(*info)); bundle_getContext(bundle, &context); info->context = context; @@ -1349,9 +1349,9 @@ void fw_addServiceListener(framework_t f info->filter = sfilter == NULL ? NULL : apr_pstrdup(subpool, sfilter); for (i = 0; i < arrayList_size(listenerHooks); i++) { - service_reference_t ref = (service_reference_t) arrayList_get(listenerHooks, i); - listener_hook_service_t hook = (listener_hook_service_t) fw_getService(framework, framework->bundle, ref); - array_list_t infos = NULL; + service_reference_pt ref = (service_reference_pt) arrayList_get(listenerHooks, i); + listener_hook_service_pt hook = (listener_hook_service_pt) fw_getService(framework, framework->bundle, ref); + array_list_pt infos = NULL; arrayList_create(subpool, &infos); arrayList_add(infos, info); hook->added(hook->handle, infos); @@ -1362,22 +1362,22 @@ void fw_addServiceListener(framework_t f apr_pool_destroy(subpool); } -void fw_removeServiceListener(framework_t framework, bundle_t bundle, service_listener_t listener) { - listener_hook_info_t info = NULL; +void fw_removeServiceListener(framework_pt framework, bundle_pt bundle, service_listener_pt listener) { + listener_hook_info_pt info = NULL; apr_pool_t *pool; unsigned int i; - fw_service_listener_t element; + fw_service_listener_pt element; - bundle_context_t context; + bundle_context_pt context; bundle_getContext(bundle, &context); bundleContext_getMemoryPool(context, &pool); for (i = 0; i < arrayList_size(framework->serviceListeners); i++) { - element = (fw_service_listener_t) arrayList_get(framework->serviceListeners, i); + element = (fw_service_listener_pt) arrayList_get(framework->serviceListeners, i); if (element->listener == listener && element->bundle == bundle) { - bundle_context_t lContext = NULL; + bundle_context_pt lContext = NULL; - info = (listener_hook_info_t) apr_palloc(pool, sizeof(*info)); + info = (listener_hook_info_pt) apr_palloc(pool, sizeof(*info)); bundle_getContext(element->bundle, &context); info->context = lContext; @@ -1400,13 +1400,13 @@ void fw_removeServiceListener(framework_ if (info != NULL) { unsigned int i; - array_list_t listenerHooks = NULL; + array_list_pt listenerHooks = NULL; serviceRegistry_getListenerHooks(framework->registry, pool, &listenerHooks); for (i = 0; i < arrayList_size(listenerHooks); i++) { - service_reference_t ref = (service_reference_t) arrayList_get(listenerHooks, i); - listener_hook_service_t hook = (listener_hook_service_t) fw_getService(framework, framework->bundle, ref); - array_list_t infos = NULL; + service_reference_pt ref = (service_reference_pt) arrayList_get(listenerHooks, i); + listener_hook_service_pt hook = (listener_hook_service_pt) fw_getService(framework, framework->bundle, ref); + array_list_pt infos = NULL; apr_pool_t *pool = NULL; bundle_getMemoryPool(bundle, &pool); @@ -1420,14 +1420,14 @@ void fw_removeServiceListener(framework_ } } -celix_status_t fw_addBundleListener(framework_t framework, bundle_t bundle, bundle_listener_t listener) { +celix_status_t fw_addBundleListener(framework_pt framework, bundle_pt bundle, bundle_listener_pt listener) { celix_status_t status = CELIX_SUCCESS; apr_pool_t *pool = NULL; - fw_bundle_listener_t bundleListener = NULL; + fw_bundle_listener_pt bundleListener = NULL; apr_pool_create(&pool, framework->mp); - bundleListener = (fw_bundle_listener_t) apr_palloc(pool, sizeof(*bundleListener)); + bundleListener = (fw_bundle_listener_pt) apr_palloc(pool, sizeof(*bundleListener)); if (!bundleListener) { status = CELIX_ENOMEM; } else { @@ -1441,14 +1441,14 @@ celix_status_t fw_addBundleListener(fram return status; } -celix_status_t fw_removeBundleListener(framework_t framework, bundle_t bundle, bundle_listener_t listener) { +celix_status_t fw_removeBundleListener(framework_pt framework, bundle_pt bundle, bundle_listener_pt listener) { celix_status_t status = CELIX_SUCCESS; unsigned int i; - fw_bundle_listener_t bundleListener; + fw_bundle_listener_pt bundleListener; for (i = 0; i < arrayList_size(framework->bundleListeners); i++) { - bundleListener = (fw_bundle_listener_t) arrayList_get(framework->bundleListeners, i); + bundleListener = (fw_bundle_listener_pt) arrayList_get(framework->bundleListeners, i); if (bundleListener->listener == listener && bundleListener->bundle == bundle) { arrayList_remove(framework->bundleListeners, i); apr_pool_destroy(bundleListener->pool); @@ -1458,28 +1458,28 @@ celix_status_t fw_removeBundleListener(f return status; } -void fw_serviceChanged(framework_t framework, service_event_type_e eventType, service_registration_t registration, properties_t oldprops) { +void fw_serviceChanged(framework_pt framework, service_event_type_e eventType, service_registration_pt registration, properties_pt oldprops) { unsigned int i; - fw_service_listener_t element; + fw_service_listener_pt element; if (arrayList_size(framework->serviceListeners) > 0) { for (i = 0; i < arrayList_size(framework->serviceListeners); i++) { int matched = 0; - properties_t props = NULL; + properties_pt props = NULL; bool matchResult = false; - element = (fw_service_listener_t) arrayList_get(framework->serviceListeners, i); + element = (fw_service_listener_pt) arrayList_get(framework->serviceListeners, i); serviceRegistration_getProperties(registration, &props); if (element->filter != NULL) { filter_match(element->filter, props, &matchResult); } matched = (element->filter == NULL) || matchResult; if (matched) { - service_reference_t reference = NULL; - service_event_t event; + service_reference_pt reference = NULL; + service_event_pt event; apr_pool_t *spool = NULL; apr_pool_create(&spool, element->listener->pool); - event = (service_event_t) apr_palloc(spool, sizeof(*event)); + event = (service_event_pt) apr_palloc(spool, sizeof(*event)); serviceRegistry_createServiceReference(framework->registry, spool, registration, &reference); @@ -1495,8 +1495,8 @@ void fw_serviceChanged(framework_t frame } matched = (element->filter == NULL) || matchResult; if (matched) { - service_reference_t reference = NULL; - service_event_t endmatch = (service_event_t) malloc(sizeof(*endmatch)); + service_reference_pt reference = NULL; + service_event_pt endmatch = (service_event_pt) malloc(sizeof(*endmatch)); serviceRegistry_createServiceReference(framework->registry, element->listener->pool, registration, &reference); @@ -1509,11 +1509,11 @@ void fw_serviceChanged(framework_t frame } } -//celix_status_t fw_isServiceAssignable(framework_t fw, bundle_t requester, service_reference_t reference, bool *assignable) { +//celix_status_t fw_isServiceAssignable(framework_pt fw, bundle_pt requester, service_reference_pt reference, bool *assignable) { // celix_status_t status = CELIX_SUCCESS; // // *assignable = true; -// service_registration_t registration = NULL; +// service_registration_pt registration = NULL; // status = serviceReference_getServiceRegistration(reference, ®istration); // if (status == CELIX_SUCCESS) { // char *serviceName = properties_get(registration->properties, (char *) OBJECTCLASS); @@ -1525,7 +1525,7 @@ void fw_serviceChanged(framework_t frame // return status; //} -celix_status_t getManifest(bundle_archive_t archive, apr_pool_t *pool, MANIFEST *manifest) { +celix_status_t getManifest(bundle_archive_pt archive, apr_pool_t *pool, manifest_pt *manifest) { celix_status_t status = CELIX_SUCCESS; char mf[256]; long refreshCount; @@ -1552,19 +1552,19 @@ celix_status_t getManifest(bundle_archiv return status; } -long framework_getNextBundleId(framework_t framework) { +long framework_getNextBundleId(framework_pt framework) { long id = framework->nextBundleId; framework->nextBundleId++; return id; } -celix_status_t framework_markResolvedModules(framework_t framework, hash_map_t resolvedModuleWireMap) { +celix_status_t framework_markResolvedModules(framework_pt framework, hash_map_pt resolvedModuleWireMap) { if (resolvedModuleWireMap != NULL) { - hash_map_iterator_t iterator = hashMapIterator_create(resolvedModuleWireMap); + hash_map_iterator_pt iterator = hashMapIterator_create(resolvedModuleWireMap); while (hashMapIterator_hasNext(iterator)) { - hash_map_entry_t entry = hashMapIterator_nextEntry(iterator); - module_t module = (module_t) hashMapEntry_getKey(entry); - linked_list_t wires = (linked_list_t) hashMapEntry_getValue(entry); + hash_map_entry_pt entry = hashMapIterator_nextEntry(iterator); + module_pt module = (module_pt) hashMapEntry_getKey(entry); + linked_list_pt wires = (linked_list_pt) hashMapEntry_getValue(entry); module_setWires(module, wires); @@ -1577,8 +1577,8 @@ celix_status_t framework_markResolvedMod return CELIX_SUCCESS; } -celix_status_t framework_markBundleResolved(framework_t framework, module_t module) { - bundle_t bundle = module_getBundle(module); +celix_status_t framework_markBundleResolved(framework_pt framework, module_pt module) { + bundle_pt bundle = module_getBundle(module); bundle_state_e state; if (bundle != NULL) { @@ -1596,30 +1596,30 @@ celix_status_t framework_markBundleResol return CELIX_SUCCESS; } -array_list_t framework_getBundles(framework_t framework) { - array_list_t bundles = NULL; - hash_map_iterator_t iterator; +array_list_pt framework_getBundles(framework_pt framework) { + array_list_pt bundles = NULL; + hash_map_iterator_pt iterator; arrayList_create(framework->mp, &bundles); iterator = hashMapIterator_create(framework->installedBundleMap); while (hashMapIterator_hasNext(iterator)) { - bundle_t bundle = (bundle_t) hashMapIterator_nextValue(iterator); + bundle_pt bundle = (bundle_pt) hashMapIterator_nextValue(iterator); arrayList_add(bundles, bundle); } hashMapIterator_destroy(iterator); return bundles; } -bundle_t framework_getBundle(framework_t framework, char * location) { - bundle_t bundle = (bundle_t) hashMap_get(framework->installedBundleMap, location); +bundle_pt framework_getBundle(framework_pt framework, char * location) { + bundle_pt bundle = (bundle_pt) hashMap_get(framework->installedBundleMap, location); return bundle; } -bundle_t framework_getBundleById(framework_t framework, long id) { - hash_map_iterator_t iter = hashMapIterator_create(framework->installedBundleMap); - bundle_t bundle = NULL; +bundle_pt framework_getBundleById(framework_pt framework, long id) { + hash_map_iterator_pt iter = hashMapIterator_create(framework->installedBundleMap); + bundle_pt bundle = NULL; while (hashMapIterator_hasNext(iter)) { - bundle_t b = (bundle_t) hashMapIterator_nextValue(iter); - bundle_archive_t archive = NULL; + bundle_pt b = (bundle_pt) hashMapIterator_nextValue(iter); + bundle_archive_pt archive = NULL; long bid; bundle_getArchive(b, &archive); bundleArchive_getId(archive, &bid); @@ -1632,7 +1632,7 @@ bundle_t framework_getBundleById(framewo return bundle; } -celix_status_t framework_acquireInstallLock(framework_t framework, char * location) { +celix_status_t framework_acquireInstallLock(framework_pt framework, char * location) { apr_thread_mutex_lock(framework->installRequestLock); while (hashMap_get(framework->installRequestMap, location) != NULL) { @@ -1645,7 +1645,7 @@ celix_status_t framework_acquireInstallL return CELIX_SUCCESS; } -celix_status_t framework_releaseInstallLock(framework_t framework, char * location) { +celix_status_t framework_releaseInstallLock(framework_pt framework, char * location) { apr_thread_mutex_lock(framework->installRequestLock); hashMap_remove(framework->installRequestMap, location); @@ -1656,7 +1656,7 @@ celix_status_t framework_releaseInstallL return CELIX_SUCCESS; } -celix_status_t framework_setBundleStateAndNotify(framework_t framework, bundle_t bundle, int state) { +celix_status_t framework_setBundleStateAndNotify(framework_pt framework, bundle_pt bundle, int state) { int ret = CELIX_SUCCESS; int err = apr_thread_mutex_lock(framework->bundleLock); @@ -1680,7 +1680,7 @@ celix_status_t framework_setBundleStateA return CELIX_SUCCESS; } -celix_status_t framework_acquireBundleLock(framework_t framework, bundle_t bundle, int desiredStates) { +celix_status_t framework_acquireBundleLock(framework_pt framework, bundle_pt bundle, int desiredStates) { celix_status_t status = CELIX_SUCCESS; bool locked; @@ -1742,7 +1742,7 @@ celix_status_t framework_acquireBundleLo return CELIX_SUCCESS; } -bool framework_releaseBundleLock(framework_t framework, bundle_t bundle) { +bool framework_releaseBundleLock(framework_pt framework, bundle_pt bundle) { bool unlocked; apr_os_thread_t lockingThread = 0; @@ -1763,7 +1763,7 @@ bool framework_releaseBundleLock(framewo return true; } -bool framework_acquireGlobalLock(framework_t framework) { +bool framework_acquireGlobalLock(framework_pt framework) { bool interrupted = false; bool isSelf = false; @@ -1797,7 +1797,7 @@ bool framework_acquireGlobalLock(framewo return !interrupted; } -celix_status_t framework_releaseGlobalLock(framework_t framework) { +celix_status_t framework_releaseGlobalLock(framework_pt framework) { int ret = CELIX_SUCCESS; if (apr_thread_mutex_lock(framework->bundleLock) != 0) { celix_log("Error locking framework bundle lock"); @@ -1825,7 +1825,7 @@ celix_status_t framework_releaseGlobalLo return ret; } -celix_status_t framework_waitForStop(framework_t framework) { +celix_status_t framework_waitForStop(framework_pt framework) { if (apr_thread_mutex_lock(framework->mutex) != 0) { celix_log("Error locking the framework, shutdown gate not set."); return CELIX_FRAMEWORK_EXCEPTION; @@ -1848,20 +1848,20 @@ celix_status_t framework_waitForStop(fra static void *APR_THREAD_FUNC framework_shutdown(apr_thread_t *thd, void *framework) { //static void * framework_shutdown(void * framework) { - framework_t fw = (framework_t) framework; - hash_map_iterator_t iterator; + framework_pt fw = (framework_pt) framework; + hash_map_iterator_pt iterator; int err; printf("FRAMEWORK: Shutdown\n"); iterator = hashMapIterator_create(fw->installedBundleMap); while (hashMapIterator_hasNext(iterator)) { - bundle_t bundle = (bundle_t) hashMapIterator_nextValue(iterator); + bundle_pt bundle = (bundle_pt) hashMapIterator_nextValue(iterator); bundle_state_e state; bundle_getState(bundle, &state); if (state == BUNDLE_ACTIVE || state == BUNDLE_STARTING) { char *location; - bundle_archive_t archive = NULL; + bundle_archive_pt archive = NULL; bundle_getArchive(bundle, &archive); bundleArchive_getLocation(archive, &location); @@ -1906,7 +1906,7 @@ static void *APR_THREAD_FUNC framework_s return NULL; } -celix_status_t framework_getMemoryPool(framework_t framework, apr_pool_t **pool) { +celix_status_t framework_getMemoryPool(framework_pt framework, apr_pool_t **pool) { celix_status_t status = CELIX_SUCCESS; if (framework != NULL && *pool == NULL) { @@ -1918,7 +1918,7 @@ celix_status_t framework_getMemoryPool(f return status; } -celix_status_t framework_getFrameworkBundle(framework_t framework, bundle_t *bundle) { +celix_status_t framework_getFrameworkBundle(framework_pt framework, bundle_pt *bundle) { celix_status_t status = CELIX_SUCCESS; if (framework != NULL && *bundle == NULL) { @@ -1930,13 +1930,13 @@ celix_status_t framework_getFrameworkBun return status; } -celix_status_t fw_fireBundleEvent(framework_t framework, bundle_event_type_e eventType, bundle_t bundle) { +celix_status_t fw_fireBundleEvent(framework_pt framework, bundle_event_type_e eventType, bundle_pt bundle) { celix_status_t status = CELIX_SUCCESS; if ((eventType != BUNDLE_EVENT_STARTING) && (eventType != BUNDLE_EVENT_STOPPING) && (eventType != BUNDLE_EVENT_LAZY_ACTIVATION)) { - request_t request = (request_t) malloc(sizeof(*request)); + request_pt request = (request_pt) malloc(sizeof(*request)); if (!request) { status = CELIX_ENOMEM; } else { @@ -1965,8 +1965,8 @@ celix_status_t fw_fireBundleEvent(framew } static void *APR_THREAD_FUNC fw_eventDispatcher(apr_thread_t *thd, void *fw) { - framework_t framework = (framework_t) fw; - request_t request = NULL; + framework_pt framework = (framework_pt) fw; + request_pt request = NULL; while (true) { int size; @@ -1989,7 +1989,7 @@ static void *APR_THREAD_FUNC fw_eventDis return NULL; } - request = (request_t) arrayList_remove(framework->requests, 0); + request = (request_pt) arrayList_remove(framework->requests, 0); if ((status = apr_thread_mutex_unlock(framework->dispatcherLock)) != 0) { celix_log("Error unlocking the dispatcher."); @@ -2002,8 +2002,8 @@ static void *APR_THREAD_FUNC fw_eventDis int size = arrayList_size(request->listeners); for (i = 0; i < size; i++) { if (request->type == BUNDLE_EVENT_TYPE) { - fw_bundle_listener_t listener = (fw_bundle_listener_t) arrayList_get(request->listeners, i); - bundle_event_t event = (bundle_event_t) apr_palloc(listener->listener->pool, sizeof(*event)); + fw_bundle_listener_pt listener = (fw_bundle_listener_pt) arrayList_get(request->listeners, i); + bundle_event_pt event = (bundle_event_pt) apr_palloc(listener->listener->pool, sizeof(*event)); event->bundle = request->bundle; event->type = request->type; @@ -2019,7 +2019,7 @@ static void *APR_THREAD_FUNC fw_eventDis } -celix_status_t fw_invokeBundleListener(framework_t framework, bundle_listener_t listener, bundle_event_t event, bundle_t bundle) { +celix_status_t fw_invokeBundleListener(framework_pt framework, bundle_listener_pt listener, bundle_event_pt event, bundle_pt bundle) { // We only support async bundle listeners for now bundle_state_e state; bundle_getState(bundle, &state); @@ -2031,16 +2031,16 @@ celix_status_t fw_invokeBundleListener(f return CELIX_SUCCESS; } -celix_status_t bundleActivator_start(void * userData, bundle_context_t context) { +celix_status_t bundleActivator_start(void * userData, bundle_context_pt context) { // nothing to do return CELIX_SUCCESS; } -celix_status_t bundleActivator_stop(void * userData, bundle_context_t context) { +celix_status_t bundleActivator_stop(void * userData, bundle_context_pt context) { celix_status_t status = CELIX_SUCCESS; apr_thread_t *shutdownThread; - framework_t framework; + framework_pt framework; if (bundleContext_getFramework(context, &framework) == CELIX_SUCCESS) { @@ -2057,6 +2057,6 @@ celix_status_t bundleActivator_stop(void return status; } -celix_status_t bundleActivator_destroy(void * userData, bundle_context_t context) { +celix_status_t bundleActivator_destroy(void * userData, bundle_context_pt context) { return CELIX_SUCCESS; } Modified: incubator/celix/trunk/framework/private/src/manifest.c URL: http://svn.apache.org/viewvc/incubator/celix/trunk/framework/private/src/manifest.c?rev=1492377&r1=1492376&r2=1492377&view=diff ============================================================================== --- incubator/celix/trunk/framework/private/src/manifest.c (original) +++ incubator/celix/trunk/framework/private/src/manifest.c Wed Jun 12 19:08:50 2013 @@ -32,10 +32,10 @@ #include "utils.h" int fpeek(FILE *stream); -celix_status_t manifest_readAttributes(MANIFEST manifest, properties_t properties, FILE *file); +celix_status_t manifest_readAttributes(manifest_pt manifest, properties_pt properties, FILE *file); apr_status_t manifest_destroy(void *manifestP); -celix_status_t manifest_create(apr_pool_t *pool, MANIFEST *manifest) { +celix_status_t manifest_create(apr_pool_t *pool, manifest_pt *manifest) { celix_status_t status = CELIX_SUCCESS; *manifest = apr_palloc(pool, sizeof(**manifest)); @@ -52,7 +52,7 @@ celix_status_t manifest_create(apr_pool_ } apr_status_t manifest_destroy(void *manifestP) { - MANIFEST manifest = manifestP; + manifest_pt manifest = manifestP; if (manifest != NULL) { properties_destroy(manifest->mainAttributes); hashMap_destroy(manifest->attributes, false, false); @@ -63,7 +63,7 @@ apr_status_t manifest_destroy(void *mani return APR_SUCCESS; } -celix_status_t manifest_createFromFile(apr_pool_t *pool, char *filename, MANIFEST *manifest) { +celix_status_t manifest_createFromFile(apr_pool_t *pool, char *filename, manifest_pt *manifest) { celix_status_t status = CELIX_SUCCESS; status = manifest_create(pool, manifest); @@ -74,20 +74,20 @@ celix_status_t manifest_createFromFile(a return status; } -void manifest_clear(MANIFEST manifest) { +void manifest_clear(manifest_pt manifest) { } -properties_t manifest_getMainAttributes(MANIFEST manifest) { +properties_pt manifest_getMainAttributes(manifest_pt manifest) { return manifest->mainAttributes; } -celix_status_t manifest_getEntries(MANIFEST manifest, hash_map_t *map) { +celix_status_t manifest_getEntries(manifest_pt manifest, hash_map_pt *map) { *map = manifest->attributes; return CELIX_SUCCESS; } -celix_status_t manifest_read(MANIFEST manifest, char *filename) { +celix_status_t manifest_read(manifest_pt manifest, char *filename) { celix_status_t status = CELIX_SUCCESS; FILE *file = fopen ( filename, "r" ); @@ -103,7 +103,7 @@ celix_status_t manifest_read(MANIFEST ma apr_pool_create(&subpool, manifest->pool); while (fgets(lbuf, sizeof(lbuf), file) != NULL ) { - properties_t attributes; + properties_pt attributes; len = strlen(lbuf); if (lbuf[--len] != '\n') { @@ -175,11 +175,11 @@ celix_status_t manifest_read(MANIFEST ma return status; } -void manifest_write(MANIFEST manifest, char * filename) { +void manifest_write(manifest_pt manifest, char * filename) { } -char * manifest_getValue(MANIFEST manifest, const char * name) { +char * manifest_getValue(manifest_pt manifest, const char * name) { char * val = properties_get(manifest->mainAttributes, (char *) name); return val; } @@ -191,7 +191,7 @@ int fpeek(FILE *stream) { return c; } -celix_status_t manifest_readAttributes(MANIFEST manifest, properties_t properties, FILE *file) { +celix_status_t manifest_readAttributes(manifest_pt manifest, properties_pt properties, FILE *file) { char *name = NULL; char *value = NULL; char *lastLine = NULL;