write_binary_data.c

Go to the documentation of this file.

/*
** write_binary_data.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:38:34 2009 Johnny Q. Hacker
** Last update Sun May 12 01:17:25 2002 Speed Blue
*/

#include <string.h>
#include <glib-2.0/glib.h>
#include <gio/gio.h>
#include "config.h"
#include <libdotcode/dotcode_generic.h>
#include <libdotcode/binary_data_common.h>
#include "write_binary_data.h"
#include "gcc_hints.h"

#define DOTCODE_WRITE_BINARY_DATA_GERROR_DOMAIN 7032

GError* dotcode_write_binary_data(const struct dotcode_data* data, GFile* file) {
  return NULL;
}


GError* dotcode_write_typed_file(const enum dotcode_type t, const void* data, GFile *outfile) {
  GError *e = NULL;
  GError *err = NULL;
  char* str;
  GFileIOStream *gfios = g_file_replace_readwrite(outfile, NULL, FALSE, G_FILE_CREATE_NONE, NULL, &e);
  if(unlikely(e != NULL)) {
    g_propagate_prefixed_error(&err, e, "libdotcode::write_binary_data::write_dotcode_typed_file: Error opening dotcode file (%s) for writing a %d(%s).", str=g_file_get_uri(outfile), t, dotcode_string_from_type2(t));
    g_free(str);
    return err;
  }
  GOutputStream *os = g_io_stream_get_output_stream((GIOStream*)gfios);
  char b;
  #ifdef WORDS_BIGENDIAN
  b = 'b';
  #else
  b = 'l';
  #endif
  gsize s;
  g_output_stream_write_all(os, &b, 1, &s, NULL, &e);
  if((e != NULL) || (s != 1)) {
    if(e != NULL) {
      g_propagate_prefixed_error(&err, e, "libdotcode::write_binary_data::write_dotcode_typed_file: Error writing endianness (%c) to output file (%s).", b, g_file_get_uri(outfile));
    }else{
      err = g_error_new(DOTCODE_WRITE_BINARY_DATA_GERROR_DOMAIN, 180, "libdotcode::write_binary_data::write_dotcode_typed_file: Error writing endianness (%c) to output file (%s): more or less than 1 byte written (%ld bytes were written)", b, g_file_get_uri(outfile), (long int)s);
    }
    return err;
  }
  err = dotcode_write_generic(t, data, TRUE, os);
  g_object_unref(gfios);
  return err;
}


GError* dotcode_write_generic(const enum dotcode_type t, const void* data, gboolean write_header, GOutputStream *os) {
  GError *err = NULL;
  switch(t) {
  case DOTCODE_FLOAT8:
    err = dotcode_write_float8(*((double*)data), write_header, os);
    break;
  case DOTCODE_FLOAT4:
    err = dotcode_write_float4((*(float*)data), write_header, os);
    break;
  case DOTCODE_INT:
    err = dotcode_write_int(*((int*)data), write_header, os);
    break;
  case DOTCODE_VECTOR:
    err = dotcode_write_vector((struct dotcode_vector*)data, write_header, os);
    break;
  case DOTCODE_ARRAY:
    err = dotcode_write_array((struct dotcode_array*)data, write_header, os);
    break;
  case DOTCODE_TENSOR:
    err = dotcode_write_tensor((struct dotcode_tensor*)data, write_header, os);
    break;
  case DOTCODE_GRID:
    err = dotcode_write_grid((struct dotcode_grid*)data, write_header, os);
    break;
  default:
    err = g_error_new(DOTCODE_WRITE_BINARY_DATA_GERROR_DOMAIN, 171, "libdotcode::read_binary_data::read_dotcode_typed_file: Can't recognize dotcode data type (%d/%s)", t, dotcode_string_from_type2(t));
    return err;
  }
  return err;
}


GError* dotcode_write_sstring(const char* str, gboolean write_header, GOutputStream *os) {
  GError* err=NULL;
  /*We need to write out the trailing NULL. It's what Craig's code
    does. WE DON'T RELY ON THE TRAILING NULL BEING IN THE STREAM,
    THO. That way lies security vulnerabilities!*/
  int len = strlen(str) + 1;
  GError *e = NULL;
  if(write_header) {
    e = dotcode_write_sstring(dotcode_string_from_type2(DOTCODE_SSTRING), FALSE, os);
    if(e != NULL) return err;
  }
  e = dotcode_write_int(len, FALSE, os);
  if(e != NULL) {
    g_propagate_prefixed_error(&err, e, "libdotcode::write_binary_data::write_sstring: error writing string length %d (%s)", len, str);
    g_error_free(e);
    return err;
  }
  gsize written;
  if((!g_output_stream_write_all(os, str, len, &written, NULL, &e)) || (len != written) || (e != NULL)) {
    if(len != written) {
      g_propagate_prefixed_error(&err, e, "libdotcode::write_binary_data::write_sstring: error writing string: (%s) len(%d) and amount written(%lu) differ!", str, len, (long unsigned int)written);
    }else{
      g_propagate_prefixed_error(&err, e, "libdotcode::write_binary_data::write_sstring: error writing string %s!", str);
    }
    return err;
  }
  return NULL;
}


GError* dotcode_write_int(int val, gboolean write_header, GOutputStream *os) {
  GError *err = NULL;
  GError *e = NULL;
  union int_union_ {
    char buffer[DOTCODE_INT_SIZE];
    int val;
  } int_union;
  int_union.val = val;
  if(write_header) {
    e = dotcode_write_sstring(dotcode_string_from_type2(DOTCODE_INT), FALSE, os);
    if(e != NULL) return err;
  }
  gsize written;
  if((!g_output_stream_write_all(os, int_union.buffer, DOTCODE_INT_SIZE, &written, NULL, &e)) || (DOTCODE_INT_SIZE != written) || (e != NULL)) {
    if(DOTCODE_INT_SIZE != written) {
      g_propagate_prefixed_error(&err, e, "libdotcode::write_binary_data::write_int: error writing int: (%d) len(%d) and amount written(%lu) differ!", val, DOTCODE_INT_SIZE, (long unsigned int)written);
    }else{
      g_propagate_prefixed_error(&err, e, "libdotcode::write_binary_data::write_int: error writing int %d!", val);
    }
    return err;
  }
  return NULL;
}


GError* dotcode_write_float8(double val, gboolean write_header, GOutputStream *os) {
  GError *err = NULL;
  GError *e = NULL;
  union float8_union_ {
    char buffer[DOTCODE_FLOAT8_SIZE];
    double val;
  } the_union;
  the_union.val = val;
  gsize written;
  if(write_header) {
    e = dotcode_write_sstring(dotcode_string_from_type2(DOTCODE_FLOAT8), FALSE, os);
    if(e != NULL) return err;
  }
  if((!g_output_stream_write_all(os, the_union.buffer, DOTCODE_FLOAT8_SIZE, &written, NULL, &e)) || (DOTCODE_FLOAT8_SIZE != written) || (e != NULL)) {
    if(DOTCODE_FLOAT8_SIZE != written) {
      g_propagate_prefixed_error(&err, e, "libdotcode::write_binary_data::write_float8: error writing float8: (%g) len(%d) and amount written(%lu) differ!", val, DOTCODE_FLOAT8_SIZE, (long unsigned int)written);
    }else{
      g_propagate_prefixed_error(&err, e, "libdotcode::write_binary_data::write_float8: error writing float8 %g!", val);
    }
    return err;
  }
  return NULL;
}


GError* dotcode_write_float4(float val, gboolean write_header, GOutputStream *os) {
  GError *err = NULL;
  GError *e = NULL;
  union float4_union_ {
    char buffer[DOTCODE_FLOAT4_SIZE];
    float val;
  } the_union;
  the_union.val = val;
  gsize written;
  if(write_header) {
    e = dotcode_write_sstring(dotcode_string_from_type2(DOTCODE_FLOAT4), FALSE, os);
    if(e != NULL) return err;
  }
  if((!g_output_stream_write_all(os, the_union.buffer, DOTCODE_FLOAT4_SIZE, &written, NULL, &e)) || (DOTCODE_FLOAT4_SIZE != written) || (e != NULL)) {
    if(DOTCODE_FLOAT4_SIZE != written) {
      g_propagate_prefixed_error(&err, e, "libdotcode::write_binary_data::write_float8: error writing float8: (%g) len(%d) and amount written(%lu) differ!", val, DOTCODE_FLOAT4_SIZE, (long unsigned int)written);
    }else{
      g_propagate_prefixed_error(&err, e, "libdotcode::write_binary_data::write_float8: error writing float8 %g!", val);
    }
    return err;
  }
  return NULL;
}


GError* dotcode_write_vector(const struct dotcode_vector* val, gboolean write_header, GOutputStream *os) {
  return g_error_new(DOTCODE_WRITE_BINARY_DATA_GERROR_DOMAIN, DOTCODE_ERROR_NOTIMPLEMENTED, "libdotcode::write_binary_data::write_vector: function not yet implmented.\n");
}

GError* dotcode_write_array(const struct dotcode_array* val, gboolean write_header, GOutputStream *os) {
  GError *err = NULL;
  GError *e = NULL;
  if(write_header) {
    GString *s = g_string_new("");
    g_string_printf(s, "%s<%s>", dotcode_string_from_type2(DOTCODE_ARRAY), dotcode_string_from_type2(val->t));
    e = dotcode_write_sstring(s->str, FALSE, os);
    g_string_free(s, TRUE);
    if(e != NULL) return err;
  }
  e = dotcode_write_int(val->imin, FALSE, os);
  if(e != NULL) {
    g_propagate_prefixed_error(&err, e, "libdotcode::write_binary_data::write_array: error writing integer imin (%d) to output stream.", val->imin);
    return err;
  }
  e = dotcode_write_int(val->imax, FALSE, os);
  if(e != NULL) {
    g_propagate_prefixed_error(&err, e, "libdotcode::write_binary_data::write_array: error writing integer imax (%d) to output stream.", val->imax);
    return err;
  }
  char* str;
  for(int i=0; i<((val->imax)-(val->imin)+1); i++) {
    switch(val->t) {
    case DOTCODE_FLOAT8:
      e = dotcode_write_float8(((double*)(val->storage))[i], FALSE, os);
      break;
    case DOTCODE_FLOAT4:
      e = dotcode_write_float4(((float*)(val->storage))[i], FALSE, os);
      break;
    case DOTCODE_INT:
      e = dotcode_write_int(((int*)(val->storage))[i], FALSE, os);
      break;
    default:
      return g_error_new(DOTCODE_WRITE_BINARY_DATA_GERROR_DOMAIN, 1, "libdotcode::write_binary_data::write_array: error writing array data to stream: unknown dotcode type %d (%s)", val->t, str=dotcode_string_from_type(val->t));
      g_free(str);
    }
    if(e != NULL) {
      g_propagate_prefixed_error(&err, e, "libdotcode::write_binary_data::write_array: error writing %dth (array index %d) to output stream.", i, i+val->imin);
      return err;
    }
  }
  return NULL;
}

GError* dotcode_write_grid(const struct dotcode_grid* grid, gboolean write_header, GOutputStream *os) {
  GError *err;
  GError *e = NULL;
  if(write_header) {
    GString *s = g_string_new("");
    g_string_printf(s, "Grid<%s>", dotcode_string_from_type2(grid->gridsites[0]->t));
    e = dotcode_write_sstring(s->str, FALSE, os);
    g_string_free(s, TRUE);
    if(e != NULL) return err;
  }
  /*First, the gridspec*/
  e = dotcode_write_sstring("GridSpec", FALSE, os);
  if(e != NULL) {
    g_propagate_prefixed_error(&err, e, "libdotcode::write_binary_data::write_grid: error writing \"GridSpec\" to output stream.");
    return err;
  }
  e = dotcode_write_sstring("2.0", FALSE, os);
  if(e != NULL) {
    g_propagate_prefixed_error(&err, e, "libdotcode::write_binary_data::write_grid: error writing \"2.0\" to output stream.");
    return err;
  }
  for(int i=0; i<3; i++) {
    e = dotcode_write_array(grid->gridsites[i], FALSE, os);
    if(e != NULL) {
      g_propagate_prefixed_error(&err, e, "libdotcode::write_binary_data::write_grid: error writing index array %d to output stream.", i);
      return err;
    }
  }
  for(int i=0; i<3; i++) {
    e = dotcode_write_int(grid->Ng[i], FALSE, os);
    if(e != NULL) {
      g_propagate_prefixed_error(&err, e, "libdotcode::write_binary_data::write_grid: error writing Ng[%d] to output stream.", i);
      return err;
    }
  }
  /*Then, the tensor*/
  e = dotcode_write_tensor(grid->data, TRUE, os);
  if(e != NULL) {
    g_propagate_prefixed_error(&err, e, "libdotcode::write_binary_data::write_grid: error writing tensor to output stream.");
    return err;
  }
  return NULL;
}

GError* dotcode_write_tensor(const struct dotcode_tensor* tensor, gboolean write_header, GOutputStream *os) {
  GError *err = NULL;
  GError *e = NULL;
  char* str;
  if(write_header) {
    GString *s = g_string_new("");
    g_string_printf(s, "%s<%s>", dotcode_string_from_type2(DOTCODE_TENSOR), dotcode_string_from_type2(tensor->t));
    e = dotcode_write_sstring(s->str, FALSE, os);
    g_string_free(s, TRUE);
    if(e != NULL) return err;
  }
  e = dotcode_write_sstring(tensor->metadata, FALSE, os);
  if(e != NULL) {
    g_propagate_prefixed_error(&err, e, "libdotcode::write_binary_data::write_tensor: error writing metadata (%s) to output stream", tensor->metadata);
    return err;
  }
  e = dotcode_write_int(tensor->Nd, FALSE, os);
  if(e != NULL) {
    g_propagate_prefixed_error(&err, e, "libdotcode::write_binary_data::write_tensor: error writing number of dimensions (%d) to output stream", tensor->Nd);
    return err;
  }
  for(int d=0; d<tensor->Nd; d++) {
    for(int m=0; m<2; m++) {
      e = dotcode_write_int(tensor->indices[m+2*d], FALSE, os);
      if(e != NULL) {
  g_propagate_prefixed_error(&err, e, "libdotcode::write_binary_data::write_tensor: error writing %s for dimension %d to output stream", m?"imax":"imin", tensor->Nd);
  return err;
      }
    }
  }
  /*Walk through the array, writing the values. Since our in-memory
    representation is identical to the on-disk representation, we're
    good to go.*/
  long unsigned int size=1;
  for(int d=0; d<tensor->Nd; d++) size *= tensor->indices[1+2*d] - tensor->indices[2*d] + 1;
  for(long unsigned int i=0; i<size; i++) {
    switch(tensor->t) {
    case DOTCODE_FLOAT8:
      e = dotcode_write_float8(((double*)(tensor->data))[i], FALSE, os);
      break;
    case DOTCODE_FLOAT4:
      e = dotcode_write_float4(((float*)(tensor->data))[i], FALSE, os);
      break;
    case DOTCODE_INT:
      e = dotcode_write_int(((int*)(tensor->data))[i], FALSE, os);
      break;
    default:
      return g_error_new(DOTCODE_WRITE_BINARY_DATA_GERROR_DOMAIN, 1, "libdotcode::write_binary_data::write_tensor: error writing tensor data to stream: unknown dotcode type %d (%s)", tensor->t, str=dotcode_string_from_type(tensor->t));
      g_free(str);
    }
    if(e != NULL) {
      g_propagate_prefixed_error(&err, e, "libdotcode::write_binary_data::write_tensor: error writing %luth datum to output stream.", i);
      return err;
    }
  }
  return NULL;
}