/simpletypesystem/trunk : contents of docs/inheritance.html at revision 11

: (revision 11)

To get this branch, use:

bzr branch
http://gegoxaren.bato24.eu/bzr/simpletypesystem/trunk

<!DOCTYPE html>
<html>
  <head>
    <title> The (Super) Simple Type System </title>
  </head>
  <body>
    <h1>inheritance</h1>
    <nav><a href="./index.html"> Back to Index </a></nav>
    <p>
      Inheritance in SSTS is interesting, it follows the same paradigm as
      <a href="https://developer.gnome.org/gobject/stable/chapter-gobject.html">
      GObject </a>.
    </p>
    <h2>Header file</h2>
    <p>
      In the header file the structs that will define the object are difened
      along with the functions that operate on the object.
    </p>
    <p>
      <code>Foo.h</code>
    </p>
    <hr/>
    <pre>
#ifndef __H_FOO__
#define __H_FOO__

#include "baseobject.h"
#include &#60;stdbool.h&#62;
typedef struct _FooClass FooClass;
typedef struct _Foo Foo;
typedef struct _FooPrivate FooPrivate; //the private data is defined in the .c file

struct _FooClass {
  SBaseObjectClass parent_class; // The parent class holds the methods of the object
  CompFunc some_method; // Some method associated with the object.
};

struct _Foo {
  SBaseObjectInstance parent;
  FooPrivate * priv;
};
    </pre>
    <hr/>
    <p>
      This was the declaration of the the data structures.
    </p><p>
      Then we need some functions to operate on the objects:
    </p>
    <hr/>
    <pre>
Foo * foo_new (char * my_str);
void foo_free (Foo * self);
bool foo_comp (Foo * self, char * other_str);
void foo_set_str (Foo * self, char * new_str);

#endif //__H_FOO__
    </pre>
    <hr/>
    <h2> C-Code file </h2>
    <p>
      In the .c file we define the real functions and methods to be used with
      the object. It is a littl fidely at first but when the objet is in place
      it should be ready to use.
    </p>
    <p>
      Remeber, never trust anyone elses code.
    </p>
    <p>
      <code>Foo.c</code>
    </p>
    <pre>
#include "Foo.h"

struct _FooPrivate {
  char * my_str; //The private data.
};

void foo_deinit_method (Foo * self); // Prototype the deinit method.
void foo_to_string_method (Foo * self); // Prototype the to_string method.
bool foo_comp_method (char * str1, char * str2); // Prototype the comp method

//The constructor
Foo * foo_new (char * my_str) {
  Foo * self = malloc ( sizeof (Foo));
  FooClass * klass = malloc( sizeof (FooClass));
  
  s_base_object_set_class (self, klass);
  s_base_object_initize (self);
  s_base_object_set_deinit_method (self, foo_deinit_method);
  s_base_object_set_to_string_method (self, foo_to_string_method);
  klass->some_method = foo_comp_method;
  
  return self;
}

void foo_free (Foo * self) {
  s_base_object_free (self); // Calls foo_deinit_method
}

bool foo_comp (Foo * self, char * other_str) {
  FooClass * klass = (FooClass *) s_base_object_get_class (self);
  return klass->some_method (self->priv->my_str, other_str);
}

void foo_set_str (Foo * self, char * new_str) {
  free (self->priv->my_str);
  self->priv->my_str = s_string_new (new_str);
}

    </pre>
    <p>
      Now we are almost done, the only things that remain is to write the
      methods. but first we have to go through what the code does.
    </p>
    <p>
      In the constructor <code> foo_new </code> we first create a pointer to 
      an instance of the object and an instance of the object class. The class
      is then set to the object instance using the
      <code> s_base_object_set_class </code> function. It is important to set
      the objects class <b> before </b> you initize the object.
    </p>
    <p>
      After the class is set the object is initized, this adds the standard
      <code> deinit, ref, unref </code> and <code> to_string </code> methods.
    </p>
    <p>
      We then have to set our own <code> to_string </code> and <code> deinit
      </code> methods using the <code> s_base_object_set_to_string_method,
      </code> and <code> s_base_object_set_deinit_method </code>.
    </p>
    <p>
      In the start of the <code>C</code>-file we wrote some prototypes or
      declarations of these methods, now it is time to implement them.
    </p>
    <pre>
void foo_deinit_method (Foo * self) {
  FooClass klass = (FooClass *) s_base_object_get_class (self);
  free(self->priv->my_str);
  free(klass);
  free(self);
}

void foo_to_string_method (Foo * self) {
  return self->priv->my_str;
}

bool foo_comp_method (char * str1, char * str2) {
  if ( strcmp ( str1, str2 ) == 0 ) {
    return true;
  } else {
    return false;
  }
}
    </pre>
    <p>
      And that is it.
    </p>
    <p>
      Please note that not any of the objects in the system are thread-safe,
      and probably never will be.
    </p>
    <footer style="padding-top: 10em">
      <!-- <A name="anchor"><p>  * Note </p></A> -->
    </footer>
  </body>
</html>

11 by Gustav Hartvigsson * Finnished up a the inheritance documentation.	1	<!DOCTYPE html>
	2	<html>
	3	<head>
	4	<title> The (Super) Simple Type System </title>
	5	</head>
	6	<body>
	7	<h1>inheritance</h1>
	8	<nav><a href="./index.html"> Back to Index </a></nav>
	9	<p>
	10	Inheritance in SSTS is interesting, it follows the same paradigm as
	11	<a href="https://developer.gnome.org/gobject/stable/chapter-gobject.html">
	12	GObject </a>.
	13	</p>
	14	<h2>Header file</h2>
	15	<p>
	16	In the header file the structs that will define the object are difened
	17	along with the functions that operate on the object.
	18	</p>
	19	<p>
	20	<code>Foo.h</code>
	21	</p>
	22	<hr/>
	23	<pre>
	24	#ifndef __H_FOO__
	25	#define __H_FOO__
	26
	27	#include "baseobject.h"
	28	#include <stdbool.h>
	29	typedef struct _FooClass FooClass;
	30	typedef struct _Foo Foo;
	31	typedef struct _FooPrivate FooPrivate; //the private data is defined in the .c file
	32
	33	struct _FooClass {
	34	SBaseObjectClass parent_class; // The parent class holds the methods of the object
	35	CompFunc some_method; // Some method associated with the object.
	36	};
	37
	38	struct _Foo {
	39	SBaseObjectInstance parent;
	40	FooPrivate * priv;
	41	};
	42	</pre>
	43	<hr/>
	44	<p>
	45	This was the declaration of the the data structures.
	46	</p><p>
	47	Then we need some functions to operate on the objects:
	48	</p>
	49	<hr/>
	50	<pre>
	51	Foo * foo_new (char * my_str);
	52	void foo_free (Foo * self);
	53	bool foo_comp (Foo * self, char * other_str);
	54	void foo_set_str (Foo * self, char * new_str);
	55
	56	#endif //__H_FOO__
	57	</pre>
	58	<hr/>
	59	<h2> C-Code file </h2>
	60	<p>
	61	In the .c file we define the real functions and methods to be used with
	62	the object. It is a littl fidely at first but when the objet is in place
	63	it should be ready to use.
	64	</p>
65	<p>
66	Remeber, never trust anyone elses code.
67	</p>
68	<p>
69	<code>Foo.c</code>
70	</p>
71	<pre>
72	#include "Foo.h"
73
74	struct _FooPrivate {
75	char * my_str; //The private data.
76	};
77
78	void foo_deinit_method (Foo * self); // Prototype the deinit method.
79	void foo_to_string_method (Foo * self); // Prototype the to_string method.
80	bool foo_comp_method (char * str1, char * str2); // Prototype the comp method
81
82	//The constructor
83	Foo * foo_new (char * my_str) {
84	Foo * self = malloc ( sizeof (Foo));
85	FooClass * klass = malloc( sizeof (FooClass));
86
87	s_base_object_set_class (self, klass);
88	s_base_object_initize (self);
89	s_base_object_set_deinit_method (self, foo_deinit_method);
90	s_base_object_set_to_string_method (self, foo_to_string_method);
91	klass->some_method = foo_comp_method;
92
93	return self;
94	}
95
96	void foo_free (Foo * self) {
97	s_base_object_free (self); // Calls foo_deinit_method
98	}
99
100	bool foo_comp (Foo * self, char * other_str) {
101	FooClass * klass = (FooClass *) s_base_object_get_class (self);
102	return klass->some_method (self->priv->my_str, other_str);
103	}
104
105	void foo_set_str (Foo * self, char * new_str) {
106	free (self->priv->my_str);
107	self->priv->my_str = s_string_new (new_str);
108	}
109
110	</pre>
111	<p>
112	Now we are almost done, the only things that remain is to write the
113	methods. but first we have to go through what the code does.
114	</p>
115	<p>
116	In the constructor <code> foo_new </code> we first create a pointer to
117	an instance of the object and an instance of the object class. The class
118	is then set to the object instance using the
119	<code> s_base_object_set_class </code> function. It is important to set
120	the objects class <b> before </b> you initize the object.
121	</p>
122	<p>
123	After the class is set the object is initized, this adds the standard
124	<code> deinit, ref, unref </code> and <code> to_string </code> methods.
125	</p>
126	<p>
127	We then have to set our own <code> to_string </code> and <code> deinit
128	</code> methods using the <code> s_base_object_set_to_string_method,
129	</code> and <code> s_base_object_set_deinit_method </code>.
130	</p>
131	<p>
132	In the start of the <code>C</code>-file we wrote some prototypes or
133	declarations of these methods, now it is time to implement them.
134	</p>
135	<pre>
136	void foo_deinit_method (Foo * self) {
137	FooClass klass = (FooClass *) s_base_object_get_class (self);
138	free(self->priv->my_str);
139	free(klass);
140	free(self);
141	}
142
143	void foo_to_string_method (Foo * self) {
144	return self->priv->my_str;
145	}
146
147	bool foo_comp_method (char * str1, char * str2) {
148	if ( strcmp ( str1, str2 ) == 0 ) {
149	return true;
150	} else {
151	return false;
152	}
153	}
154	</pre>
155	<p>
156	And that is it.
157	</p>
158	<p>
159	Please note that not any of the objects in the system are thread-safe,
160	and probably never will be.
161	</p>
162	<footer style="padding-top: 10em">
163	<!-- <A name="anchor"><p> * Note </p></A> -->
164	</footer>
165	</body>
166	</html>