> export glib_cv_stack_grows=no; \ export glib_cv_uscore=no; \ export ac_cv_func_posix_getpwuid_r=no; \ export ac_cv_func_posix_getgrgid_r=no; \ CFLAGS=-I$(TARGET_DIR)/usr/include \ LDFLAGS=-L$(TARGET_DIR)/usr/lib \ ./configure --host=arm-linux-gnueabi --prefix=$(TARGET_DIR)/usr
HTTP server push
HTTP server push (also known as HTTP streaming) is a mechanism for sending data from a web server to a web browser. HTTP server push can be achieved through several mechanisms.
Generally the web server does not terminate a connection after response data has been served to a client. The web server leaves the connection open such that if an event is received, it can immediately be sent to one or multiple clients. Otherwise the data would have to be queued until the client's next request is received. Most web servers offer this functionality via CGI (e.g. Non-Parsed Headers scripts on Apache).
Another mechanism is related to a special MIME type calledmultipart/x-mixed-replace, which was introduced by Netscape in 1995. Web browsers would interpret this as a document changing whenever the server felt like pushing a new version to the client.[1] It is still supported by Firefox, Opera and Safari today, but ignored by Internet Explorer.[2] It can be applied to HTML documents, but also for streaming images in webcam applications.
The WHATWG Web Applications 1.0 proposal[3] included a mechanism to push content to the client. On September 1, 2006, the Opera web browser implemented this new experimental technology in a feature called "Server-Sent Events."[4][5] It is now being standardized as part of HTML5.[6] Another related part of HTML5 is the WebSockets API, which allows a web server and client to communicate over a full-duplex TCP connection.
(i) "JPEGVideoRTPSink", which will be fed by
(ii) a *subclass* of "JPEGVideoSource".
> cd live > ./genMakefiles armlinux > make
... ... ...
typedef struct _CirclePrivate CirclePrivate;
... ... ...
struct _Circle
{
Shape parent;
CirclePrivate* priv;
};
struct _CircleClass
{
ShapeClass parent;
};
... ... ...
void circle_set_radius(Circle* circle, guint radius);
guint circle_get_radius(Circle* circle);
... ... ...
int main(int argc, char** argv)
{
Rectangle* rect;
Circle* circle;
g_type_init();
rect = rectangle_new(4, 5);
g_print("Area of Rectangle(0x%08x) is %u.\n",
(guint)rect, shape_calculate_area(SHAPE(rect)));
rectangle_free(rect);
circle = circle_new(6);
g_print("Area of Circle(0x%08x) is %u.\n",
(guint)circle, shape_calculate_area(SHAPE(circle)));
circle_free(circle);
return 0;
}
... ... ... ...
void rectangle_free(Rectangle* rect)
{
g_assert(rect != NULL);
g_return_if_fail(IS_RECTANGLE(rect));
g_object_unref(G_OBJECT(rect));
}
... ... ... ...
void circle_free(Circle* circle)
{
g_assert(circle != NULL);
g_return_if_fail(IS_CIRCLE(circle));
g_object_unref(G_OBJECT(circle));
}
... ... ... ...
其中，rectangle_free()與circle_free()都包裝了g_object_unref()，在本例中這僅僅是吾人為了符合C programming language的使用慣例。如果去深入追蹤GTK或是GStreamer的原始碼，可以發現程式碼中對g_object_unref()之直接呼叫。若今日系統欲搭配其他函式庫可以試著變更如下，以配合其他函式庫的使用慣例。int main(int argc, char** argv)
{
Rectangle* rect;
Circle* circle;
g_type_init();
rect = rectangle_new(4, 5);
g_print("Area of Rectangle(0x%08x) is %u.\n",
(guint)rect, shape_calculate_area(SHAPE(rect)));
g_object_unref(G_OBJECT(rect));
circle = circle_new(6);
g_print("Area of Circle(0x%08x) is %u.\n",
(guint)circle, shape_calculate_area(SHAPE(circle)));
g_object_unref(G_OBJECT(circle));
return 0;
}
值得一提的是，GObject system的實作方式有時會讓C programming language編譯時期(compilation time)的型別檢定(type checking)無法運作，導致編譯器(compiler)抱怨連連，你可以選擇忽略或是強制轉型(type casting)以滿足編譯器的型別檢查機制。OnceGObject物件之解構g_object_newhas obtained a reference to an initialized class structure, it invokes its constructor method to create an instance of the new object. Since it has just been overridden bymaman_bar_class_inittomaman_bar_constructor, the latter is called and, because it was implemented correctly, it chains up to its parent's constructor. In order to find the parent class and chain up to the parent class constructor, we can use themaman_bar_parent_classpointer that has been set up for us by theG_DEFINE_TYPEmacro.
Finally, at one point or another,g_object_constructoris invoked by the last constructor in the chain. This function allocates the object's instance' buffer throughg_type_create_instancewhich means that the instance_init function is invoked at this point if one was registered. After instance_init returns, the object is fully initialized and should be ready to answer any user-request. Wheng_type_create_instancereturns,g_object_constructorsets the construction properties (i.e. the properties which were given tog_object_new) and returns to the user's constructor which is then allowed to do useful instance initialization...
... the first phase, executed in the dispose handler is supposed to release all references to other member objects. The second phase, executed by the finalize handler is supposed to complete the object's destruction process. Object methods should be able to run without program error (that is, without segfault :) in-between the two phases.關於上面的敘述，直接參考官方文件上的範例就可一目了然。
... ... ... ...
static void maman_bar_dispose(GObject *gobject)
{
MamanBar *self = MAMAN_BAR (gobject);
/*
* In dispose, you are supposed to free all types referenced from this
* object which might themselves hold a reference to self. Generally,
* the most simple solution is to unref all members on which you own a
* reference.
*/
/* dispose might be called multiple times, so we must guard against
* calling g_object_unref() on an invalid GObject.
*/
if (self->priv->an_object)
{
g_object_unref (self->priv->an_object);
self->priv->an_object = NULL;
}
/* Chain up to the parent class */
G_OBJECT_CLASS (maman_bar_parent_class)->dispose (gobject);
}
static void maman_bar_finalize(GObject *gobject)
{
MamanBar *self = MAMAN_BAR (gobject);
g_free (self->priv->a_string);
/* Chain up to the parent class */
G_OBJECT_CLASS (maman_bar_parent_class)->finalize (gobject);
}
... ... ... ...
... ... ... ...
static gpointer circle_parent_class = NULL;
... ... ... ...
static void circle_class_init(CircleClass* klass)
{
g_print("Circle(0x%08x)::class::initialize\n", (guint)klass);
circle_parent_class = g_type_class_peek_parent(klass);
G_OBJECT_CLASS(klass)->constructor = circle_constructor;
G_OBJECT_CLASS(klass)->dispose = circle_dispose;
G_OBJECT_CLASS(klass)->finalize = circle_finalize;
SHAPE_CLASS(klass)->calculateArea = (void*)circle_calculate_area;
g_type_class_add_private(klass, sizeof(CirclePrivate));
}
static GObject* circle_constructor(GType gtype,
guint n_properties,
GObjectConstructParam* properties)
{
GObject* object;
{
/* Always chain up to the parent constructor */
object = G_OBJECT_CLASS(circle_parent_class)->constructor(gtype,
n_properties,
properties);
}
/* update the object state depending on constructor properties */
g_print("Circle(0x%08x)::constructor\n", (guint)object);
return object;
}
static void circle_dispose(GObject* object)
{
g_print("Circle(0x%08x)::dispose\n", (guint)object);
/* Chain up to the parent class */
G_OBJECT_CLASS(circle_parent_class)->dispose(object);
}
static void circle_finalize(GObject* object)
{
g_print("Circle(0x%08x)::finalize\n", (guint)object);
/* Chain up to the parent class */
G_OBJECT_CLASS(circle_parent_class)->finalize(object);
}
... ... ... ...
#ifndef __GOBJECT_TEST_RECTANGLE_CLASS_INCLUDED__
#define __GOBJECT_TEST_RECTANGLE_CLASS_INCLUDED__
#include <glib-object.h>
#include "shape.h"
G_BEGIN_DECLS
#define RECTANGLE_TYPE (rectangle_get_type())
#define IS_RECTANGLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), RECTANGLE_TYPE))
#define RECTANGLE(object) (G_TYPE_CHECK_INSTANCE_CAST((object), RECTANGLE_TYPE, Rectangle))
#define RECTANGLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), RECTANGLE_TYPE, RectangleClass))
#define IS_RECTANGLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), RECTANGLE_TYPE))
#define RECTANGLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), RECTANGLE_TYPE, RectangleClass))
typedef struct _Rectangle Rectangle;
typedef struct _RectangleClass RectangleClass;
typedef struct _RectanglePrivate RectanglePrivate;
struct _Rectangle
{
Shape parent;
RectanglePrivate* priv;
};
struct _RectangleClass
{
ShapeClass parent;
};
GType rectangle_get_type();
Rectangle* rectangle_new(guint width, guint height);
void rectangle_free(Rectangle* rect);
void rectangle_set_width(Rectangle* rect, guint width);
void rectangle_set_height(Rectangle* rect, guint height);
guint rectangle_get_width(Rectangle* rect);
guint rectangle_get_height(Rectangle* rect);
G_END_DECLS
#endif /* __GOBJECT_TEST_RECTANGLE_CLASS_INCLUDED__ */
rectangle.c#include "rectangle.h"
struct _RectanglePrivate
{
guint width;
guint height;
};
#define RECTANGLE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj), \
RECTANGLE_TYPE, RectanglePrivate))
static void rectangle_base_init(RectangleClass* klass);
static void rectangle_base_finalize(RectangleClass* klass);
static void rectangle_class_init(RectangleClass* klass);
static void rectangle_init(Rectangle* rect);
static guint rectangle_calculate_area(Rectangle* self);
GType rectangle_get_type()
{
static GType type = 0;
if (type == 0) {
static const GTypeInfo info = {
sizeof(RectangleClass),
(GBaseInitFunc)rectangle_base_init,
(GBaseFinalizeFunc)rectangle_base_finalize,
(GClassInitFunc)rectangle_class_init,
NULL,
NULL,
sizeof(Rectangle),
0,
(GInstanceInitFunc)rectangle_init,
NULL
};
type = g_type_register_static(SHAPE_TYPE, "Rectangle", &info, 0);
}
return type;
}
static void rectangle_base_init(RectangleClass* klass)
{
g_print("Rectangle(0x%08x)::base::initialize\n", (guint)klass);
}
static void rectangle_base_finalize(RectangleClass* klass)
{
g_print("Rectangle(0x%08x)::base::finalize\n", (guint)klass);
}
static void rectangle_class_init(RectangleClass* klass)
{
g_print("Rectangle(0x%08x)::class::initialize\n", (guint)klass);
SHAPE_CLASS(klass)->calculateArea = (void*)rectangle_calculate_area;
g_type_class_add_private(klass, sizeof(RectanglePrivate));
}
static void rectangle_init(Rectangle* self)
{
RectanglePrivate* priv;
g_print("Rectangle(0x%08x)::instance::initialize\n", (guint)self);
self->priv = priv = RECTANGLE_GET_PRIVATE(self);
priv->width = 0;
priv->height = 0;
}
Rectangle* rectangle_new(guint width, guint height)
{
Rectangle* rect;
rect = g_object_new(RECTANGLE_TYPE, NULL);
g_assert(rect != NULL);
rect->priv->width = width;
rect->priv->height = height;
g_print("Rectangle(0x%08x, %ux%u) is created.\n",
(guint)rect, rect->priv->width, rect->priv->height);
return rect;
}
void rectangle_free(Rectangle* rect)
{
g_assert(rect != NULL);
g_return_if_fail(IS_RECTANGLE(rect));
g_object_unref(G_OBJECT(rect));
}
static guint rectangle_calculate_area(Rectangle* self)
{
g_print("Rectangle(0x%08x)::calculateArea\n", (guint)self);
return self->priv->width * self->priv->height;
}
void rectangle_set_width(Rectangle* rect, guint width)
{
g_return_if_fail(IS_RECTANGLE(rect));
rect->priv->width = width;
}
void rectangle_set_height(Rectangle* rect, guint height)
{
g_return_if_fail(IS_RECTANGLE(rect));
rect->priv->height = height;
}
guint rectangle_get_width(Rectangle* rect)
{
g_assert(IS_RECTANGLE(rect));
return rect->priv->width;
}
guint rectangle_get_height(Rectangle* rect)
{
g_assert(IS_RECTANGLE(rect));
return rect->priv->height;
}
Circle型別宣告如下：#ifndef __GOBJECT_TEST_CIRCLE_CLASS_INCLUDED__
#define __GOBJECT_TEST_CIRCLE_CLASS_INCLUDED__
#include <glib-object.h>
#include "shape.h"
G_BEGIN_DECLS
#define CIRCLE_TYPE (circle_get_type())
#define IS_CIRCLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), CIRCLE_TYPE))
#define CIRCLE(object) (G_TYPE_CHECK_INSTANCE_CAST((object), CIRCLE_TYPE, Circle))
#define CIRCLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), CIRCLE_TYPE, CircleClass))
#define IS_CIRCLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), CIRCLE_TYPE))
#define CIRCLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), CIRCLE_TYPE, CircleClass))
typedef struct _Circle Circle;
typedef struct _CircleClass CircleClass;
typedef struct _CirclePrivate CirclePrivate;
struct _Circle
{
Shape parent;
CirclePrivate* priv;
};
struct _CircleClass
{
ShapeClass parent;
};
GType circle_get_type();
Circle* circle_new(guint radius);
void circle_free(Circle* circle);
void rectangle_set_radius(Circle* circle, guint radius);
guint rectangle_get_radius(Circle* circle);
G_END_DECLS
#endif /* __GOBJECT_TEST_CIRCLE_CLASS_INCLUDED__ */
#include "circle.h"
struct _CirclePrivate
{
guint radius;
};
#define CIRCLE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj), \
CIRCLE_TYPE, CirclePrivate))
static void circle_base_init(CircleClass* klass);
static void circle_base_finalize(CircleClass* klass);
static void circle_class_init(CircleClass* klass);
static void circle_init(Circle* circle);
static guint circle_calculate_area(Circle* self);
GType circle_get_type()
{
static GType type = 0;
if (type == 0) {
static const GTypeInfo info = {
sizeof(CircleClass),
(GBaseInitFunc)circle_base_init,
(GBaseFinalizeFunc)circle_base_finalize,
(GClassInitFunc)circle_class_init,
NULL,
NULL,
sizeof(Circle),
0,
(GInstanceInitFunc)circle_init,
NULL
};
type = g_type_register_static(SHAPE_TYPE, "Circle", &info, 0);
}
return type;
}
static void circle_base_init(CircleClass* klass)
{
g_print("Circle(0x%08x)::base::initialize\n", (guint)klass);
}
static void circle_base_finalize(CircleClass* klass)
{
g_print("Circle(0x%08x)::base::finalize\n", (guint)klass);
}
static void circle_class_init(CircleClass* klass)
{
g_print("Circle(0x%08x)::class::initialize\n", (guint)klass);
SHAPE_CLASS(klass)->calculateArea = (void*)circle_calculate_area;
g_type_class_add_private(klass, sizeof(CirclePrivate));
}
static void circle_init(Circle* self)
{
CirclePrivate* priv;
g_print("Circle(0x%08x)::instance::initialize\n", (guint)self);
self->priv = priv = CIRCLE_GET_PRIVATE(self);
priv->radius = 0;
}
Circle* circle_new(guint radius)
{
Circle* circle;
circle = g_object_new(CIRCLE_TYPE, NULL);
g_assert(circle != NULL);
circle->priv->radius = radius;
g_print("Circle(0x%08x, r=%u) is created.\n",
(guint)circle, circle->priv->radius);
return circle;
}
void circle_free(Circle* circle)
{
g_assert(circle != NULL);
g_return_if_fail(IS_CIRCLE(circle));
g_object_unref(G_OBJECT(circle));
}
static guint circle_calculate_area(Circle* self)
{
g_print("Circle(0x%08x)::calculateArea\n", (guint)self);
return self->priv->radius * self->priv->radius * 3;
}
void circle_set_radius(Circle* circle, guint radius)
{
g_return_if_fail(IS_CIRCLE(circle));
circle->priv->radius = radius;
}
guint circle_get_width(Circle* circle)
{
g_assert(IS_CIRCLE(circle));
return circle->priv->radius;
}
上面的程式碼有幾個比較值得注意的地方。首先，由於Rectangle與Circle計算面積的方法不同，所以他們都必須覆寫(override)父類別(parent class)的calculateArea()方法。覆寫的最簡單方式就是在型別初始化時就設定正確的函數指標(function pointer)，所以依據上一篇提過的觀念，於GClassInit()被喚起時進行設定是較正確的作法，也是官方文件建議的作法。當然，也可以選擇在GBaseInit()被喚起時設定函數指標(function pointer)，但採取這種方式會增加些許程式碼撰寫的工程，觀念上亦與GObject system的架構略有不符。... ... ... ...
static void circle_class_init(CircleClass* klass)
{
g_print("Circle(0x%08x)::class::initialize\n", (guint)klass);
SHAPE_CLASS(klass)->calculateArea = (void*)circle_calculate_area;
g_type_class_add_private(klass, sizeof(CirclePrivate));
}
... ... ... ...
此外，上面的程式碼亦導入RectanglePrivate與CirclePrivate結構，他們在標頭檔(header file)裡只有宣告沒有實作，這是一個常用的設計手法，透過這種方式，類別的資料內容可以被封裝保護得更完整，缺點是會增加程式撰寫的難度。GObject system建議但並不強迫使用這種作法，如果在類別宣告裡使用此作法，GObject system對類別私有資料的命名慣例為priv(不要使用 private，因為此名稱為C++的關鍵字)。至於私有資料結構的產生，只要於GClassInit時呼叫g_type_class_add_private()，爾後在該型別的物件初始化時期，GObject將自動加以配置；當該物件銷毀時，也會連帶註銷。至於物件可透過G_TYPE_INSTANCE_GET_PRIVATE()取得屬於該私有資料的指標。... ... ... ...
static void circle_class_init(CircleClass* klass)
{
g_print("Circle(0x%08x)::class::initialize\n", (guint)klass);
SHAPE_CLASS(klass)->calculateArea = (void*)circle_calculate_area;
g_type_class_add_private(klass, sizeof(CirclePrivate));
}
static void circle_init(Circle* self)
{
CirclePrivate* priv;
g_print("Circle(0x%08x)::instance::initialize\n", (guint)self);
self->priv = priv = CIRCLE_GET_PRIVATE(self);
priv->radius = 0;
}
... ... ... ...
最後，我們可以增添一個介面叫shape_calculate_area()，針對不同的Sahpe子類別(subclass)呼叫相應的calculateArea()。... ... ... ...
guint shape_calculate_area(Shape* shape)
{
if (!IS_SHAPE(shape)) return 0;
if (SHAPE_GET_CLASS(shape)->calculateArea == NULL) {
g_print("Shape::calculateArea is not implemented\n");
return 0;
}
return SHAPE_GET_CLASS(shape)->calculateArea(shape);
}
... ... ... ...
最後，透過一個簡單的測試程式，確認是否calculateArea()有被正確派送(dispatch)並處理。#include <glib.h>
#include "shape.h"
#include "rectangle.h"
#include "circle.h"
int main(int argc, char** argv)
{
Rectangle* rect;
Circle* circle;
g_type_init();
rect = rectangle_new(4, 5);
g_print("Area of Rectangle(0x%08x) is %u.\n",
(guint)rect, shape_calculate_area(SHAPE(rect)));
rectangle_free(rect);
circle = circle_new(6);
g_print("Area of Circle(0x%08x) is %u.\n",
(guint)circle, shape_calculate_area(SHAPE(circle)));
circle_free(circle);
return 0;
}
測試碼執行結果：
const GTypeInfo *info。struct _GTypeInfo
{
/* interface types, classed types, instantiated types */
guint16 class_size;
GBaseInitFunc base_init;
GBaseFinalizeFunc base_finalize;
/* interface types, classed types, instantiated types */
GClassInitFunc class_init;
GClassFinalizeFunc class_finalize;
gconstpointer class_data;
/* instantiated types */
guint16 instance_size;
guint16 n_preallocs;
GInstanceInitFunc instance_init;
/* value handling */
const GTypeValueTable *value_table;
};
GTypeInfo資料結構涉及了多個callback functions，可謂環環相扣。總的來說，在型別註冊至GObject system後，系統將透過這些callback functions來管理類別及物件的生命週期。在GObject system架構下，物件自產生至銷毀其流程大致可分為幾個步驟： |
| Figure#1 Life cycle of a object |
 |
| Figure#2 Callback functions involved in the life cycle of a object |
#include <glib.h>
#include "shape.h"
int main(int argc, char** argv)
{
Shape* shape1;
Shape* shape2;
g_type_init();
shape1 = g_object_new(SHAPE_TYPE, NULL);
g_print("shape1(0x%08x) is created.\n", (guint)shape1);
g_object_unref(shape1);
shape2 = g_object_new(SHAPE_TYPE, NULL);
g_print("shape2(0x%08x) is created.\n", (guint)shape2);
g_object_unref(shape2);
return 0;
}
Finally, at one point or another,官方文件上的文字描述實在令人有點霧裡看花的感覺，但是實際上的概念並不複雜，之後將有完整範例展示。g_object_constructoris invoked by the last constructor in the chain. This function allocates the object's instance' buffer throughg_type_create_instancewhich means that the instance_init function is invoked at this point if one was registered. After instance_init returns, the object is fully initialized and should be ready to answer any user-request. Wheng_type_create_instancereturns,g_object_constructorsets the construction properties (i.e. the properties which were given tog_object_new) and returns to the user's constructor which is then allowed to do useful instance initialization...
 |
| figure-01: Class diagram of the simple shape system |
 |
| figure-02: Composition of a typical object of GObject |
typedef struct _Shape Shape;
typedef struct _ShapeClass ShapeClass;
struct _Shape
{
GObject parent;
};
struct _ShapeClass
{
GObjectClass parent;
guint (*calculateArea)(Shape* shape);
};
struct _Shape裡面宣告的是Shape物件的資料內容，也就是上圖所說的instance data，因為Shape並無父類別(parent class)，所以在此需要將它的父類別宣告為GObject，而在Shape物件的資料宣告中也要將其放入。注意，不管是metadata或是instance data的宣告，都要將其相對的parent宣告擺在第一個位置。Shape的公共函式(public function)宣告於ShapeClass中。順帶一提的是，可以將struct _Shape定義為Shape，還有把struct _ShapeClass定義為ShapeClass，此乃GObject的命名慣例。#define SHAPE_TYPE (shape_get_type())
typedef struct _Shape Shape;
typedef struct _ShapeClass ShapeClass;
struct _Shape
{
GObject parent;
};
struct _ShapeClass
{
GObjectClass parent;
guint (*calculateArea)(Shape* shape);
};
GType shape_get_type();
static void shape_base_init(ShapeClass* self);
static void shape_base_finalize(ShapeClass* self);
static void shape_class_init(ShapeClass* self);
GType shape_get_type()
{
static GType type = 0;
if (type == 0) {
static const GTypeInfo info = {
sizeof(ShapeClass),
(GBaseInitFunc)shape_base_init,
(GBaseFinalizeFunc)shape_base_finalize,
(GClassInitFunc)shape_class_init,
NULL,
NULL,
sizeof(Shape),
0,
NULL,
NULL
};
type = g_type_register_static(G_TYPE_OBJECT, "Shape", &info, 0);
}
return type;
}
static void shape_base_init(ShapeClass* self)
{
g_print("Shape(0x%08x)::base::initialize\n", (guint)self);
}
static void shape_base_finalize(ShapeClass* self)
{
g_print("Shape(0x%08x)::base::finalize\n", (guint)self);
}
static void shape_class_init(ShapeClass* klass)
{
g_print("Shape(0x%08x)::class::initialize\n", (guint)klass);
klass->calculateArea = NULL;
}
我們可以發現光要註冊型別就讓原始碼爆增不少，不過仔細觀察可以發現這些原始碼主要是圍繞著g_type_register_static，透過g_type_register_static可向GObject註冊取得型別代碼。之後，就可以由g_object_new產生隸屬該型別之物件。其中，由實作者提供之shape_base_init、shape_base_finalize、shape_class_init乃是供GObject system於管理物件生命週期時使用。使用法將於下篇文章探討。#define IS_SHAPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), SHAPE_TYPE))
#define SHAPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), SHAPE_TYPE, ShapeClass))
struct _Shape
{
GObject parent;
};
struct _ShapeClass
{
GObjectClass parent;
guint (*calculateArea)(Shape* shape);
};
GType shape_get_type();
guint shape_calculate_area(Shape* shape);
...
guint shape_calculate_area(Shape* shape)
{
if (!IS_SHAPE(shape)) return 0;
if (SHAPE_GET_CLASS(shape)->calculateArea == NULL) {
g_print("Shape::calculateArea is not implemented\n");
return 0;
}
return SHAPE_GET_CLASS(shape)->calculateArea(shape);
}
...
由於，calculateArea()是虛擬函數，在此GObject system透過函式指標的方式，達成子類別覆寫(override)的效果。shape_calculate_area()提供一個封裝過的介面，隱藏許多實作上的細節，這也是GObject systeme官方建議的作法。