new object inheritance model

include/belle-sip/belle-sip.h

@@ -100,11 +100,13 @@ void belle_sip_object_set_name(belle_sip_object_t *obj,const char* name);
 **/
 const char* belle_sip_object_get_name(belle_sip_object_t *obj);
 
+belle_sip_object_t *belle_sip_object_clone(const belle_sip_object_t *obj);
+
 /**
- * Destroy the object: this function is intended for unowed object, that is objects
- * that were created with a 0 reference count.
+ * Delete the object: this function is intended for unowed object, that is objects
+ * that were created with a 0 reference count. For all others, use belle_sip_object_unref().
 **/
-void belle_sip_object_destroy(void *obj);
+void belle_sip_object_delete(void *obj);
 
 void *belle_sip_object_cast(belle_sip_object_t *obj, belle_sip_type_id_t id, const char *castname, const char *file, int fileno);
 

include/belle-sip/message.h

@@ -60,6 +60,9 @@ char *belle_sip_message_to_string(belle_sip_message_t *msg);
 
 int belle_sip_response_get_status_code(const belle_sip_response_t *response);
 
+belle_sip_response_t *belle_sip_response_new(void);
+belle_sip_response_t *belle_sip_response_new_from_request(belle_sip_request_t *req);
+
 BELLE_SIP_END_DECLS
 
 #endif

src/belle_sip_headers_impl.c

@@ -34,34 +34,38 @@
 GET_SET_STRING(belle_sip_header,name);
 
 void belle_sip_header_init(belle_sip_header_t *header) {
-	belle_sip_object_init_type(header,belle_sip_header_t);
-	belle_sip_object_init((belle_sip_object_t*)header); /*super*/
+
 }
 
- void belle_sip_header_destroy(belle_sip_header_t *header){
+static void belle_sip_header_destroy(belle_sip_header_t *header){
 	if (header->name) belle_sip_free((void*)header->name);
 }
 
+BELLE_SIP_INSTANCIATE_VPTR(belle_sip_header_t,belle_sip_object_t,belle_sip_header_destroy,NULL);
+
+
 /************************
  * header_address
  ***********************/
 struct _belle_sip_header_address {
-	belle_sip_parameters_t params;
+	belle_sip_parameters_t base;
 	const char* displayname;
 	belle_sip_uri_t* uri;
 };
+
 static void belle_sip_header_address_init(belle_sip_header_address_t* object){
-	belle_sip_object_init_type(object,belle_sip_header_address_t);
 	belle_sip_parameters_init((belle_sip_parameters_t*)object); /*super*/
 }
 
 static void belle_sip_header_address_destroy(belle_sip_header_address_t* contact) {
 	if (contact->displayname) belle_sip_free((void*)(contact->displayname));
 	if (contact->uri) belle_sip_object_unref(BELLE_SIP_OBJECT(contact->uri));
-	belle_sip_header_destroy((belle_sip_header_t*)contact);
 }
 
-BELLE_SIP_NEW(header_address,object)
+static void belle_sip_header_address_clone(belle_sip_header_address_t *addr){
+}
+
+BELLE_SIP_NEW(header_address,parameters)
 GET_SET_STRING(belle_sip_header_address,displayname);
 
 void belle_sip_header_address_set_quoted_displayname(belle_sip_header_address_t* address,const char* value) {
@@ -89,7 +93,9 @@ struct _belle_sip_header_contact {
  };
 
 void belle_sip_header_contact_destroy(belle_sip_header_contact_t* contact) {
-	belle_sip_header_address_destroy(BELLE_SIP_HEADER_ADDRESS(contact));
+}
+
+void belle_sip_header_contact_clone(belle_sip_header_contact_t *contact, const belle_sip_header_contact_t *orig){
 }
 
 BELLE_SIP_NEW_WITH_NAME(header_contact,header_address,"Contact")
@@ -128,15 +134,18 @@ struct _belle_sip_header_from  {
 };
 
 static void belle_sip_header_from_destroy(belle_sip_header_from_t* from) {
-	belle_sip_header_address_destroy(BELLE_SIP_HEADER_ADDRESS(from));
 }
 
+static void belle_sip_header_from_clone(belle_sip_header_from_t* from, const belle_sip_header_from_t* cloned) {
+}
+
+
 BELLE_SIP_NEW_WITH_NAME(header_from,header_address,"From")
 BELLE_SIP_PARSE(header_from)
 GET_SET_STRING_PARAM(belle_sip_header_from,tag);
 
 /**************************
-* To header object inherent from header_address
+* To header object inherits from header_address
 ****************************
 */
 struct _belle_sip_header_to  {
@@ -144,7 +153,9 @@ struct _belle_sip_header_to  {
 };
 
 static void belle_sip_header_to_destroy(belle_sip_header_to_t* to) {
-	belle_sip_header_address_destroy(BELLE_SIP_HEADER_ADDRESS(to));
+}
+
+void belle_sip_header_to_clone(belle_sip_header_to_t *contact, const belle_sip_header_to_t *orig){
 }
 
 BELLE_SIP_NEW_WITH_NAME(header_to,header_address,"To")
@@ -152,21 +163,23 @@ BELLE_SIP_PARSE(header_to)
 GET_SET_STRING_PARAM(belle_sip_header_to,tag);
 
 /**************************
-* Viq header object inherent from parameters
+* Via header object inherits from parameters
 ****************************
 */
 struct _belle_sip_header_via  {
 	belle_sip_parameters_t params_list;
-	const char* protocol;
-	const char* transport;
-	const char* host;
+	char* protocol;
+	char* transport;
+	char* host;
 	int port;
 };
 
 static void belle_sip_header_via_destroy(belle_sip_header_via_t* via) {
-	belle_sip_parameters_destroy(BELLE_SIP_PARAMETERS(via));
-	if (via->host) belle_sip_free((void*)via->host);
-	if (via->protocol) belle_sip_free((void*)via->protocol);
+	if (via->host) belle_sip_free(via->host);
+	if (via->protocol) belle_sip_free(via->protocol);
+}
+
+static void belle_sip_header_via_clone(belle_sip_header_via_t* via, const belle_sip_header_via_t*orig){
 }
 
 BELLE_SIP_NEW_WITH_NAME(header_via,header_address,"Via")
@@ -219,7 +232,7 @@ int belle_sip_header_via_get_listening_port(const belle_sip_header_via_t *via){
 }
 
 /**************************
-* call_id header object inherent from object
+* call_id header object inherits from object
 ****************************
 */
 struct _belle_sip_header_call_id  {
@@ -228,12 +241,13 @@ struct _belle_sip_header_call_id  {
 };
 
 static void belle_sip_header_call_id_destroy(belle_sip_header_call_id_t* call_id) {
-	belle_sip_object_destroy(BELLE_SIP_OBJECT(call_id));
 	if (call_id->call_id) belle_sip_free((void*)call_id->call_id);
+}
 
+static void belle_sip_header_call_id_clone(belle_sip_header_call_id_t* call_id,const belle_sip_header_call_id_t *orig){
 }
 
-BELLE_SIP_NEW_WITH_NAME(header_call_id,object,"Call-ID")
+BELLE_SIP_NEW_WITH_NAME(header_call_id,header,"Call-ID")
 BELLE_SIP_PARSE(header_call_id)
 GET_SET_STRING(belle_sip_header_call_id,call_id);
 /**************************
@@ -247,12 +261,14 @@ struct _belle_sip_header_cseq  {
 };
 
 static void belle_sip_header_cseq_destroy(belle_sip_header_cseq_t* cseq) {
-	belle_sip_object_destroy(BELLE_SIP_OBJECT(cseq));
 	if (cseq->method) belle_sip_free((void*)cseq->method);
+}
 
+static void belle_sip_header_cseq_clone(belle_sip_header_cseq_t* cseq, const belle_sip_header_cseq_t *orig) {
+	if (cseq->method) belle_sip_free((void*)cseq->method);
 }
 
-BELLE_SIP_NEW_WITH_NAME(header_cseq,object,"Cseq")
+BELLE_SIP_NEW_WITH_NAME(header_cseq,header,"Cseq")
 BELLE_SIP_PARSE(header_cseq)
 GET_SET_STRING(belle_sip_header_cseq,method);
 GET_SET_INT(belle_sip_header_cseq,seq_number,unsigned int)
@@ -267,11 +283,13 @@ struct _belle_sip_header_content_type  {
 };
 
 static void belle_sip_header_content_type_destroy(belle_sip_header_content_type_t* content_type) {
-	belle_sip_parameters_destroy(BELLE_SIP_PARAMETERS(content_type));
 	if (content_type->type) belle_sip_free((void*)content_type->type);
 	if (content_type->subtype) belle_sip_free((void*)content_type->subtype);
 }
 
+static void belle_sip_header_content_type_clone(belle_sip_header_content_type_t* content_type, const belle_sip_header_content_type_t* orig){
+}
+
 BELLE_SIP_NEW_WITH_NAME(header_content_type,parameters,"Content-Type")
 BELLE_SIP_PARSE(header_content_type)
 GET_SET_STRING(belle_sip_header_content_type,type);
@@ -285,7 +303,9 @@ struct _belle_sip_header_route  {
 };
 
 static void belle_sip_header_route_destroy(belle_sip_header_route_t* route) {
-	belle_sip_header_address_destroy(BELLE_SIP_HEADER_ADDRESS(route));
+}
+
+static void belle_sip_header_route_clone(belle_sip_header_route_t* route, const belle_sip_header_route_t* orig) {
 }
 
 BELLE_SIP_NEW_WITH_NAME(header_route,header_address,"Route")
@@ -299,7 +319,10 @@ struct _belle_sip_header_record_route  {
 };
 
 static void belle_sip_header_record_route_destroy(belle_sip_header_record_route_t* record_route) {
-	belle_sip_header_address_destroy(BELLE_SIP_HEADER_ADDRESS(record_route));
+}
+
+static void belle_sip_header_record_route_clone(belle_sip_header_record_route_t* record_route,
+                                const belle_sip_header_record_route_t* orig               ) {
 }
 
 BELLE_SIP_NEW_WITH_NAME(header_record_route,header_address,"Record-Route")
@@ -314,9 +337,13 @@ struct _belle_sip_header_content_length  {
 };
 
 static void belle_sip_header_content_length_destroy(belle_sip_header_content_length_t* content_length) {
-	belle_sip_object_destroy(BELLE_SIP_OBJECT(content_length));
+}
 
+static void belle_sip_header_content_length_clone(belle_sip_header_content_length_t* content_length,
+                                                 const belle_sip_header_content_length_t *orig ) {
 }
-BELLE_SIP_NEW_WITH_NAME(header_content_length,object,"Content-Length")
+
+
+BELLE_SIP_NEW_WITH_NAME(header_content_length,header,"Content-Length")
 BELLE_SIP_PARSE(header_content_length)
 GET_SET_INT(belle_sip_header_content_length,content_length,unsigned int)

src/belle_sip_internal.h

@@ -30,29 +30,70 @@
 #include "belle-sip/belle-sip.h"
 
 typedef void (*belle_sip_object_destroy_t)(belle_sip_object_t*);
+typedef void (*belle_sip_object_clone_t)(belle_sip_object_t* obj, const belle_sip_object_t *orig);
 
-struct _belle_sip_object{
-	uint8_t type_ids[8]; /*table of belle_sip_type_id_t for all inheritance chain*/
-	int ref;
-	void *vptr;
+struct _belle_sip_object_vptr{
+	belle_sip_type_id_t id;
+	struct _belle_sip_object_vptr *parent;
+	void *interfaces;	/*unused for the moment*/
 	belle_sip_object_destroy_t destroy;
-	const char* name;
+	belle_sip_object_clone_t clone;
 };
 
-belle_sip_object_t * _belle_sip_object_new(size_t objsize, belle_sip_type_id_t id, void *vptr, belle_sip_object_destroy_t destroy_func, int initially_unowed);
-void _belle_sip_object_init_type(belle_sip_object_t *obj, belle_sip_type_id_t id);
-void belle_sip_object_init(belle_sip_object_t *obj);
+typedef struct _belle_sip_object_vptr belle_sip_object_vptr_t;
+
+extern belle_sip_object_vptr_t belle_sip_object_t_vptr;
+
+#define BELLE_SIP_OBJECT_VPTR_NAME(object_type)	object_type##_vptr
+
+#define BELLE_SIP_DECLARE_VPTR(object_type) \
+	extern belle_sip_object_vptr_t BELLE_SIP_OBJECT_VPTR_NAME(object_type);
+
+#define BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_BEGIN(vptr_type,object_type, parent_type, destroy, clone) \
+	vptr_type object_type##_vptr={ {\
+		BELLE_SIP_TYPE_ID(object_type), \
+		(belle_sip_object_vptr_t*)&BELLE_SIP_OBJECT_VPTR_NAME(parent_type), \
+		NULL, \
+		(belle_sip_object_destroy_t)destroy,	\
+		(belle_sip_object_clone_t)clone	},
+
+#define BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_END };
+
+#define BELLE_SIP_INSTANCIATE_VPTR(object_type,parent_type,destroy,clone) \
+		belle_sip_object_vptr_t object_type##_vptr={ \
+		BELLE_SIP_TYPE_ID(object_type), \
+		(belle_sip_object_vptr_t*)&BELLE_SIP_OBJECT_VPTR_NAME(parent_type), \
+		NULL, \
+		(belle_sip_object_destroy_t)destroy,	\
+		(belle_sip_object_clone_t)clone	\
+		}
+
 
 
-#define belle_sip_object_new(_type,destroy) (_type*)_belle_sip_object_new(sizeof(_type),BELLE_SIP_TYPE_ID(_type),NULL,(belle_sip_object_destroy_t)destroy,0)
-#define belle_sip_object_new_unowed(_type,destroy) (_type*)_belle_sip_object_new(sizeof(_type),BELLE_SIP_TYPE_ID(_type),NULL,(belle_sip_object_destroy_t)destroy,1)
-#define belle_sip_object_init_type(obj, _type) _belle_sip_object_init_type((belle_sip_object_t*)obj, BELLE_SIP_TYPE_ID(_type))
 
-#define belle_sip_object_new_with_vptr(_type,vptr,destroy) (_type*)_belle_sip_object_new(sizeof(_type),BELLE_SIP_TYPE_ID(_type),vptr,(belle_sip_object_destroy_t)destroy,0)
-#define belle_sip_object_new_unowed_with_vptr(_type,vptr,destroy) (_type*)_belle_sip_object_new(sizeof(_type),BELLE_SIP_TYPE_ID(_type),vptr,(belle_sip_object_destroy_t)destroy,1)
+struct _belle_sip_object{
+	belle_sip_object_vptr_t *vptr;
+	size_t size;
+	int ref;
+	char* name;
+};
+
+belle_sip_object_t * _belle_sip_object_new(size_t objsize, belle_sip_object_vptr_t *vptr, int initially_unowed);
+
+
+#define belle_sip_object_new(_type) (_type*)_belle_sip_object_new(sizeof(_type),(belle_sip_object_vptr_t*)&BELLE_SIP_OBJECT_VPTR_NAME(_type),0)
+#define belle_sip_object_new_unowed(_type,destroy)(_type*)_belle_sip_object_new(sizeof(_type),(belle_sip_object_vptr_t*)&BELLE_SIP_OBJECT_VPTR_NAME(_type),1)
 
 #define BELLE_SIP_OBJECT_VPTR(obj,vptr_type) ((vptr_type*)(((belle_sip_object_t*)obj)->vptr))
-		
+#define belle_sip_object_init(obj)		/*nothing*/
+
+
+/*list of all vptrs (classes) used in belle-sip*/
+BELLE_SIP_DECLARE_VPTR(belle_sip_object_t);
+BELLE_SIP_DECLARE_VPTR(belle_sip_uri_t);
+BELLE_SIP_DECLARE_VPTR(belle_sip_header_t);
+BELLE_SIP_DECLARE_VPTR(belle_sip_parameters_t);
+BELLE_SIP_DECLARE_VPTR(belle_sip_header_contact_t);
 
 struct _belle_sip_list {
 	struct _belle_sip_list *next;
@@ -322,8 +363,9 @@ belle_sip_##object_type##_t* belle_sip_##object_type##_parse (const char* value)
 #define BELLE_SIP_NEW(object_type,super_type) BELLE_SIP_NEW_WITH_NAME(object_type,super_type,NULL)
 
 #define BELLE_SIP_NEW_WITH_NAME(object_type,super_type,name) \
+		BELLE_SIP_INSTANCIATE_VPTR(belle_sip_##object_type##_t,belle_sip_##super_type##_t , belle_sip_##object_type##_destroy, belle_sip_##object_type##_clone); \
 		belle_sip_##object_type##_t* belle_sip_##object_type##_new () { \
-		belle_sip_##object_type##_t* l_object = belle_sip_object_new(belle_sip_##object_type##_t, (belle_sip_object_destroy_t)belle_sip_##object_type##_destroy);\
+		belle_sip_##object_type##_t* l_object = belle_sip_object_new(belle_sip_##object_type##_t);\
 		belle_sip_##super_type##_init((belle_sip_##super_type##_t*)l_object); \
 		belle_sip_object_set_name(BELLE_SIP_OBJECT(l_object),name);\
 		return l_object;\
@@ -353,7 +395,7 @@ struct _belle_sip_header {
 	belle_sip_object_t base;
 	const char* name;
 };
-void belle_sip_header_destroy(belle_sip_header_t *header);
+
 void belle_sip_header_init(belle_sip_header_t* obj);
 /*class parameters*/
 struct _belle_sip_parameters {
@@ -363,7 +405,6 @@ struct _belle_sip_parameters {
 };
 
 void belle_sip_parameters_init(belle_sip_parameters_t *obj);
-void belle_sip_parameters_destroy(belle_sip_parameters_t* params);
 
 /*
  * Listening points and channels

src/belle_sip_loop.c

@@ -42,8 +42,10 @@ void belle_sip_fd_source_init(belle_sip_source_t *s, belle_sip_source_func_t fun
 	s->notify=func;
 }
 
+BELLE_SIP_INSTANCIATE_VPTR(belle_sip_source_t,belle_sip_object_t,belle_sip_source_destroy,NULL);
+
 belle_sip_source_t * belle_sip_fd_source_new(belle_sip_source_func_t func, void *data, int fd, unsigned int events, unsigned int timeout_value_ms){
-	belle_sip_source_t *s=belle_sip_object_new(belle_sip_source_t, belle_sip_source_destroy);
+	belle_sip_source_t *s=belle_sip_object_new(belle_sip_source_t);
 	belle_sip_fd_source_init(s,func,data,fd,events,timeout_value_ms);
 	return s;
 }
@@ -87,8 +89,10 @@ static int main_loop_done(void *data, unsigned int events){
 	return TRUE;
 }
 
+BELLE_SIP_INSTANCIATE_VPTR(belle_sip_main_loop_t,belle_sip_object_t,belle_sip_main_loop_destroy,NULL);
+
 belle_sip_main_loop_t *belle_sip_main_loop_new(void){
-	belle_sip_main_loop_t*m=belle_sip_object_new(belle_sip_main_loop_t, belle_sip_main_loop_destroy);
+	belle_sip_main_loop_t*m=belle_sip_object_new(belle_sip_main_loop_t);
 	if (pipe(m->control_fds)==-1){
 		belle_sip_fatal("Could not create control pipe.");
 	}

src/belle_sip_object.c

@@ -18,29 +18,21 @@
 
 #include "belle_sip_internal.h"
 
-static uint8_t *find_type(belle_sip_object_t *obj, belle_sip_type_id_t id){
-	int i;
-	for(i=0;i<sizeof(obj->type_ids);++i){
-		if (obj->type_ids[i]==(uint8_t)id)
-			return &obj->type_ids[i];
+static int has_type(belle_sip_object_t *obj, belle_sip_type_id_t id){
+	belle_sip_object_vptr_t *vptr=obj->vptr;
+	
+	while(vptr!=NULL){
+		if (vptr->id==id) return TRUE;
+		vptr=vptr->parent;
 	}
-	return NULL;
+	return FALSE;
 }
 
-void _belle_sip_object_init_type(belle_sip_object_t *obj, belle_sip_type_id_t id){
-	uint8_t * t=find_type(obj,id);
-	if (t!=NULL) belle_sip_fatal("This object already inherits type %i",id);
-	t=find_type(obj,0);
-	if (t==NULL) belle_sip_fatal("This object has too much inheritance !");
-	*t=id;
-}
-
-belle_sip_object_t * _belle_sip_object_new(size_t objsize, belle_sip_type_id_t id, void *vptr, belle_sip_object_destroy_t destroy_func, int initially_unowed){
+belle_sip_object_t * _belle_sip_object_new(size_t objsize, belle_sip_object_vptr_t *vptr, int initially_unowed){
 	belle_sip_object_t *obj=(belle_sip_object_t *)belle_sip_malloc0(objsize);
-	obj->type_ids[0]=id;
 	obj->ref=initially_unowed ? 0 : 1;
 	obj->vptr=vptr;
-	obj->destroy=destroy_func;
+	obj->size=objsize;
 	return obj;
 }
 
@@ -57,39 +49,82 @@ void belle_sip_object_unref(void *ptr){
 	belle_sip_object_t *obj=BELLE_SIP_OBJECT(ptr);
 	if (obj->ref==0){
 		belle_sip_warning("Destroying unowed object");
-		belle_sip_object_destroy(obj);
+		belle_sip_object_delete(obj);
 		return;
 	}
 	obj->ref--;
 	if (obj->ref==0){
-		belle_sip_object_destroy(obj);
+		belle_sip_object_delete(obj);
 	}
 }
 
-void belle_sip_object_destroy(void *ptr){
+static void _belle_sip_object_uninit(belle_sip_object_t *obj){
+	if (obj->name)
+		belle_sip_free(obj->name);
+}
+
+static void _belle_sip_object_clone(belle_sip_object_t *obj, const belle_sip_object_t *orig){
+	if (orig->name!=NULL) obj->name=belle_sip_strdup(obj->name);
+}
+
+belle_sip_object_vptr_t belle_sip_object_t_vptr={
+	BELLE_SIP_TYPE_ID(belle_sip_object_t),
+	NULL, /*no parent, it's god*/
+	NULL,
+	_belle_sip_object_uninit,
+	_belle_sip_object_clone
+};
+
+void belle_sip_object_delete(void *ptr){
 	belle_sip_object_t *obj=BELLE_SIP_OBJECT(ptr);
+	belle_sip_object_vptr_t *vptr;
 	if (obj->ref!=0){
 		belle_sip_error("Destroying referenced object !");
-		if (obj->destroy) obj->destroy(obj);
+		vptr=obj->vptr;
+		while(vptr!=NULL){
+			if (vptr->destroy) vptr->destroy(obj);
+			vptr=vptr->parent;
+		}
 		belle_sip_free(obj);
 	}
 }
 
+belle_sip_object_t *belle_sip_object_clone(const belle_sip_object_t *obj){
+	belle_sip_object_t *newobj;
+	belle_sip_object_vptr_t *vptr;
+	
+	newobj=belle_sip_malloc0(obj->size);
+	newobj->ref=1;
+	newobj->vptr=obj->vptr;
+	
+	vptr=obj->vptr;
+	while(vptr!=NULL){
+		if (vptr->clone==NULL){
+			belle_sip_fatal("Object of type %i cannot be cloned, it does not provide a clone() implementation.",vptr->id);
+			return NULL;
+		}else vptr->clone(newobj,obj);
+	}
+	return newobj;
+}
+
 void *belle_sip_object_cast(belle_sip_object_t *obj, belle_sip_type_id_t id, const char *castname, const char *file, int fileno){
-	if (find_type(obj,id)==NULL){
+	if (has_type(obj,id)==0){
 		belle_sip_fatal("Bad cast to %s at %s:%i",castname,file,fileno);
 		return NULL;
 	}
 	return obj;
 }
-void belle_sip_object_init(belle_sip_object_t *obj) {
-	belle_sip_object_init_type(obj,belle_sip_object_t);
-}
+
+
 void belle_sip_object_set_name(belle_sip_object_t* object,const char* name) {
-	if (name==NULL) return;
-	if (object->name) belle_sip_free((void*)object->name);
-	object->name=belle_sip_strdup(name);
+	if (object->name) {
+		belle_sip_free(object->name);
+		object->name=NULL;
+	}
+	if (name)
+		object->name=belle_sip_strdup(name);
 }
+
 const char* belle_sip_object_get_name(belle_sip_object_t* object) {
 	return object->name;
 }

src/belle_sip_parameters.c

@@ -20,22 +20,20 @@
 #include "belle_sip_internal.h"
 #include "belle-sip/headers.h"
 
-void belle_sip_parameters_destroy(belle_sip_parameters_t* params) {
+void belle_sip_parameters_init(belle_sip_parameters_t *obj){
+}
+
+static void belle_sip_parameters_destroy(belle_sip_parameters_t* params) {
 	if (params->param_list) belle_sip_list_free (params->param_list);
 	if (params->paramnames_list) belle_sip_list_free (params->paramnames_list);
-	belle_sip_header_destroy(BELLE_SIP_HEADER(params));
-}
-void belle_sip_parameters_init(belle_sip_parameters_t *obj) {
-	belle_sip_object_init_type(obj,belle_sip_parameters_t);
-	belle_sip_header_init((belle_sip_header_t*)obj);
 }
 
-belle_sip_parameters_t* belle_sip_parameters_new() {
-	belle_sip_parameters_t* l_object = (belle_sip_parameters_t*)belle_sip_object_new(belle_sip_parameters_t,(belle_sip_object_destroy_t)belle_sip_parameters_destroy);
-	belle_sip_header_init((belle_sip_header_t*)l_object);
-	return l_object;
+static void belle_sip_parameters_clone(belle_sip_parameters_t *params, const belle_sip_parameters_t *orig){
+	belle_sip_fatal("not implemented");
 }
 
+BELLE_SIP_NEW(parameters,header)
+
 const char*	belle_sip_parameters_get_parameter(belle_sip_parameters_t* params,const char* name) {
 	belle_sip_list_t *  lResult = belle_sip_list_find_custom(params->param_list, (belle_sip_compare_func)belle_sip_param_pair_comp_func, name);
 	if (lResult) {

src/belle_sip_uri_impl.c

@@ -56,10 +56,14 @@ void belle_sip_uri_destroy(belle_sip_uri_t* uri) {
 	belle_sip_object_unref(BELLE_SIP_OBJECT(uri->header_list));
 }
 
+
 BELLE_SIP_PARSE(uri);
 
+BELLE_SIP_INSTANCIATE_VPTR(belle_sip_uri_t,belle_sip_object_t,belle_sip_uri_destroy,NULL);
+
+
 belle_sip_uri_t* belle_sip_uri_new () {
-	belle_sip_uri_t* l_object = (belle_sip_uri_t*)belle_sip_object_new(belle_sip_uri_t,(belle_sip_object_destroy_t)belle_sip_uri_destroy);
+	belle_sip_uri_t* l_object = (belle_sip_uri_t*)belle_sip_object_new(belle_sip_uri_t);
 	belle_sip_parameters_init((belle_sip_parameters_t*)l_object); /*super*/
 	l_object->header_list = belle_sip_parameters_new();
 	return l_object;

src/listeningpoint.c

@@ -32,13 +32,16 @@
 
 
 typedef struct belle_sip_channel_vptr{
+	belle_sip_object_vptr_t base;
 	int (*channel_send)(belle_sip_channel_t *obj, const void *buf, size_t buflen);
 	int (*channel_recv)(belle_sip_channel_t *obj, void *buf, size_t buflen);
 	belle_sip_source_t *(*create_source)(belle_sip_channel_t *obj, unsigned int events, unsigned int timeout, belle_sip_source_func_t callback, void *data);
 }belle_sip_channel_vptr_t;
 
+BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_BEGIN(belle_sip_channel_vptr_t,belle_sip_channel_t,belle_sip_object_t,NULL,NULL)
+BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_END
+
 static void belle_sip_channel_init(belle_sip_channel_t *obj, belle_sip_listening_point_t *lp){
-	belle_sip_object_init_type(obj,belle_sip_channel_t);
 	obj->lp=lp;
 	obj->peer.ai_addr=(struct sockaddr*)&obj->peer_addr;
 }
@@ -100,11 +103,11 @@ static belle_sip_source_t *udp_channel_create_source(belle_sip_channel_t *obj, u
 	return belle_sip_fd_source_new(callback,data,chan->sock,events,timeout);
 }
 
-static belle_sip_channel_vptr_t udp_channel_vptr={
+BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_BEGIN(belle_sip_channel_vptr_t,belle_sip_udp_channel_t,belle_sip_channel_t,udp_channel_uninit,NULL)
 	udp_channel_send,
 	udp_channel_recv,
 	udp_channel_create_source
-};
+BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_END
 
 static int create_udp_socket(const char *addr, int port){
 	struct addrinfo hints={0};
@@ -135,7 +138,7 @@ static int create_udp_socket(const char *addr, int port){
 }
 
 belle_sip_udp_channel_t *belle_sip_udp_channel_new(belle_sip_listening_point_t *lp, int sock, const struct addrinfo *dest){
-	belle_sip_udp_channel_t *obj=belle_sip_object_new_with_vptr(belle_sip_udp_channel_t,&udp_channel_vptr,udp_channel_uninit);
+	belle_sip_udp_channel_t *obj=belle_sip_object_new(belle_sip_udp_channel_t);
 	belle_sip_channel_init((belle_sip_channel_t*)obj,lp);
 	obj->sock=sock;
 	memcpy(obj->base.peer.ai_addr,dest->ai_addr,dest->ai_addrlen);
@@ -157,11 +160,11 @@ struct belle_sip_listening_point{
 };
 
 typedef struct belle_sip_listening_point_vptr{
+	belle_sip_object_vptr_t base;
 	belle_sip_channel_t * (*find_output_channel)(belle_sip_listening_point_t *lp,const struct addrinfo *dest);
 } belle_sip_listening_point_vptr_t;
 
 static void belle_sip_listening_point_init(belle_sip_listening_point_t *lp, belle_sip_stack_t *s, const char *transport, const char *address, int port){
-	belle_sip_object_init_type(lp,belle_sip_listening_point_t);
 	lp->transport=belle_sip_strdup(transport);
 	lp->port=port;
 	lp->addr=belle_sip_strdup(address);
@@ -173,6 +176,9 @@ static void belle_sip_listening_point_uninit(belle_sip_listening_point_t *lp){
 	belle_sip_free(lp->transport);
 }
 
+BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_BEGIN(belle_sip_listening_point_vptr_t,belle_sip_listening_point_t,belle_sip_object_t,belle_sip_listening_point_uninit,NULL)
+BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_END
+
 const char *belle_sip_listening_point_get_ip_address(const belle_sip_listening_point_t *lp){