/simpletypesystem/trunk

#include "Box.h"

#include <stdlib.h>

struct

SBoxPrivate {

  sboolean                      free_data;

  SType                         object_type;

  FreeFunc                      free_func;

  union {

    SObject *                   m_sobject;

    spointer                    m_ptr;

    sboolean                    m_sboolean;

    int                         m_int;

    long                        m_long;

    short                       m_short;

    char                        m_char;

    wchar_t                     m_wchar;

    unsigned int                m_uint;

    unsigned long               m_ulong;

    unsigned short              m_ushort;

    char *                      m_string;

    wchar_t *                   m_wstring;

  } data;

};

void

s_method_box_free (SBox * self);

char *

s_method_box_to_string (SBox * self);

/* Private function to allocate and set methods to the SBox.

 */

SBox *

internal_s_box_new () {

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

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

  s_object_initialize (S_OBJECT (self), "SBox");

  s_object_set_class (S_OBJECT (self),

                      S_OBJECT_CLASS (klass));

  s_object_set_free_method (S_OBJECT (self),

                            FREE_METHOD (s_method_box_free));

  s_object_set_to_string_method (S_OBJECT (self),

                                 TO_STRING_FUNC (s_method_box_to_string));

  self->priv->free_func = NULL;

  return self;

}

SBox *

s_box_new_pointer (spointer object) {

  SBox * self = internal_s_box_new ();

  self->priv->data.m_ptr = object;

  self->priv->object_type = S_TYPE_POINTER;

  return self;

}

SBox *

s_box_new_sobject (SObject * object) {

  SBox * self = internal_s_box_new ();

  self->priv->data.m_sobject = object;

  self->priv->object_type = S_TYPE_OBJECT;

  return self;

}

SBox *

s_box_new_int (int i) {

  SBox * self = internal_s_box_new ();

  self->priv->data.m_int = i;

  self->priv->object_type = S_TYPE_INT;

  return self;

}

SBox *

s_box_new_long (long l) {

  SBox * self = internal_s_box_new ();

  self->priv->data.m_long = l;

  self->priv->object_type = S_TYPE_LONG;

  return self;

}

SBox *

s_box_new_short (short s) {

  SBox * self = internal_s_box_new ();

  self->priv->data.m_short = s;

  self->priv->object_type = S_TYPE_SHORT;

  return self;

}

SBox *

s_box_new_char (char c) {

  SBox * self = internal_s_box_new ();

  self->priv->data.m_char = c;

  self->priv->object_type = S_TYPE_CHAR;

  return self;

}

SBox *

s_box_new_wchar (wchar_t wc) {

  SBox * self = internal_s_box_new ();

  self->priv->data.m_wchar = wc;

  self->priv->object_type = S_TYPE_WCHAR;

  return self;

}

SBox *

s_box_new_uint (unsigned int ui) {

  SBox * self = internal_s_box_new ();

  self->priv->data.m_uint = ui;

  self->priv->object_type = S_TYPE_UINT;

  return self;

}

SBox *

s_box_new_ulong (unsigned long ul) {

  SBox * self = internal_s_box_new ();

  self->priv->data.m_ulong = ul;

  self->priv->object_type = S_TYPE_ULONG;

  return self;

}

SBox *

s_box_new_ushort (unsigned short us)  {

  SBox * self = internal_s_box_new ();

  self->priv->data.m_ushort = us;

  self->priv->object_type = S_TYPE_USHORT;

  return self;

}

SBox *

s_box_new_string (char * s) {

  SBox * self = internal_s_box_new ();

  self->priv->data.m_string = s;

  self->priv->object_type = S_TYPE_STRING;

  return self;

}

SBox *

s_box_new_wstring (wchar_t * ws) {

  SBox * self = internal_s_box_new ();

  self->priv->data.m_wstring = ws;

  self->priv->object_type = S_TYPE_WSTRING;

  return self;

}

void

s_box_free (SBox * self) {

  s_object_free (S_OBJECT (self));

}

void

s_box_set_free_data_on_free (SBox * self, sboolean free_data) {

  self->priv->free_data = free_data;

}

void

s_box_set_free_func (SBox * self, FreeFunc free_func) {

  self->priv->free_func = free_func;

}

spointer *

s_box_get_pointer (SBox * self);

SObject *

s_box_get_sobject (SBox * self);

int

s_box_get_int (SBox * self);

long

s_box_get_long (SBox * self);

short

s_box_get_short (SBox * self);

char

s_box_get_char (SBox * self);

wchar_t

s_box_get_wchar (SBox * self);

unsigned int

s_box_get_uint (SBox * self);

unsigned long

s_box_get_ulong (SBox * self);

unsigned short

s_box_get_ushort (SBox * self);

char *

s_box_get_string (SBox * self);

wchar_t *

s_box_get_wstring (SBox * self);

void

s_method_box_free (SBox * self) {

  SBoxClass * klass = S_BOX_CLASS (s_object_get_class(S_OBJECT(self)));

  SBoxPrivate * priv = self->priv;

  FreeFunc free_func = priv->free_func;

  if (priv->free_data) {

    switch (priv->object_type) {

      case S_TYPE_OBJECT:

        s_object_free (priv->data.m_sobject);

        break;

      case S_TYPE_POINTER:

        if (free_func) {

          free_func (priv->data.m_ptr);

        } else {

          free (priv->data.m_ptr);

        }

        break;

      case S_TYPE_STRING:

        free (priv->data.m_string);

        break;

      case S_TYPE_WSTRING:

        free (priv->data.m_wstring);

        break;

      default:

        s_warn_print ("[SBox] free_data was set despite not being an object"

                      "that can be freed.");

    }

  }

  free (self->priv);

  free (klass);

}

char *

s_method_box_to_string (SBox * self) {

  char * ret_val = NULL;

  switch (self->priv->object_type) {

    case (S_TYPE_INT):

      ret_val = s_string_new_fmt ("(SBox, Char: %i)", self->priv->data.m_int);

      break;

    case (S_TYPE_CHAR):

      ret_val = s_string_new_fmt ("(SBox, Char: %c)", self->priv->data.m_char);

      break;

    case (S_TYPE_LONG):

      ret_val = s_string_new_fmt ("(SBox, Long: %li)", self->priv->data.m_long);

      break;

    case (S_TYPE_OBJECT):

      ret_val = s_string_new_fmt ("(SBox, SObject: %s)", s_object_to_string(self->priv->data.m_sobject));

      break;

    case (S_TYPE_POINTER):

      ret_val = s_string_new_fmt ("(SBox, Pointer: %lli)", self->priv->data.m_ptr);

      break;

    case (S_TYPE_SHORT):

      ret_val = s_string_new_fmt ("(SBox, Short: %hi)", self->priv->data.m_short);

      break;

    case (S_TYPE_STRING):

      ret_val = s_string_new_fmt ("(SBox, String: \"%s\")", self->priv->data.m_string);

      break;

    case (S_TYPE_UINT):

      ret_val = s_string_new_fmt ("(SBox, Unsigned Int: %u)", self->priv->data.m_uint);

      break;

    case (S_TYPE_ULONG):

      ret_val = s_string_new_fmt ("(SBox, Unsigned Long: %lu)", self->priv->data.m_ulong);

      break;

    case (S_TYPE_USHORT):

      ret_val = s_string_new_fmt ("(SBox, Unsigned Short: %hu)", self->priv->data.m_ushort);

      break;

    case (S_TYPE_WCHAR):

      ret_val = s_string_new_fmt ("(SBox, Wide Char: %lc)", self->priv->data.m_wchar);

      break;

    case (S_TYPE_WSTRING):

      ret_val = s_string_new_fmt ("(SBox, Wide String: %s)", s_wstring_to_string (self->priv->data.m_wstring));

    default:

      s_err_print ("THIS SHOULD NOT BE ALBE TO BE REACHED.");

  }

  return ret_val;

}