incubator-celix-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From pnol...@apache.org
Subject svn commit: r1492377 [4/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 GMT
Modified: incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/paint/private/src/default_shape.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/paint/private/src/default_shape.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/paint/private/src/default_shape.c (original)
+++ incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/paint/private/src/default_shape.c Wed Jun 12 19:08:50 2013
@@ -39,13 +39,13 @@
 #include "default_shape.h"
 #define DEFAULT_FILE "underc.png"
 
-void defaultShape_draw(SIMPLE_SHAPE shape, GdkPixmap *pixMap, GtkWidget *widget, gdouble x, gdouble y);
+void defaultShape_draw(simple_shape_pt shape, GdkPixmap *pixMap, GtkWidget *widget, gdouble x, gdouble y);
 
-SIMPLE_SHAPE defaultShape_create(bundle_context_t context) {
+simple_shape_pt defaultShape_create(bundle_context_pt context) {
 	celix_status_t status = CELIX_SUCCESS;
-	bundle_t bundle;
+	bundle_pt bundle;
 	apr_pool_t *pool;
-	SIMPLE_SHAPE shape = (SIMPLE_SHAPE) malloc(sizeof(*shape));
+	simple_shape_pt shape = (simple_shape_pt) malloc(sizeof(*shape));
 	bundleContext_getBundle(context, &bundle);
 	bundleContext_getMemoryPool(context, &pool);
 	shape->icon_path = NULL;
@@ -59,7 +59,7 @@ SIMPLE_SHAPE defaultShape_create(bundle_
 	return shape;
 }
 
-void defaultShape_draw(SIMPLE_SHAPE shape, GdkPixmap *pixMap, GtkWidget *widget, gdouble x, gdouble y){
+void defaultShape_draw(simple_shape_pt shape, GdkPixmap *pixMap, GtkWidget *widget, gdouble x, gdouble y){
 	GdkRectangle update_rect;
 	GdkPixbuf *curr_pix_buf;
 	GError *gerror = NULL;

Modified: incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/paint/private/src/paint_frame.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/paint/private/src/paint_frame.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/paint/private/src/paint_frame.c (original)
+++ incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/paint/private/src/paint_frame.c Wed Jun 12 19:08:50 2013
@@ -52,29 +52,29 @@
 #include "default_shape.h"
 #include "celix_errno.h"
 
-static PAINT_FRAME this = NULL;
+static paint_frame_pt this = NULL;
 
 struct shape_info {
 	char *name;
-	SIMPLE_SHAPE shape;
+	simple_shape_pt shape;
 	GtkWidget *button;
 };
 
-typedef struct shape_info *shape_info_t;
-static celix_status_t paintFrame_redraw(PAINT_FRAME frame, GdkModifierType state);
-static celix_status_t paintFrame_show(PAINT_FRAME frame);
+typedef struct shape_info *shape_info_pt;
+static celix_status_t paintFrame_redraw(paint_frame_pt frame, GdkModifierType state);
+static celix_status_t paintFrame_show(paint_frame_pt frame);
 static void paintFrame_destroy(GtkWidget *widget, gpointer data);
 static void paintFrame_expose(GtkWidget *widget, GdkEventExpose *event, gpointer data);
 static void paintFrame_configure(GtkWidget *widget, GdkEventConfigure *event, gpointer data);
 static void paintFrame_buttonClicked(GtkWidget *button, gpointer data);
 static gboolean paintFrame_mousePressed( GtkWidget *widget, GdkEventButton *event, gpointer data);
 static gpointer paintFrame_gtkmain(gpointer a_data);
-static void paintFrame_destroyWidgets(PAINT_FRAME frame);
+static void paintFrame_destroyWidgets(paint_frame_pt frame);
 
 /**
  * Default constructor that populates the main window.
  **/
-celix_status_t paintFrame_create(bundle_context_t context, apr_pool_t *pool, PAINT_FRAME *frame) {
+celix_status_t paintFrame_create(bundle_context_pt context, apr_pool_t *pool, paint_frame_pt *frame) {
 	celix_status_t status = CELIX_SUCCESS;
 	apr_pool_t *mypool = NULL;
 	apr_pool_create(&mypool, pool);
@@ -84,7 +84,7 @@ celix_status_t paintFrame_create(bundle_
 		status = CELIX_ENOMEM;
 	} else {
 		char *builderFile;
-		bundle_t bundle;
+		bundle_pt bundle;
 		GError *error = NULL;
 		*frame = this;
 		
@@ -125,7 +125,7 @@ celix_status_t paintFrame_create(bundle_
 	return status;
 }
 
-celix_status_t paintFrame_exit(PAINT_FRAME frame) {
+celix_status_t paintFrame_exit(paint_frame_pt frame) {
 	frame->showing = false;
 
 	paintFrame_destroyWidgets(frame);
@@ -141,14 +141,14 @@ celix_status_t paintFrame_exit(PAINT_FRA
 	return CELIX_SUCCESS;
 }
 
-static celix_status_t shapeInfo_create(PAINT_FRAME frame, char* name, GtkWidget *button, SIMPLE_SHAPE shape, shape_info_t *info){
+static celix_status_t shapeInfo_create(paint_frame_pt frame, char* name, GtkWidget *button, simple_shape_pt shape, shape_info_pt *info){
 	*info = malloc(sizeof(**info));
 	(*info)->shape = shape;
 	(*info)->name = name;
 	(*info)->button = button;
 	return CELIX_SUCCESS;
 }
-static celix_status_t paintFrame_show(PAINT_FRAME frame) {
+static celix_status_t paintFrame_show(paint_frame_pt frame) {
 	gtk_widget_show(frame->drawingArea);
 	gtk_widget_show(frame->toolbar);
 	gtk_widget_show(frame->window);
@@ -163,7 +163,7 @@ static celix_status_t paintFrame_show(PA
  * @param icon The icon associated with the injected <tt>SimpleShape</tt>.
  * @param shape The injected <tt>SimpleShape</tt> instance.
  **/
-celix_status_t paintFrame_addShape(PAINT_FRAME frame, bundle_context_t context, SIMPLE_SHAPE shape) {
+celix_status_t paintFrame_addShape(paint_frame_pt frame, bundle_context_pt context, simple_shape_pt shape) {
 	celix_status_t status = CELIX_SUCCESS;
 	GError *gerror = NULL;
 	GtkWidget *button = NULL;
@@ -179,7 +179,7 @@ celix_status_t paintFrame_addShape(PAINT
 	g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (paintFrame_buttonClicked), frame);
 	gtk_widget_show(button);
 	if (hashMap_get(frame->m_shapes, shape->name) == NULL) {
-		shape_info_t info = NULL;
+		shape_info_pt info = NULL;
 		shapeInfo_create(frame, shape->name, button, shape, &info);
 		hashMap_put(frame->m_shapes, shape->name, info);
 	}
@@ -195,11 +195,11 @@ celix_status_t paintFrame_addShape(PAINT
  *
  * @param name The name of the <tt>SimpleShape</tt> to remove.
  **/
-celix_status_t paintFrame_removeShape(PAINT_FRAME frame, SIMPLE_SHAPE sshape) {
+celix_status_t paintFrame_removeShape(paint_frame_pt frame, simple_shape_pt sshape) {
 	celix_status_t status = CELIX_SUCCESS;
-	shape_info_t shape = NULL;
+	shape_info_pt shape = NULL;
 	gdk_threads_enter();
-	shape = (shape_info_t) hashMap_remove(this->m_shapes, sshape->name);
+	shape = (shape_info_pt) hashMap_remove(this->m_shapes, sshape->name);
 	if (shape != NULL) {
 		this->m_selected = NULL;
 		gtk_widget_destroy(GTK_WIDGET(shape->button));
@@ -220,8 +220,8 @@ celix_status_t paintFrame_removeShape(PA
  * @return The corresponding <tt>SimpleShape</tt> instance if available or
  *         <tt>null</tt>.
  **/
-SIMPLE_SHAPE paintFrame_getShape(PAINT_FRAME frame, char *name) {
-	shape_info_t info = (shape_info_t) hashMap_get(frame->m_shapes, name);
+simple_shape_pt paintFrame_getShape(paint_frame_pt frame, char *name) {
+	shape_info_pt info = (shape_info_pt) hashMap_get(frame->m_shapes, name);
 	if (info == NULL) {
 		return frame->m_defaultShape;
 	} else {
@@ -230,8 +230,8 @@ SIMPLE_SHAPE paintFrame_getShape(PAINT_F
 }
 
 static void paintFrame_destroy(GtkWidget *widget, gpointer data) {
-	PAINT_FRAME frame = data;
-	bundle_t bundle = NULL;
+	paint_frame_pt frame = data;
+	bundle_pt bundle = NULL;
 
 	frame->showing = false;
 
@@ -239,7 +239,7 @@ static void paintFrame_destroy(GtkWidget
 //	bundle_stop(bundle, 0);
 }
 
-static void paintFrame_destroyWidgets(PAINT_FRAME frame) {
+static void paintFrame_destroyWidgets(paint_frame_pt frame) {
 	gdk_threads_enter();
 
 	if (frame->pixMap != NULL) {
@@ -264,7 +264,7 @@ static void paintFrame_destroyWidgets(PA
 }
 
 static void paintFrame_configure(GtkWidget *widget, GdkEventConfigure *event, gpointer data) {
-	PAINT_FRAME frame = data;
+	paint_frame_pt frame = data;
 	GtkAllocation allocation;
 
 	if (frame->pixMap != NULL) {
@@ -277,7 +277,7 @@ static void paintFrame_configure(GtkWidg
 }
 
 static void paintFrame_expose(GtkWidget *widget, GdkEventExpose *event, gpointer data) {
-	PAINT_FRAME frame = data;
+	paint_frame_pt frame = data;
 	gdk_draw_pixmap(gtk_widget_get_window(widget),
 			gtk_widget_get_style(widget)->fg_gc[gtk_widget_get_state(widget)],
 			frame->pixMap, event->area.x, event->area.y, event->area.x,
@@ -285,17 +285,17 @@ static void paintFrame_expose(GtkWidget 
 }
 
 static void paintFrame_buttonClicked(GtkWidget *button, gpointer data) {
-	PAINT_FRAME frame = data;
+	paint_frame_pt frame = data;
 	frame->m_selected = (char *) gtk_widget_get_name(button);
 }
 
 static gboolean paintFrame_mousePressed( GtkWidget *widget, GdkEventButton *event, gpointer data) {
-	PAINT_FRAME frame = data;
+	paint_frame_pt frame = data;
 	if (event->button == 1 && frame->pixMap != NULL) {
 		if (frame->m_selected == NULL){
 			printf("no button selected yet\n");
 		} else {
-			SHAPE_COMPONENT sc = shapeComponent_create(frame, paintFrame_getShape(frame, frame->m_selected), event->x, event->y);
+			shape_component_pt sc = shapeComponent_create(frame, paintFrame_getShape(frame, frame->m_selected), event->x, event->y);
 			linkedList_addFirst(frame->m_shapeComponents, sc);
 			(*sc->shapeComponent_paintComponent)(sc, frame, frame->pixMap, widget);
 		}
@@ -303,11 +303,11 @@ static gboolean paintFrame_mousePressed(
 	return TRUE;
 }
 
-static celix_status_t paintFrame_redraw(PAINT_FRAME frame, GdkModifierType state) {
+static celix_status_t paintFrame_redraw(paint_frame_pt frame, GdkModifierType state) {
 	if (frame->pixMap != NULL && frame->showing) {
 		GdkRectangle update_rect;
 		GtkAllocation allocation;
-		linked_list_iterator_t it = NULL;
+		linked_list_iterator_pt it = NULL;
 
 		update_rect.x = 0;
 		update_rect.y = 0;
@@ -322,7 +322,7 @@ static celix_status_t paintFrame_redraw(
 		gtk_widget_draw(frame->drawingArea, &update_rect);
 		it = linkedListIterator_create(this->m_shapeComponents, 0);
 		while (linkedListIterator_hasNext(it)) {
-			SHAPE_COMPONENT sc = linkedListIterator_next(it);
+			shape_component_pt sc = linkedListIterator_next(it);
 			(*sc->shapeComponent_paintComponent)(sc, this, this->pixMap, frame->drawingArea);
 		}
 	}
@@ -332,7 +332,7 @@ static celix_status_t paintFrame_redraw(
 
 static gpointer paintFrame_gtkmain(gpointer a_data) {
 	GtkBuilder *builder;
-	PAINT_FRAME frame = (PAINT_FRAME) a_data;
+	paint_frame_pt frame = (paint_frame_pt) a_data;
 
 	gdk_threads_enter();
 	builder = gtk_builder_new();

Modified: incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/paint/private/src/shape_component.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/paint/private/src/shape_component.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/paint/private/src/shape_component.c (original)
+++ incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/paint/private/src/shape_component.c Wed Jun 12 19:08:50 2013
@@ -40,12 +40,12 @@
 
 static const int BOX = 54;
 
-extern void shapeComponent_paintComponent(SHAPE_COMPONENT shapeComponent, PAINT_FRAME frame,
+extern void shapeComponent_paintComponent(shape_component_pt shapeComponent, paint_frame_pt frame,
 		GdkPixmap *pixMap, GtkWidget *widget);
 
-SHAPE_COMPONENT shapeComponent_create(PAINT_FRAME frame, SIMPLE_SHAPE sshape,
+shape_component_pt shapeComponent_create(paint_frame_pt frame, simple_shape_pt sshape,
 		gdouble x, gdouble y) {
-	SHAPE_COMPONENT shape = malloc(sizeof(*shape));
+	shape_component_pt shape = malloc(sizeof(*shape));
 	shape->m_frame = frame;
 	shape->shapeName = strdup(sshape->name);
 	shape->x = x - BOX /2;
@@ -57,9 +57,9 @@ SHAPE_COMPONENT shapeComponent_create(PA
 	return shape;
 }
 
-void shapeComponent_paintComponent(SHAPE_COMPONENT shapeComponent, PAINT_FRAME frame,
+void shapeComponent_paintComponent(shape_component_pt shapeComponent, paint_frame_pt frame,
 		GdkPixmap *pixMap, GtkWidget *widget) {
-	SIMPLE_SHAPE shape = paintFrame_getShape(frame, shapeComponent->shapeName);
+	simple_shape_pt shape = paintFrame_getShape(frame, shapeComponent->shapeName);
 	if (shape == NULL) {
 		g_printerr("cannot find shape %s\n", shapeComponent->shapeName);
 	} else {

Modified: incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/simple/public/include/simple_shape.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/simple/public/include/simple_shape.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/simple/public/include/simple_shape.h (original)
+++ incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/simple/public/include/simple_shape.h Wed Jun 12 19:08:50 2013
@@ -34,7 +34,7 @@ struct simple_shape {
 	void (*simpleShape_draw) (struct simple_shape *shape, GdkPixmap *pixMap, GtkWidget *widget, gdouble x, gdouble y);
 };
 
-typedef struct simple_shape *SIMPLE_SHAPE;
+typedef struct simple_shape *simple_shape_pt;
 
 #define SIMPLE_SHAPE_SERVICE_NAME "simple_shape"
 

Modified: incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/square/private/include/square_shape.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/square/private/include/square_shape.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/square/private/include/square_shape.h (original)
+++ incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/square/private/include/square_shape.h Wed Jun 12 19:08:50 2013
@@ -26,6 +26,6 @@
 #ifndef SQUARE_SHAPE_H_
 #define SQUARE_SHAPE_H_
 
-extern SIMPLE_SHAPE squareShape_create(bundle_context_t context);
+extern simple_shape_pt squareShape_create(bundle_context_pt context);
 
 #endif /* SQUARE_SHAPE_H_ */

Modified: incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/square/private/src/activator.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/square/private/src/activator.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/square/private/src/activator.c (original)
+++ incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/square/private/src/activator.c Wed Jun 12 19:08:50 2013
@@ -37,15 +37,15 @@
 #include "simple_shape.h"
 
 struct squareActivator {
-	service_registration_t reg;
+	service_registration_pt reg;
 	apr_pool_t *pool;
 };
 
-typedef struct squareActivator *GREETING_ACTIVATOR;
+typedef struct squareActivator *greeting_activator_pt;
 
-celix_status_t bundleActivator_create(bundle_context_t context, void **userData) {
+celix_status_t bundleActivator_create(bundle_context_pt context, void **userData) {
 	apr_pool_t *pool;
-	GREETING_ACTIVATOR activator;
+	greeting_activator_pt activator;
 	celix_status_t status = bundleContext_getMemoryPool(context, &pool);
 	if (status == CELIX_SUCCESS) {
 		*userData = apr_palloc(pool, sizeof(struct squareActivator));
@@ -57,21 +57,21 @@ celix_status_t bundleActivator_create(bu
 	return status;
 }
 
-celix_status_t bundleActivator_start(void * userData, bundle_context_t ctx) {
+celix_status_t bundleActivator_start(void * userData, bundle_context_pt ctx) {
 	struct squareActivator * act = (struct squareActivator *) userData;
 	celix_status_t status = CELIX_SUCCESS;
-	SIMPLE_SHAPE es = squareShape_create(ctx);
-	properties_t props = properties_create();
+	simple_shape_pt es = squareShape_create(ctx);
+	properties_pt props = properties_create();
 	properties_set(props, "name", "square");
     status = bundleContext_registerService(ctx, SIMPLE_SHAPE_SERVICE_NAME, es, props, &act->reg);
 	printf("Square start\n");
 	return status;
 }
 
-celix_status_t bundleActivator_stop(void * userData, bundle_context_t context) {
+celix_status_t bundleActivator_stop(void * userData, bundle_context_pt context) {
 	return CELIX_SUCCESS;
 }
 
-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/examples/osgi-in-action/chapter04-paint-example/square/private/src/square_shape.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/square/private/src/square_shape.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/square/private/src/square_shape.c (original)
+++ incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/square/private/src/square_shape.c Wed Jun 12 19:08:50 2013
@@ -37,12 +37,12 @@
 #include "square_shape.h"
 #define SQUARE_FILE "square.png"
 
-void squareShape_draw(SIMPLE_SHAPE shape, GdkPixmap *pixMap, GtkWidget *widget, gdouble x, gdouble y);
+void squareShape_draw(simple_shape_pt shape, GdkPixmap *pixMap, GtkWidget *widget, gdouble x, gdouble y);
 
-SIMPLE_SHAPE squareShape_create(bundle_context_t context) {
-	bundle_t bundle;
+simple_shape_pt squareShape_create(bundle_context_pt context) {
+	bundle_pt bundle;
 	apr_pool_t *pool;
-	SIMPLE_SHAPE shape = (SIMPLE_SHAPE) malloc(sizeof(*shape));
+	simple_shape_pt shape = (simple_shape_pt) malloc(sizeof(*shape));
 	celix_status_t status = CELIX_SUCCESS;
 	bundleContext_getBundle(context, &bundle);
 	bundleContext_getMemoryPool(context, &pool);
@@ -58,7 +58,7 @@ SIMPLE_SHAPE squareShape_create(bundle_c
 	return shape;
 }
 
-void squareShape_draw(SIMPLE_SHAPE shape, GdkPixmap *pixMap, GtkWidget *widget, gdouble x, gdouble y){
+void squareShape_draw(simple_shape_pt shape, GdkPixmap *pixMap, GtkWidget *widget, gdouble x, gdouble y){
 	GdkRectangle update_rect;
 	GdkPixbuf *curr_pix_buf;
 	GError *gerror = NULL;

Modified: incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/triangle/private/include/triangle_shape.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/triangle/private/include/triangle_shape.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/triangle/private/include/triangle_shape.h (original)
+++ incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/triangle/private/include/triangle_shape.h Wed Jun 12 19:08:50 2013
@@ -27,6 +27,6 @@
 #ifndef TRIANGLE_SHAPE_H_
 #define TRIANGLE_SHAPE_H_
 
-extern SIMPLE_SHAPE triangleShape_create(bundle_context_t ctx);
+extern simple_shape_pt triangleShape_create(bundle_context_pt ctx);
 
 #endif /* TRIANGLE_SHAPE_H_ */

Modified: incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/triangle/private/src/activator.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/triangle/private/src/activator.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/triangle/private/src/activator.c (original)
+++ incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/triangle/private/src/activator.c Wed Jun 12 19:08:50 2013
@@ -37,15 +37,15 @@
 #include "simple_shape.h"
 
 struct greetingActivator {
-	service_registration_t reg;
+	service_registration_pt reg;
 	apr_pool_t *pool;
 };
 
-typedef struct greetingActivator *GREETING_ACTIVATOR;
+typedef struct greetingActivator *greeting_activator_pt;
 
-celix_status_t bundleActivator_create(bundle_context_t context, void **userData) {
+celix_status_t bundleActivator_create(bundle_context_pt context, void **userData) {
 	apr_pool_t *pool;
-	GREETING_ACTIVATOR activator;
+	greeting_activator_pt activator;
 	celix_status_t status = bundleContext_getMemoryPool(context, &pool);
 	if (status == CELIX_SUCCESS) {
 		*userData = apr_palloc(pool, sizeof(struct greetingActivator));
@@ -57,21 +57,21 @@ celix_status_t bundleActivator_create(bu
 	return status;
 }
 
-celix_status_t bundleActivator_start(void * userData, bundle_context_t ctx) {
+celix_status_t bundleActivator_start(void * userData, bundle_context_pt ctx) {
 	struct greetingActivator * act = (struct greetingActivator *) userData;
 	celix_status_t status = CELIX_SUCCESS;
-	SIMPLE_SHAPE es = triangleShape_create(ctx);
-	properties_t props = properties_create();
+	simple_shape_pt es = triangleShape_create(ctx);
+	properties_pt props = properties_create();
 	properties_set(props, "name", "triangle");
     status = bundleContext_registerService(ctx, SIMPLE_SHAPE_SERVICE_NAME, es, props, &act->reg);
 	printf("Triangle activated %d\n", status);
 	return status;
 }
 
-celix_status_t bundleActivator_stop(void * userData, bundle_context_t context) {
+celix_status_t bundleActivator_stop(void * userData, bundle_context_pt context) {
 	return CELIX_SUCCESS;
 }
 
-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/examples/osgi-in-action/chapter04-paint-example/triangle/private/src/triangle_shape.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/triangle/private/src/triangle_shape.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/triangle/private/src/triangle_shape.c (original)
+++ incubator/celix/trunk/examples/osgi-in-action/chapter04-paint-example/triangle/private/src/triangle_shape.c Wed Jun 12 19:08:50 2013
@@ -39,12 +39,12 @@
 #include "triangle_shape.h"
 #define TRIANGLE_FILE "triangle.png"
 
-void triangleShape_draw(SIMPLE_SHAPE shape, GdkPixmap *pixMap, GtkWidget *widget, gdouble x, gdouble y);
+void triangleShape_draw(simple_shape_pt shape, GdkPixmap *pixMap, GtkWidget *widget, gdouble x, gdouble y);
 
-SIMPLE_SHAPE triangleShape_create(bundle_context_t context) {
-	bundle_t bundle;
+simple_shape_pt triangleShape_create(bundle_context_pt context) {
+	bundle_pt bundle;
 	apr_pool_t *pool;
-	SIMPLE_SHAPE shape = (SIMPLE_SHAPE) malloc(sizeof(*shape));
+	simple_shape_pt shape = (simple_shape_pt) malloc(sizeof(*shape));
 	celix_status_t status = CELIX_SUCCESS;
 	bundleContext_getBundle(context, &bundle);
 	bundleContext_getMemoryPool(context, &pool);
@@ -60,7 +60,7 @@ SIMPLE_SHAPE triangleShape_create(bundle
 	return shape;
 }
 
-void triangleShape_draw(SIMPLE_SHAPE shape, GdkPixmap *pixMap, GtkWidget *widget, gdouble x, gdouble y){
+void triangleShape_draw(simple_shape_pt shape, GdkPixmap *pixMap, GtkWidget *widget, gdouble x, gdouble y){
 	GdkRectangle update_rect;
 	GdkPixbuf *curr_pix_buf;
 	GError *gerror = NULL;

Modified: incubator/celix/trunk/examples/whiteboard/publisherA/private/src/activator.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/examples/whiteboard/publisherA/private/src/activator.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/examples/whiteboard/publisherA/private/src/activator.c (original)
+++ incubator/celix/trunk/examples/whiteboard/publisherA/private/src/activator.c Wed Jun 12 19:08:50 2013
@@ -32,13 +32,13 @@
 #include "service_registration.h"
 
 struct activatorData {
-    PUBLISHER_SERVICE ps;
-    PUBLISHER pub;
+    publisher_service_pt ps;
+    publisher_pt pub;
 
-    service_registration_t reg;
+    service_registration_pt reg;
 };
 
-celix_status_t bundleActivator_create(bundle_context_t context, void **userData) {
+celix_status_t bundleActivator_create(bundle_context_pt context, void **userData) {
     apr_pool_t *pool;
     celix_status_t status = bundleContext_getMemoryPool(context, &pool);
     if (status == CELIX_SUCCESS) {
@@ -49,12 +49,12 @@ celix_status_t bundleActivator_create(bu
     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) {
     celix_status_t status = CELIX_SUCCESS;
     apr_pool_t *pool;
     status = bundleContext_getMemoryPool(context, &pool);
     if (status == CELIX_SUCCESS) {
-		properties_t props = NULL;
+		properties_pt props = NULL;
 
         struct activatorData * data = (struct activatorData *) userData;
         data->ps = apr_pcalloc(pool, sizeof(*(data->ps)));
@@ -76,7 +76,7 @@ celix_status_t bundleActivator_start(voi
     return status;
 }
 
-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;
 
     struct activatorData * data = (struct activatorData *) userData;
@@ -85,6 +85,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/examples/whiteboard/publisherA/private/src/publisher.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/examples/whiteboard/publisherA/private/src/publisher.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/examples/whiteboard/publisherA/private/src/publisher.c (original)
+++ incubator/celix/trunk/examples/whiteboard/publisherA/private/src/publisher.c Wed Jun 12 19:08:50 2013
@@ -27,7 +27,7 @@
 
 #include "publisher_private.h"
 
-void publisher_invoke(PUBLISHER publisher, char * text) {
+void publisher_invoke(publisher_pt publisher, char * text) {
 	printf("Publisher A received: %s\n", text);
 }
 

Modified: incubator/celix/trunk/examples/whiteboard/publisherB/private/src/activator.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/examples/whiteboard/publisherB/private/src/activator.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/examples/whiteboard/publisherB/private/src/activator.c (original)
+++ incubator/celix/trunk/examples/whiteboard/publisherB/private/src/activator.c Wed Jun 12 19:08:50 2013
@@ -31,13 +31,13 @@
 #include "service_registration.h"
 
 struct activatorData {
-	PUBLISHER_SERVICE ps;
-	PUBLISHER pub;
+	publisher_service_pt ps;
+	publisher_pt pub;
 
-	service_registration_t reg;
+	service_registration_pt reg;
 };
 
-celix_status_t bundleActivator_create(bundle_context_t context, void **userData) {
+celix_status_t bundleActivator_create(bundle_context_pt context, void **userData) {
     apr_pool_t *pool;
     celix_status_t status = bundleContext_getMemoryPool(context, &pool);
     if (status == CELIX_SUCCESS) {
@@ -48,12 +48,12 @@ celix_status_t bundleActivator_create(bu
     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) {
     celix_status_t status = CELIX_SUCCESS;
     apr_pool_t *pool;
     status = bundleContext_getMemoryPool(context, &pool);
     if (status == CELIX_SUCCESS) {
-		properties_t props = properties_create();
+		properties_pt props = properties_create();
 
         struct activatorData * data = (struct activatorData *) userData;
         data->ps = apr_pcalloc(pool, sizeof(*(data->ps)));
@@ -71,7 +71,7 @@ celix_status_t bundleActivator_start(voi
     return status;
 }
 
-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;
 
     struct activatorData * data = (struct activatorData *) userData;
@@ -80,6 +80,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/examples/whiteboard/publisherB/private/src/publisher.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/examples/whiteboard/publisherB/private/src/publisher.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/examples/whiteboard/publisherB/private/src/publisher.c (original)
+++ incubator/celix/trunk/examples/whiteboard/publisherB/private/src/publisher.c Wed Jun 12 19:08:50 2013
@@ -27,7 +27,7 @@
 
 #include "publisher_private.h"
 
-void publisher_invoke(PUBLISHER publisher, char * text) {
+void publisher_invoke(publisher_pt publisher, char * text) {
 	printf("Publisher B received: %s\n", text);
 }
 

Modified: incubator/celix/trunk/examples/whiteboard/publisherService/private/include/publisher_private.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/examples/whiteboard/publisherService/private/include/publisher_private.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/examples/whiteboard/publisherService/private/include/publisher_private.h (original)
+++ incubator/celix/trunk/examples/whiteboard/publisherService/private/include/publisher_private.h Wed Jun 12 19:08:50 2013
@@ -33,6 +33,6 @@ struct publisher {
 	void *data;
 };
 
-void publisher_invoke(PUBLISHER publisher, char * text);
+void publisher_invoke(publisher_pt publisher, char * text);
 
 #endif /* PUBLISHER_PRIVATE_H_ */

Modified: incubator/celix/trunk/examples/whiteboard/publisherService/public/include/publisher.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/examples/whiteboard/publisherService/public/include/publisher.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/examples/whiteboard/publisherService/public/include/publisher.h (original)
+++ incubator/celix/trunk/examples/whiteboard/publisherService/public/include/publisher.h Wed Jun 12 19:08:50 2013
@@ -29,14 +29,14 @@
 
 #define PUBLISHER_NAME "Publisher"
 
-typedef struct publisher * PUBLISHER;
+typedef struct publisher * publisher_pt;
 
 struct publisherService {
-	PUBLISHER publisher;
-	void (*invoke)(PUBLISHER pub, char * text);
+	publisher_pt publisher;
+	void (*invoke)(publisher_pt pub, char * text);
 };
 
-typedef struct publisherService * PUBLISHER_SERVICE;
+typedef struct publisherService * publisher_service_pt;
 
 
 #endif /* PUBLISHER_H_ */

Modified: incubator/celix/trunk/examples/whiteboard/tracker/private/src/activator.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/examples/whiteboard/tracker/private/src/activator.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/examples/whiteboard/tracker/private/src/activator.c (original)
+++ incubator/celix/trunk/examples/whiteboard/tracker/private/src/activator.c Wed Jun 12 19:08:50 2013
@@ -32,9 +32,9 @@
 #include "bundle_context.h"
 
 struct data {
-	bundle_context_t context;
-	service_tracker_t tracker;
-	array_list_t publishers;
+	bundle_context_pt context;
+	service_tracker_pt tracker;
+	array_list_pt publishers;
 	apr_thread_t *sender;
 	bool running;
 };
@@ -44,7 +44,7 @@ static void *APR_THREAD_FUNC trk_send(ap
 	while (data->running) {
 		int i;
 		for (i = 0; i < arrayList_size(data->publishers); i++) {
-			PUBLISHER_SERVICE pub = arrayList_get(data->publishers, i);
+			publisher_service_pt pub = arrayList_get(data->publishers, i);
 			pub->invoke(pub->publisher, "test");
 		}
 		apr_sleep(1000000);
@@ -53,7 +53,7 @@ static void *APR_THREAD_FUNC trk_send(ap
 	return NULL;
 }
 
-celix_status_t addingServ(void * handle, service_reference_t ref, void **service) {
+celix_status_t addingServ(void * handle, service_reference_pt ref, void **service) {
     struct data * data = (struct data *) handle;
 
     printf("Adding\n");
@@ -62,27 +62,27 @@ celix_status_t addingServ(void * handle,
 	return CELIX_SUCCESS;
 }
 
-celix_status_t addedServ(void * handle, service_reference_t ref, void * service) {
+celix_status_t addedServ(void * handle, service_reference_pt ref, void * service) {
 	struct data * data = (struct data *) handle;
 	arrayList_add(data->publishers, service);
 	printf("Added %p\n", service);
 	return CELIX_SUCCESS;
 }
 
-celix_status_t modifiedServ(void * handle, service_reference_t ref, void * service) {
+celix_status_t modifiedServ(void * handle, service_reference_pt ref, void * service) {
 	struct data * data = (struct data *) handle;
 	printf("Modified\n");
 	return CELIX_SUCCESS;
 }
 
-celix_status_t removedServ(void * handle, service_reference_t ref, void * service) {
+celix_status_t removedServ(void * handle, service_reference_pt ref, void * service) {
 	struct data * data = (struct data *) handle;
 	arrayList_removeElement(data->publishers, service);
 	printf("Removed %p\n", service);
 	return CELIX_SUCCESS;
 }
 
-celix_status_t bundleActivator_create(bundle_context_t context, void **userData) {
+celix_status_t bundleActivator_create(bundle_context_pt context, void **userData) {
     apr_pool_t *pool;
     celix_status_t status = bundleContext_getMemoryPool(context, &pool);
     if (status == CELIX_SUCCESS) {
@@ -95,14 +95,14 @@ celix_status_t bundleActivator_create(bu
     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) {
     celix_status_t status = CELIX_SUCCESS;
     apr_pool_t *pool;
     status = bundleContext_getMemoryPool(context, &pool);
     if (status == CELIX_SUCCESS) {
         struct data * data = (struct data *) userData;
-		service_tracker_customizer_t cust = NULL;
-		service_tracker_t tracker = NULL;
+		service_tracker_customizer_pt cust = NULL;
+		service_tracker_pt tracker = NULL;
         
 		data->context = context;
 
@@ -121,7 +121,7 @@ celix_status_t bundleActivator_start(voi
     return status;
 }
 
-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;
     struct data * data = (struct data *) userData;
 
@@ -133,7 +133,7 @@ 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) {
     celix_status_t status = CELIX_SUCCESS;
     struct data * data = (struct data *) userData;
 

Modified: incubator/celix/trunk/examples/whiteboard/tracker_depman/private/include/tracker.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/examples/whiteboard/tracker_depman/private/include/tracker.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/examples/whiteboard/tracker_depman/private/include/tracker.h (original)
+++ incubator/celix/trunk/examples/whiteboard/tracker_depman/private/include/tracker.h Wed Jun 12 19:08:50 2013
@@ -31,21 +31,21 @@
 #include "log_service.h"
 
 struct data {
-	SERVICE service;
-	bundle_context_t context;
-	array_list_t publishers;
+	service_pt service;
+	bundle_context_pt context;
+	array_list_pt publishers;
 	apr_thread_t *sender;
 	bool running;
-	log_service_t logger;
+	log_service_pt logger;
 };
 
-void tracker_addedServ(void * handle, service_reference_t ref, void * service);
-void tracker_modifiedServ(void * handle, service_reference_t ref, void * service);
-void tracker_removedServ(void * handle, service_reference_t ref, void * service);
+void tracker_addedServ(void * handle, service_reference_pt ref, void * service);
+void tracker_modifiedServ(void * handle, service_reference_pt ref, void * service);
+void tracker_removedServ(void * handle, service_reference_pt ref, void * service);
 
-void tracker_addLog(void * handle, service_reference_t ref, void * service);
-void tracker_modifiedLog(void * handle, service_reference_t ref, void * service);
-void tracker_removeLog(void * handle, service_reference_t ref, void * service);
+void tracker_addLog(void * handle, service_reference_pt ref, void * service);
+void tracker_modifiedLog(void * handle, service_reference_pt ref, void * service);
+void tracker_removeLog(void * handle, service_reference_pt ref, void * service);
 
 
 #endif /* TRACKER_H_ */

Modified: incubator/celix/trunk/examples/whiteboard/tracker_depman/private/src/dependency_activator.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/examples/whiteboard/tracker_depman/private/src/dependency_activator.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/examples/whiteboard/tracker_depman/private/src/dependency_activator.c (original)
+++ incubator/celix/trunk/examples/whiteboard/tracker_depman/private/src/dependency_activator.c Wed Jun 12 19:08:50 2013
@@ -34,7 +34,7 @@
 #include "log_service.h"
 #include "bundle_context.h"
 
-void * dm_create(bundle_context_t context) {
+void * dm_create(bundle_context_pt context) {
 	struct data * data = malloc(sizeof(*data));
 	apr_pool_t *pool = NULL;
 	bundleContext_getMemoryPool(context, &pool);
@@ -48,11 +48,11 @@ void * dm_create(bundle_context_t contex
 	return data;
 }
 
-void dm_init(void * userData, bundle_context_t context, DEPENDENCY_MANAGER manager) {
+void dm_init(void * userData, bundle_context_pt context, dependency_manager_pt manager) {
 	struct data * data = (struct data *) userData;
-	SERVICE service = NULL;
-	SERVICE_DEPENDENCY dep = NULL;
-	SERVICE_DEPENDENCY dep2 = NULL;
+	service_pt service = NULL;
+	service_dependency_pt dep = NULL;
+	service_dependency_pt dep2 = NULL;
 
 	data->context = context;
 
@@ -75,7 +75,7 @@ void dm_init(void * userData, bundle_con
 	dependencyManager_add(manager, service);
 }
 
-void dm_destroy(void * userData, bundle_context_t context, DEPENDENCY_MANAGER manager) {
+void dm_destroy(void * userData, bundle_context_pt context, dependency_manager_pt manager) {
 	struct data * data = (struct data *) userData;
 	dependencyManager_remove(manager, data->service);
 	arrayList_destroy(data->publishers);

Modified: incubator/celix/trunk/examples/whiteboard/tracker_depman/private/src/tracker.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/examples/whiteboard/tracker_depman/private/src/tracker.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/examples/whiteboard/tracker_depman/private/src/tracker.c (original)
+++ incubator/celix/trunk/examples/whiteboard/tracker_depman/private/src/tracker.c Wed Jun 12 19:08:50 2013
@@ -37,7 +37,7 @@ static void *APR_THREAD_FUNC dp_send(apr
 	while (data->running) {
 		int i;
 		for (i = 0; i < arrayList_size(data->publishers); i++) {
-			PUBLISHER_SERVICE pub = (PUBLISHER_SERVICE) arrayList_get(data->publishers, i);
+			publisher_service_pt pub = (publisher_service_pt) arrayList_get(data->publishers, i);
 			pub->invoke(pub->publisher, "Tracker message");
 			if (data->logger != NULL) {
 				data->logger->log(data->logger->logger, LOG_INFO, "Sending message to publisher");
@@ -72,38 +72,38 @@ void service_destroy(void * userData) {
 
 }
 
-void tracker_addedServ(void * handle, service_reference_t ref, void * service) {
+void tracker_addedServ(void * handle, service_reference_pt ref, void * service) {
 	struct data * data = (struct data *) handle;
 	arrayList_add(data->publishers, service);
 	printf("Service Added\n");
 }
 
-void tracker_modifiedServ(void * handle, service_reference_t ref, void * service) {
+void tracker_modifiedServ(void * handle, service_reference_pt ref, void * service) {
 	struct data * data = (struct data *) handle;
 	printf("Service Changed\n");
 }
 
-void tracker_removedServ(void * handle, service_reference_t ref, void * service) {
+void tracker_removedServ(void * handle, service_reference_pt ref, void * service) {
 	struct data * data = (struct data *) handle;
 	arrayList_removeElement(data->publishers, service);
 	printf("Service Removed\n");
 }
 
-void tracker_addLog(void *handle, service_reference_t ref, void *service) {
+void tracker_addLog(void *handle, service_reference_pt ref, void *service) {
     struct data * data = (struct data *) handle;
     printf("Add log\n");
     data->logger = service;
-    ((log_service_t) service)->log(((log_service_t) service)->logger, LOG_DEBUG, "test");
+    ((log_service_pt) service)->log(((log_service_pt) service)->logger, LOG_DEBUG, "test");
 }
 
-void tracker_modifiedLog(void *handle, service_reference_t ref, void *service) {
+void tracker_modifiedLog(void *handle, service_reference_pt ref, void *service) {
     struct data * data = (struct data *) handle;
     printf("Modify log\n");
     data->logger = service;
-    ((log_service_t) service)->log(((log_service_t) service)->logger, LOG_DEBUG, "test");
+    ((log_service_pt) service)->log(((log_service_pt) service)->logger, LOG_DEBUG, "test");
 }
 
-void tracker_removeLog(void *handle, service_reference_t ref, void *service) {
+void tracker_removeLog(void *handle, service_reference_pt ref, void *service) {
     struct data * data = (struct data *) handle;
     data->logger = NULL;
     printf("Remove log\n");

Modified: incubator/celix/trunk/framework/private/include/attribute.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/framework/private/include/attribute.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/framework/private/include/attribute.h (original)
+++ incubator/celix/trunk/framework/private/include/attribute.h Wed Jun 12 19:08:50 2013
@@ -29,11 +29,11 @@
 #include <apr_general.h>
 #include "celix_errno.h"
 
-typedef struct attribute *attribute_t;
+typedef struct attribute *attribute_pt;
 
-celix_status_t attribute_create(char * key, char * value, apr_pool_t *memory_pool, attribute_t *attribute);
+celix_status_t attribute_create(char * key, char * value, apr_pool_t *memory_pool, attribute_pt *attribute);
 
-celix_status_t attribute_getKey(attribute_t attribute, char **key);
-celix_status_t attribute_getValue(attribute_t attribute, char **value);
+celix_status_t attribute_getKey(attribute_pt attribute, char **key);
+celix_status_t attribute_getValue(attribute_pt attribute, char **value);
 
 #endif /* ATTRIBUTE_H_ */

Modified: incubator/celix/trunk/framework/private/include/bundle_cache.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/framework/private/include/bundle_cache.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/framework/private/include/bundle_cache.h (original)
+++ incubator/celix/trunk/framework/private/include/bundle_cache.h Wed Jun 12 19:08:50 2013
@@ -38,9 +38,9 @@
 #include "bundle_archive.h"
 
 /**
- * Type definition for the bundle_cache_t abstract data type.
+ * Type definition for the bundle_cache_pt abstract data type.
  */
-typedef struct bundleCache *bundle_cache_t;
+typedef struct bundleCache *bundle_cache_pt;
 
 /**
  * Creates the bundle cache using the supplied configuration map.
@@ -53,7 +53,7 @@ typedef struct bundleCache *bundle_cache
  * 		- CELIX_ILLEGAL_ARGUMENT If <code>bundle_cache</code> not is null.
  * 		- CELIX_ENOMEM If allocating memory for <code>bundle_cache</code> failed.
  */
-celix_status_t bundleCache_create(properties_t configurationMap, apr_pool_t *mp, bundle_cache_t *bundle_cache);
+celix_status_t bundleCache_create(properties_pt configurationMap, apr_pool_t *mp, bundle_cache_pt *bundle_cache);
 
 /**
  * Recreates and retrieves the list of archives for the given bundle cache.
@@ -68,7 +68,7 @@ celix_status_t bundleCache_create(proper
  * 		- CELIX_ENOMEM If allocating memory for <code>archives</code> failed.
  * 		- CELIX_FILE_IO_EXCEPTION If the cache cannot be opened or read.
  */
-celix_status_t bundleCache_getArchives(bundle_cache_t cache, apr_pool_t *pool, array_list_t *archives);
+celix_status_t bundleCache_getArchives(bundle_cache_pt cache, apr_pool_t *pool, array_list_pt *archives);
 
 /**
  * Creates a new archive for the given bundle (using the id and location). The archive is created on the supplied bundlePool.
@@ -85,7 +85,7 @@ celix_status_t bundleCache_getArchives(b
  * 		- CELIX_ILLEGAL_ARGUMENT If <code>bundle_archive</code> not is null.
  * 		- CELIX_ENOMEM If allocating memory for <code>bundle_archive</code> failed.
  */
-celix_status_t bundleCache_createArchive(bundle_cache_t cache, apr_pool_t *bundlePool, long id, char * location, char *inputFile, bundle_archive_t *archive);
+celix_status_t bundleCache_createArchive(bundle_cache_pt cache, apr_pool_t *bundlePool, long id, char * location, char *inputFile, bundle_archive_pt *archive);
 
 /**
  * Deletes the entire bundle cache.
@@ -96,7 +96,7 @@ celix_status_t bundleCache_createArchive
  * 		- CELIX_ILLEGAL_ARGUMENT If the cache is invalid
  * 		- CELIX_FILE_IO_EXCEPTION If the cache cannot be opened or read.
  */
-celix_status_t bundleCache_delete(bundle_cache_t cache);
+celix_status_t bundleCache_delete(bundle_cache_pt cache);
 
 /**
  * @}

Modified: incubator/celix/trunk/framework/private/include/manifest_parser.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/framework/private/include/manifest_parser.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/framework/private/include/manifest_parser.h (original)
+++ incubator/celix/trunk/framework/private/include/manifest_parser.h Wed Jun 12 19:08:50 2013
@@ -32,13 +32,13 @@
 #include "manifest.h"
 #include "linkedlist.h"
 
-typedef struct manifestParser * manifest_parser_t;
+typedef struct manifestParser * manifest_parser_pt;
 
-celix_status_t manifestParser_create(module_t owner, MANIFEST manifest, apr_pool_t *memory_pool, manifest_parser_t *manifest_parser);
+celix_status_t manifestParser_create(module_pt owner, manifest_pt manifest, apr_pool_t *memory_pool, manifest_parser_pt *manifest_parser);
 
-celix_status_t manifestParser_getSymbolicName(manifest_parser_t parser, apr_pool_t *pool, char **symbolicName);
-celix_status_t manifestParser_getBundleVersion(manifest_parser_t parser, apr_pool_t *pool, version_t *version);
-celix_status_t manifestParser_getCapabilities(manifest_parser_t parser, apr_pool_t *pool, linked_list_t *capabilities);
-celix_status_t manifestParser_getRequirements(manifest_parser_t parser, apr_pool_t *pool, linked_list_t *requirements);
+celix_status_t manifestParser_getSymbolicName(manifest_parser_pt parser, apr_pool_t *pool, char **symbolicName);
+celix_status_t manifestParser_getBundleVersion(manifest_parser_pt parser, apr_pool_t *pool, version_pt *version);
+celix_status_t manifestParser_getCapabilities(manifest_parser_pt parser, apr_pool_t *pool, linked_list_pt *capabilities);
+celix_status_t manifestParser_getRequirements(manifest_parser_pt parser, apr_pool_t *pool, linked_list_pt *requirements);
 
 #endif /* MANIFEST_PARSER_H_ */

Modified: incubator/celix/trunk/framework/private/include/resolver.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/framework/private/include/resolver.h?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/framework/private/include/resolver.h (original)
+++ incubator/celix/trunk/framework/private/include/resolver.h Wed Jun 12 19:08:50 2013
@@ -31,9 +31,9 @@
 #include "wire.h"
 #include "hash_map.h"
 
-hash_map_t resolver_resolve(module_t root);
-void resolver_moduleResolved(module_t module);
-void resolver_addModule(module_t module);
-void resolver_removeModule(module_t module);
+hash_map_pt resolver_resolve(module_pt root);
+void resolver_moduleResolved(module_pt module);
+void resolver_addModule(module_pt module);
+void resolver_removeModule(module_pt module);
 
 #endif /* RESOLVER_H_ */

Modified: incubator/celix/trunk/framework/private/src/attribute.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/framework/private/src/attribute.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/framework/private/src/attribute.c (original)
+++ incubator/celix/trunk/framework/private/src/attribute.c Wed Jun 12 19:08:50 2013
@@ -33,13 +33,13 @@ struct attribute {
 	char * value;
 };
 
-celix_status_t attribute_create(char * key, char * value, apr_pool_t *memory_pool, attribute_t *attribute) {
+celix_status_t attribute_create(char * key, char * value, apr_pool_t *memory_pool, attribute_pt *attribute) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	if (key == NULL || value == NULL || memory_pool == NULL || *attribute != NULL) {
 		status = CELIX_ILLEGAL_ARGUMENT;
 	} else {
-		attribute_t attr = apr_palloc(memory_pool, sizeof(*attr));
+		attribute_pt attr = apr_palloc(memory_pool, sizeof(*attr));
 		if (!attr) {
 			status = CELIX_ENOMEM;
 		} else {
@@ -53,12 +53,12 @@ celix_status_t attribute_create(char * k
 	return status;
 }
 
-celix_status_t attribute_getKey(attribute_t attribute, char **key) {
+celix_status_t attribute_getKey(attribute_pt attribute, char **key) {
 	*key = attribute->key;
 	return CELIX_SUCCESS;
 }
 
-celix_status_t attribute_getValue(attribute_t attribute, char **value) {
+celix_status_t attribute_getValue(attribute_pt attribute, char **value) {
 	*value = attribute->value;
 	return CELIX_SUCCESS;
 }

Modified: incubator/celix/trunk/framework/private/src/bundle.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/framework/private/src/bundle.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/framework/private/src/bundle.c (original)
+++ incubator/celix/trunk/framework/private/src/bundle.c Wed Jun 12 19:08:50 2013
@@ -40,13 +40,13 @@
 #include "utils.h"
 
 struct bundle {
-	bundle_context_t context;
-	ACTIVATOR activator;
+	bundle_context_pt context;
+	activator_pt activator;
 	bundle_state_e state;
 	void * handle;
-	bundle_archive_t archive;
-	array_list_t modules;
-	MANIFEST manifest;
+	bundle_archive_pt archive;
+	array_list_pt modules;
+	manifest_pt manifest;
 	apr_pool_t *memoryPool;
 
 	apr_thread_mutex_t *lock;
@@ -56,20 +56,20 @@ struct bundle {
 	struct framework * framework;
 };
 
-celix_status_t bundle_createModule(bundle_t bundle, module_t *module);
-celix_status_t bundle_closeRevisions(bundle_t bundle);
+celix_status_t bundle_createModule(bundle_pt bundle, module_pt *module);
+celix_status_t bundle_closeRevisions(bundle_pt bundle);
 
-celix_status_t bundle_create(bundle_t * bundle, apr_pool_t *mp) {
+celix_status_t bundle_create(bundle_pt * bundle, apr_pool_t *mp) {
     celix_status_t status = CELIX_SUCCESS;
-    bundle_archive_t archive = NULL;
+    bundle_archive_pt archive = NULL;
 
-	*bundle = (bundle_t) apr_palloc(mp, sizeof(**bundle));
+	*bundle = (bundle_pt) apr_palloc(mp, sizeof(**bundle));
 	if (*bundle == NULL) {
 		return CELIX_ENOMEM;
 	}
 	status = bundleArchive_createSystemBundleArchive(mp, &archive);
 	if (status == CELIX_SUCCESS) {
-        module_t module;
+        module_pt module;
 		apr_status_t apr_status;
 
 		(*bundle)->memoryPool = mp;
@@ -101,12 +101,12 @@ celix_status_t bundle_create(bundle_t * 
 	return status;
 }
 
-celix_status_t bundle_createFromArchive(bundle_t * bundle, framework_t framework, bundle_archive_t archive, apr_pool_t *bundlePool) {
-    module_t module;
+celix_status_t bundle_createFromArchive(bundle_pt * bundle, framework_pt framework, bundle_archive_pt archive, apr_pool_t *bundlePool) {
+    module_pt module;
 	
 	celix_status_t status = CELIX_SUCCESS;
 
-	*bundle = (bundle_t) apr_pcalloc(bundlePool, sizeof(**bundle));
+	*bundle = (bundle_pt) apr_pcalloc(bundlePool, sizeof(**bundle));
 	if (*bundle == NULL) {
 		return CELIX_ENOMEM;
 	}
@@ -141,10 +141,10 @@ celix_status_t bundle_createFromArchive(
 	return status;
 }
 
-celix_status_t bundle_destroy(bundle_t bundle) {
-	array_list_iterator_t iter = arrayListIterator_create(bundle->modules);
+celix_status_t bundle_destroy(bundle_pt bundle) {
+	array_list_iterator_pt iter = arrayListIterator_create(bundle->modules);
 	while (arrayListIterator_hasNext(iter)) {
-		module_t module = arrayListIterator_next(iter);
+		module_pt module = arrayListIterator_next(iter);
 		module_destroy(module);
 	}
 	arrayListIterator_destroy(iter);
@@ -152,7 +152,7 @@ celix_status_t bundle_destroy(bundle_t b
 	return CELIX_SUCCESS;
 }
 
-celix_status_t bundle_getArchive(bundle_t bundle, bundle_archive_t *archive) {
+celix_status_t bundle_getArchive(bundle_pt bundle, bundle_archive_pt *archive) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	if (bundle != NULL && *archive == NULL) {
@@ -164,7 +164,7 @@ celix_status_t bundle_getArchive(bundle_
 	return status;
 }
 
-celix_status_t bundle_getCurrentModule(bundle_t bundle, module_t *module) {
+celix_status_t bundle_getCurrentModule(bundle_pt bundle, module_pt *module) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	if (bundle == NULL || *module != NULL) {
@@ -176,64 +176,64 @@ celix_status_t bundle_getCurrentModule(b
 	return status;
 }
 
-array_list_t bundle_getModules(bundle_t bundle) {
+array_list_pt bundle_getModules(bundle_pt bundle) {
     return bundle->modules;
 }
 
-void * bundle_getHandle(bundle_t bundle) {
+void * bundle_getHandle(bundle_pt bundle) {
 	return bundle->handle;
 }
 
-void bundle_setHandle(bundle_t bundle, void * handle) {
+void bundle_setHandle(bundle_pt bundle, void * handle) {
 	bundle->handle = handle;
 }
 
-ACTIVATOR bundle_getActivator(bundle_t bundle) {
+activator_pt bundle_getActivator(bundle_pt bundle) {
 	return bundle->activator;
 }
 
-celix_status_t bundle_setActivator(bundle_t bundle, ACTIVATOR activator) {
+celix_status_t bundle_setActivator(bundle_pt bundle, activator_pt activator) {
 	bundle->activator = activator;
 	return CELIX_SUCCESS;
 }
 
-celix_status_t bundle_getContext(bundle_t bundle, bundle_context_t *context) {
+celix_status_t bundle_getContext(bundle_pt bundle, bundle_context_pt *context) {
 	*context = bundle->context;
 	return CELIX_SUCCESS;
 }
 
-celix_status_t bundle_setContext(bundle_t bundle, bundle_context_t context) {
+celix_status_t bundle_setContext(bundle_pt bundle, bundle_context_pt context) {
 	bundle->context = context;
 	return CELIX_SUCCESS;
 }
 
-celix_status_t bundle_getEntry(bundle_t bundle, char * name, apr_pool_t *pool, char **entry) {
+celix_status_t bundle_getEntry(bundle_pt bundle, char * name, apr_pool_t *pool, char **entry) {
 	return framework_getBundleEntry(bundle->framework, bundle, name, pool, entry);
 }
 
-celix_status_t bundle_getState(bundle_t bundle, bundle_state_e *state) {
+celix_status_t bundle_getState(bundle_pt bundle, bundle_state_e *state) {
 	*state = bundle->state;
 	return CELIX_SUCCESS;
 }
 
-celix_status_t bundle_setState(bundle_t bundle, bundle_state_e state) {
+celix_status_t bundle_setState(bundle_pt bundle, bundle_state_e state) {
 	bundle->state = state;
 	return CELIX_SUCCESS;
 }
 
-celix_status_t bundle_getManifest(bundle_t bundle, MANIFEST *manifest) {
+celix_status_t bundle_getManifest(bundle_pt bundle, manifest_pt *manifest) {
 	*manifest = bundle->manifest;
 	return CELIX_SUCCESS;
 }
 
-celix_status_t bundle_setManifest(bundle_t bundle, MANIFEST manifest) {
+celix_status_t bundle_setManifest(bundle_pt bundle, manifest_pt manifest) {
 	bundle->manifest = manifest;
 	return CELIX_SUCCESS;
 }
 
-celix_status_t bundle_createModule(bundle_t bundle, module_t *module) {
+celix_status_t bundle_createModule(bundle_pt bundle, module_pt *module) {
 	celix_status_t status = CELIX_SUCCESS;
-	MANIFEST headerMap = NULL;
+	manifest_pt headerMap = NULL;
 	status = getManifest(bundle->archive, bundle->memoryPool, &headerMap);
 	if (status == CELIX_SUCCESS) {
         long bundleId;
@@ -251,21 +251,21 @@ celix_status_t bundle_createModule(bundl
 			*module = module_create(headerMap, apr_pstrdup(bundle->memoryPool, moduleId), bundle);
 
 			if (*module != NULL) {
-				version_t bundleVersion = module_getVersion(*module);
+				version_pt bundleVersion = module_getVersion(*module);
 				char * symName = NULL;
 				status = module_getSymbolicName(*module, &symName);
 				if (status == CELIX_SUCCESS) {
-					array_list_t bundles = framework_getBundles(bundle->framework);
+					array_list_pt bundles = framework_getBundles(bundle->framework);
 					unsigned int i;
 					for (i = 0; i < arrayList_size(bundles); i++) {
-						bundle_t check = (bundle_t) arrayList_get(bundles, i);
+						bundle_pt check = (bundle_pt) arrayList_get(bundles, i);
 
 						long id;
 						if (bundleArchive_getId(check->archive, &id) == CELIX_SUCCESS) {
 							if (id != bundleId) {
-								module_t mod = NULL;
+								module_pt mod = NULL;
 								char * sym = NULL;
-								version_t version;
+								version_pt version;
 								int cmp;
 								status = bundle_getCurrentModule(check, &mod);
 								status = module_getSymbolicName(mod, &sym);
@@ -293,7 +293,7 @@ celix_status_t bundle_createModule(bundl
 	return status;
 }
 
-celix_status_t bundle_start(bundle_t bundle, int options) {
+celix_status_t bundle_start(bundle_pt bundle, int options) {
 	celix_status_t status = CELIX_SUCCESS;
     if (bundle != NULL) {
         status = fw_startBundle(bundle->framework, bundle, options);
@@ -301,19 +301,19 @@ celix_status_t bundle_start(bundle_t bun
     return status;
 }
 
-celix_status_t bundle_update(bundle_t bundle, char *inputFile) {
+celix_status_t bundle_update(bundle_pt bundle, char *inputFile) {
 	return framework_updateBundle(bundle->framework, bundle, inputFile);
 }
 
-celix_status_t bundle_stop(bundle_t bundle, int options) {
+celix_status_t bundle_stop(bundle_pt bundle, int options) {
 	return fw_stopBundle(bundle->framework, bundle, ((options & 1) == 0));
 }
 
-celix_status_t bundle_uninstall(bundle_t bundle) {
+celix_status_t bundle_uninstall(bundle_pt bundle) {
     return fw_uninstallBundle(bundle->framework, bundle);
 }
 
-celix_status_t bundle_setPersistentStateInactive(bundle_t bundle) {
+celix_status_t bundle_setPersistentStateInactive(bundle_pt bundle) {
 	celix_status_t status = CELIX_SUCCESS;
 	bool systemBundle;
 
@@ -327,7 +327,7 @@ celix_status_t bundle_setPersistentState
 	return status;
 }
 
-celix_status_t bundle_setPersistentStateUninstalled(bundle_t bundle) {
+celix_status_t bundle_setPersistentStateUninstalled(bundle_pt bundle) {
 	celix_status_t status = CELIX_SUCCESS;
 	bool systemBundle;
 
@@ -341,11 +341,11 @@ celix_status_t bundle_setPersistentState
     return status;
 }
 
-celix_status_t bundle_isUsed(bundle_t bundle, bool *used) {
+celix_status_t bundle_isUsed(bundle_pt bundle, bool *used) {
 	bool unresolved = true;
-	array_list_iterator_t iter = arrayListIterator_create(bundle->modules);
+	array_list_iterator_pt iter = arrayListIterator_create(bundle->modules);
 	while (arrayListIterator_hasNext(iter)) {
-		module_t module = arrayListIterator_next(iter);
+		module_pt module = arrayListIterator_next(iter);
 		if (module_isResolved(module)) {
 			unresolved = false;
 		}
@@ -354,22 +354,22 @@ celix_status_t bundle_isUsed(bundle_t bu
 	*used = false;
 	iter = arrayListIterator_create(bundle->modules);
 	while (arrayListIterator_hasNext(iter) && !unresolved && !*used) {
-		module_t module = arrayListIterator_next(iter);
+		module_pt module = arrayListIterator_next(iter);
 		module_getDependents(module);
 	}
 	arrayListIterator_destroy(iter);
 	return CELIX_SUCCESS;
 }
 
-celix_status_t bundle_revise(bundle_t bundle, char * location, char *inputFile) {
+celix_status_t bundle_revise(bundle_pt bundle, char * location, char *inputFile) {
 	celix_status_t status = CELIX_SUCCESS;
 
-	bundle_archive_t archive = NULL;
+	bundle_archive_pt archive = NULL;
 	status = bundle_getArchive(bundle, &archive);
 	if (status == CELIX_SUCCESS) {
 		status = bundleArchive_revise(archive, location, inputFile);
 		if (status == CELIX_SUCCESS) {
-			module_t module;
+			module_pt module;
 			status = bundle_createModule(bundle, &module);
 			if (status == CELIX_SUCCESS) {
 				status = bundle_addModule(bundle, module);
@@ -385,21 +385,21 @@ celix_status_t bundle_revise(bundle_t bu
 	return status;
 }
 
-//bool bundle_rollbackRevise(bundle_t bundle) {
-//	module_t module = arrayList_remove(bundle->modules, arrayList_set(bundle->modules) - 1);
+//bool bundle_rollbackRevise(bundle_pt bundle) {
+//	module_pt module = arrayList_remove(bundle->modules, arrayList_set(bundle->modules) - 1);
 //	return resolver_removeModule(module);
 //}
 
-celix_status_t bundle_addModule(bundle_t bundle, module_t module) {
+celix_status_t bundle_addModule(bundle_pt bundle, module_pt module) {
 	arrayList_add(bundle->modules, module);
 	resolver_addModule(module);
 	return CELIX_SUCCESS;
 }
 
-celix_status_t bundle_isSystemBundle(bundle_t bundle, bool *systemBundle) {
+celix_status_t bundle_isSystemBundle(bundle_pt bundle, bool *systemBundle) {
 	celix_status_t status = CELIX_SUCCESS;
 	long bundleId;
-	bundle_archive_t archive = NULL;
+	bundle_archive_pt archive = NULL;
 
 	status = bundle_getArchive(bundle, &archive);
 	if (status == CELIX_SUCCESS) {
@@ -412,7 +412,7 @@ celix_status_t bundle_isSystemBundle(bun
 	return status;
 }
 
-celix_status_t bundle_isLockable(bundle_t bundle, bool *lockable) {
+celix_status_t bundle_isLockable(bundle_pt bundle, bool *lockable) {
 	celix_status_t status = CELIX_SUCCESS;
 	apr_status_t apr_status;
 
@@ -435,7 +435,7 @@ celix_status_t bundle_isLockable(bundle_
 	return status;
 }
 
-celix_status_t bundle_getLockingThread(bundle_t bundle, apr_os_thread_t *thread) {
+celix_status_t bundle_getLockingThread(bundle_pt bundle, apr_os_thread_t *thread) {
 	celix_status_t status = CELIX_SUCCESS;
 	apr_status_t apr_status;
 
@@ -454,7 +454,7 @@ celix_status_t bundle_getLockingThread(b
 	return status;
 }
 
-celix_status_t bundle_lock(bundle_t bundle, bool *locked) {
+celix_status_t bundle_lock(bundle_pt bundle, bool *locked) {
 	celix_status_t status = CELIX_SUCCESS;
 	bool equals;
 
@@ -476,7 +476,7 @@ celix_status_t bundle_lock(bundle_t bund
 	return status;
 }
 
-celix_status_t bundle_unlock(bundle_t bundle, bool *unlocked) {
+celix_status_t bundle_unlock(bundle_pt bundle, bool *unlocked) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	bool equals;
@@ -504,8 +504,8 @@ celix_status_t bundle_unlock(bundle_t bu
 	return status;
 }
 
-celix_status_t bundle_close(bundle_t bundle) {
-	bundle_archive_t archive = NULL;
+celix_status_t bundle_close(bundle_pt bundle) {
+	bundle_archive_pt archive = NULL;
 	
 	celix_status_t status = CELIX_SUCCESS;
 
@@ -519,10 +519,10 @@ celix_status_t bundle_close(bundle_t bun
     return status;
 }
 
-celix_status_t bundle_closeAndDelete(bundle_t bundle) {
+celix_status_t bundle_closeAndDelete(bundle_pt bundle) {
 	celix_status_t status = CELIX_SUCCESS;
 
-	bundle_archive_t archive = NULL;
+	bundle_archive_pt archive = NULL;
 
     bundle_closeModules(bundle);
     bundle_closeRevisions(bundle);
@@ -534,19 +534,19 @@ celix_status_t bundle_closeAndDelete(bun
     return status;
 }
 
-celix_status_t bundle_closeRevisions(bundle_t bundle) {
+celix_status_t bundle_closeRevisions(bundle_pt bundle) {
     celix_status_t status = CELIX_SUCCESS;
 
     // TODO implement this
     return status;
 }
 
-celix_status_t bundle_closeModules(bundle_t bundle) {
+celix_status_t bundle_closeModules(bundle_pt bundle) {
     celix_status_t status = CELIX_SUCCESS;
 
     unsigned int i = 0;
     for (i = 0; i < arrayList_size(bundle->modules); i++) {
-        module_t module = (module_t) arrayList_get(bundle->modules, i);
+        module_pt module = (module_pt) arrayList_get(bundle->modules, i);
         resolver_removeModule(module);
         module_setWires(module, NULL);
     }
@@ -554,9 +554,9 @@ celix_status_t bundle_closeModules(bundl
     return status;
 }
 
-celix_status_t bundle_refresh(bundle_t bundle) {
+celix_status_t bundle_refresh(bundle_pt bundle) {
 	celix_status_t status = CELIX_SUCCESS;
-	module_t module;
+	module_pt module;
 
 	status = bundle_closeModules(bundle);
 	if (status == CELIX_SUCCESS) {
@@ -572,9 +572,9 @@ celix_status_t bundle_refresh(bundle_t b
     return status;
 }
 
-celix_status_t bundle_getBundleId(bundle_t bundle, long *id) {
+celix_status_t bundle_getBundleId(bundle_pt bundle, long *id) {
 	celix_status_t status = CELIX_SUCCESS;
-	bundle_archive_t archive = NULL;
+	bundle_archive_pt archive = NULL;
 	status = bundle_getArchive(bundle, &archive);
 	if (status == CELIX_SUCCESS) {
 		status = bundleArchive_getId(archive, id);
@@ -582,7 +582,7 @@ celix_status_t bundle_getBundleId(bundle
 	return status;
 }
 
-celix_status_t bundle_getRegisteredServices(bundle_t bundle, apr_pool_t *pool, array_list_t *list) {
+celix_status_t bundle_getRegisteredServices(bundle_pt bundle, apr_pool_t *pool, array_list_pt *list) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	status = fw_getBundleRegisteredServices(bundle->framework, pool, bundle, list);
@@ -590,7 +590,7 @@ celix_status_t bundle_getRegisteredServi
 	return status;
 }
 
-celix_status_t bundle_getServicesInUse(bundle_t bundle, array_list_t *list) {
+celix_status_t bundle_getServicesInUse(bundle_pt bundle, array_list_pt *list) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	status = fw_getBundleServicesInUse(bundle->framework, bundle, list);
@@ -598,7 +598,7 @@ celix_status_t bundle_getServicesInUse(b
 	return status;
 }
 
-celix_status_t bundle_getMemoryPool(bundle_t bundle, apr_pool_t **pool) {
+celix_status_t bundle_getMemoryPool(bundle_pt bundle, apr_pool_t **pool) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	if (bundle != NULL && *pool == NULL) {
@@ -610,7 +610,7 @@ celix_status_t bundle_getMemoryPool(bund
 	return status;
 }
 
-celix_status_t bundle_setFramework(bundle_t bundle, framework_t framework) {
+celix_status_t bundle_setFramework(bundle_pt bundle, framework_pt framework) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	if (bundle != NULL && framework != NULL) {
@@ -622,7 +622,7 @@ celix_status_t bundle_setFramework(bundl
 	return status;
 }
 
-celix_status_t bundle_getFramework(bundle_t bundle, framework_t *framework) {
+celix_status_t bundle_getFramework(bundle_pt bundle, framework_pt *framework) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	if (bundle != NULL && *framework == NULL) {

Modified: incubator/celix/trunk/framework/private/src/bundle_archive.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/framework/private/src/bundle_archive.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/framework/private/src/bundle_archive.c (original)
+++ incubator/celix/trunk/framework/private/src/bundle_archive.c Wed Jun 12 19:08:50 2013
@@ -41,7 +41,7 @@ struct bundleArchive {
 	char * location;
 	apr_dir_t * archiveRootDir;
 	char * archiveRoot;
-	linked_list_t revisions;
+	linked_list_pt revisions;
 	long refreshCount;
 	time_t lastModified;
 
@@ -52,28 +52,28 @@ struct bundleArchive {
 
 static apr_status_t bundleArchive_destroy(void *archiveP);
 
-static celix_status_t bundleArchive_getRevisionLocation(bundle_archive_t archive, long revNr, char **revision_location);
-static celix_status_t bundleArchive_setRevisionLocation(bundle_archive_t archive, char * location, long revNr);
+static celix_status_t bundleArchive_getRevisionLocation(bundle_archive_pt archive, long revNr, char **revision_location);
+static celix_status_t bundleArchive_setRevisionLocation(bundle_archive_pt archive, char * location, long revNr);
 
-static celix_status_t bundleArchive_initialize(bundle_archive_t archive);
+static celix_status_t bundleArchive_initialize(bundle_archive_pt archive);
 
 static celix_status_t bundleArchive_deleteTree(char * directory, apr_pool_t *mp);
 
-static celix_status_t bundleArchive_createRevisionFromLocation(bundle_archive_t archive, char *location, char *inputFile, long revNr, bundle_revision_t *bundle_revision);
-static celix_status_t bundleArchive_reviseInternal(bundle_archive_t archive, bool isReload, long revNr, char * location, char *inputFile);
+static celix_status_t bundleArchive_createRevisionFromLocation(bundle_archive_pt archive, char *location, char *inputFile, long revNr, bundle_revision_pt *bundle_revision);
+static celix_status_t bundleArchive_reviseInternal(bundle_archive_pt archive, bool isReload, long revNr, char * location, char *inputFile);
 
-static celix_status_t bundleArchive_readLastModified(bundle_archive_t archive, time_t *time);
-static celix_status_t bundleArchive_writeLastModified(bundle_archive_t archive);
+static celix_status_t bundleArchive_readLastModified(bundle_archive_pt archive, time_t *time);
+static celix_status_t bundleArchive_writeLastModified(bundle_archive_pt archive);
 
-celix_status_t bundleArchive_createSystemBundleArchive(apr_pool_t *mp, bundle_archive_t *bundle_archive) {
+celix_status_t bundleArchive_createSystemBundleArchive(apr_pool_t *mp, bundle_archive_pt *bundle_archive) {
     celix_status_t status;
-	bundle_archive_t archive;
+	bundle_archive_pt archive;
 	apr_pool_t *revisions_pool;
 
 	if (mp == NULL || *bundle_archive != NULL) {
 	    status = CELIX_ILLEGAL_ARGUMENT;
 	} else {
-        archive = (bundle_archive_t) apr_palloc(mp, sizeof(*archive));
+        archive = (bundle_archive_pt) apr_palloc(mp, sizeof(*archive));
         if (archive == NULL) {
             status = CELIX_ENOMEM;
         } else {
@@ -103,15 +103,15 @@ celix_status_t bundleArchive_createSyste
     return status;
 }
 
-celix_status_t bundleArchive_create(char * archiveRoot, long id, char * location, char *inputFile, apr_pool_t *mp, bundle_archive_t *bundle_archive) {
+celix_status_t bundleArchive_create(char * archiveRoot, long id, char * location, char *inputFile, apr_pool_t *mp, bundle_archive_pt *bundle_archive) {
     celix_status_t status = CELIX_SUCCESS;
     apr_pool_t *revisions_pool;
-    bundle_archive_t archive;
+    bundle_archive_pt archive;
 
     if (*bundle_archive != NULL) {
     	status = CELIX_ILLEGAL_ARGUMENT;
     } else {
-		archive = (bundle_archive_t) apr_pcalloc(mp, sizeof(*archive));
+		archive = (bundle_archive_pt) apr_pcalloc(mp, sizeof(*archive));
 		if (archive != NULL) {
 			apr_pool_pre_cleanup_register(mp, archive, bundleArchive_destroy);
 			if (apr_pool_create(&revisions_pool, mp) == APR_SUCCESS) {
@@ -145,7 +145,7 @@ celix_status_t bundleArchive_create(char
 }
 
 static apr_status_t bundleArchive_destroy(void *archiveP) {
-	bundle_archive_t archive = archiveP;
+	bundle_archive_pt archive = archiveP;
 	if (archive != NULL) {
 		if (archive->archiveRootDir != NULL) {
 			apr_dir_close(archive->archiveRootDir);
@@ -156,13 +156,13 @@ static apr_status_t bundleArchive_destro
 	return APR_SUCCESS;
 }
 
-celix_status_t bundleArchive_recreate(char * archiveRoot, apr_pool_t *mp, bundle_archive_t *bundle_archive) {
+celix_status_t bundleArchive_recreate(char * archiveRoot, apr_pool_t *mp, bundle_archive_pt *bundle_archive) {
     apr_pool_t *revisions_pool;
     celix_status_t status;
-    bundle_archive_t archive;
+    bundle_archive_pt archive;
 
     status = CELIX_SUCCESS;
-	archive = (bundle_archive_t) apr_pcalloc(mp, sizeof(*archive));
+	archive = (bundle_archive_pt) apr_pcalloc(mp, sizeof(*archive));
 	if (archive != NULL) {
 		apr_pool_pre_cleanup_register(mp, archive, bundleArchive_destroy);
 	    if (apr_pool_create(&revisions_pool, mp) == APR_SUCCESS) {
@@ -213,7 +213,7 @@ celix_status_t bundleArchive_recreate(ch
 	return status;
 }
 
-celix_status_t bundleArchive_getId(bundle_archive_t archive, long *id) {
+celix_status_t bundleArchive_getId(bundle_archive_pt archive, long *id) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	if (archive->id < 0) {
@@ -246,7 +246,7 @@ celix_status_t bundleArchive_getId(bundl
 	return status;
 }
 
-celix_status_t bundleArchive_getLocation(bundle_archive_t archive, char **location) {
+celix_status_t bundleArchive_getLocation(bundle_archive_pt archive, char **location) {
 	celix_status_t status = CELIX_SUCCESS;
 	if (archive->location == NULL) {
 		apr_file_t *bundleLocationFile;
@@ -278,14 +278,14 @@ celix_status_t bundleArchive_getLocation
 	return status;
 }
 
-celix_status_t bundleArchive_getArchiveRoot(bundle_archive_t archive, char **archiveRoot) {
+celix_status_t bundleArchive_getArchiveRoot(bundle_archive_pt archive, char **archiveRoot) {
 	*archiveRoot = archive->archiveRoot;
 	return CELIX_SUCCESS;
 }
 
-celix_status_t bundleArchive_getCurrentRevisionNumber(bundle_archive_t archive, long *revisionNumber) {
+celix_status_t bundleArchive_getCurrentRevisionNumber(bundle_archive_pt archive, long *revisionNumber) {
 	celix_status_t status = CELIX_SUCCESS;
-	bundle_revision_t revision;
+	bundle_revision_pt revision;
 	*revisionNumber = -1;
 	
 	status = bundleArchive_getCurrentRevision(archive, &revision);
@@ -296,17 +296,17 @@ celix_status_t bundleArchive_getCurrentR
 	return status;
 }
 
-celix_status_t bundleArchive_getCurrentRevision(bundle_archive_t archive, bundle_revision_t *revision) {
+celix_status_t bundleArchive_getCurrentRevision(bundle_archive_pt archive, bundle_revision_pt *revision) {
 	*revision = linkedList_isEmpty(archive->revisions) ? NULL : linkedList_getLast(archive->revisions);
 	return CELIX_SUCCESS;
 }
 
-celix_status_t bundleArchive_getRevision(bundle_archive_t archive, long revNr, bundle_revision_t *revision) {
+celix_status_t bundleArchive_getRevision(bundle_archive_pt archive, long revNr, bundle_revision_pt *revision) {
 	*revision = linkedList_get(archive->revisions, revNr);
 	return CELIX_SUCCESS;
 }
 
-celix_status_t bundleArchive_getPersistentState(bundle_archive_t archive, bundle_state_e *state) {
+celix_status_t bundleArchive_getPersistentState(bundle_archive_pt archive, bundle_state_e *state) {
 	celix_status_t status = CELIX_SUCCESS;
 	apr_status_t apr_status;
 
@@ -348,7 +348,7 @@ celix_status_t bundleArchive_getPersiste
 	return status;
 }
 
-celix_status_t bundleArchive_setPersistentState(bundle_archive_t archive, bundle_state_e state) {
+celix_status_t bundleArchive_setPersistentState(bundle_archive_pt archive, bundle_state_e state) {
 	celix_status_t status = CELIX_SUCCESS;
 	apr_status_t apr_status;
 	char * persistentStateLocation = NULL;
@@ -388,7 +388,7 @@ celix_status_t bundleArchive_setPersiste
 	return status;
 }
 
-celix_status_t bundleArchive_getRefreshCount(bundle_archive_t archive, long *refreshCount) {
+celix_status_t bundleArchive_getRefreshCount(bundle_archive_pt archive, long *refreshCount) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	if (archive->refreshCount == -1) {
@@ -420,7 +420,7 @@ celix_status_t bundleArchive_getRefreshC
 	return status;
 }
 
-celix_status_t bundleArchive_setRefreshCount(bundle_archive_t archive) {
+celix_status_t bundleArchive_setRefreshCount(bundle_archive_pt archive) {
 	apr_file_t * refreshCounterFile;
 	apr_status_t apr_status;
 	celix_status_t status = CELIX_SUCCESS;
@@ -445,7 +445,7 @@ celix_status_t bundleArchive_setRefreshC
 	return status;
 }
 
-celix_status_t bundleArchive_getLastModified(bundle_archive_t archive, time_t *lastModified) {
+celix_status_t bundleArchive_getLastModified(bundle_archive_pt archive, time_t *lastModified) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	if (archive->lastModified == (time_t) NULL) {
@@ -459,7 +459,7 @@ celix_status_t bundleArchive_getLastModi
 	return status;
 }
 
-celix_status_t bundleArchive_setLastModified(bundle_archive_t archive, time_t lastModifiedTime) {
+celix_status_t bundleArchive_setLastModified(bundle_archive_pt archive, time_t lastModifiedTime) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	archive->lastModified = lastModifiedTime;
@@ -468,7 +468,7 @@ celix_status_t bundleArchive_setLastModi
 	return status;
 }
 
-static celix_status_t bundleArchive_readLastModified(bundle_archive_t archive, time_t *time) {
+static celix_status_t bundleArchive_readLastModified(bundle_archive_pt archive, time_t *time) {
 	char timeStr[20];
 	apr_file_t *lastModifiedFile;
 	apr_status_t apr_status;
@@ -507,7 +507,7 @@ static celix_status_t bundleArchive_read
 	return status;
 }
 
-static celix_status_t bundleArchive_writeLastModified(bundle_archive_t archive) {
+static celix_status_t bundleArchive_writeLastModified(bundle_archive_pt archive) {
 	celix_status_t status = CELIX_SUCCESS;
 	apr_file_t *lastModifiedFile;
 	char timeStr[20];
@@ -535,7 +535,7 @@ static celix_status_t bundleArchive_writ
 	return status;
 }
 
-celix_status_t bundleArchive_revise(bundle_archive_t archive, char * location, char *inputFile) {
+celix_status_t bundleArchive_revise(bundle_archive_pt archive, char * location, char *inputFile) {
 	celix_status_t status = CELIX_SUCCESS;
 	long revNr = 0l;
 	if (!linkedList_isEmpty(archive->revisions)) {
@@ -549,9 +549,9 @@ celix_status_t bundleArchive_revise(bund
 	return status;
 }
 
-static celix_status_t bundleArchive_reviseInternal(bundle_archive_t archive, bool isReload, long revNr, char * location, char *inputFile) {
+static celix_status_t bundleArchive_reviseInternal(bundle_archive_pt archive, bool isReload, long revNr, char * location, char *inputFile) {
     celix_status_t status;
-    bundle_revision_t revision = NULL;
+    bundle_revision_pt revision = NULL;
 
     if (inputFile != NULL) {
 		location = "inputstream:";
@@ -570,19 +570,19 @@ static celix_status_t bundleArchive_revi
 	return status;
 }
 
-celix_status_t bundleArchive_rollbackRevise(bundle_archive_t archive, bool *rolledback) {
+celix_status_t bundleArchive_rollbackRevise(bundle_archive_pt archive, bool *rolledback) {
 	*rolledback = true;
 	return CELIX_SUCCESS;
 }
 
-static celix_status_t bundleArchive_createRevisionFromLocation(bundle_archive_t archive, char *location, char *inputFile, long revNr, bundle_revision_t *bundle_revision) {
+static celix_status_t bundleArchive_createRevisionFromLocation(bundle_archive_pt archive, char *location, char *inputFile, long revNr, bundle_revision_pt *bundle_revision) {
     celix_status_t status = CELIX_SUCCESS;
     char root[256];
     long refreshCount;
 
     status = bundleArchive_getRefreshCount(archive, &refreshCount);
     if (status == CELIX_SUCCESS) {
-		bundle_revision_t revision = NULL;
+		bundle_revision_pt revision = NULL;
 		apr_pool_t *pool = NULL;
 		
 		sprintf(root, "%s/version%ld.%ld", archive->archiveRoot, refreshCount, revNr);
@@ -604,7 +604,7 @@ static celix_status_t bundleArchive_crea
 	return status;
 }
 
-static celix_status_t bundleArchive_getRevisionLocation(bundle_archive_t archive, long revNr, char **revision_location) {
+static celix_status_t bundleArchive_getRevisionLocation(bundle_archive_pt archive, long revNr, char **revision_location) {
     celix_status_t status;
 	char revisionLocation[256];
 	long refreshCount;
@@ -632,7 +632,7 @@ static celix_status_t bundleArchive_getR
 	return status;
 }
 
-static celix_status_t bundleArchive_setRevisionLocation(bundle_archive_t archive, char * location, long revNr) {
+static celix_status_t bundleArchive_setRevisionLocation(bundle_archive_pt archive, char * location, long revNr) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	char revisionLocation[256];
@@ -655,13 +655,13 @@ static celix_status_t bundleArchive_setR
 	return status;
 }
 
-celix_status_t bundleArchive_close(bundle_archive_t archive) {
+celix_status_t bundleArchive_close(bundle_archive_pt archive) {
 	// close revision
 	// not yet needed/possible
 	return CELIX_SUCCESS;
 }
 
-celix_status_t bundleArchive_closeAndDelete(bundle_archive_t archive) {
+celix_status_t bundleArchive_closeAndDelete(bundle_archive_pt archive) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	status = bundleArchive_close(archive);
@@ -672,7 +672,7 @@ celix_status_t bundleArchive_closeAndDel
 	return status;
 }
 
-static celix_status_t bundleArchive_initialize(bundle_archive_t archive) {
+static celix_status_t bundleArchive_initialize(bundle_archive_pt archive) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	if (archive->archiveRootDir == NULL) {

Modified: incubator/celix/trunk/framework/private/src/bundle_cache.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/framework/private/src/bundle_cache.c?rev=1492377&r1=1492376&r2=1492377&view=diff
==============================================================================
--- incubator/celix/trunk/framework/private/src/bundle_cache.c (original)
+++ incubator/celix/trunk/framework/private/src/bundle_cache.c Wed Jun 12 19:08:50 2013
@@ -38,7 +38,7 @@
 #include "constants.h"
 
 struct bundleCache {
-	properties_t configurationMap;
+	properties_pt configurationMap;
 	char * cacheDir;
 	apr_pool_t *mp;
 };
@@ -46,11 +46,11 @@ struct bundleCache {
 static celix_status_t bundleCache_deleteTree(char * directory, apr_pool_t *mp);
 static apr_status_t bundleCache_destroy(void *cacheP);
 
-celix_status_t bundleCache_create(properties_t configurationMap, apr_pool_t *mp, bundle_cache_t *bundle_cache) {
+celix_status_t bundleCache_create(properties_pt configurationMap, apr_pool_t *mp, bundle_cache_pt *bundle_cache) {
     celix_status_t status;
-   bundle_cache_t cache;
+   bundle_cache_pt cache;
 
-	cache = (bundle_cache_t) apr_palloc(mp, (sizeof(*cache)));
+	cache = (bundle_cache_pt) apr_palloc(mp, (sizeof(*cache)));
     if (cache == NULL) {
         status = CELIX_ENOMEM;
     } else {
@@ -76,16 +76,16 @@ celix_status_t bundleCache_create(proper
 }
 
 apr_status_t bundleCache_destroy(void *cacheP) {
-	bundle_cache_t cache = (bundle_cache_t) cacheP;
+	bundle_cache_pt cache = (bundle_cache_pt) cacheP;
     properties_destroy(cache->configurationMap);
     return CELIX_SUCCESS;
 }
 
-celix_status_t bundleCache_delete(bundle_cache_t cache) {
+celix_status_t bundleCache_delete(bundle_cache_pt cache) {
 	return bundleCache_deleteTree(cache->cacheDir, cache->mp);
 }
 
-celix_status_t bundleCache_getArchives(bundle_cache_t cache, apr_pool_t *pool, array_list_t *archives) {
+celix_status_t bundleCache_getArchives(bundle_cache_pt cache, apr_pool_t *pool, array_list_pt *archives) {
 	celix_status_t status = CELIX_SUCCESS;
 
 	apr_dir_t *dir;
@@ -97,7 +97,7 @@ celix_status_t bundleCache_getArchives(b
 	}
 
 	if (aprStatus == APR_SUCCESS) {
-        array_list_t list = NULL;
+        array_list_pt list = NULL;
 		apr_finfo_t dp;
         arrayList_create(pool, &list);
         
@@ -118,7 +118,7 @@ celix_status_t bundleCache_getArchives(b
                     && (strncmp(dp.name, "bundle", 6) == 0)
                     && (strcmp(dp.name, "bundle0") != 0)) {
 
-                bundle_archive_t archive = NULL;
+                bundle_archive_pt archive = NULL;
                 status = bundleArchive_recreate(apr_pstrdup(cache->mp, archiveRoot), cache->mp, &archive);
                 if (status == CELIX_SUCCESS) {
                     arrayList_add(list, archive);
@@ -139,7 +139,7 @@ celix_status_t bundleCache_getArchives(b
 	return status;
 }
 
-celix_status_t bundleCache_createArchive(bundle_cache_t cache, apr_pool_t *bundlePool, long id, char * location, char *inputFile, bundle_archive_t *bundle_archive) {
+celix_status_t bundleCache_createArchive(bundle_cache_pt cache, apr_pool_t *bundlePool, long id, char * location, char *inputFile, bundle_archive_pt *bundle_archive) {
 	celix_status_t status = CELIX_SUCCESS;
 	char *archiveRoot = NULL;
 



Mime
View raw message