Difference between revisions of "D-Bus examples"

From Apertium
Jump to navigation Jump to search
m (→‎Java: Fixed my bad grammar)
(Category:Documentation in English)
 
(13 intermediate revisions by 7 users not shown)
Line 14: Line 14:
   
 
mode_name = 'en-af'; # The name of the installed mode
 
mode_name = 'en-af'; # The name of the installed mode
dbus_mode_name = '/' + '_'.join(pair_name.split('-')); # Some mandatory mangling
 
   
 
bus = dbus.SessionBus(); # Create a new session bus
 
bus = dbus.SessionBus(); # Create a new session bus
   
 
# Get the translator
 
# Get the translator
translator = dbus.Interface(bus.get_object('org.apertium.mode', dbus_mode_name), 'org.apertium.Mode');
+
translator = dbus.Interface(bus.get_object('org.apertium.mode', '/'), 'org.apertium.Translate');
   
 
input = sys.stdin.read(); # Read the data
 
input = sys.stdin.read(); # Read the data
   
print translator.translate({}, input); # Print the translation
+
print translator.translate(mode_name, {}, input); # Print the translation
   
 
</pre>
 
</pre>
   
 
==Java==
 
==Java==
  +
{{see-also|Installing the Java D-Bus bindings|Compiling a Java D-Bus program}}
 
 
{{Java_D-Bus_snippet}}
 
{{Java_D-Bus_snippet}}
   
  +
In this program, we simply use the proxy object to invoke the <code>modes</code> method on the D-Bus object <code>org.apertium.info</code>. This returns a Java <code>List&lt;String&gt;</code>; we enumerate this list, printing each string.
We have a guide on [[Installing the Java D-Bus bindings|installing the Java D-Bus bindings]] and a guide on [[Compiling a Java D-Bus program|compiling a small Java application which uses an Apertium D-Bus service]].
 
  +
  +
==C++==
  +
{{see-also|Installing the C++ D-Bus bindings|Compiling a C++ D-Bus program}}
  +
{{C++_D-Bus_snippet}}
  +
  +
This program is a simple emulation of the main apertium program. It takes a single parameter, which is the translation mode (something like en-ca). It reads words from stdin and calls the method <code>translate</code> on the D-Bus proxy object <code>translator</code> to translate the text read from stdin. When the translation is complete, it writes the translated string to stdout.
  +
  +
==Clojure==
  +
<pre>
  +
(import '(org.freedesktop.dbus DBusConnection))
  +
  +
(def bus (. DBusConnection (getConnection (. DBusConnection SESSION))))
  +
(def info (. bus (getRemoteObject "org.apertium.info" "/" (class org.apertium.Info))))
  +
  +
(doseq mode (. info (modes))
  +
(prn mode))
  +
  +
(. bus (disconnect))
  +
</pre>
  +
  +
[http://clojure.sourceforge.net/ Clojure] is a new Lisp dialect aimed at the Java Virtual Machine. You can see that the Clojure implementation is close to the Java implementation. To run the Clojure code, you will need to pass the same command line parameters to the Java Virtual Machine as for the Java example above.
  +
  +
== C - Glib Bindings ==
  +
<pre>
  +
#include <glib.h>
  +
#include <glib-object.h>
  +
#include <dbus/dbus.h>
  +
#include <dbus/dbus-glib.h>
  +
  +
#define APERTIUM_SERVICE_NAME "org.apertium.mode"
  +
#define APERTIUM_INTERFACE "org.apertium.Translate"
  +
#define APERTIUM_OBJECT_PATH "/"
  +
  +
gboolean apertium_dbus_init();
  +
gboolean apertium_dbus_translate(const gchar*, gboolean, gchar*);
  +
  +
static DBusGConnection *conn = NULL;
  +
static DBusGProxy *proxy = NULL;
  +
static gchar *ceviri = NULL;
  +
  +
gboolean apertium_dbus_init()
  +
{
  +
GError *error = NULL;
  +
  +
conn = dbus_g_bus_get(DBUS_BUS_SESSION, &error);
  +
  +
if (conn == NULL) {
  +
g_warning("Error %s\n", error->message);
  +
g_error_free(error);
  +
return FALSE;
  +
}
  +
else
  +
{
  +
g_debug("conn object is %d\n", conn);
  +
}
  +
  +
proxy = dbus_g_proxy_new_for_name_owner(conn,
  +
APERTIUM_SERVICE_NAME,
  +
APERTIUM_OBJECT_PATH,
  +
APERTIUM_INTERFACE,
  +
&error);
  +
  +
g_debug("proxy %d\n", proxy);
  +
  +
if (proxy == NULL || error != NULL)
  +
{
  +
g_warning("Cannot connect to the apertium service : %s\n", error->message);
  +
g_error_free(error);
  +
return FALSE;
  +
}
  +
else
  +
{
  +
return TRUE;
  +
}
  +
  +
}
  +
  +
gboolean apertium_dbus_translate(const gchar* given_string, gboolean mark_unknown, gchar *translated_string)
  +
{
  +
  +
GError *error = NULL;
  +
gchar *ceviri = NULL;
  +
GHashTable *hash = NULL;
  +
gchar *option_key = "mark_unknown";
  +
gchar *option_value = NULL;
  +
  +
hash = g_hash_table_new(g_str_hash, g_str_equal);
  +
  +
if (mark_unknown)
  +
{
  +
g_hash_table_insert(hash, "mark_unknown", "true");
  +
}
  +
else
  +
{
  +
g_hash_table_insert(hash, "mark_unknown", "false");
  +
}
  +
  +
dbus_g_proxy_call(proxy, "translate", &error,
  +
G_TYPE_STRING, "en-es",
  +
DBUS_TYPE_G_STRING_STRING_HASHTABLE, hash,
  +
G_TYPE_STRING, given_string,
  +
G_TYPE_INVALID,
  +
G_TYPE_STRING,
  +
&translated_string,
  +
G_TYPE_INVALID);
  +
  +
g_hash_table_destroy(hash);
  +
  +
if (error)
  +
{
  +
g_error_free(error);
  +
return FALSE;
  +
}
  +
else
  +
{
  +
g_error_free(error);
  +
return TRUE;
  +
}
  +
}
  +
  +
  +
int main(int argc, char** argv)
  +
{
  +
if (argc <= 1)
  +
return 1;
  +
  +
g_type_init();
  +
  +
if (apertium_dbus_init() == FALSE)
  +
g_error("apertium_dbus_init, unable to connect apertium DBUS service");
  +
else
  +
{
  +
apertium_dbus_translate(argv[1], TRUE, ceviri);
  +
g_print("%s is : %s\n", argv[1], ceviri);
  +
g_free(ceviri);
  +
g_object_unref(proxy);
  +
}
  +
return 0;
  +
}
  +
</pre>
   
 
[[Category:Development]]
 
[[Category:Development]]
  +
[[Category:Documentation in English]]

Latest revision as of 11:30, 24 March 2012

Here are some code snippets for various programming languages (complete with completely unnecessary comments) showing how you can interface with Apertium by means of D-Bus. You'll need to install the D-Bus service for Apertium.

Python[edit]

#!/usr/bin/python
# coding=utf-8
# -*- encoding: utf-8 -*-

import dbus, sys, codecs;

sys.stdin = codecs.getwriter('utf-8')(sys.stdin);
sys.stdout = codecs.getwriter('utf-8')(sys.stdout);

mode_name = 'en-af'; # The name of the installed mode

bus = dbus.SessionBus(); # Create a new session bus

# Get the translator
translator = dbus.Interface(bus.get_object('org.apertium.mode', '/'), 'org.apertium.Translate'); 

input = sys.stdin.read(); # Read the data

print translator.translate(mode_name, {}, input); # Print the translation

Java[edit]

See also: Installing the Java D-Bus bindings and Compiling a Java D-Bus program
import org.freedesktop.DBus;
import org.freedesktop.dbus.DBusConnection;
import org.freedesktop.dbus.exceptions.DBusException;

import org.apertium.Info; // The interface we use to access org.apertium.info/

class TestDBus {

        public static void main(String[] args) throws org.freedesktop.dbus.exceptions.DBusException {
                DBusConnection bus = null;
                Info info = null;

                bus = DBusConnection.getConnection(DBusConnection.SESSION);
                info = bus.getRemoteObject("org.apertium.info", "/", Info.class);

                for (String s : info.modes()) {
                        System.out.println(s);
                }

                bus.disconnect();
        }
}

In this program, we simply use the proxy object to invoke the modes method on the D-Bus object org.apertium.info. This returns a Java List<String>; we enumerate this list, printing each string.

C++[edit]

See also: Installing the C++ D-Bus bindings and Compiling a C++ D-Bus program
#include <map>
#include <iostream>
#include <sstream>
#include <string>

#include <dbus-c++/dbus.h>
#include "Translate-glue.h"

static const char* TRANSLATE_SERVICE_NAME = "org.apertium.mode";
static const char* TRANSLATE_OBJECT_PATH = "/";

class Translate
: public org::apertium::Translate,
  public DBus::IntrospectableProxy,
  public DBus::ObjectProxy
{
public:
    Translate(DBus::Connection& connection, const char* path, const char* name)
    : DBus::ObjectProxy(connection, path, name) {
    }
};

DBus::BusDispatcher dispatcher;

int main(int argc, char** argv) {
    DBus::default_dispatcher = &dispatcher;
    DBus::Connection bus = DBus::Connection::SessionBus();

    std::stringstream input;
    std::string mode;
    std::map< ::DBus::String, ::DBus::String> translate_options;

    if (argc != 2) {
        std::cerr << "usage: dbus_test <mode>" << std::endl;
        return 1;
    }

    mode = std::string(argv[1]);

    while (!std::cin.eof() and std::cin) {
        std::string str;
        std::cin >> str;
        input << str << " ";
    }

    Translate translator(bus, TRANSLATE_OBJECT_PATH, TRANSLATE_SERVICE_NAME);
    std::cout << translator.translate(mode, translate_options, input.str()) 
              << std::endl;
}

This program is a simple emulation of the main apertium program. It takes a single parameter, which is the translation mode (something like en-ca). It reads words from stdin and calls the method translate on the D-Bus proxy object translator to translate the text read from stdin. When the translation is complete, it writes the translated string to stdout.

Clojure[edit]

(import '(org.freedesktop.dbus DBusConnection))

(def bus (. DBusConnection (getConnection (. DBusConnection SESSION))))
(def info (. bus (getRemoteObject "org.apertium.info" "/" (class org.apertium.Info))))

(doseq mode (. info (modes))
       (prn mode))

(. bus (disconnect))

Clojure is a new Lisp dialect aimed at the Java Virtual Machine. You can see that the Clojure implementation is close to the Java implementation. To run the Clojure code, you will need to pass the same command line parameters to the Java Virtual Machine as for the Java example above.

C - Glib Bindings[edit]

#include 	<glib.h>
#include	<glib-object.h>
#include	<dbus/dbus.h>
#include	<dbus/dbus-glib.h>

#define 	APERTIUM_SERVICE_NAME   "org.apertium.mode"
#define 	APERTIUM_INTERFACE	"org.apertium.Translate"
#define 	APERTIUM_OBJECT_PATH	"/"

gboolean apertium_dbus_init();
gboolean apertium_dbus_translate(const gchar*, gboolean, gchar*);

static DBusGConnection *conn = NULL;
static DBusGProxy *proxy = NULL;
static gchar *ceviri = NULL;

gboolean apertium_dbus_init()
{
	GError *error = NULL;
	
	conn = dbus_g_bus_get(DBUS_BUS_SESSION, &error);
	
	if (conn == NULL) {
		g_warning("Error %s\n", error->message);
                g_error_free(error);
		return FALSE;
	}
	else
	{
		g_debug("conn object is %d\n", conn);
	}

	proxy = dbus_g_proxy_new_for_name_owner(conn,
						APERTIUM_SERVICE_NAME,
						APERTIUM_OBJECT_PATH,
						APERTIUM_INTERFACE,
					        &error);
		
	g_debug("proxy %d\n", proxy);
									
	if (proxy == NULL || error != NULL)
	{
		g_warning("Cannot connect to the apertium service : %s\n", error->message);
		g_error_free(error);
		return FALSE;
	}
	else
	{
		return TRUE;
	}
	
}

gboolean apertium_dbus_translate(const gchar* given_string, gboolean mark_unknown, gchar *translated_string)
{
		
	GError *error = NULL;
	gchar *ceviri = NULL;
	GHashTable *hash = NULL;
	gchar *option_key = "mark_unknown";
	gchar *option_value = NULL;
	
	hash = g_hash_table_new(g_str_hash, g_str_equal);
	
	if (mark_unknown)
	{
		g_hash_table_insert(hash, "mark_unknown", "true");
	}
	else
	{
		g_hash_table_insert(hash, "mark_unknown", "false");
	}
	
	dbus_g_proxy_call(proxy, "translate", &error, 
					G_TYPE_STRING, "en-es", 
					DBUS_TYPE_G_STRING_STRING_HASHTABLE, hash, 
					G_TYPE_STRING, given_string,
					G_TYPE_INVALID,
					G_TYPE_STRING,
					&translated_string,
					G_TYPE_INVALID);
									
	g_hash_table_destroy(hash);
	
	if (error) 
        {
	    g_error_free(error);
            return FALSE;
        }
	else
        {
            g_error_free(error);
	    return TRUE;
        }
}


int main(int argc, char** argv)
{
	if (argc <= 1)
		return 1;
	
	g_type_init();	
	
	if (apertium_dbus_init() == FALSE)
		g_error("apertium_dbus_init, unable to connect apertium DBUS service");
	else
	{
		apertium_dbus_translate(argv[1], TRUE, ceviri);	
		g_print("%s is : %s\n", argv[1], ceviri);
		g_free(ceviri);
		g_object_unref(proxy);
	}	
	return 0;
}