/Users/maurits/Documents/studie/afstuderen/biosphere/common/copy.c

Go to the documentation of this file.

/*
 * Author: MA Hartman
 * Date: may 1, 2007
 * 
 * Function:
 * Deep copy and deletion routines for pool allocated structures.
 * 
 * License information:
 * 
 * Copyright (c) 2006 Maurits Hartman
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following
 * conditions:
 * 
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 * 
 */
 
#include "copy.h"
#include "str.h"

#include <assert.h>
#include <stdlib.h>
#include <string.h>


static inline bs_data_type *copy_data_type(const bs_data_type *orig)
{
        bs_data_type *ret;
        assert(orig);
        
        ret = (bs_data_type *) calloc(1, sizeof(bs_data_type));
        ret->name = (char *) calloc(1, strlen(orig->name) + 1);
        strcpy(ret->name, orig->name);
        ret->builtin = ret->builtin;
        return ret;
}


static void copy_data_types(const bs_definition *orig, bs_definition *cpy){
        assert(orig && cpy);
        if (orig->num_data_types > 0) {
                unsigned i;
                
                cpy->data_types = (bs_data_type **) calloc(orig->num_data_types,
                                sizeof(bs_data_type *));
                cpy->num_data_types = orig->num_data_types;
                for (i = 0; i < orig->num_data_types; i++)
                        cpy->data_types[i] = copy_data_type(orig->data_types[i]);
        }
}


static bs_message_part *copy_message_part(bs_message_part *orig,
                const bs_definition *curdef)
{
        unsigned i;
        bs_message_part *cpy;
        assert(orig && !curdef->from_mp);
        
        /* Set name and from_mp: */
        cpy = (bs_message_part *) calloc(1, sizeof(bs_message_part));
        cpy->name = (char *) calloc(1, strlen(orig->name) + 1);
        strcpy(cpy->name, orig->name);
        
        /* Find the corresponding data type in the current copied bs_definition: */
        for (i = 0; i < curdef->num_data_types; i++) {
                bs_data_type *type = curdef->data_types[i];
                if (streq(orig->type->name, type->name)) {
                        cpy->type = type;
                        break;
                }
        }
        assert(cpy->type);
        return cpy;
}


static void copy_message_parts(const bs_message *orig, bs_message *cpy,
                const bs_definition *curdef)
{
        assert(orig && cpy);
        if (orig->num_parts > 0) {
                unsigned i;
                
                cpy->parts = (bs_message_part **) calloc(orig->num_parts, sizeof(bs_message_part *));
                cpy->num_parts = orig->num_parts;
                for (i = 0; i < orig->num_parts; i++)
                        cpy->parts[i] = copy_message_part(orig->parts[i], curdef);
        }       
}


static void copy_messages(const bs_definition *orig, bs_definition *cpy)
{
        assert(orig && cpy);
        if (orig->num_messages > 0) {
                unsigned i;
                
                cpy->messages = (bs_message **) calloc(orig->num_messages, sizeof(bs_message *));
                cpy->num_messages = orig->num_messages;
                for (i = 0; i < orig->num_messages; i++) {
                        cpy->messages[i] = (bs_message *) calloc(1, sizeof(bs_message));
                        cpy->messages[i]->name = (char *) calloc(1, strlen(orig->messages[i]->name) + 1);
                        strcpy(cpy->messages[i]->name, orig->messages[i]->name);
                        copy_message_parts(orig->messages[i], cpy->messages[i], cpy);   
                }
        }       
}


static void copy_operation(const bs_operation *orig, bs_operation *cpy,
                const bs_definition *curdef)
{
        unsigned i;
        assert(orig && cpy);
        
        /* Set name and from_mp: */
        cpy->name = (char *) calloc(1, strlen(orig->name) + 1);
        strcpy(cpy->name, orig->name);
        
        /* Search the current copied bs_definition for the in-, output and fault messages: */
        for (i = 0; i < curdef->num_messages; i++) {
                bs_message *msg = curdef->messages[i];
                if (orig->input && streq(orig->input->name, msg->name))
                        cpy->input = msg;
                if (orig->output && streq(orig->output->name, msg->name))
                        cpy->output = msg;
                if (orig->fault && streq(orig->fault->name, msg->name))
                        cpy->fault = msg;
        }       
}


static void copy_operations(const bs_port_type *orig, bs_port_type *cpy,
                const bs_definition *curdef)
{
        assert(orig && cpy && curdef);
        if (orig->num_operations > 0) {
                unsigned i;
                
                cpy->operations = (bs_operation **) calloc(orig->num_operations, sizeof(bs_operation *));
                cpy->num_operations = orig->num_operations;
                for (i = 0; i < orig->num_operations; i++) {
                        cpy->operations[i] = (bs_operation *) calloc(1, sizeof(bs_operation));
                        copy_operation(orig->operations[i], cpy->operations[i], curdef);
                }
        }               
}


static void copy_port_types(const bs_definition *orig, bs_definition *cpy)
{
        assert(orig && cpy);
        if (orig->num_port_types > 0) {
                unsigned i;
                
                cpy->port_types = (bs_port_type **) calloc(orig->num_port_types, sizeof(bs_port_type *));
                cpy->num_port_types = orig->num_port_types;
                for (i = 0; i < orig->num_port_types; i++) {
                        cpy->port_types[i] = (bs_port_type *) calloc(1, sizeof(bs_port_type));
                        cpy->port_types[i]->name = (char *) calloc(1, strlen(orig->port_types[i]->name) + 1);
                        strcpy(cpy->port_types[i]->name, orig->port_types[i]->name);
                        copy_operations(orig->port_types[i], cpy->port_types[i], cpy);  
                }
        }
}


static void copy_port(const bs_port *orig, bs_port *cpy, const bs_definition *curdef)
{
        unsigned i;
        assert(orig && cpy && curdef);
        
        /* Set name and from_mp: */
        cpy->name = (char *) calloc(1, strlen(orig->name) + 1);
        strcpy(cpy->name, orig->name);
        
        /* Find the corresponding port_type in the current copied bs_definition: */
        for (i = 0; i < curdef->num_port_types; i++) {
                bs_port_type *type = curdef->port_types[i];
                if (streq(orig->port_type->name, type->name)) {
                        cpy->port_type = type;
                        break;
                }
        }       
}


static void copy_ports(const bs_service *orig, bs_service *cpy,
                const bs_definition *curdef)
{
        assert(orig && cpy && curdef);
        if (orig->num_ports > 0) {
                unsigned i;
                
                cpy->ports = (bs_port **) calloc(orig->num_ports, sizeof(bs_port *));
                cpy->num_ports = orig->num_ports;
                for (i = 0; i < orig->num_ports; i++) {
                        cpy->ports[i] = (bs_port *) calloc(1, sizeof(bs_port));
                        copy_port(orig->ports[i], cpy->ports[i], curdef);
                }
        }       
}


static void copy_services(const bs_definition *orig, bs_definition *cpy)
{
        assert(orig && cpy);
        if (orig->num_services > 0) {
                unsigned i;
                
                cpy->services = (bs_service **) calloc(orig->num_services, sizeof(bs_service *));
                cpy->num_services = orig->num_services;
                for (i = 0; i < orig->num_services; i++) {
                        cpy->services[i] = (bs_service *) calloc(1, sizeof(bs_service));
                        cpy->services[i]->name = (char *) calloc(1, strlen(orig->services[i]->name) + 1);
                        strcpy(cpy->services[i]->name, orig->services[i]->name);
                        copy_ports(orig->services[i], cpy->services[i], cpy);   
                }
        }
}


bs_definition *copy_definition(const bs_definition *def)
{
        assert(def);
        bs_definition *result;
        
        /* Allocate and copy name: */
        result = (bs_definition *) calloc(1, sizeof(bs_definition));
        result->name = (char *) calloc(1, strlen(def->name) + 1);
        strcpy(result->name, def->name);
        
        copy_data_types(def, result);
        copy_messages(def, result);
        copy_port_types(def, result);
        copy_services(def, result);
        
        return result;
}


static bs_part_instance *copy_part_instance(const bs_part_instance *orig)
{
        bs_part_instance *cpy;
        
        cpy = (bs_part_instance *) calloc(1, sizeof(bs_part_instance));
        cpy->name = (char *) calloc(1, strlen(orig->name) + 1);
        strcpy(cpy->name, orig->name);
        cpy->type = copy_data_type(orig->type);
        
        /* Copy the data: */
        cpy->size = orig->size;
        cpy->data = calloc(1, cpy->size + 1);
        memcpy(cpy->data, orig->data, cpy->size);
        return cpy;
}


static void copy_message_instance_data(const bs_message_instance *orig,
                bs_message_instance *cpy)
{
        if (!orig) return;
        cpy->name = (char *) calloc(1, strlen(orig->name) + 1);
        strcpy(cpy->name, orig->name);
        
        if (orig->num_parts > 0) {
                bs_uint16 i;
                cpy->num_parts = orig->num_parts;
                cpy->parts = (bs_part_instance **) calloc(cpy->num_parts, sizeof(bs_part_instance *));
                for (i = 0; i < cpy->num_parts; i++)
                        cpy->parts[i] = copy_part_instance(orig->parts[i]);
        }
}


bs_service_request *copy_request(const bs_service_request *req)
{
        bs_service_request *ret;
        unsigned i;
        
        assert(req);
        
        /* Copy UUID, service, port and operation: */
        ret = (bs_service_request *) calloc(1, sizeof(bs_service_request));
        for (i = 0; i < sizeof(ret->uuid); i++) ret->uuid[i] = req->uuid[i];
        
        ret->service = (char *) calloc(1, strlen(req->service) + 1);
        strcpy(ret->service, req->service);
        
        ret->port = (char *) calloc(1, strlen(req->port) + 1);
        strcpy(ret->port, req->port);
        
        ret->operation = (char *) calloc(1, strlen(req->operation) + 1);
        strcpy(ret->operation, req->operation);
        
        /* Copy instance data: */
        ret->input = (bs_message_instance *) calloc(1, sizeof(bs_message_instance));
        copy_message_instance_data(req->input, ret->input);
        return ret;     
}


bs_service_response *copy_response(const bs_service_response *resp)
{
        bs_service_response *ret;
        unsigned i;
        
        assert(resp);
        
        /* Copy UUID, service, port and operation: */
        ret = (bs_service_response *) calloc(1, sizeof(bs_service_response));
        for (i = 0; i < sizeof(ret->uuid); i++) ret->uuid[i] = resp->uuid[i];
        
        ret->service = (char *) calloc(1, strlen(resp->service) + 1);
        strcpy(ret->service, resp->service);
        
        ret->port = (char *) calloc(1, strlen(resp->port) + 1);
        strcpy(ret->port, resp->port);
        
        ret->operation = (char *) calloc(1, strlen(resp->operation) + 1);
        strcpy(ret->operation, resp->operation);
        
        /* Copy instance data: */
        ret->output = (bs_message_instance *) calloc(1, sizeof(bs_message_instance));
        ret->fault = (bs_message_instance *) calloc(1, sizeof(bs_message_instance));
        copy_message_instance_data(resp->output, ret->output);
        copy_message_instance_data(resp->fault, ret->fault);
        return ret;
}


static void delete_data_types(bs_definition *def)
{
        unsigned i;
        assert(!def->from_mp);
        for (i = 0; i < def->num_data_types; i++) {
                bs_data_type *type = def->data_types[i];
                free(type->name);       
        }
        free(def->data_types);
}


static void delete_message_parts(bs_message *msg)
{
        unsigned i;
        assert(!msg->from_mp);
        for (i = 0; i < msg->num_parts; i++)
                free(msg->parts[i]->name);
        free(msg->parts);       
}


static void delete_messages(bs_definition *def)
{
        unsigned i;
        assert(!def->from_mp);
        for (i = 0; i < def->num_messages; i++) {
                bs_message *msg = def->messages[i];
                free(msg->name);
                delete_message_parts(msg);
        }
        free(def->messages);
}


static void delete_operations(bs_port_type *type)
{
        unsigned i;
        assert(!type->from_mp);
        for (i = 0; i < type->num_operations; i++)
                free(type->operations[i]->name);
        free(type->operations); 
}


static void delete_port_types(bs_definition *def)
{
        unsigned i;
        assert(!def->from_mp);
        for (i = 0; i < def->num_port_types; i++) {
                bs_port_type *type = def->port_types[i];
                free(type->name);
                delete_operations(type);
        }
        free(def->port_types);  
}


static void delete_ports(bs_service *svc)
{
        unsigned i;
        assert(!svc->from_mp);
        for (i = 0; i < svc->num_ports; i++)
                free(svc->ports[i]->name);
        free(svc->ports);       
}


static void delete_services(bs_definition *def)
{
        unsigned i;
        assert(!def->from_mp);
        for (i = 0; i < def->num_services; i++) {
                bs_service *svc = def->services[i];
                free(svc->name);
                delete_ports(svc);
        }
        free(def->services);            
}


void delete_definition(bs_definition *def)
{
        if (!def || def->from_mp) return;
        
        free(def->name);
        
        /* Delete recursively, top-to-bottom: */
        delete_data_types(def);
        delete_messages(def);
        delete_port_types(def);
        delete_services(def);
        
        free(def);
}


static inline void delete_instance_part(bs_part_instance *part)
{
        free(part->name);
        free(part->data);
        free(part->type->name);
        free(part->type);
        free(part);
}


static void delete_message_instance(bs_message_instance *msg)
{
        if (!msg || msg->from_mp) return;
        
        free(msg->name);
        if (msg->num_parts) {   
                unsigned i;
                
                for (i = 0; i < msg->num_parts; i++)
                        delete_instance_part(msg->parts[i]);
                        
                free(msg->parts);
        }
        free(msg);
}


void delete_request(bs_service_request *req)
{
        if (!req || req->from_mp) return;
        
        free(req->service);
        free(req->port);
        free(req->operation);
        
        delete_message_instance(req->input);
        
        free(req);
}


void delete_response(bs_service_response *resp)
{
        if (!resp || resp->from_mp) return;
        
        free(resp->service);
        free(resp->port);
        free(resp->operation);
        
        delete_message_instance(resp->output);
        delete_message_instance(resp->fault);
        
        free(resp);
}

---