/simpletypesystem/trunk

/*
    (C) Gustav Hartvigsson, 2013.
    
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as
    published by the Free Software Foundation, either version 3 of the
    License.

    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 General Public License for more details.

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

#include "baseobject.h"
#include <stdlib.h>
#include <string.h>
#include <stdio.h>


/* ---------------------------
 * Concrete method definitions
 * These are implemented towards the end of this file.
 * ---------------------------
 */

// SBaseObjectInstance * method_base_init (SBaseObjectInstance * self);

void method_base_deinit (SBaseObjectInstance * self);

int method_base_ref (SBaseObjectInstance * self);

int method_base_unref (SBaseObjectInstance * self);

int method_base_get_refcount (SBaseObjectInstance * self);

char * method_base_to_string (SBaseObjectInstance * self);

/* -----------------
 * Helper functions...
 * -----------------
 */
/**
 * This function is used to set the method to initize a new instance of an
 * object.
 *
 * This has no use, rely...(?)
 */ /*
void s_base_object_set_init_method (SBaseObjectInstance * self, SBaseObjectInstance * (* method)(* SBaseObjectInstance)) {
  SBaseObjectClass * klass = s_base_object_get_class (self);
  klass->initize = method;
}
*/

/**
 * This function is used to set the method to deinitize an object.
 * 
 * set it to a method that deinitize your object.
 */
void s_base_object_set_deinit_method (SBaseObjectInstance * self, void (* method)(SBaseObjectInstance *)) {
  SBaseObjectClass * klass = s_base_object_get_class (self);
  klass->deinitize = method;
} 

/**
 * This fuction is used to set the ref method.
 * 
 * DO NOT USE THIS UNLESS YOU KNOW WHAT YOU ARE DOING.
 */
void s_base_object_set_ref_method (SBaseObjectInstance * self, int (* method)(SBaseObjectInstance *)) {
  SBaseObjectClass * klass = s_base_object_get_class (self);
  klass->ref = method;
}

/**
 * This fuction is used to set the unref method.
 * 
 * DO NOT USE THIS UNLESS YOU KNOW WHAT YOU ARE DOING.
 */
void s_base_object_set_unref_method (SBaseObjectInstance * self, int (* method)(SBaseObjectInstance *)) {
  SBaseObjectClass * klass = s_base_object_get_class (self);
  klass->unref = method;
}

/**
 * This fuction is used to set the get_refcount method.
 * 
 * DO NOT USE THIS UNLESS YOU KNOW WHAT YOU ARE DOING.
 */
void s_base_object_set_get_refcount_method (SBaseObjectInstance * self, int (* method)(SBaseObjectInstance *)) {
  SBaseObjectClass * klass = s_base_object_get_class (self);
  klass->get_refcount = method;
}

/**
 * This fuction is used to set the to_string method.
 */
void s_base_object_set_to_string_method (SBaseObjectInstance * self, char * (*method)(SBaseObjectInstance *)) {
  SBaseObjectClass * klass = s_base_object_get_class (self);
  klass->to_string = method;
}

/* ----------------------
 * Base object functions.
 * ----------------------
 */

/**
 * This function initizes an intance of the BaseObject, it also sets the methods
 * to be used with the object and sets the refrence count to one.
 */
void s_base_object_initize (SBaseObjectInstance * self) {
  self->refcount = 1;
  // s_base_object_set_init_method (self, method_base_init);
  s_base_object_set_deinit_method (self, method_base_deinit);
  s_base_object_set_ref_method (self, method_base_ref);
  s_base_object_set_unref_method (self, method_base_unref);
  s_base_object_set_get_refcount_method (self, method_base_get_refcount);
  s_base_object_set_to_string_method (self, method_base_to_string);
}

/**
 * This function creates a new base object.
 */
SBaseObjectInstance * s_base_object_new () {
  SBaseObjectInstance * self = malloc (sizeof (SBaseObjectInstance) + 1);
  //allocate the class definition of the object.
  self->base_class = malloc (sizeof(SBaseObjectClass));
  //initize it.
  s_base_object_initize (self);
  return self;
}

/**
 * This function deinitizes/frees an object even if it is still referenced.
 * This is usualy a bad idea, use s_base_object_unref instead.
 */
void s_base_object_free (SBaseObjectInstance * self) {
  SBaseObjectClass * klass = s_base_object_get_class (self);
  klass->deinitize (self);
}

/**
 * This function gets the class (which hold the object methods).
 */
void * s_base_object_get_class (SBaseObjectInstance * self) {
  return self->base_class;
}

/**
 * This function sets the instance class of an object.
 */
void s_base_object_set_class (SBaseObjectInstance * self, SBaseObjectClass * klass) {
  self->base_class = klass;
}

/**
 * This function is used to decrese the reference count of an object.
 * When an object reaches zero, it will deinitize the object using the objects
 * deititize method.
 * 
 * It returns the current reference count.
 */
int s_base_object_unref (SBaseObjectInstance * self) {
  unsigned int ret = self->base_class->unref (self);
  return ret;
}

/**
 * This function is used to increse the reference count of an object.
 *
 * Returns the current reference count.
 */
int s_base_object_ref (SBaseObjectInstance * self) {
  unsigned int ret = self->base_class->ref (self);
  return ret;
}

/**
 * This function returns the current reference count without chaning it.
 */
int s_base_object_get_refcount (SBaseObjectInstance * self) {
  unsigned int ret = self->base_class->get_refcount (self);
  return ret;
}

/**
 * This function returns a textual (string) that represesnts the object.
 * The method can be set using s_base_object_set_to_string_method.
 *
 * Note: The string that is returned must be freed.
 */
char * s_base_object_to_string (SBaseObjectInstance * self) {
  char * ret = self->base_class->to_string (self);
  return ret;
}

/* -----------------
 * Contrete methods.
 * -----------------
 */
 
 
// SBaseObjectInstance * method_base_init (SBaseObjectInstance * self) { }

void method_base_deinit (SBaseObjectInstance * self) {
  free (self->base_class);
  free (self);
}

int method_base_ref (SBaseObjectInstance * self) {
  self->refcount = self->refcount + 1;
  return self->refcount;
}

int method_base_unref (SBaseObjectInstance * self) {
  self->refcount = self->refcount - 1;
  if (self->refcount == 0) {
    self->base_class->deinitize (self);
    return 0;
  }
  return self->refcount;
}

int method_base_get_refcount (SBaseObjectInstance * self) {
  return self->refcount;
}

char * method_base_to_string (SBaseObjectInstance * self) {
  char * ret_string = malloc (sizeof (char) * 32); // I am bad with maths..
  sprintf (ret_string, "References: %d ", self->base_class->get_refcount(self));
  return ret_string;
}