/simpletypesystem/trunk

/*

Copyright (c) 2013-2014 Gustav Hartvigsson

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 "Error.h"

#include <stdlib.h>

#include <string.h>

#include <stdio.h>

#include <assert.h>

#include "utils.h"

#include "LinkedList.h"

#include "DynamicArray.h"

/* **************************************************************************

 *********************** INTERNALS ******************************************

 **************************************************************************** */

typedef

struct SErrorItem {

  schar * message;

  SErrorDomain error_domain;

  sint error_type;

} SErrorItem;

struct SError {

  SLinkedList * error_list; /* SLinkedList<SErrorItem *> */

};

typedef

struct SErrorDomainItem {

  SErrorDomain domain;

  SErrorDomainToString to_string_func;

  schar * domain_name;

} SErrorDomainItem;

static

SDynamicArray *

_internal_s_error_domain_list = NULL; /* <SErrorDomainItem *> */

void

_internal_s_error_domain_item_free (SErrorDomainItem * self);

void

_internal_s_error_item_free (SErrorItem * self);

void

_internal_s_error_list_for_each_item (SDynamicArray * in_array,

                                      SErrorItem * item,

                                      SDynamicArray * out_array);

schar *

s_default_error_domain_to_string (sint error_id, schar * msg) {

  schar * ret_val = s_string_new_fmt ("Error %d (%s): %s",

                                      error_id,

                                      s_default_error_get_name (error_id),

                                      msg);

  return ret_val;

}

schar *

s_default_error_get_name (SDefaultErrorType k) {

  return SDefaultErrorTypeName[k];

}

/* **************************************************************************

 ************************** SError ******************************************

 **************************************************************************** */

SError *

s_error_new (void) {

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

  self->error_list = s_linked_list_new (FREEFUNC (_internal_s_error_item_free));

  return self;

}

void

s_error_append (SError * self ,

                sint error, const char * message,

                SErrorDomain error_domain) {

  assert (self != NULL);

  if (error_domain < 0) {

    s_err_print ("Invalid ErrorDomain");

    print_backtrace ();

    return;

  }

  SErrorItem * item = s_malloc (sizeof (SErrorItem));

  item->message = s_string_new (message);

  item->error_type = error;

  item->error_domain = error_domain;

  s_linked_list_append (self->error_list, item);

}

sboolean

s_error_has_error (SError * self) {

  if (self != NULL) {

    if (s_linked_list_get_current (self->error_list)) {

      return TRUE;

    }

  }

  return FALSE;

}

SDynamicArray *

s_error_to_string_array (SError * self) {

  assert (self != NULL);

  size_t out_arr_len = s_linked_list_len (self->error_list);

  SDynamicArray * ret_val = s_dynamic_array_new (out_arr_len, NULL);

  s_linked_list_for_each (self->error_list,

                          FOREACHFUNC(_internal_s_error_list_for_each_item),

                          ret_val);

  return ret_val;

}

void

s_error_free (SError * self) {

  s_linked_list_free (self->error_list, TRUE);

  s_free (self);

}

void

s_error_teardown () {

  s_dbg_print ("Taring down error system....");

  if (_internal_s_error_domain_list) {

    s_dynamic_array_free (_internal_s_error_domain_list, TRUE);

  }

  s_dbg_print ("Done tearing down error system.");

}

/* **************************************************************************

 *********************** SErrorDomain ***************************************

 **************************************************************************** */

SErrorDomain

s_error_get_domain (const schar * name, SErrorDomainToString to_string_func) {

  SErrorDomainItem * item = NULL;

  if (strlen (name) == 0 || to_string_func == NULL) {

    s_err_print ("Domain name or to_string_func not set.\n");

    return -2;

  }

  if (!(_internal_s_error_domain_list)) {

    s_dbg_print ("Array does not exist, lets create it!");

    _internal_s_error_domain_list =

          s_dynamic_array_new (S_ERROR_DOMAIN_RANGE_MAX,

          FREEFUNC (_internal_s_error_domain_item_free));

    // The default key is always 0

    item = s_malloc (sizeof (SErrorDomainItem));

    item->domain = 0;

    item->to_string_func = s_default_error_domain_to_string;

    item->domain_name = s_string_new ("default");

    s_dynamic_array_set (_internal_s_error_domain_list, 0, item);

  }

  if (s_string_is_equal (name, "default")) {

    if (to_string_func != s_default_error_domain_to_string) {

      s_err_print ("Trying to override the default error domain to string "

                   "callback.\n"

                   "This is not allowed! \n");

      return -1;

    }

    return 0;

  }

  /* We hash the domain name and see it the domain exists. */

  SErrorDomain domain = s_hash (name) % S_ERROR_DOMAIN_RANGE_MAX;

  SErrorDomainItem * item_2 = (SErrorDomainItem *) s_dynamic_array_get

                              (_internal_s_error_domain_list, domain);

  if ((item_2) == NULL) {

    /*

     * The item dose not exist in the array, lets just add it.

     */

    item = s_malloc (sizeof (SErrorDomainItem));

    item->domain = domain;

    item->to_string_func = to_string_func;

    item->domain_name = s_string_new (name);

    s_dynamic_array_set (_internal_s_error_domain_list ,domain, item);

    return domain;

  } else {

    /* We got something. See it it is correct */

    if (s_string_is_equal(item_2->domain_name, name)) {

      if (item_2->to_string_func != to_string_func) {

        s_err_print ("Trying to overwrite the to string handler"

                     "for error domain %s, this is not allowd.",

                     name);

        return -1;

      }

      return domain;

    }

    /*

     * We must now check each item untill we reach a NULL.

     */

    for (sint i = domain;

           i <= s_dynamic_array_size (_internal_s_error_domain_list);

             i++) {

      item_2 = (SErrorDomainItem *) s_dynamic_array_get (_internal_s_error_domain_list, i);

      if ((item_2) == NULL) {

        break; // This jumps out of the loop and to the for-loop below.

      } else {

        if (s_string_is_equal (item_2->domain_name, name)) {

          if (item_2->to_string_func != to_string_func) {

            s_err_print ("Trying to override to string function for error "

                         "domain %s.\nThis is not allowed!\n", name);

            return -1;

          } else {

            return i;

          }

        }

      }

    }

  }

  /*

   * The error domain does not exist.

   */

  for (/* domain */;

       domain <= s_dynamic_array_size (_internal_s_error_domain_list) + 1;

       domain++) {

    if (!(s_dynamic_array_get(_internal_s_error_domain_list ,domain))) {

      item = s_malloc (sizeof (SErrorDomainItem));

      item->domain = domain;

      item->domain_name = s_string_new (name);

      item->to_string_func = to_string_func;

      return domain;

    }

  }

  s_err_print ("Reaching a place where it should not reach. This is a sign "

               "that the devil has been messing with time and space.\n");

  print_backtrace ();

  return -666;

}

/* **************************************************************************

 *********************** INTERNALS ******************************************

 **************************************************************************** */

void

_internal_s_error_domain_item_free (SErrorDomainItem * self) {

  s_dbg_print ("(SErrorDomainItem) Freeing: %d, %s",

               self->domain,

               self->domain_name);

  s_free (self->domain_name);

  s_free (self);

}

void

_internal_s_error_list_for_each_item (SDynamicArray * in_array,

                                      SErrorItem * item,

                                      SDynamicArray * out_array) {

  SErrorDomainItem * domain_item = s_dynamic_array_get (

                                          _internal_s_error_domain_list,

                                          item->error_domain);

  SErrorDomainToString to_string_func = domain_item->to_string_func;

  s_dynamic_array_append (out_array, to_string_func (item->error_type,

                                                     item->message));

}

void

_internal_s_error_item_free (SErrorItem * self) {

  s_dbg_print ("Running free on errori item!");

  s_free (self->message);

  s_free (self);

}