generic intmap serialization

critter.c

@@ -7,56 +7,50 @@
 
 IntMap *critters;
 
+//------------------------------------------------------------------------------
+static void crit_serialzier(void *cptr, void **obuf, uint32_t *osize)
+{
+	Critter *c = (Critter*) cptr;
+	c->vtable->serialize(c, obuf, osize);
+}
+
 //------------------------------------------------------------------------------
 void critters_serialize(void **buf, uint32_t *size)
+{	
+	intmap_serialize(critters, crit_serialzier, buf, size);
+}
+
+//------------------------------------------------------------------------------
+static uint32_t crit_deserializer(void *cptr, void *inbuf)
 {
-	*buf = malloc(sizeof(uint32_t));
-	*size = sizeof(uint32_t);	
-	uint32_t cri_count = critters->size - critters->free;
-	memcpy(*buf, &cri_count, sizeof(uint32_t));
-	printf("Sending %d critters\n", cri_count);
-
-	void *cbuf;
-	uint32_t csize;
-	for (int i=0; i<critters->size; i++) {
-		if (critters->keys[i]) {
-			Critter *c = critters->data[i];
-			c->vtable->serialize(c, &cbuf, &csize);
-			*buf = realloc(*buf, *size + sizeof(uint32_t) + csize);
-			memcpy(*buf + *size, &critters->keys[i], sizeof(uint32_t));
-			memcpy(*buf + *size + sizeof(uint32_t), cbuf, csize);
-			*size +=  sizeof(uint32_t) + csize;			
-			free(cbuf);
-		}
-	}	
+	Critter *c = (Critter*)cptr;
+	uint8_t type = *(uint8_t*)(inbuf);
+	switch (type) {
+	case CRITTER_HUMAN:		
+		c->vtable->deserialize(c, inbuf, human_pack_size());
+		return human_pack_size();
+		break;
+	default:
+		printf("error: unknown critter type!\n");
+		exit(1);
+	}
+}
+
+//------------------------------------------------------------------------------
+static void *crit_ctor(void *inbuf)
+{	
+	uint8_t type = *(uint8_t*)(inbuf);
+	switch (type) {
+	case CRITTER_HUMAN:				
+		return new_human(0,0,0); // bad! 		
+	default:
+		printf("error: unknown critter type!\n");
+		exit(1);
+	}
 }
 
 //------------------------------------------------------------------------------
 void critters_deserialize(void *buf)
 {
-	uint32_t count;
-	memcpy(&count, buf, sizeof(uint32_t));
-
-	uint32_t off = sizeof(uint32_t);
-	for (int i=0; i<count; i++) {
-		uint32_t key;		
-		memcpy(&key, buf+off, sizeof(uint32_t));
-		off += sizeof(uint32_t);
-
-		Critter *c = intmap_find(critters, key);
-		uint8_t type = *(uint8_t*)(buf+off);
-		switch (type) {
-		case CRITTER_HUMAN:
-			if (c == NULL) {
-				c = new_human(0,0,0); // bad!
-				intmap_ins(critters, key, c);				
-			}
-			c->vtable->deserialize(c, buf+off, human_pack_size());
-			off += human_pack_size();			
-			break;
-		default:
-			printf("error: unknown critter type!\n");
-			exit(1);
-		}
-	}
+	intmap_deserialize(critters, crit_deserializer, crit_ctor, buf);
 }

hashmap.c

@@ -270,4 +270,47 @@ void intmap_rem(IntMap *im, uint32_t key)
 }
 
 //-----------------------------------------------------------------------------
+void intmap_serialize(IntMap *im, void (*serializer)(void*,void **,uint32_t*), void **buf, uint32_t *size)
+{
+	*buf = malloc(sizeof(uint32_t));
+	*size = sizeof(uint32_t);
+	uint32_t elem_count = im->size - im->free;
+	memcpy(*buf, &elem_count, sizeof(uint32_t));	
+
+	void *elembuf;
+	uint32_t elemsize;
+	for (int i=0; i<im->size; i++) {
+		if (im->keys[i]) {
+			void *elem = im->data[i];
+			serializer(elem, &elembuf, &elemsize); 			
+			*buf = realloc(*buf, *size + sizeof(uint32_t) + elemsize);
+			memcpy(*buf + *size, &im->keys[i], sizeof(uint32_t));
+			memcpy(*buf + *size + sizeof(uint32_t), elembuf, elemsize);
+			*size +=  sizeof(uint32_t) + elemsize;
+			free(elembuf);
+		}
+	}	
+}
+
+//-----------------------------------------------------------------------------
+void intmap_deserialize(IntMap *im, uint32_t (*deserializer)(void*,void*), void* (*ctor)(void *), void *buf)
+{
+	uint32_t count;
+	memcpy(&count, buf, sizeof(uint32_t));
+
+	uint32_t off = sizeof(uint32_t);
+	for (int i=0; i<count; i++) {
+		uint32_t key;
+		memcpy(&key, buf+off, sizeof(uint32_t));
+		off += sizeof(uint32_t);
+
+		void *elem = intmap_find(im, key);
+		if (elem == NULL) {
+			elem = ctor(buf+off);
+			intmap_ins(im, key, elem);
+		}		
+		off += deserializer(elem, buf+off);		
+	}
+}
+
 

hashmap.h

@@ -35,5 +35,10 @@ int intmap_ins(IntMap *im, uint32_t key, void *elem);
 void intmap_rem(IntMap *im, uint32_t key);
 void *intmap_find(IntMap *im, uint32_t key);
 
+/* serializer(elem, outbuf, outbuf_size) */
+void intmap_serialize(IntMap *im, void (*serializer)(void*,void **,uint32_t*), void **buf, uint32_t *size);
+/* deserializer(elem, inbuf), returns read data; ctor(inbuf) returns new elem ptr */
+void intmap_deserialize(IntMap *im, uint32_t (*deserializer)(void*,void*), void* (*ctor)(void *), void *buf);
+
 
 #endif // __HASHMAP_H__

main.c

@@ -411,11 +411,7 @@ void server_loop(NetworkType * network)
 	spells = new_ptrarray();
 
 	while (1) {
-		network->tick(network->state);
-		//while (ticks) {
-		//	game_logic_tick(network);
-			//ticks--;
-		//}		
+		network->tick(network->state);			
 	}
 }
 

tcp_server_state.c

@@ -95,6 +95,8 @@ static void tick(void *d)
 			}
 		}				
 		state->bulk_size = 9;
+
+		/* this is thought to be executed very fast in network time scale */
 		state->newturn_callback();
 	}
 }