binary_data_common.c

Go to the documentation of this file.

/*
** binary_data_common.c
** 

Copyright (C) 2009 Joseph Pingenot

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program 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.  See the
GNU Affero General Public License for more details.

You should have received a copy of the GNU Affero General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

** Made by (Johnny Q. Hacker)
** Login   <solarion@nathan>
** 
** Started on  Tue Nov 24 21:39:39 2009 Johnny Q. Hacker
** Last update Sun May 12 01:17:25 2002 Speed Blue
*/

#include <stdlib.h>
#include <string.h>
#include <glib-2.0/glib.h>
#include <stdio.h>
#include "binary_data_common.h"

#define DOTCODE_BINARY_DATA_COMMON_GERROR_DOMAN 43712

enum dotcode_type dotcode_type_from_string(const char* s) {
  if(!g_ascii_strncasecmp(s, "float8", strlen("float8"))){
    return DOTCODE_FLOAT8;
  }else if(!g_ascii_strncasecmp(s, "float4", strlen("float4"))){
    return DOTCODE_FLOAT4;
  }else if(!g_ascii_strncasecmp(s, "int", strlen("int"))){
    return DOTCODE_INT;
  }else if(!g_ascii_strncasecmp(s, "int4", strlen("int4"))){
    return DOTCODE_INT;
  }else if(!g_ascii_strncasecmp(s, "Vector", strlen("Vector"))){
    return DOTCODE_VECTOR;
  }else if(!g_ascii_strncasecmp(s, "Array", strlen("Array"))){
    return DOTCODE_ARRAY;
  }else if(!g_ascii_strncasecmp(s, "Tensor", strlen("Tensor"))){
    return DOTCODE_TENSOR;
  }else if(!g_ascii_strncasecmp(s, "Grid", strlen("Grid"))){
    return DOTCODE_GRID;
  }else if(!g_ascii_strncasecmp(s, "SString", strlen("SString"))){
    return DOTCODE_SSTRING;
  }
  return DOTCODE_INVALID_TYPE;
}

char* dotcode_string_from_type(enum dotcode_type t) {
  const char* s = dotcode_string_from_type2(t);
  if(s == NULL) return NULL;
  return g_strdup(s);
}

const char* dotcode_string_from_type2(enum dotcode_type t) {
  switch(t) {
  case DOTCODE_FLOAT8:
    return g_strdup("float8");
  case DOTCODE_FLOAT4:
    return g_strdup("float4");
  case DOTCODE_INT:
    return g_strdup("int4");
  case DOTCODE_VECTOR:
    return g_strdup("Vector");
  case DOTCODE_ARRAY:
    return g_strdup("Array");
  case DOTCODE_TENSOR:
    return g_strdup("Tensor");
  case DOTCODE_GRID:
    return g_strdup("Grid");
  case DOTCODE_SSTRING:
    return g_strdup("SString");
  case DOTCODE_INVALID_TYPE:
    return g_strdup("INVALID TYPE");
  default:
    return NULL;
  }
  return NULL;
}

void flip_endian(char* buffer, int num_bytes) {
  int i, j;
  char c;
  int max = num_bytes >> 1;
  for(i=0, j=(num_bytes-1); i<max; ++i, --j) {
    c=buffer[i];
    buffer[i]=buffer[j];
    buffer[j]=c;
  }
}

/*It is assumed that ptr points to a buffer of count objects.*/
void dotcode_free_type(enum dotcode_type t, void* ptr, long unsigned int count, GError **err, gboolean free_struct) {
  GError *e = NULL;
  /*If we have a buffer of a simple type, just free it.*/
  switch(t) {
  case DOTCODE_FLOAT8:
  case DOTCODE_FLOAT4:
  case DOTCODE_INT:
  case DOTCODE_SSTRING:
    free(ptr);
    return;
  default:
    break;
  }
  long unsigned int size = 1;
  for(long unsigned int i=0; i<count; i++) {
    /*Since these are freeing an array of actual structures (as
      opposed to an array of pointers to structures) we don't need to
      free the struct at the end.*/
    switch(t) {
    case DOTCODE_VECTOR:
      dotcode_free_type(((struct dotcode_vector*)ptr)->t, 
      ((struct dotcode_vector*)ptr)->data,
      3,
      &e,
      FALSE);
      break;
    case DOTCODE_ARRAY:
      dotcode_free_type(((struct dotcode_array*)ptr)->t, 
      ((struct dotcode_array*)ptr)->storage,
      (((struct dotcode_array*)ptr)->imax - ((struct dotcode_array*)ptr)->imax +1),
      &e,
      FALSE);
      break;
    case DOTCODE_TENSOR:
      /*need to know how many items there are, for the derived types
  (irrelevant for float, int)*/
      size = 1;
      for(long unsigned int j=0; j<((struct dotcode_tensor*)ptr)->Nd; j++) 
       size*=((((struct dotcode_tensor*)ptr)->indices)[2*j+1]-(((struct dotcode_tensor*)ptr)->indices)[2*j]+1);
      /*need to know how many items there are*/
      dotcode_free_type(((struct dotcode_tensor*)ptr)->t, 
      ((struct dotcode_tensor*)ptr)->data,
      size,
      &e,
      FALSE);
      free(((struct dotcode_tensor*)ptr)->indices);
      free(((struct dotcode_tensor*)ptr)->metadata);
      break;
    case DOTCODE_GRID:
      for(int i=0; i<3; i++) {
  dotcode_free_type(DOTCODE_ARRAY,
      ((struct dotcode_grid*)ptr)->gridsites[i],
      1,
      &e,
      TRUE);
      }
      dotcode_free_type(DOTCODE_TENSOR,
      ((struct dotcode_grid*)ptr)->data,
      1,
      &e,
      TRUE);
      break;
    default:
      *err = g_error_new(DOTCODE_BINARY_DATA_COMMON_GERROR_DOMAN, 1, "dotcode::binary_data_common::dotcode_free_type: Invalid type %d (%s)", t, dotcode_string_from_type2(t));
      return;
    }
    if(e != NULL) {
      g_propagate_prefixed_error(err, e, "dotcode::binary_data_common::dotcode_free_type: Failure when freeing type %d (%s)", t, dotcode_string_from_type2(t));
      return;
    }
  }
  if(free_struct) {
    switch(t) {
    case DOTCODE_VECTOR:
      free((struct dotcode_vector*)ptr);
      break;
    case DOTCODE_ARRAY:
      free((struct dotcode_array*)ptr);
      break;
    case DOTCODE_TENSOR:
      free((struct dotcode_tensor*)ptr);
      break;
    case DOTCODE_GRID:
      free((struct dotcode_grid*)ptr);
      break;
    default:
      break;
    }
  }
}

/**Determines a type from a type string.
 *\param t1 is the first item in the char** returned from g_strsplit(str, "<", 1)
 *\param t2 is the second string in the char**
 *\param tlist a pointer to an *existing* NULL GList*.
 *Types may be nested, hence the need for a GList of types.
 *The data in the GList is enum dotcode_type.
 *NOTE that the tlist MUST be initialized to NULL before calling this 
 *  function, as it's recursive.
 */
static void determine_templated_type_(char* t1, char*t2 , GList** tlist, GError **err) {
  if(t1 == NULL) return;
  enum dotcode_type *t = (enum dotcode_type*)malloc(sizeof(enum dotcode_type));
  if(t == NULL) {
    *err = g_error_new(DOTCODE_BINARY_DATA_COMMON_GERROR_DOMAN, 180, "dotcode::read_binary_data::read_vector: ERROR failed to allocate storage for a new vector.");
  }
  *t = dotcode_type_from_string(t1);
  if(t2 != NULL) {
    /*Here's the recursive step.*/
    char** sstr = g_strsplit(t2, "<", 2);
    determine_templated_type_(sstr[0], sstr[1], tlist, err);
    g_strfreev(sstr);
  }
  *tlist = g_list_prepend(*tlist, t);
}

/**This is the front-end to the determine_templated_type_ function.
 *\param str is the list
 *\param tlist a pointer to an *existing* GList*, which will be set to NULL.
 *\param err is a pointer to an existing NULL GError*
 *\note the tlist is a GList of pointers to dotcode_types, in order of occurrance.
 *   Thus, a GList of a, b, c means a templated with b, which is in turn
 *   templated with c.
 */
void dotcode_determine_templated_type(const char* str, GList** tlist, GError **err) {
  *tlist = NULL;
  /*Remove invalid chars; valid are alphanumeric, underscoe, and >; this will
    remove '>', but that's fine; we don't really want it.
   */
  char* dstr = g_strdup(str);
  g_strcanon(dstr, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_<", ' ');
  g_strchug(dstr);
  char** sstr = g_strsplit(dstr, "<", 2);
  determine_templated_type_(sstr[0], sstr[1], tlist, err);
  g_free(dstr);
  g_strfreev(sstr);
}