src/parsec/disk-image/parsec/parsec-benchmark/pkgs/libs/glib/src/docs/reference/gobject/html/howto-gobject-chainup.html - public/gem5-resources - Git at Google

 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <title>Chaining up</title>
 <meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
 <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-methods.html" title="Object methods">
 <link rel="next" href="howto-interface.html" title="How to define and implement interfaces">
 <meta name="generator" content="GTK-Doc V1.14 (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="2"><tr valign="middle">
 <td><a accesskey="p" href="howto-gobject-methods.html"><img src="left.png" width="24" height="24" border="0" alt="Prev"></a></td>
 <td><a accesskey="u" href="howto-gobject.html"><img src="up.png" width="24" height="24" border="0" alt="Up"></a></td>
 <td><a accesskey="h" href="index.html"><img src="home.png" width="24" height="24" border="0" alt="Home"></a></td>
 <th width="100%" align="center">GObject Reference Manual</th>
 <td><a accesskey="n" href="howto-interface.html"><img src="right.png" width="24" height="24" border="0" alt="Next"></a></td>
 </tr></table>
 <div class="sect1" title="Chaining up">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="howto-gobject-chainup"></a>Chaining up</h2></div></div></div>
 <p>Chaining up is often loosely defined by the following set of
     conditions:
       </p>
 <div class="itemizedlist"><ul class="itemizedlist" type="disc">
 <li class="listitem"><p>Parent class A defines a public virtual method named <code class="function">foo</code> and
         provides a default implementation.</p></li>
 <li class="listitem"><p>Child class B re-implements method <code class="function">foo</code>.</p></li>
 <li class="listitem"><p>In the method B::foo, the child class B calls its parent class method A::foo.</p></li>
 </ul></div>
 <p>
       There are many uses to this idiom:
       </p>
 <div class="itemizedlist"><ul class="itemizedlist" type="disc">
 <li class="listitem"><p>You need to change the behaviour of a class without modifying its code. You create
           a subclass to inherit its implementation, re-implement a public virtual method to modify the behaviour
           slightly and chain up to ensure that the previous behaviour is not really modified, just extended.
           </p></li>
 <li class="listitem"><p>You are lazy, you have access to the source code of the parent class but you don't want
           to modify it to add method calls to new specialized method calls: it is faster to hack the child class
           to chain up than to modify the parent to call down.</p></li>
 <li class="listitem"><p>You need to implement the Chain Of Responsibility pattern: each object of the inheritance
           tree chains up to its parent (typically, at the beginning or the end of the method) to ensure that
           they each handler is run in turn.</p></li>
 </ul></div>
 <p>
       I am personally not really convinced any of the last two uses are really a good idea but since this
       programming idiom is often used, this section attempts to explain how to implement it.
     </p>
 <p>
       To explicitly chain up to the implementation of the virtual method in the parent class,
       you first need a handle to the original parent class structure. This pointer can then be used to
       access the original class function pointer and invoke it directly.
       <sup>[<a name="id637346" href="#ftn.id637346" class="footnote">11</a>]</sup>
     </p>
 <p>The function <code class="function"><a class="link" href="gobject-Type-Information.html#g-type-class-peek-parent" title="g_type_class_peek_parent ()">g_type_class_peek_parent</a></code> is used to access the original parent
     class structure. Its input is a pointer to the class of the derived object and it returns a pointer
     to the original parent class structure. The code below shows how you could use it:
 </p>
 <pre class="programlisting">
 static void
 b_method_to_call (B *obj, int a)
 {
   BClass *klass;
   AClass *parent_class;

   klass = B_GET_CLASS (obj);
   parent_class = g_type_class_peek_parent (klass);

   /* do stuff before chain up */

   parent_class-&gt;method_to_call (obj, a);

   /* do stuff after chain up */
 }
 </pre>
 <p>
   </p>
 <div class="footnotes">
 <br><hr width="100" align="left">
 <div class="footnote"><p><sup>[<a name="ftn.id637346" href="#id637346" class="para">11</a>] </sup>
           The <span class="emphasis"><em>original</em></span> adjective used in this sentence is not innocuous. To fully
           understand its meaning, you need to recall how class structures are initialized: for each object type,
           the class structure associated to this object is created by first copying the class structure of its
           parent type (a simple <code class="function">memcpy</code>) and then by invoking the class_init callback on
           the resulting class structure. Since the class_init callback is responsible for overwriting the class structure
           with the user re-implementations of the class methods, we cannot merely use the modified copy of the parent class
           structure stored in our derived instance. We want to get a copy of the class structure of an instance of the parent
           class.
         </p></div>
 </div>
 </div>
 <div class="footer">
 <hr>
           Generated by GTK-Doc V1.14</div>
 </body>
 </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>Chaining up</title>
	<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
	<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-methods.html" title="Object methods">
	<link rel="next" href="howto-interface.html" title="How to define and implement interfaces">
	<meta name="generator" content="GTK-Doc V1.14 (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="2"><tr valign="middle">
	<td><a accesskey="p" href="howto-gobject-methods.html"><img src="left.png" width="24" height="24" border="0" alt="Prev"></a></td>
	<td><a accesskey="u" href="howto-gobject.html"><img src="up.png" width="24" height="24" border="0" alt="Up"></a></td>
	<td><a accesskey="h" href="index.html"><img src="home.png" width="24" height="24" border="0" alt="Home"></a></td>
	<th width="100%" align="center">GObject Reference Manual</th>
	<td><a accesskey="n" href="howto-interface.html"><img src="right.png" width="24" height="24" border="0" alt="Next"></a></td>
	</tr></table>
	<div class="sect1" title="Chaining up">
	<div class="titlepage"><div><div><h2 class="title" style="clear: both">
	<a name="howto-gobject-chainup"></a>Chaining up</h2></div></div></div>
	<p>Chaining up is often loosely defined by the following set of
	conditions:
	</p>
	<div class="itemizedlist"><ul class="itemizedlist" type="disc">
	<li class="listitem"><p>Parent class A defines a public virtual method named <code class="function">foo</code> and
	provides a default implementation.</p></li>
	<li class="listitem"><p>Child class B re-implements method <code class="function">foo</code>.</p></li>
	<li class="listitem"><p>In the method B::foo, the child class B calls its parent class method A::foo.</p></li>
	</ul></div>
	<p>
	There are many uses to this idiom:
	</p>
	<div class="itemizedlist"><ul class="itemizedlist" type="disc">
	<li class="listitem"><p>You need to change the behaviour of a class without modifying its code. You create
	a subclass to inherit its implementation, re-implement a public virtual method to modify the behaviour
	slightly and chain up to ensure that the previous behaviour is not really modified, just extended.
	</p></li>
	<li class="listitem"><p>You are lazy, you have access to the source code of the parent class but you don't want
	to modify it to add method calls to new specialized method calls: it is faster to hack the child class
	to chain up than to modify the parent to call down.</p></li>
	<li class="listitem"><p>You need to implement the Chain Of Responsibility pattern: each object of the inheritance
	tree chains up to its parent (typically, at the beginning or the end of the method) to ensure that
	they each handler is run in turn.</p></li>
	</ul></div>
	<p>
	I am personally not really convinced any of the last two uses are really a good idea but since this
	programming idiom is often used, this section attempts to explain how to implement it.
	</p>
	<p>
	To explicitly chain up to the implementation of the virtual method in the parent class,
	you first need a handle to the original parent class structure. This pointer can then be used to
	access the original class function pointer and invoke it directly.
	<sup>[<a name="id637346" href="#ftn.id637346" class="footnote">11</a>]</sup>
	</p>
	<p>The function <code class="function"><a class="link" href="gobject-Type-Information.html#g-type-class-peek-parent" title="g_type_class_peek_parent ()">g_type_class_peek_parent</a></code> is used to access the original parent
	class structure. Its input is a pointer to the class of the derived object and it returns a pointer
	to the original parent class structure. The code below shows how you could use it:
	</p>
	<pre class="programlisting">
	static void
	b_method_to_call (B *obj, int a)
	{
	BClass *klass;
	AClass *parent_class;

	klass = B_GET_CLASS (obj);
	parent_class = g_type_class_peek_parent (klass);

	/* do stuff before chain up */

	parent_class->method_to_call (obj, a);

	/* do stuff after chain up */
	}
	</pre>
	<p>
	</p>
	<div class="footnotes">
	<br><hr width="100" align="left">
	<div class="footnote"><p><sup>[<a name="ftn.id637346" href="#id637346" class="para">11</a>] </sup>
	The <span class="emphasis"><em>original</em></span> adjective used in this sentence is not innocuous. To fully
	understand its meaning, you need to recall how class structures are initialized: for each object type,
	the class structure associated to this object is created by first copying the class structure of its
	parent type (a simple <code class="function">memcpy</code>) and then by invoking the class_init callback on
	the resulting class structure. Since the class_init callback is responsible for overwriting the class structure
	with the user re-implementations of the class methods, we cannot merely use the modified copy of the parent class
	structure stored in our derived instance. We want to get a copy of the class structure of an instance of the parent
	class.
	</p></div>
	</div>
	</div>
	<div class="footer">
	<hr>
	Generated by GTK-Doc V1.14</div>
	</body>
	</html>