Default page

Your IP: 216.73.216.10
Server IP: 157.245.101.34
Server: Linux skvinfotech-website 5.4.0-131-generic #147-Ubuntu SMP Fri Oct 14 17:07:22 UTC 2022 x86_64
Server Software: Apache/2.4.41 (Ubuntu)
PHP Version: 7.4.33
Buat File | Buat Folder

Dir : ~/proc/self/root/usr/share/gtk-doc/html/gobject/

Edit File: howto-gobject-methods.html

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Object methods: GObject Reference Manual</title>
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="index.html" title="GObject Reference Manual">
<link rel="up" href="howto-gobject.html" title="How to define and implement a new GObject">
<link rel="prev" href="howto-gobject-destruction.html" title="Object destruction">
<link rel="next" href="howto-gobject-chainup.html" title="Chaining up">
<meta name="generator" content="GTK-Doc V1.32 (XML mode)">
<link rel="stylesheet" href="style.css" type="text/css">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table class="navigation" id="top" width="100%" summary="Navigation header" cellpadding="2" cellspacing="5"><tr valign="middle">
<td width="100%" align="left" class="shortcuts"></td>
<td><a accesskey="h" href="index.html"><img src="home.png" width="16" height="16" border="0" alt="Home"></a></td>
<td><a accesskey="u" href="howto-gobject.html"><img src="up.png" width="16" height="16" border="0" alt="Up"></a></td>
<td><a accesskey="p" href="howto-gobject-destruction.html"><img src="left.png" width="16" height="16" border="0" alt="Prev"></a></td>
<td><a accesskey="n" href="howto-gobject-chainup.html"><img src="right.png" width="16" height="16" border="0" alt="Next"></a></td>
</tr></table>
<div class="sect1">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="howto-gobject-methods"></a>Object methods</h2></div></div></div>

 Just as with C++, there are many different ways to define object
 methods and extend them: the following list and sections draw on
 C++ vocabulary. (Readers are expected to know basic C++ concepts.
 Those who have not had to write C++ code recently can refer to e.g.
 <a class="ulink" href="http://www.cplusplus.com/doc/tutorial/" target="_top">http://www.cplusplus.com/doc/tutorial/</a> to refresh
 their memories.)
 
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
 non-virtual public methods,
 </li>
<li class="listitem">
 virtual public methods and
 </li>
<li class="listitem">
 virtual private methods
 </li>
</ul></div>

 
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="non-virtual-public-methods"></a>Non-virtual public methods</h3></div></div></div>

 These are the simplest, providing a simple method which
 acts on the object. Provide a function
 prototype in the header and an implementation of that prototype
 in the source file.

<div class="informalexample">
 <table class="listing_frame" border="0" cellpadding="0" cellspacing="0">
 <tbody>
 <tr>
 <td class="listing_lines" align="right"><pre>1
2
3
4
5
6
7
8
9
10
11
12
13
14</pre></td>
 <td class="listing_code"><pre class="programlisting">/* declaration in the header. */
void viewer_file_open (ViewerFile *self,
 GError **error);

/* implementation in the source file */
void
viewer_file_open (ViewerFile *self,
 GError **error)
{
 g_return_if_fail (VIEWER_IS_FILE (self));
 g_return_if_fail (error == NULL || *error == NULL);

/* do stuff here. */
}</pre></td>
 </tr>
 </tbody>
 </table>
</div>

</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="virtual-public-methods"></a>Virtual public methods</h3></div></div></div>

 This is the preferred way to create GObjects with overridable methods:
 
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
 Define the common method and its virtual function in the
 class structure in the public header
 </li>
<li class="listitem">
 Define the common method in the header file and implement it in the
 source file
 </li>
<li class="listitem">
 Implement a base version of the virtual function in the source
 file and initialize the virtual function pointer to this
 implementation in the object’s <code class="function">class_init</code>
 function; or leave it as <code class="constant">NULL</code> for a ‘pure
 virtual’ method which must be overridden by derived classes
 </li>
<li class="listitem">
 Re-implement the virtual function in each derived class which needs
 to override it
 </li>
</ul></div>

 

 Note that virtual functions can only be defined if the class is
 derivable, declared using
 <a class="link" href="gobject-Type-Information.html#G-DECLARE-DERIVABLE-TYPE:CAPS" title="G_DECLARE_DERIVABLE_TYPE()"><code class="function">G_DECLARE_DERIVABLE_TYPE</code></a>
 so the class structure can be defined.

<div class="informalexample">
 <table class="listing_frame" border="0" cellpadding="0" cellspacing="0">
 <tbody>
 <tr>
 <td class="listing_lines" align="right"><pre>1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35</pre></td>
 <td class="listing_code"><pre class="programlisting">/* declaration in viewer-file.h. */
#define VIEWER_TYPE_FILE viewer_file_get_type ()
G_DECLARE_DERIVABLE_TYPE (ViewerFile, viewer_file, VIEWER, FILE, GObject)

struct _ViewerFileClass
{
 GObjectClass parent_class;

/* stuff */
 void (*open) (ViewerFile *self,
 GError **error);

/* Padding to allow adding up to 12 new virtual functions without
 * breaking ABI. */
 gpointer padding[12];
};

void viewer_file_open (ViewerFile *self,
 GError **error);

/* implementation in viewer-file.c */
void
viewer_file_open (ViewerFile *self,
 GError **error)
{
 ViewerFileClass *klass;

g_return_if_fail (VIEWER_IS_FILE (self));
 g_return_if_fail (error == NULL || *error == NULL);

klass = VIEWER_FILE_GET_CLASS (self);
 g_return_if_fail (klass->open != NULL);

klass->open (self, error);
}</pre></td>
 </tr>
 </tbody>
 </table>
</div>

The code above simply redirects the <code class="function">open</code> call
 to the relevant virtual function.
 

 It is possible to provide a default
 implementation for this class method in the object's
 <code class="function">class_init</code> function: initialize the
 <code class="function">klass->open</code> field to a pointer to the
 actual implementation.
 By default, class methods that are not inherited are initialized to
 <code class="function">NULL</code>, and thus are to be considered "pure virtual".

<div class="informalexample">
 <table class="listing_frame" border="0" cellpadding="0" cellspacing="0">
 <tbody>
 <tr>
 <td class="listing_lines" align="right"><pre>1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53</pre></td>
 <td class="listing_code"><pre class="programlisting">static void
viewer_file_real_close (ViewerFile *self,
 GError **error)
{
 /* Default implementation for the virtual method. */
}

static void
viewer_file_class_init (ViewerFileClass *klass)
{
 /* this is not necessary, except for demonstration purposes.
 *
 * pure virtual method: mandates implementation in children.
 */
 klass->open = NULL;

/* merely virtual method. */
 klass->close = viewer_file_real_close;
}

void
viewer_file_open (ViewerFile *self,
 GError **error)
{
 ViewerFileClass *klass;

g_return_if_fail (VIEWER_IS_FILE (self));
 g_return_if_fail (error == NULL || *error == NULL);

klass = VIEWER_FILE_GET_CLASS (self);

/* if the method is purely virtual, then it is a good idea to
 * check that it has been overridden before calling it, and,
 * depending on the intent of the class, either ignore it silently
 * or warn the user.
 */
 g_return_if_fail (klass->open != NULL);
 klass->open (self, error);
}

void
viewer_file_close (ViewerFile *self,
 GError **error)
{
 ViewerFileClass *klass;

g_return_if_fail (VIEWER_IS_FILE (self));
 g_return_if_fail (error == NULL || *error == NULL);

klass = VIEWER_FILE_GET_CLASS (self);
 if (klass->close != NULL)
 klass->close (self, error);
}</pre></td>
 </tr>
 </tbody>
 </table>
</div>

</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="virtual-private-methods"></a>Virtual private Methods</h3></div></div></div>

 These are very similar to <a class="link" href="howto-gobject-methods.html#virtual-public-methods" title="Virtual public methods">virtual
 public methods</a>. They just don't
 have a public function to call directly. The header
 file contains only a declaration of the virtual function:

<div class="informalexample">
 <table class="listing_frame" border="0" cellpadding="0" cellspacing="0">
 <tbody>
 <tr>
 <td class="listing_lines" align="right"><pre>1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19</pre></td>
 <td class="listing_code"><pre class="programlisting">/* declaration in viewer-file.h. */
struct _ViewerFileClass
{
 GObjectClass parent;

/* Public virtual method as before. */
 void (*open) (ViewerFile *self,
 GError **error);

/* Private helper function to work out whether the file can be loaded via
 * memory mapped I/O, or whether it has to be read as a stream. */
 gboolean (*can_memory_map) (ViewerFile *self);

/* Padding to allow adding up to 12 new virtual functions without
 * breaking ABI. */
 gpointer padding[12];
};

void viewer_file_open (ViewerFile *self, GError **error);</pre></td>
 </tr>
 </tbody>
 </table>
</div>

These virtual functions are often used to delegate part of the job
 to child classes:

<div class="informalexample">
 <table class="listing_frame" border="0" cellpadding="0" cellspacing="0">
 <tbody>
 <tr>
 <td class="listing_lines" align="right"><pre>1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27</pre></td>
 <td class="listing_code"><pre class="programlisting">/* this accessor function is static: it is not exported outside of this file. */
static gboolean 
viewer_file_can_memory_map (ViewerFile *self)
{
 return VIEWER_FILE_GET_CLASS (self)->can_memory_map (self);
}

void
viewer_file_open (ViewerFile *self,
 GError **error)
{
 g_return_if_fail (VIEWER_IS_FILE (self));
 g_return_if_fail (error == NULL || *error == NULL);

/*
 * Try to load the file using memory mapped I/O, if the implementation of the
 * class determines that is possible using its private virtual method.
 */
 if (viewer_file_can_memory_map (self))
 {
 /* Load the file using memory mapped I/O. */
 }
 else
 {
 /* Fall back to trying to load the file using streaming I/O… */
 }
}</pre></td>
 </tr>
 </tbody>
 </table>
</div>

Again, it is possible to provide a default implementation for this
 private virtual function:

<div class="informalexample">
 <table class="listing_frame" border="0" cellpadding="0" cellspacing="0">
 <tbody>
 <tr>
 <td class="listing_lines" align="right"><pre>1
2
3
4
5
6
7
8
9
10
11
12
13
14</pre></td>
 <td class="listing_code"><pre class="programlisting">static gboolean
viewer_file_real_can_memory_map (ViewerFile *self)
{
 /* As an example, always return false. Or, potentially return true if the
 * file is local. */
 return FALSE;
}

static void
viewer_file_class_init (ViewerFileClass *klass)
{
 /* non-pure virtual method; does not have to be implemented in children. */
 klass->can_memory_map = viewer_file_real_can_memory_map;
}</pre></td>
 </tr>
 </tbody>
 </table>
</div>

Derived classes can then override the method with code such as:

<div class="informalexample">
 <table class="listing_frame" border="0" cellpadding="0" cellspacing="0">
 <tbody>
 <tr>
 <td class="listing_lines" align="right"><pre>1
2
3
4
5
6
7
8</pre></td>
 <td class="listing_code"><pre class="programlisting">static void
viewer_audio_file_class_init (ViewerAudioFileClass *klass)
{
 ViewerFileClass *file_class = VIEWER_FILE_CLASS (klass);

/* implement pure virtual function. */
 file_class->can_memory_map = viewer_audio_file_can_memory_map;
}</pre></td>
 </tr>
 </tbody>
 </table>
</div>

</div>
</div>
<div class="footer">
<hr>Generated by GTK-Doc V1.32</div>
</body>
</html>