Author: buildbot
Date: Mon Jun 1 20:08:06 2015
New Revision: 953474
Log:
Staging update by buildbot for thrift
Added:
websites/staging/thrift/trunk/content/tutorial/c_glib.html
Modified:
websites/staging/thrift/trunk/content/ (props changed)
websites/staging/thrift/trunk/content/sitemap.html
websites/staging/thrift/trunk/content/tutorial/index.html
Propchange: websites/staging/thrift/trunk/content/
------------------------------------------------------------------------------
--- cms:source-revision (original)
+++ cms:source-revision Mon Jun 1 20:08:06 2015
@@ -1 +1 @@
-1681248
+1682986
Modified: websites/staging/thrift/trunk/content/sitemap.html
==============================================================================
--- websites/staging/thrift/trunk/content/sitemap.html (original)
+++ websites/staging/thrift/trunk/content/sitemap.html Mon Jun 1 20:08:06 2015
@@ -135,6 +135,9 @@
<li><a href="/test/keys"></a></li>
<li><a href="/tutorial/">Index of tutorial/</a><ul>
<li><a href="/tutorial/as3">Actionscript 3.0</a></li>
+</ul>
+</li>
+<li><a href="/tutorial/c_glib"></a></li>
<li><a href="/tutorial/cpp">C++</a></li>
<li><a href="/tutorial/csharp">CSharp</a></li>
<li><a href="/tutorial/d">D</a></li>
@@ -152,8 +155,6 @@
<li><a href="/tutorial/py">Python</a></li>
<li><a href="/tutorial/rb">Ruby</a></li>
</ul>
-</li>
-</ul>
</div>
<div class="container">
<hr>
Added: websites/staging/thrift/trunk/content/tutorial/c_glib.html
==============================================================================
--- websites/staging/thrift/trunk/content/tutorial/c_glib.html (added)
+++ websites/staging/thrift/trunk/content/tutorial/c_glib.html Mon Jun 1
20:08:06 2015
@@ -0,0 +1,821 @@
+<!DOCTYPE html>
+<html xmlns="http://www.w3.org/1999/xhtml"; xml:lang="en" lang="en">
+ <head>
+ <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
+ <meta content="en-us" http-equiv="Content-Language" />
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+
+ <link href="/static/images/favicon.ico" rel="shortcut icon" />
+ <link href="/static/css/style.css" rel="stylesheet" type="text/css" />
+ <link href="/static/css/codehilite.css" rel="stylesheet" type="text/css" />
+ <link href="/static/css/bootstrap.css" media="screen, projection"
rel="stylesheet" type="text/css" />
+
+ <script src="/static/js/jquery.min.js"></script>
+ <script src="/static/js/bootstrap-dropdown.js"></script>
+ <script src="/static/js/bootstrap-tab.js"></script>
+
+ <title>Apache Thrift - </title>
+ </head>
+ <body>
+ <div class="navbar">
+ <div class="navbar-inner">
+ <div class="container">
+ <a class="brand" href="/">Apache Thrift ™</a>
+ <div class="nav-collapse">
+ <ul class="nav pull-right">
+ <li>
+ <a href="/download">Download</a>
+ </li>
+ <li>
+ <a
href="/docs">Documentation</a>
+ </li>
+ <li>
+ <a
href="/developers">Developers</a>
+ </li>
+ <li>
+ <a href="/lib">Libraries</a>
+ </li>
+ <li>
+ <a href="/tutorial">Tutorial</a>
+ </li>
+ <li>
+ <a href="/test">Test Suite</a>
+ </li>
+ <li>
+ <a href="/about">About</a>
+ </li>
+ <li class="dropdown">
+ <a href="#"
class="dropdown-toggle" data-toggle="dropdown">
+ Apache <b
class="caret"></b>
+ </a>
+ <ul class="dropdown-menu">
+ <li>
+ <a
href="http://www.apache.org/"; target="_blank">Apache Home</a>
+ </li>
+ <li>
+ <a
href="http://www.apache.org/licenses/"; target="_blank">Apache License v2.0</a>
+ </li>
+ <li>
+ <a
href="http://www.apache.org/foundation/sponsorship.html";
target="_blank">Donate</a>
+ </li>
+ <li>
+ <a
href="http://www.apache.org/foundation/thanks.html"; target="_blank">Thanks</a>
+ </li>
+ <li>
+ <a
href="http://www.apache.org/security/"; target="_blank">Security</a>
+ </li>
+ </ul>
+ </li>
+ </ul>
+ </div>
+ </div>
+ </div>
+</div>
+
+ <div class="container">
+ <h2 id="tutorial">Tutorial</h2>
+<hr />
+<h3 id="introduction">Introduction</h3>
+<p>All Apache Thrift tutorials require that you have:</p>
+<ol>
+<li>Built and installed the Apache Thrift Compiler and Libraries, see <a
href="/docs/BuildingFromSource">Building from source</a> for more details.</li>
+<li>
+<p>Generated the <a
href="https://git-wip-us.apache.org/repos/asf?p=thrift.git;a=blob_plain;f=tutorial/tutorial.thrift";>tutorial.thrift</a>
and <a
href="https://git-wip-us.apache.org/repos/asf?p=thrift.git;a=blob_plain;f=tutorial/shared.thrift";>shared.thrift</a>
files as <a href="/tutorial/">discussed here</a>.</p>
+<div class="codehilite"><pre><span class="n">thrift</span> <span
class="o">-</span><span class="n">r</span> <span class="o">--</span><span
class="n">gen</span> <span class="n">tutorial</span><span
class="p">.</span><span class="n">thrift</span>
+</pre></div>
+
+
+</li>
+<li>
+<p>Followed all prerequisites listed below.</p>
+</li>
+</ol>
+<h3 id="prerequisites">Prerequisites</h3>
+<h3 id="client">Client</h3>
+<div class="codehilite"><pre><span class="cp">#include <stdio.h></span>
+<span class="cp">#include <glib-object.h></span>
+
+<span class="cp">#include
<thrift/c_glib/protocol/thrift_binary_protocol.h></span>
+<span class="cp">#include
<thrift/c_glib/transport/thrift_buffered_transport.h></span>
+<span class="cp">#include
<thrift/c_glib/transport/thrift_socket.h></span>
+
+<span class="cp">#include "gen-c_glib/calculator.h"</span>
+
+<span class="kt">int</span> <span class="nf">main</span> <span
class="p">(</span><span class="kt">void</span><span class="p">)</span>
+<span class="p">{</span>
+ <span class="n">ThriftSocket</span> <span class="o">*</span><span
class="n">socket</span><span class="p">;</span>
+ <span class="n">ThriftTransport</span> <span class="o">*</span><span
class="n">transport</span><span class="p">;</span>
+ <span class="n">ThriftProtocol</span> <span class="o">*</span><span
class="n">protocol</span><span class="p">;</span>
+ <span class="n">CalculatorIf</span> <span class="o">*</span><span
class="n">client</span><span class="p">;</span>
+
+ <span class="n">GError</span> <span class="o">*</span><span
class="n">error</span> <span class="o">=</span> <span
class="nb">NULL</span><span class="p">;</span>
+ <span class="n">InvalidOperation</span> <span class="o">*</span><span
class="n">invalid_operation</span> <span class="o">=</span> <span
class="nb">NULL</span><span class="p">;</span>
+
+ <span class="n">Work</span> <span class="o">*</span><span
class="n">work</span><span class="p">;</span>
+
+ <span class="n">gint32</span> <span class="n">sum</span><span
class="p">;</span>
+ <span class="n">gint32</span> <span class="n">diff</span><span
class="p">;</span>
+
+ <span class="kt">int</span> <span class="n">exit_status</span> <span
class="o">=</span> <span class="mi">0</span><span class="p">;</span>
+
+<span class="cp">#if (!GLIB_CHECK_VERSION (2, 36, 0))</span>
+ <span class="n">g_type_init</span> <span class="p">();</span>
+<span class="cp">#endif</span>
+
+ <span class="n">socket</span> <span class="o">=</span> <span
class="n">g_object_new</span> <span class="p">(</span><span
class="n">THRIFT_TYPE_SOCKET</span><span class="p">,</span>
+ <span class="s">"hostname"</span><span
class="p">,</span> <span class="s">"localhost"</span><span
class="p">,</span>
+ <span class="s">"port"</span><span
class="p">,</span> <span class="mi">9090</span><span class="p">,</span>
+ <span class="nb">NULL</span><span
class="p">);</span>
+ <span class="n">transport</span> <span class="o">=</span> <span
class="n">g_object_new</span> <span class="p">(</span><span
class="n">THRIFT_TYPE_BUFFERED_TRANSPORT</span><span class="p">,</span>
+ <span class="s">"transport"</span><span
class="p">,</span> <span class="n">socket</span><span class="p">,</span>
+ <span class="nb">NULL</span><span
class="p">);</span>
+ <span class="n">protocol</span> <span class="o">=</span> <span
class="n">g_object_new</span> <span class="p">(</span><span
class="n">THRIFT_TYPE_BINARY_PROTOCOL</span><span class="p">,</span>
+ <span class="s">"transport"</span><span
class="p">,</span> <span class="n">transport</span><span class="p">,</span>
+ <span class="nb">NULL</span><span
class="p">);</span>
+
+ <span class="n">thrift_transport_open</span> <span class="p">(</span><span
class="n">transport</span><span class="p">,</span> <span
class="o">&</span><span class="n">error</span><span class="p">);</span>
+
+
+ <span class="cm">/* In the C (GLib) implementation of Thrift, service
methods on the</span>
+<span class="cm"> server are accessed via a generated client class that
implements</span>
+<span class="cm"> the service interface. In this tutorial, we access a
Calculator</span>
+<span class="cm"> service through an instance of CalculatorClient, which
implements</span>
+<span class="cm"> CalculatorIf. */</span>
+ <span class="n">client</span> <span class="o">=</span> <span
class="n">g_object_new</span> <span class="p">(</span><span
class="n">TYPE_CALCULATOR_CLIENT</span><span class="p">,</span>
+ <span
class="s">"input_protocol"</span><span class="p">,</span> <span
class="n">protocol</span><span class="p">,</span>
+ <span
class="s">"output_protocol"</span><span class="p">,</span> <span
class="n">protocol</span><span class="p">,</span>
+ <span class="nb">NULL</span><span class="p">);</span>
+
+ <span class="cm">/* Each of the client methods requires at least two
parameters: A</span>
+<span class="cm"> pointer to the client-interface implementation (the
client</span>
+<span class="cm"> object), and a handle to a GError structure to
receive</span>
+<span class="cm"> information about any error that occurs.</span>
+
+<span class="cm"> On success, client methods return TRUE. A return value
of FALSE</span>
+<span class="cm"> indicates an error occurred and the error parameter has
been</span>
+<span class="cm"> set. */</span>
+ <span class="k">if</span> <span class="p">(</span><span
class="o">!</span><span class="n">error</span> <span
class="o">&&</span> <span class="n">calculator_if_ping</span> <span
class="p">(</span><span class="n">client</span><span class="p">,</span> <span
class="o">&</span><span class="n">error</span><span class="p">))</span>
<span class="p">{</span>
+ <span class="n">puts</span> <span class="p">(</span><span
class="s">"ping()"</span><span class="p">);</span>
+ <span class="p">}</span>
+
+ <span class="cm">/* Service methods that return a value do so by passing the
result</span>
+<span class="cm"> back via an output parameter (here, "sum").
*/</span>
+ <span class="k">if</span> <span class="p">(</span><span
class="o">!</span><span class="n">error</span> <span
class="o">&&</span> <span class="n">calculator_if_add</span> <span
class="p">(</span><span class="n">client</span><span class="p">,</span> <span
class="o">&</span><span class="n">sum</span><span class="p">,</span> <span
class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span
class="p">,</span> <span class="o">&</span><span
class="n">error</span><span class="p">))</span> <span class="p">{</span>
+ <span class="n">printf</span> <span class="p">(</span><span
class="s">"1+1=%d</span><span class="se">\n</span><span
class="s">"</span><span class="p">,</span> <span class="n">sum</span><span
class="p">);</span>
+ <span class="p">}</span>
+
+ <span class="cm">/* Thrift structs are implemented as GObjects, with each of
the</span>
+<span class="cm"> struct's members exposed as an object property.
*/</span>
+ <span class="n">work</span> <span class="o">=</span> <span
class="n">g_object_new</span> <span class="p">(</span><span
class="n">TYPE_WORK</span><span class="p">,</span> <span
class="nb">NULL</span><span class="p">);</span>
+
+ <span class="k">if</span> <span class="p">(</span><span
class="o">!</span><span class="n">error</span><span class="p">)</span> <span
class="p">{</span>
+ <span class="n">g_object_set</span> <span class="p">(</span><span
class="n">work</span><span class="p">,</span>
+ <span class="s">"num1"</span><span
class="p">,</span> <span class="mi">1</span><span class="p">,</span>
+ <span class="s">"num2"</span><span
class="p">,</span> <span class="mi">0</span><span class="p">,</span>
+ <span class="s">"op"</span><span
class="p">,</span> <span class="n">OPERATION_DIVIDE</span><span
class="p">,</span>
+ <span class="nb">NULL</span><span class="p">);</span>
+
+ <span class="cm">/* Exceptions are passed back from service methods in a
manner</span>
+<span class="cm"> similar to return values. */</span>
+ <span class="k">if</span> <span class="p">(</span><span
class="n">calculator_if_calculate</span> <span class="p">(</span><span
class="n">client</span><span class="p">,</span>
+ <span class="nb">NULL</span><span
class="p">,</span>
+ <span class="mi">1</span><span
class="p">,</span>
+ <span class="n">work</span><span
class="p">,</span>
+ <span class="o">&</span><span
class="n">invalid_operation</span><span class="p">,</span>
+ <span class="o">&</span><span
class="n">error</span><span class="p">))</span> <span class="p">{</span>
+ <span class="n">puts</span> <span class="p">(</span><span
class="s">"Whoa? We can divide by zero!"</span><span
class="p">);</span>
+ <span class="p">}</span>
+ <span class="k">else</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="p">(</span><span
class="n">invalid_operation</span><span class="p">)</span> <span
class="p">{</span>
+ <span class="n">gchar</span> <span class="o">*</span><span
class="n">why</span><span class="p">;</span>
+
+ <span class="cm">/* Like structs, exceptions are implemented as
objects with</span>
+<span class="cm"> properties. */</span>
+ <span class="n">g_object_get</span> <span class="p">(</span><span
class="n">invalid_operation</span><span class="p">,</span> <span
class="s">"why"</span><span class="p">,</span> <span
class="o">&</span><span class="n">why</span><span class="p">,</span> <span
class="nb">NULL</span><span class="p">);</span>
+
+ <span class="n">printf</span> <span class="p">(</span><span
class="s">"InvalidOperation: %s</span><span class="se">\n</span><span
class="s">"</span><span class="p">,</span> <span class="n">why</span><span
class="p">);</span>
+
+ <span class="k">if</span> <span class="p">(</span><span
class="n">why</span> <span class="o">!=</span> <span
class="nb">NULL</span><span class="p">)</span>
+ <span class="n">g_free</span> <span class="p">(</span><span
class="n">why</span><span class="p">);</span>
+ <span class="n">g_object_unref</span> <span class="p">(</span><span
class="n">invalid_operation</span><span class="p">);</span>
+ <span class="n">invalid_operation</span> <span class="o">=</span>
<span class="nb">NULL</span><span class="p">;</span>
+ <span class="p">}</span>
+
+ <span class="n">g_clear_error</span> <span class="p">(</span><span
class="o">&</span><span class="n">error</span><span class="p">);</span>
+ <span class="p">}</span>
+ <span class="p">}</span>
+
+ <span class="k">if</span> <span class="p">(</span><span
class="o">!</span><span class="n">error</span><span class="p">)</span> <span
class="p">{</span>
+ <span class="cm">/* Struct objects can be reused across method
invocations. */</span>
+ <span class="n">g_object_set</span> <span class="p">(</span><span
class="n">work</span><span class="p">,</span>
+ <span class="s">"num1"</span><span
class="p">,</span> <span class="mi">15</span><span class="p">,</span>
+ <span class="s">"num2"</span><span
class="p">,</span> <span class="mi">10</span><span class="p">,</span>
+ <span class="s">"op"</span><span
class="p">,</span> <span class="n">OPERATION_SUBTRACT</span><span
class="p">,</span>
+ <span class="nb">NULL</span><span class="p">);</span>
+
+ <span class="k">if</span> <span class="p">(</span><span
class="n">calculator_if_calculate</span> <span class="p">(</span><span
class="n">client</span><span class="p">,</span>
+ <span class="o">&</span><span
class="n">diff</span><span class="p">,</span>
+ <span class="mi">1</span><span
class="p">,</span>
+ <span class="n">work</span><span
class="p">,</span>
+ <span class="o">&</span><span
class="n">invalid_operation</span><span class="p">,</span>
+ <span class="o">&</span><span
class="n">error</span><span class="p">))</span> <span class="p">{</span>
+ <span class="n">printf</span> <span class="p">(</span><span
class="s">"15-10=%d</span><span class="se">\n</span><span
class="s">"</span><span class="p">,</span> <span
class="n">diff</span><span class="p">);</span>
+ <span class="p">}</span>
+ <span class="p">}</span>
+
+ <span class="n">g_object_unref</span> <span class="p">(</span><span
class="n">work</span><span class="p">);</span>
+
+ <span class="k">if</span> <span class="p">(</span><span
class="o">!</span><span class="n">error</span><span class="p">)</span> <span
class="p">{</span>
+ <span class="n">SharedStruct</span> <span class="o">*</span><span
class="n">shared_struct</span><span class="p">;</span>
+ <span class="n">gchar</span> <span class="o">*</span><span
class="n">value</span><span class="p">;</span>
+
+ <span class="n">shared_struct</span> <span class="o">=</span> <span
class="n">g_object_new</span> <span class="p">(</span><span
class="n">TYPE_SHARED_STRUCT</span><span class="p">,</span> <span
class="nb">NULL</span><span class="p">);</span>
+
+ <span class="cm">/* As defined in the Thrift file, the Calculator service
extends</span>
+<span class="cm"> the SharedService service. Correspondingly, in the
generated</span>
+<span class="cm"> code CalculatorIf inherits from SharedServiceIf, and
the parent</span>
+<span class="cm"> service's methods are accessible through a simple
cast. */</span>
+ <span class="k">if</span> <span class="p">(</span><span
class="n">shared_service_client_get_struct</span> <span class="p">(</span><span
class="n">SHARED_SERVICE_IF</span> <span class="p">(</span><span
class="n">client</span><span class="p">),</span>
+ <span class="o">&</span><span
class="n">shared_struct</span><span class="p">,</span>
+ <span class="mi">1</span><span
class="p">,</span>
+ <span class="o">&</span><span
class="n">error</span><span class="p">))</span> <span class="p">{</span>
+ <span class="n">g_object_get</span> <span class="p">(</span><span
class="n">shared_struct</span><span class="p">,</span> <span
class="s">"value"</span><span class="p">,</span> <span
class="o">&</span><span class="n">value</span><span class="p">,</span>
<span class="nb">NULL</span><span class="p">);</span>
+ <span class="n">printf</span> <span class="p">(</span><span
class="s">"Check log: %s</span><span class="se">\n</span><span
class="s">"</span><span class="p">,</span> <span
class="n">value</span><span class="p">);</span>
+ <span class="n">g_free</span> <span class="p">(</span><span
class="n">value</span><span class="p">);</span>
+ <span class="p">}</span>
+
+ <span class="n">g_object_unref</span> <span class="p">(</span><span
class="n">shared_struct</span><span class="p">);</span>
+ <span class="p">}</span>
+
+ <span class="k">if</span> <span class="p">(</span><span
class="n">error</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">printf</span> <span class="p">(</span><span
class="s">"ERROR: %s</span><span class="se">\n</span><span
class="s">"</span><span class="p">,</span> <span
class="n">error</span><span class="o">-></span><span
class="n">message</span><span class="p">);</span>
+ <span class="n">g_clear_error</span> <span class="p">(</span><span
class="o">&</span><span class="n">error</span><span class="p">);</span>
+
+ <span class="n">exit_status</span> <span class="o">=</span> <span
class="mi">1</span><span class="p">;</span>
+ <span class="p">}</span>
+
+ <span class="n">thrift_transport_close</span> <span class="p">(</span><span
class="n">transport</span><span class="p">,</span> <span
class="nb">NULL</span><span class="p">);</span>
+
+ <span class="n">g_object_unref</span> <span class="p">(</span><span
class="n">client</span><span class="p">);</span>
+ <span class="n">g_object_unref</span> <span class="p">(</span><span
class="n">protocol</span><span class="p">);</span>
+ <span class="n">g_object_unref</span> <span class="p">(</span><span
class="n">transport</span><span class="p">);</span>
+ <span class="n">g_object_unref</span> <span class="p">(</span><span
class="n">socket</span><span class="p">);</span>
+
+ <span class="k">return</span> <span class="n">exit_status</span><span
class="p">;</span>
+<span class="p">}</span>
+</pre></div>
+
+<p class='snippet_footer'>
+ This snippet was generated by Apache Thrift's <strong>source tree
docs</strong>:
+ <a
href="http://git-wip-us.apache.org/repos/asf?p=thrift.git;a=blob;f=tutorial/c_glib/c_glib_client.c;hb=HEAD";</a>tutorial/c_glib/c_glib_client.c</a>
+</p>
+
+<h3 id="server">Server</h3>
+<div class="codehilite"><pre><span class="cp">#include
<glib-object.h></span>
+<span class="cp">#include <signal.h></span>
+<span class="cp">#include <stdio.h></span>
+<span class="cp">#include <string.h></span>
+
+<span class="cp">#include <thrift/c_glib/thrift.h></span>
+<span class="cp">#include
<thrift/c_glib/protocol/thrift_binary_protocol_factory.h></span>
+<span class="cp">#include
<thrift/c_glib/protocol/thrift_protocol_factory.h></span>
+<span class="cp">#include <thrift/c_glib/server/thrift_server.h></span>
+<span class="cp">#include
<thrift/c_glib/server/thrift_simple_server.h></span>
+<span class="cp">#include
<thrift/c_glib/transport/thrift_buffered_transport_factory.h></span>
+<span class="cp">#include
<thrift/c_glib/transport/thrift_server_socket.h></span>
+<span class="cp">#include
<thrift/c_glib/transport/thrift_server_transport.h></span>
+
+<span class="cp">#include "gen-c_glib/calculator.h"</span>
+
+<span class="n">G_BEGIN_DECLS</span>
+
+<span class="cm">/* In the C (GLib) implementation of Thrift, the actual work
done by a</span>
+<span class="cm"> server---that is, the code that runs when a client invokes
a</span>
+<span class="cm"> service method---is defined in a separate
"handler" class that</span>
+<span class="cm"> implements the service interface. Here we define the</span>
+<span class="cm"> TutorialCalculatorHandler class, which implements the
CalculatorIf</span>
+<span class="cm"> interface and provides the behavior expected by tutorial
clients.</span>
+<span class="cm"> (Typically this code would be placed in its own module but
for</span>
+<span class="cm"> clarity this tutorial is presented entirely in a single
file.)</span>
+
+<span class="cm"> For each service the Thrift compiler generates an abstract
base</span>
+<span class="cm"> class from which handler implementations should inherit.
In our</span>
+<span class="cm"> case TutorialCalculatorHandler inherits from
CalculatorHandler,</span>
+<span class="cm"> defined in gen-c_glib/calculator.h.</span>
+
+<span class="cm"> If you're new to GObject, try not to be intimidated by
the quantity</span>
+<span class="cm"> of code here---much of it is boilerplate and can mostly
be</span>
+<span class="cm"> copied-and-pasted from existing work. For more information
refer to</span>
+<span class="cm"> the GObject Reference Manual, available online at</span>
+<span class="cm"> https://developer.gnome.org/gobject/. */</span>
+
+<span class="cp">#define TYPE_TUTORIAL_CALCULATOR_HANDLER \</span>
+<span class="cp"> (tutorial_calculator_handler_get_type ())</span>
+
+<span class="cp">#define TUTORIAL_CALCULATOR_HANDLER(obj)
\</span>
+<span class="cp"> (G_TYPE_CHECK_INSTANCE_CAST ((obj),
\</span>
+<span class="cp">
TYPE_TUTORIAL_CALCULATOR_HANDLER, \</span>
+<span class="cp">
TutorialCalculatorHandler))</span>
+<span class="cp">#define TUTORIAL_CALCULATOR_HANDLER_CLASS(c)
\</span>
+<span class="cp"> (G_TYPE_CHECK_CLASS_CAST ((c),
\</span>
+<span class="cp"> TYPE_TUTORIAL_CALCULATOR_HANDLER,
\</span>
+<span class="cp">
TutorialCalculatorHandlerClass))</span>
+<span class="cp">#define IS_TUTORIAL_CALCULATOR_HANDLER(obj)
\</span>
+<span class="cp"> (G_TYPE_CHECK_INSTANCE_TYPE ((obj),
\</span>
+<span class="cp">
TYPE_TUTORIAL_CALCULATOR_HANDLER))</span>
+<span class="cp">#define IS_TUTORIAL_CALCULATOR_HANDLER_CLASS(c)
\</span>
+<span class="cp"> (G_TYPE_CHECK_CLASS_TYPE ((c),
\</span>
+<span class="cp">
TYPE_TUTORIAL_CALCULATOR_HANDLER))</span>
+<span class="cp">#define TUTORIAL_CALCULATOR_HANDLER_GET_CLASS(obj)
\</span>
+<span class="cp"> (G_TYPE_INSTANCE_GET_CLASS ((obj),
\</span>
+<span class="cp">
TYPE_TUTORIAL_CALCULATOR_HANDLER, \</span>
+<span class="cp">
TutorialCalculatorHandlerClass))</span>
+
+<span class="k">struct</span> <span
class="n">_TutorialCalculatorHandler</span> <span class="p">{</span>
+ <span class="n">CalculatorHandler</span> <span
class="n">parent_instance</span><span class="p">;</span>
+
+ <span class="cm">/* private */</span>
+ <span class="n">GHashTable</span> <span class="o">*</span><span
class="n">log</span><span class="p">;</span>
+<span class="p">};</span>
+<span class="k">typedef</span> <span class="k">struct</span> <span
class="n">_TutorialCalculatorHandler</span> <span
class="n">TutorialCalculatorHandler</span><span class="p">;</span>
+
+<span class="k">struct</span> <span
class="n">_TutorialCalculatorHandlerClass</span> <span class="p">{</span>
+ <span class="n">CalculatorHandlerClass</span> <span
class="n">parent_class</span><span class="p">;</span>
+<span class="p">};</span>
+<span class="k">typedef</span> <span class="k">struct</span> <span
class="n">_TutorialCalculatorHandlerClass</span> <span
class="n">TutorialCalculatorHandlerClass</span><span class="p">;</span>
+
+<span class="n">GType</span> <span
class="n">tutorial_calculator_handler_get_type</span> <span
class="p">(</span><span class="kt">void</span><span class="p">);</span>
+
+<span class="n">G_END_DECLS</span>
+
+<span class="cm">/*
---------------------------------------------------------------- */</span>
+
+<span class="cm">/* The implementation of TutorialCalculatorHandler follows.
*/</span>
+
+<span class="n">G_DEFINE_TYPE</span> <span class="p">(</span><span
class="n">TutorialCalculatorHandler</span><span class="p">,</span>
+ <span class="n">tutorial_calculator_handler</span><span
class="p">,</span>
+ <span class="n">TYPE_CALCULATOR_HANDLER</span><span
class="p">);</span>
+
+<span class="cm">/* Each of a handler's methods accepts at least two
parameters: A</span>
+<span class="cm"> pointer to the service-interface implementation (the
handler object</span>
+<span class="cm"> itself) and a handle to a GError structure to receive
information</span>
+<span class="cm"> about any error that occurs.</span>
+
+<span class="cm"> On success, a handler method returns TRUE. A return value
of FALSE</span>
+<span class="cm"> indicates an error occurred and the error parameter has
been</span>
+<span class="cm"> set. (Methods should not return FALSE without first
setting the</span>
+<span class="cm"> error parameter.) */</span>
+<span class="k">static</span> <span class="n">gboolean</span>
+<span class="nf">tutorial_calculator_handler_ping</span> <span
class="p">(</span><span class="n">CalculatorIf</span> <span
class="o">*</span><span class="n">iface</span><span class="p">,</span>
+ <span class="n">GError</span> <span
class="o">**</span><span class="n">error</span><span class="p">)</span>
+<span class="p">{</span>
+ <span class="n">THRIFT_UNUSED_VAR</span> <span class="p">(</span><span
class="n">iface</span><span class="p">);</span>
+ <span class="n">THRIFT_UNUSED_VAR</span> <span class="p">(</span><span
class="n">error</span><span class="p">);</span>
+
+ <span class="n">puts</span> <span class="p">(</span><span
class="s">"ping()"</span><span class="p">);</span>
+
+ <span class="k">return</span> <span class="n">TRUE</span><span
class="p">;</span>
+<span class="p">}</span>
+
+<span class="cm">/* Service-method parameters are passed through as parameters
to the</span>
+<span class="cm"> handler method.</span>
+
+<span class="cm"> If the service method returns a value an output parameter,
_return,</span>
+<span class="cm"> is additionally passed to the handler method. This
parameter should</span>
+<span class="cm"> be set appropriately before the method returns, whenever
it</span>
+<span class="cm"> succeeds.</span>
+
+<span class="cm"> The return value from this method happens to be of a base
type,</span>
+<span class="cm"> i32, but note if a method returns a complex type such as a
map or</span>
+<span class="cm"> list *_return will point to a pre-allocated data structure
that</span>
+<span class="cm"> does not need to be re-allocated and should not be
destroyed. */</span>
+<span class="k">static</span> <span class="n">gboolean</span>
+<span class="nf">tutorial_calculator_handler_add</span> <span
class="p">(</span><span class="n">CalculatorIf</span> <span
class="o">*</span><span class="n">iface</span><span class="p">,</span>
+ <span class="n">gint32</span> <span
class="o">*</span><span class="n">_return</span><span class="p">,</span>
+ <span class="k">const</span> <span
class="n">gint32</span> <span class="n">num1</span><span class="p">,</span>
+ <span class="k">const</span> <span
class="n">gint32</span> <span class="n">num2</span><span class="p">,</span>
+ <span class="n">GError</span> <span
class="o">**</span><span class="n">error</span><span class="p">)</span>
+<span class="p">{</span>
+ <span class="n">THRIFT_UNUSED_VAR</span> <span class="p">(</span><span
class="n">iface</span><span class="p">);</span>
+ <span class="n">THRIFT_UNUSED_VAR</span> <span class="p">(</span><span
class="n">error</span><span class="p">);</span>
+
+ <span class="n">printf</span> <span class="p">(</span><span
class="s">"add(%d,%d)</span><span class="se">\n</span><span
class="s">"</span><span class="p">,</span> <span
class="n">num1</span><span class="p">,</span> <span class="n">num2</span><span
class="p">);</span>
+ <span class="o">*</span><span class="n">_return</span> <span
class="o">=</span> <span class="n">num1</span> <span class="o">+</span> <span
class="n">num2</span><span class="p">;</span>
+
+ <span class="k">return</span> <span class="n">TRUE</span><span
class="p">;</span>
+<span class="p">}</span>
+
+<span class="cm">/* Any handler method can return a ThriftApplicationException
to the</span>
+<span class="cm"> client by setting its error parameter appropriately and
returning</span>
+<span class="cm"> FALSE. See the ThriftApplicationExceptionError enumeration
defined</span>
+<span class="cm"> in thrift_application_exception.h for a list of
recognized</span>
+<span class="cm"> exception types (GError codes).</span>
+
+<span class="cm"> If a service method can also throw a custom exception
(that is, one</span>
+<span class="cm"> defined in the .thrift file) an additional output
parameter will be</span>
+<span class="cm"> provided (here, "ouch") to hold an instance of
the exception, when</span>
+<span class="cm"> necessary. Note there will be a separate parameter added
for each</span>
+<span class="cm"> type of exception the method can throw.</span>
+
+<span class="cm"> Unlike return values, exception objects are never
pre-created; this</span>
+<span class="cm"> is always the responsibility of the handler method.
*/</span>
+<span class="k">static</span> <span class="n">gboolean</span>
+<span class="nf">tutorial_calculator_handler_calculate</span> <span
class="p">(</span><span class="n">CalculatorIf</span> <span
class="o">*</span><span class="n">iface</span><span class="p">,</span>
+ <span class="n">gint32</span>
<span class="o">*</span><span class="n">_return</span><span class="p">,</span>
+ <span class="k">const</span> <span
class="n">gint32</span> <span class="n">logid</span><span
class="p">,</span>
+ <span class="k">const</span> <span
class="n">Work</span> <span class="o">*</span><span
class="n">w</span><span class="p">,</span>
+ <span class="n">InvalidOperation</span>
<span class="o">**</span><span class="n">ouch</span><span class="p">,</span>
+ <span class="n">GError</span>
<span class="o">**</span><span class="n">error</span><span class="p">)</span>
+<span class="p">{</span>
+ <span class="n">THRIFT_UNUSED_VAR</span> <span class="p">(</span><span
class="n">error</span><span class="p">);</span>
+
+ <span class="n">TutorialCalculatorHandler</span> <span
class="o">*</span><span class="n">self</span><span class="p">;</span>
+
+ <span class="n">gint</span> <span class="o">*</span><span
class="n">log_key</span><span class="p">;</span>
+ <span class="n">gchar</span> <span class="n">log_value</span><span
class="p">[</span><span class="mi">12</span><span class="p">];</span>
+ <span class="n">SharedStruct</span> <span class="o">*</span><span
class="n">log_struct</span><span class="p">;</span>
+
+ <span class="n">gint</span> <span class="n">num1</span><span
class="p">;</span>
+ <span class="n">gint</span> <span class="n">num2</span><span
class="p">;</span>
+ <span class="n">Operation</span> <span class="n">op</span><span
class="p">;</span>
+ <span class="n">gboolean</span> <span class="n">result</span> <span
class="o">=</span> <span class="n">TRUE</span><span class="p">;</span>
+
+ <span class="n">g_return_val_if_fail</span> <span class="p">(</span><span
class="n">IS_TUTORIAL_CALCULATOR_HANDLER</span> <span class="p">(</span><span
class="n">iface</span><span class="p">),</span>
+ <span class="n">FALSE</span><span class="p">);</span>
+ <span class="n">self</span> <span class="o">=</span> <span
class="n">TUTORIAL_CALCULATOR_HANDLER</span> <span class="p">(</span><span
class="n">iface</span><span class="p">);</span>
+
+ <span class="cm">/* Remember: Exception objects are never pre-created
*/</span>
+ <span class="n">g_assert</span> <span class="p">(</span><span
class="o">*</span><span class="n">ouch</span> <span class="o">==</span> <span
class="nb">NULL</span><span class="p">);</span>
+
+ <span class="cm">/* Fetch the contents of our Work parameter.</span>
+
+<span class="cm"> Note that integer properties of thirty-two bits or fewer
in width</span>
+<span class="cm"> are _always_ of type gint, regardless of the range of
values they</span>
+<span class="cm"> hold. A common error is trying to retrieve, say, a
structure</span>
+<span class="cm"> member defined in the .thrift file as type i16 into a
variable of</span>
+<span class="cm"> type gint16, which will clobber variables adjacent on
the</span>
+<span class="cm"> stack. Remember: If you're retrieving an integer
property the</span>
+<span class="cm"> receiving variable must be of either type gint or
gint64, as</span>
+<span class="cm"> appropriate. */</span>
+ <span class="n">g_object_get</span> <span class="p">((</span><span
class="n">Work</span> <span class="o">*</span><span class="p">)</span><span
class="n">w</span><span class="p">,</span>
+ <span class="s">"num1"</span><span
class="p">,</span> <span class="o">&</span><span class="n">num1</span><span
class="p">,</span>
+ <span class="s">"num2"</span><span
class="p">,</span> <span class="o">&</span><span class="n">num2</span><span
class="p">,</span>
+ <span class="s">"op"</span><span class="p">,</span>
<span class="o">&</span><span class="n">op</span><span class="p">,</span>
+ <span class="nb">NULL</span><span class="p">);</span>
+
+ <span class="n">printf</span> <span class="p">(</span><span
class="s">"calculate(%d,{%d,%d,%d})</span><span class="se">\n</span><span
class="s">"</span><span class="p">,</span> <span
class="n">logid</span><span class="p">,</span> <span class="n">op</span><span
class="p">,</span> <span class="n">num1</span><span class="p">,</span> <span
class="n">num2</span><span class="p">);</span>
+
+ <span class="k">switch</span> <span class="p">(</span><span
class="n">op</span><span class="p">)</span> <span class="p">{</span>
+ <span class="k">case</span> <span class="n">OPERATION_ADD</span>:
+ <span class="o">*</span><span class="n">_return</span> <span
class="o">=</span> <span class="n">num1</span> <span class="o">+</span> <span
class="n">num2</span><span class="p">;</span>
+ <span class="k">break</span><span class="p">;</span>
+
+ <span class="k">case</span> <span class="n">OPERATION_SUBTRACT</span>:
+ <span class="o">*</span><span class="n">_return</span> <span
class="o">=</span> <span class="n">num1</span> <span class="o">-</span> <span
class="n">num2</span><span class="p">;</span>
+ <span class="k">break</span><span class="p">;</span>
+
+ <span class="k">case</span> <span class="n">OPERATION_MULTIPLY</span>:
+ <span class="o">*</span><span class="n">_return</span> <span
class="o">=</span> <span class="n">num1</span> <span class="o">*</span> <span
class="n">num2</span><span class="p">;</span>
+ <span class="k">break</span><span class="p">;</span>
+
+ <span class="k">case</span> <span class="n">OPERATION_DIVIDE</span>:
+ <span class="k">if</span> <span class="p">(</span><span
class="n">num2</span> <span class="o">==</span> <span class="mi">0</span><span
class="p">)</span> <span class="p">{</span>
+ <span class="cm">/* For each custom exception type a subclass of
ThriftStruct is</span>
+<span class="cm"> generated by the Thrift compiler. Throw an exception
by</span>
+<span class="cm"> setting the corresponding output parameter to a new
instance</span>
+<span class="cm"> of its type and returning FALSE. */</span>
+ <span class="o">*</span><span class="n">ouch</span> <span
class="o">=</span> <span class="n">g_object_new</span> <span
class="p">(</span><span class="n">TYPE_INVALID_OPERATION</span><span
class="p">,</span>
+ <span class="s">"whatOp"</span><span
class="p">,</span> <span class="n">op</span><span class="p">,</span>
+ <span class="s">"why"</span><span
class="p">,</span> <span class="n">g_strdup</span> <span
class="p">(</span><span class="s">"Cannot divide by 0"</span><span
class="p">),</span>
+ <span class="nb">NULL</span><span
class="p">);</span>
+ <span class="n">result</span> <span class="o">=</span> <span
class="n">FALSE</span><span class="p">;</span>
+
+ <span class="cm">/* Note the call to g_strdup above: All the memory used
by a</span>
+<span class="cm"> ThriftStruct's properties belongs to the object
itself and</span>
+<span class="cm"> will be freed on destruction. Removing this call to
g_strdup</span>
+<span class="cm"> will lead to a segmentation fault as the object
tries to</span>
+<span class="cm"> release memory allocated statically to the program.
*/</span>
+ <span class="p">}</span>
+ <span class="k">else</span> <span class="p">{</span>
+ <span class="o">*</span><span class="n">_return</span> <span
class="o">=</span> <span class="n">num1</span> <span class="o">/</span> <span
class="n">num2</span><span class="p">;</span>
+ <span class="p">}</span>
+ <span class="k">break</span><span class="p">;</span>
+
+ <span class="nl">default:</span>
+ <span class="o">*</span><span class="n">ouch</span> <span
class="o">=</span> <span class="n">g_object_new</span> <span
class="p">(</span><span class="n">TYPE_INVALID_OPERATION</span><span
class="p">,</span>
+ <span class="s">"whatOp"</span><span
class="p">,</span> <span class="n">op</span><span class="p">,</span>
+ <span class="s">"why"</span><span
class="p">,</span> <span class="n">g_strdup</span> <span
class="p">(</span><span class="s">"Invalid Operation"</span><span
class="p">),</span>
+ <span class="nb">NULL</span><span class="p">);</span>
+ <span class="n">result</span> <span class="o">=</span> <span
class="n">FALSE</span><span class="p">;</span>
+ <span class="p">}</span>
+
+ <span class="cm">/* On success, log a record of the result to our hash table
*/</span>
+ <span class="k">if</span> <span class="p">(</span><span
class="n">result</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">log_key</span> <span class="o">=</span> <span
class="n">g_malloc</span> <span class="p">(</span><span class="k">sizeof</span>
<span class="o">*</span><span class="n">log_key</span><span class="p">);</span>
+ <span class="o">*</span><span class="n">log_key</span> <span
class="o">=</span> <span class="n">logid</span><span class="p">;</span>
+
+ <span class="n">snprintf</span> <span class="p">(</span><span
class="n">log_value</span><span class="p">,</span> <span
class="k">sizeof</span> <span class="n">log_value</span><span
class="p">,</span> <span class="s">"%d"</span><span
class="p">,</span> <span class="o">*</span><span class="n">_return</span><span
class="p">);</span>
+
+ <span class="n">log_struct</span> <span class="o">=</span> <span
class="n">g_object_new</span> <span class="p">(</span><span
class="n">TYPE_SHARED_STRUCT</span><span class="p">,</span>
+ <span class="s">"key"</span><span
class="p">,</span> <span class="o">*</span><span
class="n">log_key</span><span class="p">,</span>
+ <span class="s">"value"</span><span
class="p">,</span> <span class="n">g_strdup</span> <span
class="p">(</span><span class="n">log_value</span><span class="p">),</span>
+ <span class="nb">NULL</span><span
class="p">);</span>
+ <span class="n">g_hash_table_replace</span> <span class="p">(</span><span
class="n">self</span><span class="o">-></span><span
class="n">log</span><span class="p">,</span> <span
class="n">log_key</span><span class="p">,</span> <span
class="n">log_struct</span><span class="p">);</span>
+ <span class="p">}</span>
+
+ <span class="k">return</span> <span class="n">result</span><span
class="p">;</span>
+<span class="p">}</span>
+
+<span class="cm">/* A one-way method has the same signature as an equivalent,
regular</span>
+<span class="cm"> method that returns no value. */</span>
+<span class="k">static</span> <span class="n">gboolean</span>
+<span class="nf">tutorial_calculator_handler_zip</span> <span
class="p">(</span><span class="n">CalculatorIf</span> <span
class="o">*</span><span class="n">iface</span><span class="p">,</span>
+ <span class="n">GError</span> <span
class="o">**</span><span class="n">error</span><span class="p">)</span>
+<span class="p">{</span>
+ <span class="n">THRIFT_UNUSED_VAR</span> <span class="p">(</span><span
class="n">iface</span><span class="p">);</span>
+ <span class="n">THRIFT_UNUSED_VAR</span> <span class="p">(</span><span
class="n">error</span><span class="p">);</span>
+
+ <span class="n">puts</span> <span class="p">(</span><span
class="s">"zip()"</span><span class="p">);</span>
+
+ <span class="k">return</span> <span class="n">TRUE</span><span
class="p">;</span>
+<span class="p">}</span>
+
+<span class="cm">/* As specified in the .thrift file (tutorial.thrift), the
Calculator</span>
+<span class="cm"> service extends the SharedService service.
Correspondingly, in the</span>
+<span class="cm"> generated code the Calculator interface, CalculatorIf,
extends the</span>
+<span class="cm"> SharedService interface, SharedServiceIf, and subclasses
of</span>
+<span class="cm"> CalculatorHandler should implement its methods as
well.</span>
+
+<span class="cm"> Here we provide an implementation for the getStruct method
from the</span>
+<span class="cm"> parent service. */</span>
+<span class="k">static</span> <span class="n">gboolean</span>
+<span class="nf">tutorial_calculator_handler_get_struct</span> <span
class="p">(</span><span class="n">SharedServiceIf</span> <span
class="o">*</span><span class="n">iface</span><span class="p">,</span>
+ <span class="n">SharedStruct</span>
<span class="o">**</span><span class="n">_return</span><span class="p">,</span>
+ <span class="k">const</span> <span
class="n">gint32</span> <span class="n">key32</span><span
class="p">,</span>
+ <span class="n">GError</span>
<span class="o">**</span><span class="n">error</span><span class="p">)</span>
+<span class="p">{</span>
+ <span class="n">THRIFT_UNUSED_VAR</span> <span class="p">(</span><span
class="n">error</span><span class="p">);</span>
+
+ <span class="n">gint</span> <span class="n">key</span> <span
class="o">=</span> <span class="p">(</span><span class="n">gint</span><span
class="p">)</span><span class="n">key32</span><span class="p">;</span>
+ <span class="n">TutorialCalculatorHandler</span> <span
class="o">*</span><span class="n">self</span><span class="p">;</span>
+ <span class="n">SharedStruct</span> <span class="o">*</span><span
class="n">log_struct</span><span class="p">;</span>
+ <span class="n">gint</span> <span class="n">log_key</span><span
class="p">;</span>
+ <span class="n">gchar</span> <span class="o">*</span><span
class="n">log_value</span><span class="p">;</span>
+
+ <span class="n">g_return_val_if_fail</span> <span class="p">(</span><span
class="n">IS_TUTORIAL_CALCULATOR_HANDLER</span> <span class="p">(</span><span
class="n">iface</span><span class="p">),</span>
+ <span class="n">FALSE</span><span class="p">);</span>
+ <span class="n">self</span> <span class="o">=</span> <span
class="n">TUTORIAL_CALCULATOR_HANDLER</span> <span class="p">(</span><span
class="n">iface</span><span class="p">);</span>
+
+ <span class="cm">/* Remember: Complex return types are always pre-created
and need</span>
+<span class="cm"> only be populated */</span>
+ <span class="n">g_assert</span> <span class="p">(</span><span
class="o">*</span><span class="n">_return</span> <span class="o">!=</span>
<span class="nb">NULL</span><span class="p">);</span>
+
+ <span class="n">printf</span> <span class="p">(</span><span
class="s">"getStruct(%d)</span><span class="se">\n</span><span
class="s">"</span><span class="p">,</span> <span class="n">key</span><span
class="p">);</span>
+
+ <span class="cm">/* If the key exists in our log, return the corresponding
logged</span>
+<span class="cm"> data (or an empty SharedStruct structure if it does
not).</span>
+
+<span class="cm"> Incidentally, note we _must_ here copy the values from
the hash</span>
+<span class="cm"> table into the return structure. All memory used by the
return</span>
+<span class="cm"> structure belongs to the structure itself and will be
freed once</span>
+<span class="cm"> a response is sent to the client. If we merely freed
*_return and</span>
+<span class="cm"> set it to point to our hash-table entry, that would mean
memory</span>
+<span class="cm"> would be released (effectively, data erased) out of the
hash</span>
+<span class="cm"> table! */</span>
+ <span class="n">log_struct</span> <span class="o">=</span> <span
class="n">g_hash_table_lookup</span> <span class="p">(</span><span
class="n">self</span><span class="o">-></span><span
class="n">log</span><span class="p">,</span> <span class="o">&</span><span
class="n">key</span><span class="p">);</span>
+ <span class="k">if</span> <span class="p">(</span><span
class="n">log_struct</span> <span class="o">!=</span> <span
class="nb">NULL</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">g_object_get</span> <span class="p">(</span><span
class="n">log_struct</span><span class="p">,</span>
+ <span class="s">"key"</span><span
class="p">,</span> <span class="o">&</span><span
class="n">log_key</span><span class="p">,</span>
+ <span class="s">"value"</span><span
class="p">,</span> <span class="o">&</span><span
class="n">log_value</span><span class="p">,</span>
+ <span class="nb">NULL</span><span class="p">);</span>
+ <span class="n">g_object_set</span> <span class="p">(</span><span
class="o">*</span><span class="n">_return</span><span class="p">,</span>
+ <span class="s">"key"</span><span
class="p">,</span> <span class="n">log_key</span><span class="p">,</span>
+ <span class="s">"value"</span><span
class="p">,</span> <span class="n">g_strdup</span> <span
class="p">(</span><span class="n">log_value</span><span class="p">),</span>
+ <span class="nb">NULL</span><span class="p">);</span>
+ <span class="p">}</span>
+
+ <span class="k">return</span> <span class="n">TRUE</span><span
class="p">;</span>
+<span class="p">}</span>
+
+<span class="cm">/* TutorialCalculatorHandler's instance finalizer
(destructor) */</span>
+<span class="k">static</span> <span class="kt">void</span>
+<span class="nf">tutorial_calculator_handler_finalize</span> <span
class="p">(</span><span class="n">GObject</span> <span class="o">*</span><span
class="n">object</span><span class="p">)</span>
+<span class="p">{</span>
+ <span class="n">TutorialCalculatorHandler</span> <span
class="o">*</span><span class="n">self</span> <span class="o">=</span>
+ <span class="n">TUTORIAL_CALCULATOR_HANDLER</span> <span
class="p">(</span><span class="n">object</span><span class="p">);</span>
+
+ <span class="cm">/* Free our calculation-log hash table */</span>
+ <span class="n">g_hash_table_unref</span> <span class="p">(</span><span
class="n">self</span><span class="o">-></span><span
class="n">log</span><span class="p">);</span>
+ <span class="n">self</span><span class="o">-></span><span
class="n">log</span> <span class="o">=</span> <span class="nb">NULL</span><span
class="p">;</span>
+
+ <span class="cm">/* Chain up to the parent class */</span>
+ <span class="n">G_OBJECT_CLASS</span> <span class="p">(</span><span
class="n">tutorial_calculator_handler_parent_class</span><span
class="p">)</span><span class="o">-></span>
+ <span class="n">finalize</span> <span class="p">(</span><span
class="n">object</span><span class="p">);</span>
+<span class="p">}</span>
+
+<span class="cm">/* TutorialCalculatorHandler's instance initializer
(constructor) */</span>
+<span class="k">static</span> <span class="kt">void</span>
+<span class="nf">tutorial_calculator_handler_init</span> <span
class="p">(</span><span class="n">TutorialCalculatorHandler</span> <span
class="o">*</span><span class="n">self</span><span class="p">)</span>
+<span class="p">{</span>
+ <span class="cm">/* Create our calculation-log hash table */</span>
+ <span class="n">self</span><span class="o">-></span><span
class="n">log</span> <span class="o">=</span> <span
class="n">g_hash_table_new_full</span> <span class="p">(</span><span
class="n">g_int_hash</span><span class="p">,</span>
+ <span class="n">g_int_equal</span><span
class="p">,</span>
+ <span class="n">g_free</span><span
class="p">,</span>
+ <span
class="n">g_object_unref</span><span class="p">);</span>
+<span class="p">}</span>
+
+<span class="cm">/* TutorialCalculatorHandler's class initializer */</span>
+<span class="k">static</span> <span class="kt">void</span>
+<span class="nf">tutorial_calculator_handler_class_init</span> <span
class="p">(</span><span class="n">TutorialCalculatorHandlerClass</span> <span
class="o">*</span><span class="n">klass</span><span class="p">)</span>
+<span class="p">{</span>
+ <span class="n">GObjectClass</span> <span class="o">*</span><span
class="n">gobject_class</span> <span class="o">=</span> <span
class="n">G_OBJECT_CLASS</span> <span class="p">(</span><span
class="n">klass</span><span class="p">);</span>
+ <span class="n">SharedServiceHandlerClass</span> <span
class="o">*</span><span class="n">shared_service_handler_class</span> <span
class="o">=</span>
+ <span class="n">SHARED_SERVICE_HANDLER_CLASS</span> <span
class="p">(</span><span class="n">klass</span><span class="p">);</span>
+ <span class="n">CalculatorHandlerClass</span> <span class="o">*</span><span
class="n">calculator_handler_class</span> <span class="o">=</span>
+ <span class="n">CALCULATOR_HANDLER_CLASS</span> <span
class="p">(</span><span class="n">klass</span><span class="p">);</span>
+
+ <span class="cm">/* Register our destructor */</span>
+ <span class="n">gobject_class</span><span class="o">-></span><span
class="n">finalize</span> <span class="o">=</span> <span
class="n">tutorial_calculator_handler_finalize</span><span class="p">;</span>
+
+ <span class="cm">/* Register our implementations of CalculatorHandler's
methods */</span>
+ <span class="n">calculator_handler_class</span><span
class="o">-></span><span class="n">ping</span> <span class="o">=</span>
+ <span class="n">tutorial_calculator_handler_ping</span><span
class="p">;</span>
+ <span class="n">calculator_handler_class</span><span
class="o">-></span><span class="n">add</span> <span class="o">=</span>
+ <span class="n">tutorial_calculator_handler_add</span><span
class="p">;</span>
+ <span class="n">calculator_handler_class</span><span
class="o">-></span><span class="n">calculate</span> <span class="o">=</span>
+ <span class="n">tutorial_calculator_handler_calculate</span><span
class="p">;</span>
+ <span class="n">calculator_handler_class</span><span
class="o">-></span><span class="n">zip</span> <span class="o">=</span>
+ <span class="n">tutorial_calculator_handler_zip</span><span
class="p">;</span>
+
+ <span class="cm">/* Register our implementation of
SharedServiceHandler's method */</span>
+ <span class="n">shared_service_handler_class</span><span
class="o">-></span><span class="n">get_struct</span> <span class="o">=</span>
+ <span class="n">tutorial_calculator_handler_get_struct</span><span
class="p">;</span>
+<span class="p">}</span>
+
+<span class="cm">/*
---------------------------------------------------------------- */</span>
+
+<span class="cm">/* That ends the implementation of
TutorialCalculatorHandler.</span>
+<span class="cm"> Everything below is fairly generic code that sets up a
minimal</span>
+<span class="cm"> Thrift server for tutorial clients. */</span>
+
+
+<span class="cm">/* Our server object, declared globally so it is accessible
within the</span>
+<span class="cm"> SIGINT signal handler */</span>
+<span class="n">ThriftServer</span> <span class="o">*</span><span
class="n">server</span> <span class="o">=</span> <span
class="nb">NULL</span><span class="p">;</span>
+
+<span class="cm">/* A flag that indicates whether the server was interrupted
with</span>
+<span class="cm"> SIGINT (i.e. Ctrl-C) so we can tell whether its
termination was</span>
+<span class="cm"> abnormal */</span>
+<span class="n">gboolean</span> <span class="n">sigint_received</span> <span
class="o">=</span> <span class="n">FALSE</span><span class="p">;</span>
+
+<span class="cm">/* Handle SIGINT ("Ctrl-C") signals by gracefully
stopping the</span>
+<span class="cm"> server */</span>
+<span class="k">static</span> <span class="kt">void</span>
+<span class="nf">sigint_handler</span> <span class="p">(</span><span
class="kt">int</span> <span class="n">signal_number</span><span
class="p">)</span>
+<span class="p">{</span>
+ <span class="n">THRIFT_UNUSED_VAR</span> <span class="p">(</span><span
class="n">signal_number</span><span class="p">);</span>
+
+ <span class="cm">/* Take note we were called */</span>
+ <span class="n">sigint_received</span> <span class="o">=</span> <span
class="n">TRUE</span><span class="p">;</span>
+
+ <span class="cm">/* Shut down the server gracefully */</span>
+ <span class="k">if</span> <span class="p">(</span><span
class="n">server</span> <span class="o">!=</span> <span
class="nb">NULL</span><span class="p">)</span>
+ <span class="n">thrift_server_stop</span> <span class="p">(</span><span
class="n">server</span><span class="p">);</span>
+<span class="p">}</span>
+
+<span class="kt">int</span> <span class="nf">main</span> <span
class="p">(</span><span class="kt">void</span><span class="p">)</span>
+<span class="p">{</span>
+ <span class="n">TutorialCalculatorHandler</span> <span
class="o">*</span><span class="n">handler</span><span class="p">;</span>
+ <span class="n">CalculatorProcessor</span> <span class="o">*</span><span
class="n">processor</span><span class="p">;</span>
+
+ <span class="n">ThriftServerTransport</span> <span class="o">*</span><span
class="n">server_transport</span><span class="p">;</span>
+ <span class="n">ThriftTransportFactory</span> <span class="o">*</span><span
class="n">transport_factory</span><span class="p">;</span>
+ <span class="n">ThriftProtocolFactory</span> <span class="o">*</span><span
class="n">protocol_factory</span><span class="p">;</span>
+
+ <span class="k">struct</span> <span class="n">sigaction</span> <span
class="n">sigint_action</span><span class="p">;</span>
+
+ <span class="n">GError</span> <span class="o">*</span><span
class="n">error</span><span class="p">;</span>
+ <span class="kt">int</span> <span class="n">exit_status</span> <span
class="o">=</span> <span class="mi">0</span><span class="p">;</span>
+
+<span class="cp">#if (!GLIB_CHECK_VERSION (2, 36, 0))</span>
+ <span class="n">g_type_init</span> <span class="p">();</span>
+<span class="cp">#endif</span>
+
+ <span class="cm">/* Create an instance of our handler, which provides the
service's</span>
+<span class="cm"> methods' implementation */</span>
+ <span class="n">handler</span> <span class="o">=</span>
+ <span class="n">g_object_new</span> <span class="p">(</span><span
class="n">TYPE_TUTORIAL_CALCULATOR_HANDLER</span><span class="p">,</span>
+ <span class="nb">NULL</span><span class="p">);</span>
+
+ <span class="cm">/* Create an instance of the service's processor,
automatically</span>
+<span class="cm"> generated by the Thrift compiler, which parses incoming
messages</span>
+<span class="cm"> and dispatches them to the appropriate method in the
handler */</span>
+ <span class="n">processor</span> <span class="o">=</span>
+ <span class="n">g_object_new</span> <span class="p">(</span><span
class="n">TYPE_CALCULATOR_PROCESSOR</span><span class="p">,</span>
+ <span class="s">"handler"</span><span
class="p">,</span> <span class="n">handler</span><span class="p">,</span>
+ <span class="nb">NULL</span><span class="p">);</span>
+
+ <span class="cm">/* Create our server socket, which binds to the specified
port and</span>
+<span class="cm"> listens for client connections */</span>
+ <span class="n">server_transport</span> <span class="o">=</span>
+ <span class="n">g_object_new</span> <span class="p">(</span><span
class="n">THRIFT_TYPE_SERVER_SOCKET</span><span class="p">,</span>
+ <span class="s">"port"</span><span
class="p">,</span> <span class="mi">9090</span><span class="p">,</span>
+ <span class="nb">NULL</span><span class="p">);</span>
+
+ <span class="cm">/* Create our transport factory, used by the server to wrap
"raw"</span>
+<span class="cm"> incoming connections from the client (in this case with
a</span>
+<span class="cm"> ThriftBufferedTransport to improve performance) */</span>
+ <span class="n">transport_factory</span> <span class="o">=</span>
+ <span class="n">g_object_new</span> <span class="p">(</span><span
class="n">THRIFT_TYPE_BUFFERED_TRANSPORT_FACTORY</span><span class="p">,</span>
+ <span class="nb">NULL</span><span class="p">);</span>
+
+ <span class="cm">/* Create our protocol factory, which determines which wire
protocol</span>
+<span class="cm"> the server will use (in this case, Thrift's binary
protocol) */</span>
+ <span class="n">protocol_factory</span> <span class="o">=</span>
+ <span class="n">g_object_new</span> <span class="p">(</span><span
class="n">THRIFT_TYPE_BINARY_PROTOCOL_FACTORY</span><span class="p">,</span>
+ <span class="nb">NULL</span><span class="p">);</span>
+
+ <span class="cm">/* Create the server itself */</span>
+ <span class="n">server</span> <span class="o">=</span>
+ <span class="n">g_object_new</span> <span class="p">(</span><span
class="n">THRIFT_TYPE_SIMPLE_SERVER</span><span class="p">,</span>
+ <span class="s">"processor"</span><span
class="p">,</span> <span class="n">processor</span><span
class="p">,</span>
+ <span class="s">"server_transport"</span><span
class="p">,</span> <span class="n">server_transport</span><span
class="p">,</span>
+ <span
class="s">"input_transport_factory"</span><span class="p">,</span>
<span class="n">transport_factory</span><span class="p">,</span>
+ <span
class="s">"output_transport_factory"</span><span class="p">,</span>
<span class="n">transport_factory</span><span class="p">,</span>
+ <span
class="s">"input_protocol_factory"</span><span class="p">,</span>
<span class="n">protocol_factory</span><span class="p">,</span>
+ <span
class="s">"output_protocol_factory"</span><span class="p">,</span>
<span class="n">protocol_factory</span><span class="p">,</span>
+ <span class="nb">NULL</span><span class="p">);</span>
+
+ <span class="cm">/* Install our SIGINT handler, which handles Ctrl-C being
pressed by</span>
+<span class="cm"> stopping the server gracefully (not strictly necessary,
but a</span>
+<span class="cm"> nice touch) */</span>
+ <span class="n">memset</span> <span class="p">(</span><span
class="o">&</span><span class="n">sigint_action</span><span
class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span
class="k">sizeof</span> <span class="p">(</span><span
class="n">sigint_action</span><span class="p">));</span>
+ <span class="n">sigint_action</span><span class="p">.</span><span
class="n">sa_handler</span> <span class="o">=</span> <span
class="n">sigint_handler</span><span class="p">;</span>
+ <span class="n">sigint_action</span><span class="p">.</span><span
class="n">sa_flags</span> <span class="o">=</span> <span
class="n">SA_RESETHAND</span><span class="p">;</span>
+ <span class="n">sigaction</span> <span class="p">(</span><span
class="n">SIGINT</span><span class="p">,</span> <span
class="o">&</span><span class="n">sigint_action</span><span
class="p">,</span> <span class="nb">NULL</span><span class="p">);</span>
+
+ <span class="cm">/* Start the server, which will run until its stop method
is invoked</span>
+<span class="cm"> (from within the SIGINT handler, in this case) */</span>
+ <span class="n">puts</span> <span class="p">(</span><span
class="s">"Starting the server..."</span><span class="p">);</span>
+ <span class="n">thrift_server_serve</span> <span class="p">(</span><span
class="n">server</span><span class="p">,</span> <span
class="o">&</span><span class="n">error</span><span class="p">);</span>
+
+ <span class="cm">/* If the server stopped for any reason other than having
been</span>
+<span class="cm"> interrupted by the user, report the error */</span>
+ <span class="k">if</span> <span class="p">(</span><span
class="o">!</span><span class="n">sigint_received</span><span
class="p">)</span> <span class="p">{</span>
+ <span class="n">g_message</span> <span class="p">(</span><span
class="s">"thrift_server_serve: %s"</span><span class="p">,</span>
+ <span class="n">error</span> <span class="o">!=</span> <span
class="nb">NULL</span> <span class="o">?</span> <span
class="n">error</span><span class="o">-></span><span
class="n">message</span> <span class="o">:</span> <span
class="s">"(null)"</span><span class="p">);</span>
+ <span class="n">g_clear_error</span> <span class="p">(</span><span
class="o">&</span><span class="n">error</span><span class="p">);</span>
+ <span class="p">}</span>
+
+ <span class="n">puts</span> <span class="p">(</span><span
class="s">"done."</span><span class="p">);</span>
+
+ <span class="n">g_object_unref</span> <span class="p">(</span><span
class="n">server</span><span class="p">);</span>
+ <span class="n">g_object_unref</span> <span class="p">(</span><span
class="n">transport_factory</span><span class="p">);</span>
+ <span class="n">g_object_unref</span> <span class="p">(</span><span
class="n">protocol_factory</span><span class="p">);</span>
+ <span class="n">g_object_unref</span> <span class="p">(</span><span
class="n">server_transport</span><span class="p">);</span>
+
+ <span class="n">g_object_unref</span> <span class="p">(</span><span
class="n">processor</span><span class="p">);</span>
+ <span class="n">g_object_unref</span> <span class="p">(</span><span
class="n">handler</span><span class="p">);</span>
+
+ <span class="k">return</span> <span class="n">exit_status</span><span
class="p">;</span>
+<span class="p">}</span>
+</pre></div>
+
+<p class='snippet_footer'>
+ This snippet was generated by Apache Thrift's <strong>source tree
docs</strong>:
+ <a
href="http://git-wip-us.apache.org/repos/asf?p=thrift.git;a=blob;f=tutorial/c_glib/c_glib_server.c;hb=HEAD";</a>tutorial/c_glib/c_glib_server.c</a>
+</p>
+ </div>
+ <div class="container">
+ <hr>
+ <footer class="footer">
+ <div class="row">
+ <div class="span3">
+ <h3>Links</h3>
+ <ul class="unstyled">
+ <li><a
href="/download">Download</a></li>
+ <li><a
href="/developers">Developers</a></li>
+ <li><a
href="/tutorial">Tutorials</a></li>
+ </ul>
+ <ul class="unstyled">
+ <li><a href="/sitemap">Sitemap</a></li>
+ </ul>
+ </div>
+ <div class="span3">
+ <h3>Get Involved</h3>
+ <ul class="unstyled">
+ <li><a href="/mailing">Mailing
Lists</a></li>
+ <li><a
href="http://issues.apache.org/jira/browse/THRIFT";>Issue Tracking</a></li>
+ <li><a href="/docs/HowToContribute">How
To Contribute</a></li>
+ </ul>
+ </div>
+ <div class="span6">
+ <a href="http://www.apache.org/";><img
src="/static/images/favicon.ico" /></a> Copyright 2014 <a
href="http://www.apache.org/";>Apache Software Foundation</a>. Licensed under
the <a href="http://www.apache.org/licenses/";>Apache License v2.0</a>. Apache,
Apache Thrift, and the Apache feather logo are trademarks of The Apache
Software Foundation.
+ </div>
+ </div>
+
+ </footer>
+</div>
+
+ </body>
+</html>
Modified: websites/staging/thrift/trunk/content/tutorial/index.html
==============================================================================
--- websites/staging/thrift/trunk/content/tutorial/index.html (original)
+++ websites/staging/thrift/trunk/content/tutorial/index.html Mon Jun 1
20:08:06 2015
@@ -116,6 +116,7 @@ Both files will be used to demonstrate h
<h2 id="examples-clients-and-servers">Examples Clients and Servers</h2>
<ul>
<li><a href="/tutorial/as3">Actionscript 3.0</a></li>
+<li><a href="/tutorial/c_glib"></a></li>
<li><a href="/tutorial/cpp">C++</a></li>
<li><a href="/tutorial/csharp">CSharp</a></li>
<li><a href="/tutorial/d">D</a></li>
