ne_dyn.c

Go to the documentation of this file.

/*===========================================================================
 NetEvo Foundation Library
 Copyright (C) 2009, 2010 Thomas E. Gorochowski <tgorochowski@me.com>
 Bristol Centre for Complexity Sciences, University of Bristol, Bristol, UK
 ---------------------------------------------------------------------------- 
 NetEvo is a computing framework designed to allow researchers to investigate 
 evolutionary aspects of dynamical complex networks. By providing tools to 
 easily integrate each of these factors in a coherent way, it is hoped a 
 greater understanding can be gained of key attributes and features displayed 
 by complex systems.
 
 NetEvo is open-source software released under the Open Source Initiative 
 (OSI) approved Non-Profit Open Software License ("Non-Profit OSL") 3.0. 
 Detailed information about this licence can be found in the COPYING file 
 included as part of the source distribution.
 
 This library is distributed in the hope that it will be useful, but
 WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 ============================================================================*/
#include "ne_dyn.h"
#include <gsl/gsl_rng.h>
#include <string.h>


/* Global random number generator (from GSL library). */
extern gsl_rng* neRng;

ne_dyn_node_lib_t *neNodeDynLib = NULL;

ne_dyn_edge_lib_t *neEdgeDynLib = NULL;


void ne_dyn_finalise (void)
{
   ne_dyn_node_lib_t *curNodePtr;
   ne_dyn_edge_lib_t *curEdgePtr;
   
   curNodePtr = neNodeDynLib;
   curEdgePtr = neEdgeDynLib;
   
   /* Free all memory used by the dynamics library */
   while (curNodePtr != NULL) {
      neNodeDynLib = curNodePtr->next;
      free(curNodePtr);
      curNodePtr = neNodeDynLib;
   }
   
   /* Free all memory used by the dynamics library */
   while (curEdgePtr != NULL) {
      neEdgeDynLib = curEdgePtr->next;
      free(curEdgePtr);
      curEdgePtr = neEdgeDynLib;
   }
}


ne_err_code_t ne_dyn_add_node_dyn (ne_dyn_node_t *nodeDyn)
{
   ne_dyn_node_lib_t *newDyn, *oldStart;
   
   /* Create the new item */
   newDyn = (ne_dyn_node_lib_t *)malloc(sizeof(ne_dyn_node_lib_t));
   
   /* Hold the current start item */
   oldStart = neNodeDynLib;
   
   /* Setup the new item */
   newDyn->nodeDyn = nodeDyn;
   newDyn->next = oldStart;
   
   /* Repoint the start of the list */
   neNodeDynLib = newDyn;
   
   return NE_SUCCESS;
}


ne_err_code_t ne_dyn_add_edge_dyn (ne_dyn_edge_t *edgeDyn)
{
   ne_dyn_edge_lib_t *newDyn, *oldStart;
   
   /* Create the new item */
   newDyn = (ne_dyn_edge_lib_t *)malloc(sizeof(ne_dyn_edge_lib_t));
   
   /* Hold the current start item */
   oldStart = neEdgeDynLib;
   
   /* Setup the new item */
   newDyn->edgeDyn = edgeDyn;
   newDyn->next = oldStart;
   
   /* Repoint the start of the list */
   neEdgeDynLib = newDyn;
   
   return NE_SUCCESS;
}


ne_err_code_t ne_dyn_remove_node_dyn (const char *name)
{
   ne_dyn_node_lib_t *curPtr, *prevPtr;
   
   /* Check that the list exists */
   if (neNodeDynLib == NULL) {
      return NE_FAILURE;
   }
   
   /* Initialise the pointers */
   curPtr = neNodeDynLib;
   prevPtr = NULL;
   
   do {
      
      /* Check to see if found dynamic */
      if (strcmp(name, curPtr->nodeDyn->name) == 0) {
      
         /* We have found the dynamic reshuffle pointers */
         if (prevPtr == NULL) {
            neNodeDynLib = curPtr->next;
         }
         else {
            prevPtr->next = curPtr->next;
         }
         
         /* Deallocate the dynamic item */
         free(curPtr->nodeDyn);
         free(curPtr);
         
         return NE_SUCCESS;
      }
      
      /* Update the pointers to the next item */
      prevPtr = curPtr;
      curPtr = curPtr->next;
      
   } while (curPtr != NULL);
   
   /* Didn't find dynamic */
   return NE_FAILURE;
}


ne_err_code_t ne_dyn_remove_edge_dyn (const char *name)
{
   ne_dyn_edge_lib_t *curPtr, *prevPtr;
   
   /* Check that the list exists */
   if (neEdgeDynLib == NULL) {
      return NE_FAILURE;
   }
   
   /* Initialise the pointers */
   curPtr = neEdgeDynLib;
   prevPtr = NULL;
   
   do {
      
      /* Check to see if found dynamic */
      if (strcmp(name, curPtr->edgeDyn->name) == 0) {
         
         /* We have found the dynamic reshuffle pointers */
         if (prevPtr == NULL) {
            neEdgeDynLib = curPtr->next;
         }
         else {
            prevPtr->next = curPtr->next;
         }
         
         /* Deallocate the dynamic item */
         free(curPtr->edgeDyn);
         free(curPtr);
         
         return NE_SUCCESS;
      }
      
      /* Update the pointers to the next item */
      prevPtr = curPtr;
      curPtr = curPtr->next;
      
   } while (curPtr != NULL);
   
   /* Didn't find dynamic */
   return NE_FAILURE;   
}


ne_dyn_node_t * ne_dyn_find_node_dyn (const char *name)
{
   ne_dyn_node_lib_t *curPtr;
   
   /* Initialise the current pointer to the start */
   curPtr = neNodeDynLib;
   
   /* Look through the linked list - ends with NULL pointer */
   while (curPtr != NULL) {
      
      /* Check the names */
      if (strcmp(name, curPtr->nodeDyn->name) == 0) {
         /* Found the dynamic return a pointer to this */
         return curPtr->nodeDyn;
      }
      
      /* Update the pointer to next item in list */
      curPtr = curPtr->next;
   }
   
   /* Didn't find the name in the list */
   return NULL;
}


ne_dyn_edge_t * ne_dyn_find_edge_dyn (const char *name)
{
   ne_dyn_edge_lib_t *curPtr;
   
   /* Initialise the current pointer to the start */
   curPtr = neEdgeDynLib;
   
   /* Look through the linked list - ends with NULL pointer */
   while (curPtr != NULL) {
      
      /* Check the names */
      if (strcmp(name, curPtr->edgeDyn->name) == 0) {
         
         /* Found the dynamic return a pointer to this */
         return curPtr->edgeDyn;
      }
      
      /* Update the pointer to next item in list */
      curPtr = curPtr->next;
   } 
   
   /* Didn't find the name in the list */
   return NULL;
}