/simpletypesystem/trunk

#include "Error.h"

#include "SimpleTypeSystem.h"

#include <stdlib.h>

#include <string.h>

#include <stdio.h>

struct _SErrorPrivate {

  SErrorType error_type;

  char * message;

};

char * error_to_string_method (SError * self);

void error_deinit_method (SError * self);

SError * s_error_new (SErrorType error, char * message) {

  SError * self = malloc (sizeof (SError));

  SErrorClass * klass = malloc (sizeof (SErrorClass));

  self->priv = malloc (sizeof (SErrorPrivate));

  s_base_object_set_class ((SBaseObjectInstance *) self, (SBaseObjectClass *) klass);

  s_base_object_initize ((SBaseObjectInstance *) self);

  s_base_object_set_to_string_method ((SBaseObjectInstance *) self, error_to_string_method);

  s_base_object_set_deinit_method ((SBaseObjectInstance *) self, error_deinit_method);

  self->priv->message = s_string_new (message);

  self->priv->error_type = error;

  return self;

}

void s_error_free (SError * self) {

  s_base_object_free ((SBaseObjectInstance *) self);

}

char * error_to_string_method (SError * self) {

  char * ret_val = malloc (sizeof(char) * 32);

  char * error_type_str = NULL;

  switch (self->priv->error_type) {

    case S_ERROR_NONE:

      error_type_str = s_string_new ("NONE");

      break;

    case S_ERROR_INPUT_OUTPUT:

      error_type_str = s_string_new ("INPUT/OUTPUT");

      break;

    case S_ERROR_OVERFLOW:

      error_type_str = s_string_new ("OVERFLOW");

      break;

    case S_ERROR_OTHER:

      error_type_str = s_string_new ("OTHER");

      break;

    case S_ERROR_NULL:

      error_type_str = s_string_new ("NULL");

      break;

    default:

      error_type_str = s_string_new ("(null)");

  }

  sprintf (ret_val, "Error: %s, Message: %s", error_type_str, self->priv->message);

  free (error_type_str);

  return ret_val;

}

void error_deinit_method (SError * self) {

  free (self->priv->message);

  free (self->priv);

  SBaseObjectInstance * base = (SBaseObjectInstance *) self;

  SErrorClass * klass = (SErrorClass *) base->base_class;

  free (klass);

  free (self);

}