Mercurial > projects > dbus-d
changeset 0:a5576806d36d
recreate repository without any libs for lightweight repository
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/.hgignore Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,9 @@ +syntax: regexp +^bin +^dbus-d-javahelper/bin + +^dbus-d-javatests/bin +^dbus-d-javatests/dsrc/dsss_objs +^dbus-d-javatests/dsrc/dsss.last +^dbus-d-javatests/dsrc/DHelper +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbus-d-javahelper/.classpath Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,7 @@ +<?xml version="1.0" encoding="UTF-8"?> +<classpath> + <classpathentry kind="src" path="jsrc"/> + <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/> + <classpathentry combineaccessrules="false" exported="true" kind="src" path="/dbus-java"/> + <classpathentry kind="output" path="bin"/> +</classpath>
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbus-d-javahelper/.project Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,17 @@ +<?xml version="1.0" encoding="UTF-8"?> +<projectDescription> + <name>dbus-d-javahelper</name> + <comment></comment> + <projects> + </projects> + <buildSpec> + <buildCommand> + <name>org.eclipse.jdt.core.javabuilder</name> + <arguments> + </arguments> + </buildCommand> + </buildSpec> + <natures> + <nature>org.eclipse.jdt.core.javanature</nature> + </natures> +</projectDescription>
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbus-d-javahelper/.settings/org.eclipse.jdt.core.prefs Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,12 @@ +#Wed Aug 29 10:28:04 MESZ 2007 +org.eclipse.jdt.core.compiler.debug.localVariable=generate +org.eclipse.jdt.core.compiler.debug.sourceFile=generate +org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve +org.eclipse.jdt.core.compiler.compliance=1.5 +org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5 +org.eclipse.jdt.core.compiler.problem.enumIdentifier=error +org.eclipse.jdt.core.compiler.debug.lineNumber=generate +org.eclipse.jdt.core.compiler.problem.assertIdentifier=error +org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled +org.eclipse.jdt.core.compiler.source=1.5 +eclipse.preferences.version=1
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbus-d-javahelper/jsrc/dbus_d_javahelper/ConsoleProcess.java Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,66 @@ +/* + * License: Public Domain + * written by Frank Benoit + */ +package dbus_d_javahelper; + +import java.io.BufferedReader; +import java.io.File; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.io.OutputStream; +import java.io.OutputStreamWriter; +import java.io.PrintWriter; + +public class ConsoleProcess { + + private final Thread threadStdout; + private final Thread threadStderr; + private final Process process; + + private class StreamPump extends Thread { + + private final InputStream istr; + private final OutputStream ostr; + + public StreamPump(InputStream istr, OutputStream ostr) { + this.istr = istr; + this.ostr = ostr; + } + + public void run() { + BufferedReader inputStream = new BufferedReader( + new InputStreamReader(istr)); + PrintWriter writer = new PrintWriter(new OutputStreamWriter(ostr)); + String c; + try { + while ((c = inputStream.readLine()) != null) { + writer.println(c); + writer.flush(); + } + } catch (IOException e) { + e.printStackTrace(); + } + } + } + public ConsoleProcess( String[] cmdarray, String[] envp, File basedir, OutputStream stdout, OutputStream stderr ) throws IOException{ + process = Runtime.getRuntime().exec( cmdarray, envp, basedir ); + threadStdout = new StreamPump( process.getInputStream(), stdout ); + threadStderr = new StreamPump( process.getErrorStream(), stderr ); + + threadStdout.start(); + threadStderr.start(); + } + + public int join() throws InterruptedException{ + process.waitFor(); + threadStdout.join(); + threadStderr.join(); + return process.exitValue(); + } + + public void interrupt() { + process.destroy(); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbus-d-javahelper/jsrc/dbus_d_javahelper/DBusDLoader.java Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,91 @@ +/* + * License: Public Domain + * written by Frank Benoit + */ +package dbus_d_javahelper; + +import java.io.File; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.InputStream; + +import org.freedesktop.dbus.DirectConnection; + +public class DBusDLoader { + + + private DirectConnection dc; + private final String dhelper; + private final String address; + private InputStream resourceStream = null; + + public DBusDLoader( String dhelper ){ + this.dhelper = dhelper; + address = DirectConnection.createDynamicTCPSession(); + } + + public DBusDLoader( InputStream resourceStream, File helperLocation ){ + this( new File( helperLocation, "DHelper.exe" ).getAbsolutePath() ); + this.resourceStream = resourceStream; + } + + public DirectConnection getConnection(){ + return dc; + } + + public void ensure( boolean cond ){ + if( !cond ){ + throw new RuntimeException( "ensure failed" ); + } + } + + public synchronized DirectConnection startup() throws Exception { + + if( resourceStream != null ){ + FileOutputStream ostr = new FileOutputStream( dhelper ); + int c, s = 0; + byte[] data = new byte[0x10000]; + while((c=resourceStream.read(data)) > 0 ){ + ostr.write( data, 0, c ); + s++; + } + resourceStream.close(); + ostr.close(); + + // set execute permission + Process prc = Runtime.getRuntime().exec( new String[]{ "chmod", "u+x", dhelper }); + prc.waitFor(); + } + new Thread() { + @Override + public void run() { + try { + ConsoleProcess process = new ConsoleProcess( + new String[] { + dhelper }, + new String[] { + "DBUS_ADDRESS="+address }, + null, + System.out, + System.err); + process.join(); + } catch (InterruptedException e) { + e.printStackTrace(); + } catch (IOException e) { + e.printStackTrace(); + } + } + }.start(); + + dc = new DirectConnection(address + ",listen=true"); + return dc; + } + + public synchronized void disconnect(){ + if( dc != null ){ + dc.disconnect(); + dc = null; + } + } + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbus-d-javatests/.classpath Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,8 @@ +<?xml version="1.0" encoding="UTF-8"?> +<classpath> + <classpathentry kind="src" path="jsrc"/> + <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/> + <classpathentry combineaccessrules="false" kind="src" path="/dbus-d-javahelper"/> + <classpathentry kind="con" path="org.eclipse.jdt.USER_LIBRARY/JFace"/> + <classpathentry kind="output" path="bin"/> +</classpath>
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbus-d-javatests/.project Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,17 @@ +<?xml version="1.0" encoding="UTF-8"?> +<projectDescription> + <name>Tests</name> + <comment></comment> + <projects> + </projects> + <buildSpec> + <buildCommand> + <name>org.eclipse.jdt.core.javabuilder</name> + <arguments> + </arguments> + </buildCommand> + </buildSpec> + <natures> + <nature>org.eclipse.jdt.core.javanature</nature> + </natures> +</projectDescription>
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbus-d-javatests/.settings/org.eclipse.jdt.core.prefs Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,12 @@ +#Fri Aug 17 16:35:38 CEST 2007 +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled +org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5 +org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve +org.eclipse.jdt.core.compiler.compliance=1.5 +org.eclipse.jdt.core.compiler.debug.lineNumber=generate +org.eclipse.jdt.core.compiler.debug.localVariable=generate +org.eclipse.jdt.core.compiler.debug.sourceFile=generate +org.eclipse.jdt.core.compiler.problem.assertIdentifier=error +org.eclipse.jdt.core.compiler.problem.enumIdentifier=error +org.eclipse.jdt.core.compiler.source=1.5
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbus-d-javatests/.settings/org.eclipse.jdt.ui.prefs Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,3 @@ +#Sat Sep 01 04:25:33 CEST 2007 +eclipse.preferences.version=1 +internal.default.compliance=default
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbus-d-javatests/README.txt Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,14 @@ +To compile and run this example, it is required to have the following jars +in the classpath: + +org.eclipse.core.commands_3.3.0.I20070605-0010.jar +org.eclipse.equinox.common_3.3.0.v20070426.jar +org.eclipse.jface_3.3.0.I20070606-0010.jar +org.eclipse.osgi_3.3.0.v20070530.jar +org.eclipse.swt.win32.win32.x86_3.3.0.v3346.jar +org.eclipse.swt_3.3.0.v3346.jar + +Probably other versions will work also :) +I placed them into a 'lib' called subdirectory. + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbus-d-javatests/dsrc/DBusTests.d Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,203 @@ +module DBusTests; + +import DBusTestsInterfaces; +import org.freedesktop.dbus.Variant; +import org.freedesktop.dbus.DBus; + +import tango.core.Signal; +import tango.io.Stdout; + +void main(char[][] args) { + if( args.length != 2 ){ + Stderr.formatln( "there is not exaclty one argument" ); + } + Stdout.formatln("... started D app ..."); + DirectConnection dc = new DirectConnection( args[1] ); + Stdout.formatln("Connected"); + auto o = new Tests(); + o.registerDBusObject( dc.conn ); + Stdout.formatln("Export obj : {}", o.getDBusInstanceName() ); +Stdout.flush(); + dc.mainLoop(); + Stdout.formatln("Disconnected"); +Stdout.flush(); +Stderr.flush(); +} + + +class Tests : DBusObject, DBusInterface.dbustests.Tests { + public this(){ + super(); + signalVoid().attach( & detectSignalVoid ); + signalInt().attach( & detectSignalInt ); + signalStruct().attach( & detectSignalStruct ); + signalArray().attach( & detectSignalArray ); + } + public void identityVoid(){ + } + public bool identityBool(in bool input ){ + return input; + } + public byte identityByte(in byte input ){ + return input; + } + public short identityShort(in short input ){ + return input; + } + public ushort identityUShort(in ushort input ){ + return input; + } + public int identityInt(in int input ){ + return input; + } + public uint identityUInt(in uint input ){ + return input; + } + public long identityLong(in long input ){ + //Stdout.formatln( "D: identityLong {}", input ).flush(); + return input; + } + public ulong identityULong(in ulong input ){ + return input; + } + public double identityDouble(in double input ){ + return input; + } + public char[] identityString(in char[] input ){ + return input; + } + public DBusVariant identityVariant(in DBusVariant input ){ + return input; + } + + public bool[] identityArrayBool(in bool[] input ){ + Stdout.formatln( "identityArrayBool length {}", input.length ); + return input.dup; + } + public byte[] identityArrayByte(in byte[] input ){ + return input; + } + public short[] identityArrayShort(in short[] input ){ + return input; + } + public ushort[] identityArrayUShort(in ushort[] input ){ + return input; + } + public int[] identityArrayInt(in int[] input ){ + return input; + } + public uint[] identityArrayUInt(in uint[] input ){ + return input; + } + public long[] identityArrayLong(in long[] input ){ + return input; + } + public ulong[] identityArrayULong(in ulong[] input ){ + return input; + } + public double[] identityArrayDouble(in double[] input ){ + return input; + } + public char[][] identityArrayString(in char[][] input ){ + return input; + } + public DBusVariant[] identityArrayVariant(in DBusVariant[] input ){ + return input; + } + public long Sum(in int[] input ){ + long res; + foreach( v; input ){ + res += v; + } + return res; + } + public uint Sum(in byte[] input ){ + long res; + foreach( v; input ){ + res += v; + } + return res; + } + public char[][][ char[] ] InvertMapping(in char[][ char[] ] input ){ + Stderr.formatln( "InvertMapping();" ).flush; + char[][][ char[] ] res; + foreach( k, v; input ){ + if( v in res ){ + char[][] data = res[ v ]; + data ~= k.dup; + res[ v ] = data; + } + else{ + res[ v.dup ] = [k.dup]; + } + } + Stderr.formatln( "InvertMapping();" ).flush; + return res; + } + public void DeStruct( + in Struct!( char[], uint, short ) input, + out char[] res_1, + out uint res_2, + out short res_3 ) + { + res_1 = input.t[0]; + res_2 = input.t[1]; + res_3 = input.t[2]; + } + + public DBusVariant[] Primitize(in DBusVariant input ){ + DBusVariant[] res; + return null; + } + public bool Invert(in bool input ){ + return !input; + } + + // ------------------------------------------ + Signal!() signalVoid_; + public Signal!()* signalVoid(){ + return & signalVoid_; + } + private void detectSignalVoid(){ + Stdout.formatln( "signalVoid();" ); + } + // ------------------------------------------ + Signal!( int ) signalInt_; + public Signal!( int )* signalInt(){ + return & signalInt_; + } + private void detectSignalInt( int v ){ + Stdout.formatln( "signalInt({});", v ); + } + // ------------------------------------------ + Signal!( Struct!( char[], uint, short ) ) signalStruct_; + public Signal!( Struct!( char[], uint, short ) )* signalStruct(){ + return & signalStruct_; + } + private void detectSignalStruct( Struct!( char[], uint, short ) value ){ + Stdout.formatln( "signalStruct( Struct!( {}, {}, {} ) );", value.t[0], value.t[1], value.t[2] ); + } + // ------------------------------------------ + Signal!( Struct!( char[], uint, short )[] ) signalArray_; + public Signal!( Struct!( char[], uint, short )[] )* signalArray(){ + return & signalArray_; + } + private void detectSignalArray(Struct!( char[], uint, short )[] value ){ + Stdout.formatln( "signalArray() with {} elements", value.length ); + foreach( v; value ){ + Stdout.formatln( " {} {} {}", v.t[0], v.t[1], v.t[2] ); + } + Stdout.flush; + } + // ------------------------------------------ + Signal!( DBusVariant ) signalVariant_; + public Signal!( DBusVariant )* signalVariant(){ + return & signalVariant_; + } + // ------------------------------------------ + +} + + + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbus-d-javatests/dsrc/DBusTestsInterfaces.d Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,784 @@ +/** + * Generated with TioLink + * TioLink was written by Frank Benoit <benoit@tionex.de> + * http://www.dsource.org/projects/tiolink + * + * File type: D programming language source code + */ +module DBusTestsInterfaces; + +public import org.freedesktop.dbus.Struct; +public import org.freedesktop.dbus.Variant; + +import tango.core.Signal; +import org.freedesktop.dbus.DBus; +import org.freedesktop.dbus.c.Connection : DBusConnection; +import org.freedesktop.dbus.c.Message : DBusMessage; +import org.freedesktop.dbus.c.Shared : DBusHandlerResult; + + +// DBus interfaces +public interface DBusInterface { + // org + public interface org { + // org.freedesktop + public interface freedesktop { + // org.freedesktop.DBus + public interface DBus { + // org.freedesktop.DBus.Peer + public interface Peer { + public void Ping(); + public char[] GetMachineId(); + } + // org.freedesktop.DBus.Introspectable + public interface Introspectable { + public char[] Introspect(); + } + // org.freedesktop.DBus.Properties + public interface Properties { + public DBusVariant Get( in char[] intf_name, in char[] prop_name ); + public void Set( in char[] intf_name, in char[] prop_name, in DBusVariant prop ); + public DBusVariant[ char[] ] GetAll( in char[] intf_name ); + } + } + } + } + // dbustests + public interface dbustests { + // dbustests.Tests + public interface Tests { + public void identityVoid(); + public bool identityBool( in bool input ); + public byte identityByte( in byte input ); + public short identityShort( in short input ); + public ushort identityUShort( in ushort input ); + public int identityInt( in int input ); + public uint identityUInt( in uint input ); + public long identityLong( in long input ); + public ulong identityULong( in ulong input ); + public double identityDouble( in double input ); + public char[] identityString( in char[] input ); + public DBusVariant identityVariant( in DBusVariant input ); + public bool[] identityArrayBool( in bool[] input ); + public byte[] identityArrayByte( in byte[] input ); + public short[] identityArrayShort( in short[] input ); + public ushort[] identityArrayUShort( in ushort[] input ); + public int[] identityArrayInt( in int[] input ); + public uint[] identityArrayUInt( in uint[] input ); + public long[] identityArrayLong( in long[] input ); + public ulong[] identityArrayULong( in ulong[] input ); + public double[] identityArrayDouble( in double[] input ); + public char[][] identityArrayString( in char[][] input ); + public DBusVariant[] identityArrayVariant( in DBusVariant[] input ); + public long Sum( in int[] input ); + public uint Sum( in byte[] input ); + public char[][][ char[] ] InvertMapping( in char[][ char[] ] input ); + public void DeStruct( in Struct!( char[], uint, short ) input, out char[] res_1, out uint res_2, out short res_3 ); + public DBusVariant[] Primitize( in DBusVariant input ); + public bool Invert( in bool input ); + public tango.core.Signal.Signal!()* signalVoid(); + public tango.core.Signal.Signal!( int )* signalInt(); + public tango.core.Signal.Signal!( Struct!( char[], uint, short ) )* signalStruct(); + public tango.core.Signal.Signal!( Struct!( char[], uint, short )[] )* signalArray(); + public tango.core.Signal.Signal!( DBusVariant )* signalVariant(); + } + } +} + + +// Peer implementations +public interface DBusPeers { + // org + public class org : DBusPeerObject, DBusInterface.org { + // org.freedesktop + public class freedesktop : DBusPeerObject, DBusInterface.org.freedesktop { + // org.freedesktop.DBus + public class DBus : DBusPeerObject, DBusInterface.org.freedesktop.DBus { + // org.freedesktop.DBus.Peer + public class Peer : DBusPeerObject, DBusInterface.org.freedesktop.DBus.Peer { + public void Ping(){ + } + public char[] GetMachineId(){ + } + } + // org.freedesktop.DBus.Introspectable + public class Introspectable : DBusPeerObject, DBusInterface.org.freedesktop.DBus.Introspectable { + public char[] Introspect(){ + } + } + // org.freedesktop.DBus.Properties + public class Properties : DBusPeerObject, DBusInterface.org.freedesktop.DBus.Properties { + public DBusVariant Get( in char[] intf_name, in char[] prop_name ){ + } + public void Set( in char[] intf_name, in char[] prop_name, in DBusVariant prop ){ + } + public DBusVariant[ char[] ] GetAll( in char[] intf_name ){ + } + } + } + } + } + // dbustests + public class dbustests : DBusPeerObject, DBusInterface.dbustests { + // dbustests.Tests + public class Tests : DBusPeerObject, DBusInterface.dbustests.Tests { + public void identityVoid(){ + } + public bool identityBool( in bool input ){ + } + public byte identityByte( in byte input ){ + } + public short identityShort( in short input ){ + } + public ushort identityUShort( in ushort input ){ + } + public int identityInt( in int input ){ + } + public uint identityUInt( in uint input ){ + } + public long identityLong( in long input ){ + } + public ulong identityULong( in ulong input ){ + } + public double identityDouble( in double input ){ + } + public char[] identityString( in char[] input ){ + } + public DBusVariant identityVariant( in DBusVariant input ){ + } + public bool[] identityArrayBool( in bool[] input ){ + } + public byte[] identityArrayByte( in byte[] input ){ + } + public short[] identityArrayShort( in short[] input ){ + } + public ushort[] identityArrayUShort( in ushort[] input ){ + } + public int[] identityArrayInt( in int[] input ){ + } + public uint[] identityArrayUInt( in uint[] input ){ + } + public long[] identityArrayLong( in long[] input ){ + } + public ulong[] identityArrayULong( in ulong[] input ){ + } + public double[] identityArrayDouble( in double[] input ){ + } + public char[][] identityArrayString( in char[][] input ){ + } + public DBusVariant[] identityArrayVariant( in DBusVariant[] input ){ + } + public long Sum( in int[] input ){ + } + public uint Sum( in byte[] input ){ + } + public char[][][ char[] ] InvertMapping( in char[][ char[] ] input ){ + } + public void DeStruct( in Struct!( char[], uint, short ) input, out char[] res_1, out uint res_2, out short res_3 ){ + } + public DBusVariant[] Primitize( in DBusVariant input ){ + } + public bool Invert( in bool input ){ + } + } + } +} + + +// DBusObject +public class DBusObject : DBusObjectImpl, DBusInterface.org.freedesktop.DBus.Introspectable { + this(){ + super(); + } + public char[] Introspect(){ + return super.Introspect(); + } +} + + +// DBusPeerObject +public class DBusPeerObject { +} + + +private void init_introspectionData(){ + registerIntrospectionData( + DBusInterface.org.freedesktop.DBus.Peer.classinfo, + `<interface name="org.freedesktop.DBus.Peer">\n` + ` <method name="Ping">\n` + ` </method>\n` + ` <method name="GetMachineId">\n` + ` <annotation name="org.dsource.tiolink.Returns" value="machine_uuid" />\n` + ` <arg name="machine_uuid" type="s" direction="out" />\n` + ` </method>\n` + `</interface>\n`); + registerIntrospectionData( + DBusInterface.org.freedesktop.DBus.Introspectable.classinfo, + `<interface name="org.freedesktop.DBus.Introspectable">\n` + ` <method name="Introspect">\n` + ` <annotation name="org.dsource.tiolink.Returns" value="xml_data" />\n` + ` <arg name="xml_data" type="s" direction="out" />\n` + ` </method>\n` + `</interface>\n`); + registerIntrospectionData( + DBusInterface.org.freedesktop.DBus.Properties.classinfo, + `<interface name="org.freedesktop.DBus.Properties">\n` + ` <method name="Get">\n` + ` <annotation name="org.dsource.tiolink.Returns" value="prop" />\n` + ` <arg name="intf_name" type="s" direction="in" />\n` + ` <arg name="prop_name" type="s" direction="in" />\n` + ` <arg name="prop" type="v" direction="out" />\n` + ` </method>\n` + ` <method name="Set">\n` + ` <arg name="intf_name" type="s" direction="in" />\n` + ` <arg name="prop_name" type="s" direction="in" />\n` + ` <arg name="prop" type="v" direction="in" />\n` + ` </method>\n` + ` <method name="GetAll">\n` + ` <annotation name="org.dsource.tiolink.Returns" value="allprops" />\n` + ` <arg name="intf_name" type="s" direction="in" />\n` + ` <arg name="allprops" type="a{sv}" direction="out" />\n` + ` </method>\n` + `</interface>\n`); + registerIntrospectionData( + DBusInterface.dbustests.Tests.classinfo, + `<interface name="dbustests.Tests">\n` + ` <method name="identityVoid">\n` + ` </method>\n` + ` <method name="identityBool">\n` + ` <annotation name="org.dsource.tiolink.Returns" value="res" />\n` + ` <arg name="res" type="b" direction="out" />\n` + ` <arg name="input" type="b" direction="in" />\n` + ` </method>\n` + ` <method name="identityByte">\n` + ` <annotation name="org.dsource.tiolink.Returns" value="res" />\n` + ` <arg name="res" type="y" direction="out" />\n` + ` <arg name="input" type="y" direction="in" />\n` + ` </method>\n` + ` <method name="identityShort">\n` + ` <annotation name="org.dsource.tiolink.Returns" value="res" />\n` + ` <arg name="res" type="n" direction="out" />\n` + ` <arg name="input" type="n" direction="in" />\n` + ` </method>\n` + ` <method name="identityUShort">\n` + ` <annotation name="org.dsource.tiolink.Returns" value="res" />\n` + ` <arg name="res" type="q" direction="out" />\n` + ` <arg name="input" type="q" direction="in" />\n` + ` </method>\n` + ` <method name="identityInt">\n` + ` <annotation name="org.dsource.tiolink.Returns" value="res" />\n` + ` <arg name="res" type="i" direction="out" />\n` + ` <arg name="input" type="i" direction="in" />\n` + ` </method>\n` + ` <method name="identityUInt">\n` + ` <annotation name="org.dsource.tiolink.Returns" value="res" />\n` + ` <arg name="res" type="u" direction="out" />\n` + ` <arg name="input" type="u" direction="in" />\n` + ` </method>\n` + ` <method name="identityLong">\n` + ` <annotation name="org.dsource.tiolink.Returns" value="res" />\n` + ` <arg name="res" type="x" direction="out" />\n` + ` <arg name="input" type="x" direction="in" />\n` + ` </method>\n` + ` <method name="identityULong">\n` + ` <annotation name="org.dsource.tiolink.Returns" value="res" />\n` + ` <arg name="res" type="t" direction="out" />\n` + ` <arg name="input" type="t" direction="in" />\n` + ` </method>\n` + ` <method name="identityDouble">\n` + ` <annotation name="org.dsource.tiolink.Returns" value="res" />\n` + ` <arg name="res" type="d" direction="out" />\n` + ` <arg name="input" type="d" direction="in" />\n` + ` </method>\n` + ` <method name="identityString">\n` + ` <annotation name="org.dsource.tiolink.Returns" value="res" />\n` + ` <arg name="res" type="s" direction="out" />\n` + ` <arg name="input" type="s" direction="in" />\n` + ` </method>\n` + ` <method name="identityVariant">\n` + ` <annotation name="org.dsource.tiolink.Returns" value="res" />\n` + ` <arg name="res" type="v" direction="out" />\n` + ` <arg name="input" type="v" direction="in" />\n` + ` </method>\n` + ` <method name="identityArrayBool">\n` + ` <annotation name="org.dsource.tiolink.Returns" value="res" />\n` + ` <arg name="res" type="ab" direction="out" />\n` + ` <arg name="input" type="ab" direction="in" />\n` + ` </method>\n` + ` <method name="identityArrayByte">\n` + ` <annotation name="org.dsource.tiolink.Returns" value="res" />\n` + ` <arg name="res" type="ay" direction="out" />\n` + ` <arg name="input" type="ay" direction="in" />\n` + ` </method>\n` + ` <method name="identityArrayShort">\n` + ` <annotation name="org.dsource.tiolink.Returns" value="res" />\n` + ` <arg name="res" type="an" direction="out" />\n` + ` <arg name="input" type="an" direction="in" />\n` + ` </method>\n` + ` <method name="identityArrayUShort">\n` + ` <annotation name="org.dsource.tiolink.Returns" value="res" />\n` + ` <arg name="res" type="aq" direction="out" />\n` + ` <arg name="input" type="aq" direction="in" />\n` + ` </method>\n` + ` <method name="identityArrayInt">\n` + ` <annotation name="org.dsource.tiolink.Returns" value="res" />\n` + ` <arg name="res" type="ai" direction="out" />\n` + ` <arg name="input" type="ai" direction="in" />\n` + ` </method>\n` + ` <method name="identityArrayUInt">\n` + ` <annotation name="org.dsource.tiolink.Returns" value="res" />\n` + ` <arg name="res" type="au" direction="out" />\n` + ` <arg name="input" type="au" direction="in" />\n` + ` </method>\n` + ` <method name="identityArrayLong">\n` + ` <annotation name="org.dsource.tiolink.Returns" value="res" />\n` + ` <arg name="res" type="ax" direction="out" />\n` + ` <arg name="input" type="ax" direction="in" />\n` + ` </method>\n` + ` <method name="identityArrayULong">\n` + ` <annotation name="org.dsource.tiolink.Returns" value="res" />\n` + ` <arg name="res" type="at" direction="out" />\n` + ` <arg name="input" type="at" direction="in" />\n` + ` </method>\n` + ` <method name="identityArrayDouble">\n` + ` <annotation name="org.dsource.tiolink.Returns" value="res" />\n` + ` <arg name="res" type="ad" direction="out" />\n` + ` <arg name="input" type="ad" direction="in" />\n` + ` </method>\n` + ` <method name="identityArrayString">\n` + ` <annotation name="org.dsource.tiolink.Returns" value="res" />\n` + ` <arg name="res" type="as" direction="out" />\n` + ` <arg name="input" type="as" direction="in" />\n` + ` </method>\n` + ` <method name="identityArrayVariant">\n` + ` <annotation name="org.dsource.tiolink.Returns" value="res" />\n` + ` <arg name="res" type="av" direction="out" />\n` + ` <arg name="input" type="av" direction="in" />\n` + ` </method>\n` + ` <method name="Sum">\n` + ` <annotation name="org.dsource.tiolink.Returns" value="res" />\n` + ` <arg name="res" type="x" direction="out" />\n` + ` <arg name="input" type="ai" direction="in" />\n` + ` </method>\n` + ` <method name="Sum">\n` + ` <annotation name="org.dsource.tiolink.Returns" value="res" />\n` + ` <arg name="res" type="u" direction="out" />\n` + ` <arg name="input" type="ay" direction="in" />\n` + ` </method>\n` + ` <method name="InvertMapping">\n` + ` <annotation name="org.dsource.tiolink.Returns" value="res" />\n` + ` <arg name="res" type="a{sas}" direction="out" />\n` + ` <arg name="input" type="a{ss}" direction="in" />\n` + ` </method>\n` + ` <method name="DeStruct">\n` + ` <arg name="input" type="(sun)" direction="in" />\n` + ` <arg name="res_1" type="s" direction="out" />\n` + ` <arg name="res_2" type="u" direction="out" />\n` + ` <arg name="res_3" type="n" direction="out" />\n` + ` </method>\n` + ` <method name="Primitize">\n` + ` <annotation name="org.dsource.tiolink.Returns" value="res" />\n` + ` <arg name="input" type="v" direction="in" />\n` + ` <arg name="res" type="av" direction="out" />\n` + ` </method>\n` + ` <method name="Invert">\n` + ` <annotation name="org.dsource.tiolink.Returns" value="res" />\n` + ` <arg name="res" type="b" direction="out" />\n` + ` <arg name="input" type="b" direction="in" />\n` + ` </method>\n` + `</interface>\n`); +} +private DBusHandlerResult intfHandler__org_freedesktop_DBus_Peer( DBusConnection* conn, DBusMessage* message, void* user_data ){ + DBusInterface.org.freedesktop.DBus.Peer o = cast(DBusInterface.org.freedesktop.DBus.Peer)cast(Object)user_data; + if( o is null || !checkIntf( "org.freedesktop.DBus.Peer", message) ) + return DBusHandlerResult.DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + + try{ + char[METHOD_SIG_MAXLENGTH] buf; + switch( methodSignature( message, buf ) ){ + case "Ping|": + { + o.Ping(); + sendReply( conn, message ); + } + break; + case "GetMachineId|": + { + Struct!( char[] ) po; + po.t[0] = o.GetMachineId(); + sendReplyData!( char[] )( conn, message, po ); + } + break; + default: + return DBusHandlerResult.DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + } + } + catch( Exception e ){ + sendException( conn, message, e ); + } + return DBusHandlerResult.DBUS_HANDLER_RESULT_HANDLED; +} + +private DBusHandlerResult intfHandler__org_freedesktop_DBus_Introspectable( DBusConnection* conn, DBusMessage* message, void* user_data ){ + DBusInterface.org.freedesktop.DBus.Introspectable o = cast(DBusInterface.org.freedesktop.DBus.Introspectable)cast(Object)user_data; + if( o is null || !checkIntf( "org.freedesktop.DBus.Introspectable", message) ) + return DBusHandlerResult.DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + + try{ + char[METHOD_SIG_MAXLENGTH] buf; + switch( methodSignature( message, buf ) ){ + case "Introspect|": + { + Struct!( char[] ) po; + po.t[0] = o.Introspect(); + sendReplyData!( char[] )( conn, message, po ); + } + break; + default: + return DBusHandlerResult.DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + } + } + catch( Exception e ){ + sendException( conn, message, e ); + } + return DBusHandlerResult.DBUS_HANDLER_RESULT_HANDLED; +} + +private DBusHandlerResult intfHandler__org_freedesktop_DBus_Properties( DBusConnection* conn, DBusMessage* message, void* user_data ){ + DBusInterface.org.freedesktop.DBus.Properties o = cast(DBusInterface.org.freedesktop.DBus.Properties)cast(Object)user_data; + if( o is null || !checkIntf( "org.freedesktop.DBus.Properties", message) ) + return DBusHandlerResult.DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + + try{ + char[METHOD_SIG_MAXLENGTH] buf; + switch( methodSignature( message, buf ) ){ + case "Get|ss": + { + Struct!( char[], char[] ) pi = getCallValues!( char[], char[] )( message ); + Struct!( DBusVariant ) po; + po.t[0] = o.Get( pi.t[0], pi.t[1] ); + sendReplyData!( DBusVariant )( conn, message, po ); + } + break; + case "Set|ssv": + { + Struct!( char[], char[], DBusVariant ) pi = getCallValues!( char[], char[], DBusVariant )( message ); + o.Set( pi.t[0], pi.t[1], pi.t[2] ); + sendReply( conn, message ); + } + break; + case "GetAll|s": + { + Struct!( char[] ) pi = getCallValues!( char[] )( message ); + Struct!( DBusVariant[ char[] ] ) po; + po.t[0] = o.GetAll( pi.t[0] ); + sendReplyData!( DBusVariant[ char[] ] )( conn, message, po ); + } + break; + default: + return DBusHandlerResult.DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + } + } + catch( Exception e ){ + sendException( conn, message, e ); + } + return DBusHandlerResult.DBUS_HANDLER_RESULT_HANDLED; +} + +private DBusHandlerResult intfHandler__dbustests_Tests( DBusConnection* conn, DBusMessage* message, void* user_data ){ + DBusInterface.dbustests.Tests o = cast(DBusInterface.dbustests.Tests)cast(Object)user_data; + if( o is null || !checkIntf( "dbustests.Tests", message) ) + return DBusHandlerResult.DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + + try{ + char[METHOD_SIG_MAXLENGTH] buf; + switch( methodSignature( message, buf ) ){ + case "identityVoid|": + { + o.identityVoid(); + sendReply( conn, message ); + } + break; + case "identityBool|b": + { + Struct!( bool ) pi = getCallValues!( bool )( message ); + Struct!( bool ) po; + po.t[0] = o.identityBool( pi.t[0] ); + sendReplyData!( bool )( conn, message, po ); + } + break; + case "identityByte|y": + { + Struct!( byte ) pi = getCallValues!( byte )( message ); + Struct!( byte ) po; + po.t[0] = o.identityByte( pi.t[0] ); + sendReplyData!( byte )( conn, message, po ); + } + break; + case "identityShort|n": + { + Struct!( short ) pi = getCallValues!( short )( message ); + Struct!( short ) po; + po.t[0] = o.identityShort( pi.t[0] ); + sendReplyData!( short )( conn, message, po ); + } + break; + case "identityUShort|q": + { + Struct!( ushort ) pi = getCallValues!( ushort )( message ); + Struct!( ushort ) po; + po.t[0] = o.identityUShort( pi.t[0] ); + sendReplyData!( ushort )( conn, message, po ); + } + break; + case "identityInt|i": + { + Struct!( int ) pi = getCallValues!( int )( message ); + Struct!( int ) po; + po.t[0] = o.identityInt( pi.t[0] ); + sendReplyData!( int )( conn, message, po ); + } + break; + case "identityUInt|u": + { + Struct!( uint ) pi = getCallValues!( uint )( message ); + Struct!( uint ) po; + po.t[0] = o.identityUInt( pi.t[0] ); + sendReplyData!( uint )( conn, message, po ); + } + break; + case "identityLong|x": + { + Struct!( long ) pi = getCallValues!( long )( message ); + Struct!( long ) po; + po.t[0] = o.identityLong( pi.t[0] ); + sendReplyData!( long )( conn, message, po ); + } + break; + case "identityULong|t": + { + Struct!( ulong ) pi = getCallValues!( ulong )( message ); + Struct!( ulong ) po; + po.t[0] = o.identityULong( pi.t[0] ); + sendReplyData!( ulong )( conn, message, po ); + } + break; + case "identityDouble|d": + { + Struct!( double ) pi = getCallValues!( double )( message ); + Struct!( double ) po; + po.t[0] = o.identityDouble( pi.t[0] ); + sendReplyData!( double )( conn, message, po ); + } + break; + case "identityString|s": + { + Struct!( char[] ) pi = getCallValues!( char[] )( message ); + Struct!( char[] ) po; + po.t[0] = o.identityString( pi.t[0] ); + sendReplyData!( char[] )( conn, message, po ); + } + break; + case "identityVariant|v": + { + Struct!( DBusVariant ) pi = getCallValues!( DBusVariant )( message ); + Struct!( DBusVariant ) po; + po.t[0] = o.identityVariant( pi.t[0] ); + sendReplyData!( DBusVariant )( conn, message, po ); + } + break; + case "identityArrayBool|ab": + { + Struct!( bool[] ) pi = getCallValues!( bool[] )( message ); + Struct!( bool[] ) po; + po.t[0] = o.identityArrayBool( pi.t[0] ); + sendReplyData!( bool[] )( conn, message, po ); + } + break; + case "identityArrayByte|ay": + { + Struct!( byte[] ) pi = getCallValues!( byte[] )( message ); + Struct!( byte[] ) po; + po.t[0] = o.identityArrayByte( pi.t[0] ); + sendReplyData!( byte[] )( conn, message, po ); + } + break; + case "identityArrayShort|an": + { + Struct!( short[] ) pi = getCallValues!( short[] )( message ); + Struct!( short[] ) po; + po.t[0] = o.identityArrayShort( pi.t[0] ); + sendReplyData!( short[] )( conn, message, po ); + } + break; + case "identityArrayUShort|aq": + { + Struct!( ushort[] ) pi = getCallValues!( ushort[] )( message ); + Struct!( ushort[] ) po; + po.t[0] = o.identityArrayUShort( pi.t[0] ); + sendReplyData!( ushort[] )( conn, message, po ); + } + break; + case "identityArrayInt|ai": + { + Struct!( int[] ) pi = getCallValues!( int[] )( message ); + Struct!( int[] ) po; + po.t[0] = o.identityArrayInt( pi.t[0] ); + sendReplyData!( int[] )( conn, message, po ); + } + break; + case "identityArrayUInt|au": + { + Struct!( uint[] ) pi = getCallValues!( uint[] )( message ); + Struct!( uint[] ) po; + po.t[0] = o.identityArrayUInt( pi.t[0] ); + sendReplyData!( uint[] )( conn, message, po ); + } + break; + case "identityArrayLong|ax": + { + Struct!( long[] ) pi = getCallValues!( long[] )( message ); + Struct!( long[] ) po; + po.t[0] = o.identityArrayLong( pi.t[0] ); + sendReplyData!( long[] )( conn, message, po ); + } + break; + case "identityArrayULong|at": + { + Struct!( ulong[] ) pi = getCallValues!( ulong[] )( message ); + Struct!( ulong[] ) po; + po.t[0] = o.identityArrayULong( pi.t[0] ); + sendReplyData!( ulong[] )( conn, message, po ); + } + break; + case "identityArrayDouble|ad": + { + Struct!( double[] ) pi = getCallValues!( double[] )( message ); + Struct!( double[] ) po; + po.t[0] = o.identityArrayDouble( pi.t[0] ); + sendReplyData!( double[] )( conn, message, po ); + } + break; + case "identityArrayString|as": + { + Struct!( char[][] ) pi = getCallValues!( char[][] )( message ); + Struct!( char[][] ) po; + po.t[0] = o.identityArrayString( pi.t[0] ); + sendReplyData!( char[][] )( conn, message, po ); + } + break; + case "identityArrayVariant|av": + { + Struct!( DBusVariant[] ) pi = getCallValues!( DBusVariant[] )( message ); + Struct!( DBusVariant[] ) po; + po.t[0] = o.identityArrayVariant( pi.t[0] ); + sendReplyData!( DBusVariant[] )( conn, message, po ); + } + break; + case "Sum|ai": + { + Struct!( int[] ) pi = getCallValues!( int[] )( message ); + Struct!( long ) po; + po.t[0] = o.Sum( pi.t[0] ); + sendReplyData!( long )( conn, message, po ); + } + break; + case "Sum|ay": + { + Struct!( byte[] ) pi = getCallValues!( byte[] )( message ); + Struct!( uint ) po; + po.t[0] = o.Sum( pi.t[0] ); + sendReplyData!( uint )( conn, message, po ); + } + break; + case "InvertMapping|a{ss}": + { + Struct!( char[][ char[] ] ) pi = getCallValues!( char[][ char[] ] )( message ); + Struct!( char[][][ char[] ] ) po; + po.t[0] = o.InvertMapping( pi.t[0] ); + sendReplyData!( char[][][ char[] ] )( conn, message, po ); + } + break; + case "DeStruct|(sun)": + { + Struct!( Struct!( char[], uint, short ) ) pi = getCallValues!( Struct!( char[], uint, short ) )( message ); + Struct!( char[], uint, short ) po; + o.DeStruct( pi.t[0], po.t[0], po.t[1], po.t[2] ); + sendReplyData!( char[], uint, short )( conn, message, po ); + } + break; + case "Primitize|v": + { + Struct!( DBusVariant ) pi = getCallValues!( DBusVariant )( message ); + Struct!( DBusVariant[] ) po; + po.t[0] = o.Primitize( pi.t[0] ); + sendReplyData!( DBusVariant[] )( conn, message, po ); + } + break; + case "Invert|b": + { + Struct!( bool ) pi = getCallValues!( bool )( message ); + Struct!( bool ) po; + po.t[0] = o.Invert( pi.t[0] ); + sendReplyData!( bool )( conn, message, po ); + } + break; + case "signalVoid>": + { + o.signalVoid().opCall(); + } + break; + case "signalInt>i": + { + Struct!( int ) pi = getCallValues!( int )( message ); + o.signalInt().opCall( pi.t[0] ); + } + break; + case "signalStruct>(sun)": + { + Struct!( Struct!( char[], uint, short ) ) pi = getCallValues!( Struct!( char[], uint, short ) )( message ); + o.signalStruct().opCall( pi.t[0] ); + } + break; + case "signalArray>a(sun)": + { + Struct!( Struct!( char[], uint, short )[] ) pi = getCallValues!( Struct!( char[], uint, short )[] )( message ); + o.signalArray().opCall( pi.t[0] ); + } + break; + case "signalVariant>v": + { + Struct!( DBusVariant ) pi = getCallValues!( DBusVariant )( message ); + o.signalVariant().opCall( pi.t[0] ); + } + break; + default: + return DBusHandlerResult.DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + } + } + catch( Exception e ){ + sendException( conn, message, e ); + } + return DBusHandlerResult.DBUS_HANDLER_RESULT_HANDLED; +} + +private void init_handlers(){ + registerHandler( + DBusInterface.org.freedesktop.DBus.Peer.classinfo, + & intfHandler__org_freedesktop_DBus_Peer ); + registerHandler( + DBusInterface.org.freedesktop.DBus.Introspectable.classinfo, + & intfHandler__org_freedesktop_DBus_Introspectable ); + registerHandler( + DBusInterface.org.freedesktop.DBus.Properties.classinfo, + & intfHandler__org_freedesktop_DBus_Properties ); + registerHandler( + DBusInterface.dbustests.Tests.classinfo, + & intfHandler__dbustests_Tests ); +} + +static this(){ + init_introspectionData(); + init_handlers(); +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbus-d-javatests/dsrc/GenIntf.d Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,399 @@ +/** + * Generated with TioLink + * TioLink was written by Frank Benoit <benoit@tionex.de> + * http://www.dsource.org/projects/tiolink + * + * File type: D programming language source code + */ +module GenIntf; + +public import org.freedesktop.dbus.Struct; +public import org.freedesktop.dbus.Variant; + +import org.freedesktop.dbus.DBus; +import org.freedesktop.dbus.c.Connection : DBusConnection; +import org.freedesktop.dbus.c.Message : DBusMessage; +import org.freedesktop.dbus.c.Shared : DBusHandlerResult; + + +// DBus interfaces +public interface DBusInterface { + // org + public interface org { + // org.freedesktop + public interface freedesktop { + // org.freedesktop.DBus + public interface DBus { + // org.freedesktop.DBus.Peer + public interface Peer { + public void Ping(); + public char[] GetMachineId(); + } + // org.freedesktop.DBus.Introspectable + public interface Introspectable { + public char[] Introspect(); + } + // org.freedesktop.DBus.Properties + public interface Properties { + public DBusVariant Get(in char[] intf_name,in char[] prop_name ); + public void Set(in char[] intf_name,in char[] prop_name,in DBusVariant prop ); + public DBusVariant[ char[] ] GetAll(in char[] intf_name ); + } + } + // org.freedesktop.SampleInterface + public interface SampleInterface { + public void Frobate(in int foo,out char[] bar,out char[][ uint ] baz ); + public DBusVariant Bazify(in Struct!( int, int, uint ) bar ); + public void Mogrify(in Struct!( int, int, DBusVariant[] ) bar ); + } + } + } + // filetree + public interface filetree { + // filetree.DataFileSystem + public interface DataFileSystem { + public DBusObject[] getRoots(); + } + // filetree.DataItem + public interface DataItem { + public DBusObject[] getChilds(); + public bool isFolder(); + public bool isDrive(); + public char[] getName(); + } + } +} + + +// DBusObject +public class DBusObject : DBusObjectImpl, DBusInterface.org.freedesktop.DBus.Introspectable { + this(){ + super(); + } + public char[] Introspect(){ + return super.Introspect(); + } +} + + +private void init_introspectionData(){ + registerIntrospectionData( + DBusInterface.org.freedesktop.DBus.Peer.classinfo, + `<interface name="org.freedesktop.DBus.Peer">\n` + ` <method name="Ping">\n` + ` </method>\n` + ` <method name="GetMachineId">\n` + ` <annotation name="org.dsource.tiolink.Returns" value="machine_uuid" />\n` + ` <arg name="machine_uuid" type="s" direction="out" />\n` + ` </method>\n` + `</interface>\n`); + registerIntrospectionData( + DBusInterface.org.freedesktop.DBus.Introspectable.classinfo, + `<interface name="org.freedesktop.DBus.Introspectable">\n` + ` <method name="Introspect">\n` + ` <annotation name="org.dsource.tiolink.Returns" value="xml_data" />\n` + ` <arg name="xml_data" type="s" direction="out" />\n` + ` </method>\n` + `</interface>\n`); + registerIntrospectionData( + DBusInterface.org.freedesktop.DBus.Properties.classinfo, + `<interface name="org.freedesktop.DBus.Properties">\n` + ` <method name="Get">\n` + ` <annotation name="org.dsource.tiolink.Returns" value="prop" />\n` + ` <arg name="intf_name" type="s" direction="in" />\n` + ` <arg name="prop_name" type="s" direction="in" />\n` + ` <arg name="prop" type="v" direction="out" />\n` + ` </method>\n` + ` <method name="Set">\n` + ` <arg name="intf_name" type="s" direction="in" />\n` + ` <arg name="prop_name" type="s" direction="in" />\n` + ` <arg name="prop" type="v" direction="in" />\n` + ` </method>\n` + ` <method name="GetAll">\n` + ` <annotation name="org.dsource.tiolink.Returns" value="allprops" />\n` + ` <arg name="intf_name" type="s" direction="in" />\n` + ` <arg name="allprops" type="a{sv}" direction="out" />\n` + ` </method>\n` + `</interface>\n`); + registerIntrospectionData( + DBusInterface.org.freedesktop.SampleInterface.classinfo, + `<interface name="org.freedesktop.SampleInterface">\n` + ` <method name="Frobate">\n` + ` <annotation name="org.freedesktop.DBus.Deprecated" value="true" />\n` + ` <arg name="foo" type="i" direction="in" />\n` + ` <arg name="bar" type="s" direction="out" />\n` + ` <arg name="baz" type="a{us}" direction="out" />\n` + ` </method>\n` + ` <method name="Bazify">\n` + ` <annotation name="org.dsource.tiolink.Returns" value="bar" />\n` + ` <arg name="bar" type="(iiu)" direction="in" />\n` + ` <arg name="bar" type="v" direction="out" />\n` + ` </method>\n` + ` <method name="Mogrify">\n` + ` <arg name="bar" type="(iiav)" direction="in" />\n` + ` </method>\n` + `</interface>\n`); + registerIntrospectionData( + DBusInterface.filetree.DataFileSystem.classinfo, + `<interface name="filetree.DataFileSystem">\n` + ` <method name="getRoots">\n` + ` <annotation name="org.dsource.tiolink.Returns" value="roots" />\n` + ` <arg name="roots" type="ao" direction="out" />\n` + ` </method>\n` + `</interface>\n`); + registerIntrospectionData( + DBusInterface.filetree.DataItem.classinfo, + `<interface name="filetree.DataItem">\n` + ` <method name="getChilds">\n` + ` <annotation name="org.dsource.tiolink.Returns" value="childs" />\n` + ` <arg name="childs" type="ao" direction="out" />\n` + ` </method>\n` + ` <method name="isFolder">\n` + ` <annotation name="org.dsource.tiolink.Returns" value="res" />\n` + ` <arg name="res" type="b" direction="out" />\n` + ` </method>\n` + ` <method name="isDrive">\n` + ` <annotation name="org.dsource.tiolink.Returns" value="res" />\n` + ` <arg name="res" type="b" direction="out" />\n` + ` </method>\n` + ` <method name="getName">\n` + ` <annotation name="org.dsource.tiolink.Returns" value="res" />\n` + ` <arg name="res" type="s" direction="out" />\n` + ` </method>\n` + `</interface>\n`); +} +private DBusHandlerResult intfHandler__org_freedesktop_DBus_Peer( DBusConnection* conn, DBusMessage* message, void* user_data ){ + DBusInterface.org.freedesktop.DBus.Peer o = cast(DBusInterface.org.freedesktop.DBus.Peer)cast(Object)user_data; + if( o is null || !checkIntf( "org.freedesktop.DBus.Peer", message) ) + return DBusHandlerResult.DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + + try{ + char[METHOD_SIG_MAXLENGTH] buf; + switch( methodSignature( message, buf ) ){ + case "Ping|": + { + o.Ping(); + sendReply( conn, message ); + } + break; + case "GetMachineId|": + { + Struct!( char[] ) po; + po.t[0] = o.GetMachineId(); + sendReplyData!( char[] )( conn, message, po ); + } + break; + default: + return DBusHandlerResult.DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + } + } + catch( Exception e ){ + sendException( conn, message, e ); + } + return DBusHandlerResult.DBUS_HANDLER_RESULT_HANDLED; +} + +private DBusHandlerResult intfHandler__org_freedesktop_DBus_Introspectable( DBusConnection* conn, DBusMessage* message, void* user_data ){ + DBusInterface.org.freedesktop.DBus.Introspectable o = cast(DBusInterface.org.freedesktop.DBus.Introspectable)cast(Object)user_data; + if( o is null || !checkIntf( "org.freedesktop.DBus.Introspectable", message) ) + return DBusHandlerResult.DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + + try{ + char[METHOD_SIG_MAXLENGTH] buf; + switch( methodSignature( message, buf ) ){ + case "Introspect|": + { + Struct!( char[] ) po; + po.t[0] = o.Introspect(); + sendReplyData!( char[] )( conn, message, po ); + } + break; + default: + return DBusHandlerResult.DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + } + } + catch( Exception e ){ + sendException( conn, message, e ); + } + return DBusHandlerResult.DBUS_HANDLER_RESULT_HANDLED; +} + +private DBusHandlerResult intfHandler__org_freedesktop_DBus_Properties( DBusConnection* conn, DBusMessage* message, void* user_data ){ + DBusInterface.org.freedesktop.DBus.Properties o = cast(DBusInterface.org.freedesktop.DBus.Properties)cast(Object)user_data; + if( o is null || !checkIntf( "org.freedesktop.DBus.Properties", message) ) + return DBusHandlerResult.DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + + try{ + char[METHOD_SIG_MAXLENGTH] buf; + switch( methodSignature( message, buf ) ){ + case "Get|ss": + { + Struct!( char[], char[] ) pi = getCallValues!( char[], char[] )( message ); + Struct!( DBusVariant ) po; + po.t[0] = o.Get( pi.t[0], pi.t[1] ); + sendReplyData!( DBusVariant )( conn, message, po ); + } + break; + case "Set|ssv": + { + Struct!( char[], char[], DBusVariant ) pi = getCallValues!( char[], char[], DBusVariant )( message ); + o.Set( pi.t[0], pi.t[1], pi.t[2] ); + sendReply( conn, message ); + } + break; + case "GetAll|s": + { + Struct!( char[] ) pi = getCallValues!( char[] )( message ); + Struct!( DBusVariant[ char[] ] ) po; + po.t[0] = o.GetAll( pi.t[0] ); + sendReplyData!( DBusVariant[ char[] ] )( conn, message, po ); + } + break; + default: + return DBusHandlerResult.DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + } + } + catch( Exception e ){ + sendException( conn, message, e ); + } + return DBusHandlerResult.DBUS_HANDLER_RESULT_HANDLED; +} + +private DBusHandlerResult intfHandler__org_freedesktop_SampleInterface( DBusConnection* conn, DBusMessage* message, void* user_data ){ + DBusInterface.org.freedesktop.SampleInterface o = cast(DBusInterface.org.freedesktop.SampleInterface)cast(Object)user_data; + if( o is null || !checkIntf( "org.freedesktop.SampleInterface", message) ) + return DBusHandlerResult.DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + + try{ + char[METHOD_SIG_MAXLENGTH] buf; + switch( methodSignature( message, buf ) ){ + case "Frobate|i": + { + Struct!( int ) pi = getCallValues!( int )( message ); + Struct!( char[], char[][ uint ] ) po; + o.Frobate( pi.t[0], po.t[0], po.t[1] ); + sendReplyData!( char[], char[][ uint ] )( conn, message, po ); + } + break; + case "Bazify|(iiu)": + { + Struct!( Struct!( int, int, uint ) ) pi = getCallValues!( Struct!( int, int, uint ) )( message ); + Struct!( DBusVariant ) po; + po.t[0] = o.Bazify( pi.t[0] ); + sendReplyData!( DBusVariant )( conn, message, po ); + } + break; + case "Mogrify|(iiav)": + { + Struct!( Struct!( int, int, DBusVariant[] ) ) pi = getCallValues!( Struct!( int, int, DBusVariant[] ) )( message ); + o.Mogrify( pi.t[0] ); + sendReply( conn, message ); + } + break; + default: + return DBusHandlerResult.DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + } + } + catch( Exception e ){ + sendException( conn, message, e ); + } + return DBusHandlerResult.DBUS_HANDLER_RESULT_HANDLED; +} + +private DBusHandlerResult intfHandler__filetree_DataFileSystem( DBusConnection* conn, DBusMessage* message, void* user_data ){ + DBusInterface.filetree.DataFileSystem o = cast(DBusInterface.filetree.DataFileSystem)cast(Object)user_data; + if( o is null || !checkIntf( "filetree.DataFileSystem", message) ) + return DBusHandlerResult.DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + + try{ + char[METHOD_SIG_MAXLENGTH] buf; + switch( methodSignature( message, buf ) ){ + case "getRoots|": + { + Struct!( DBusObject[] ) po; + po.t[0] = o.getRoots(); + sendReplyData!( DBusObject[] )( conn, message, po ); + } + break; + default: + return DBusHandlerResult.DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + } + } + catch( Exception e ){ + sendException( conn, message, e ); + } + return DBusHandlerResult.DBUS_HANDLER_RESULT_HANDLED; +} + +private DBusHandlerResult intfHandler__filetree_DataItem( DBusConnection* conn, DBusMessage* message, void* user_data ){ + DBusInterface.filetree.DataItem o = cast(DBusInterface.filetree.DataItem)cast(Object)user_data; + if( o is null || !checkIntf( "filetree.DataItem", message) ) + return DBusHandlerResult.DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + + try{ + char[METHOD_SIG_MAXLENGTH] buf; + switch( methodSignature( message, buf ) ){ + case "getChilds|": + { + Struct!( DBusObject[] ) po; + po.t[0] = o.getChilds(); + sendReplyData!( DBusObject[] )( conn, message, po ); + } + break; + case "isFolder|": + { + Struct!( bool ) po; + po.t[0] = o.isFolder(); + sendReplyData!( bool )( conn, message, po ); + } + break; + case "isDrive|": + { + Struct!( bool ) po; + po.t[0] = o.isDrive(); + sendReplyData!( bool )( conn, message, po ); + } + break; + case "getName|": + { + Struct!( char[] ) po; + po.t[0] = o.getName(); + sendReplyData!( char[] )( conn, message, po ); + } + break; + default: + return DBusHandlerResult.DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + } + } + catch( Exception e ){ + sendException( conn, message, e ); + } + return DBusHandlerResult.DBUS_HANDLER_RESULT_HANDLED; +} + +private void init_handlers(){ + registerHandler( + DBusInterface.org.freedesktop.DBus.Peer.classinfo, + & intfHandler__org_freedesktop_DBus_Peer ); + registerHandler( + DBusInterface.org.freedesktop.DBus.Introspectable.classinfo, + & intfHandler__org_freedesktop_DBus_Introspectable ); + registerHandler( + DBusInterface.org.freedesktop.DBus.Properties.classinfo, + & intfHandler__org_freedesktop_DBus_Properties ); + registerHandler( + DBusInterface.org.freedesktop.SampleInterface.classinfo, + & intfHandler__org_freedesktop_SampleInterface ); + registerHandler( + DBusInterface.filetree.DataFileSystem.classinfo, + & intfHandler__filetree_DataFileSystem ); + registerHandler( + DBusInterface.filetree.DataItem.classinfo, + & intfHandler__filetree_DataItem ); +} + +static this(){ + init_introspectionData(); + init_handlers(); +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbus-d-javatests/dsrc/dsss.conf Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,29 @@ + +[DHelper.d] +target=DHelper +version(linux){ + buildflags+=~/Dater/dsss/lib/libSDD-tango-*.a + buildflags+=-I../../dbus-d/dsrc + buildflags+=-L-ldbus-1 +} +version(Windows){ + buildflags+=-S..\libs + buildflags+=-ll"libdbus-1" + buildflags+=-L/SUBSYSTEM:console:5 +} + +[DBusTests.d] +target=DBusTests +version(linux){ + buildflags+=/Dater/ext/flectioned/flectioned.d + buildflags+=-I../../dbus-d/dsrc + buildflags+=-L-ldbus-1 +} +version(Windows){ + buildflags+=-S..\libs + buildflags+=-ll"libdbus-1" + buildflags+=-L/SUBSYSTEM:console:5 +} + +[t.d] +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbus-d-javatests/filetree.xml Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,34 @@ +<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN" "http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd"> +<node> + + <interface name="filetree.DataFileSystem"> + <method name="getRoots"> + <annotation name="org.dsource.tiolink.Returns" value="roots"/> + <arg name="roots" type="ao" direction="out"/> + </method> + </interface> + + <interface name="filetree.DataItem"> + <method name="getChilds"> + <annotation name="org.dsource.tiolink.Returns" value="childs"/> + <arg name="childs" type="ao" direction="out"/> + </method> + <method name="isFolder"> + <annotation name="org.dsource.tiolink.Returns" value="res"/> + <arg name="res" type="b" direction="out"/> + </method> + <method name="isDrive"> + <annotation name="org.dsource.tiolink.Returns" value="res"/> + <arg name="res" type="b" direction="out"/> + </method> + <method name="getName"> + <annotation name="org.dsource.tiolink.Returns" value="res"/> + <arg name="res" type="s" direction="out"/> + </method> + </interface> + +</node> + + + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbus-d-javatests/jsrc/filetree/DataFileSystem.d Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,135 @@ +/* + * Generated with TioLink + * TioLink was written by Frank Benoit <benoit@tionex.de> + * http://www.dsource.org/projects/tiolink + * + * User specific code can be place after the generated comment line containing: + * "USER CONTENT STARTS HERE". + * Everything before that line will be programmatically overwritten. + * + * File type: D programming language source code + */ +module filetree.DataFileSystem; + +import org.freedesktop.dbus.DBus; +import org.freedesktop.dbus.Introspectable; + +// Interface for DataFileSystem + +interface DataFileSystem : org.freedesktop.dbus.DBusInterface.DBusInterface { + public filetree.DataItem.DataItem[] getRoots(); + const static char[] introspectionXml = + `<interface name="filetree.DataFileSystem"/>`\n + ` <method name="getRoots">`\n + ` <arg name="p0" type="ao" direction="out"/>`\n + ` </method>`\n + `</interface>`\n + ; +} + +CConnection.DBusHandlerResult intfHandler__filetree_DataFileSystem_DataFileSystem( CConnection.DBusConnection* conn, CConnection.DBusMessage* message, void* user_data ){ + DataFileSystem o = cast(DataFileSystem)cast(Object)user_data; + if( o is null || !checkIntf( "filetree.DataFileSystem", message) ) + return CConnection.DBusHandlerResult.DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + + try{ + char[METHOD_SIG_MAXLENGTH] buf; + switch( methodSignature( message, buf ) ){ + case "getRoots|": + { + filetree.DataItem.DataItem[] callResult = o.getRoots(); + sendReply( conn, message, callResult ); + } + break; + default: + return CConnection.DBusHandlerResult.DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + } + } + catch( Exception e ){ + sendException( conn, message, e ); + } + return CConnection.DBusHandlerResult.DBUS_HANDLER_RESULT_HANDLED; +} +void intfFree__filetree_DataFileSystem_DataFileSystem( CConnection.DBusConnection *connection, void *user_data ){ +} + + +// Dimpl for MyDataFileSystem + +extern(C) CConnection.DBusHandlerResult dimplHandler__filetree_DataFileSystem_MyDataFileSystem( CConnection.DBusConnection* conn, CConnection.DBusMessage* message, void* user_data ){ + CConnection.DBusHandlerResult res = CConnection.DBusHandlerResult.DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + if( res == CConnection.DBusHandlerResult.DBUS_HANDLER_RESULT_NOT_YET_HANDLED ){ + res = intfHandler__filetree_DataFileSystem_DataFileSystem( conn, message, user_data ); + } + if( res == CConnection.DBusHandlerResult.DBUS_HANDLER_RESULT_NOT_YET_HANDLED ){ + res = intfHandler__org_freedesktop_dbus_Introspectable_Introspectable( conn, message, user_data ); + } + return res; +} + +extern(C) void dimplFree__filetree_DataFileSystem_MyDataFileSystem( CConnection.DBusConnection *connection, void *user_data ){ +} + +CConnection.DBusObjectPathVTable vtable__filetree_DataFileSystem_MyDataFileSystem = { + unregister_function : & dimplFree__filetree_DataFileSystem_MyDataFileSystem, + message_function : & dimplHandler__filetree_DataFileSystem_MyDataFileSystem +}; + + +static assert( is( MyDataFileSystem : filetree.DataFileSystem.DataFileSystem )); +static assert( is( MyDataFileSystem : org.freedesktop.dbus.Introspectable.Introspectable )); + +// --- USER CONTENT STARTS HERE (do not change this marker line) --- +import tango.io.Stdout; +import tango.io.FileRoots; +import tango.io.FilePath; +import filetree.DataItem; + +class MyDataFileSystem : DBusObject, DataFileSystem, Introspectable { + + public this(){ + super( this.classinfo ); + } + + public DBusObjectPathVTable* getDBusVTable(){ + return &vtable__filetree_DataFileSystem_MyDataFileSystem; + } + + public DataItem[] getRoots(){ + auto roots = FileRoots.list(); + DataItem[] res = new DataItem[ roots.length ]; + for( int i = 0; i < roots.length; i++ ){ + res[i] = new MyDataItem( new FilePath(roots[i]) ); + } + return res; + } + public char[] Introspect(){ + Stdout.formatln( "FileSys inspect" ); + return buildIntrospect( [DataFileSystem.introspectionXml, Introspectable.introspectionXml ], null ); + } +/+ + public this( char[] path ){ + super( new FilePath( path )); + } + + public String getName(){ + char[] name = file.toUtf8(); + Stdout.formatln( "{} {} {}", __LINE__, __FILE__, name ); + auto res = toJavaString( name ); + Stdout.formatln( "{} {} ", __LINE__, __FILE__ ); + return res; +// return toJavaString( file.name() ); + } + + public override bool isFolder(){ + return true; + } + public override bool isDrive(){ + return true; + } ++/ +} + + + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbus-d-javatests/jsrc/filetree/DataFileSystem.java Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,9 @@ +package filetree; + +import java.util.List; + +import org.freedesktop.dbus.DBusInterface; + +public interface DataFileSystem extends DBusInterface{ + public DataItem[] getRoots(); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbus-d-javatests/jsrc/filetree/DataItem.d Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,187 @@ +/* + * Generated with TioLink + * TioLink was written by Frank Benoit <benoit@tionex.de> + * http://www.dsource.org/projects/tiolink + * + * User specific code can be place after the generated comment line containing: + * "USER CONTENT STARTS HERE". + * Everything before that line will be programmatically overwritten. + * + * File type: D programming language source code + */ +module filetree.DataItem; + +import org.freedesktop.dbus.DBus; +import org.freedesktop.dbus.Introspectable; + +// Interface for DataItem + +interface DataItem : org.freedesktop.dbus.DBusInterface.DBusInterface { + public filetree.DataItem.DataItem[] getChilds(); + public bool isFolder(); + public bool isDrive(); + public char[] getName(); + const static char[] introspectionXml = + `<interface name="filetree.DataItem"/>`\n + ` <method name="getChilds">`\n + ` <arg name="p0" type="ao" direction="out"/>`\n + ` </method>`\n + ` <method name="isFolder">`\n + ` <arg name="p0" type="b" direction="out"/>`\n + ` </method>`\n + ` <method name="isDrive">`\n + ` <arg name="p0" type="b" direction="out"/>`\n + ` </method>`\n + ` <method name="getName">`\n + ` <arg name="p0" type="s" direction="out"/>`\n + ` </method>`\n + `</interface>`\n + ; +} + +CConnection.DBusHandlerResult intfHandler__filetree_DataItem_DataItem( CConnection.DBusConnection* conn, CConnection.DBusMessage* message, void* user_data ){ + DataItem o = cast(DataItem)cast(Object)user_data; + if( o is null || !checkIntf( "filetree.DataItem", message) ) + return CConnection.DBusHandlerResult.DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + + try{ + char[METHOD_SIG_MAXLENGTH] buf; + switch( methodSignature( message, buf ) ){ + case "getChilds|": + { + filetree.DataItem.DataItem[] callResult = o.getChilds(); + sendReply( conn, message, callResult ); + } + break; + case "isFolder|": + { + bool callResult = o.isFolder(); + sendReply( conn, message, callResult ); + } + break; + case "isDrive|": + { + bool callResult = o.isDrive(); + sendReply( conn, message, callResult ); + } + break; + case "getName|": + { + char[] callResult = o.getName(); + sendReply( conn, message, callResult ); + } + break; + default: + return CConnection.DBusHandlerResult.DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + } + } + catch( Exception e ){ + sendException( conn, message, e ); + } + return CConnection.DBusHandlerResult.DBUS_HANDLER_RESULT_HANDLED; +} +void intfFree__filetree_DataItem_DataItem( CConnection.DBusConnection *connection, void *user_data ){ +} + + +// Dimpl for MyDataItem + +extern(C) CConnection.DBusHandlerResult dimplHandler__filetree_DataItem_MyDataItem( CConnection.DBusConnection* conn, CConnection.DBusMessage* message, void* user_data ){ + CConnection.DBusHandlerResult res = CConnection.DBusHandlerResult.DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + if( res == CConnection.DBusHandlerResult.DBUS_HANDLER_RESULT_NOT_YET_HANDLED ){ + res = intfHandler__filetree_DataItem_DataItem( conn, message, user_data ); + } + if( res == CConnection.DBusHandlerResult.DBUS_HANDLER_RESULT_NOT_YET_HANDLED ){ + res = intfHandler__org_freedesktop_dbus_Introspectable_Introspectable( conn, message, user_data ); + } + return res; +} + +extern(C) void dimplFree__filetree_DataItem_MyDataItem( CConnection.DBusConnection *connection, void *user_data ){ +} + +CConnection.DBusObjectPathVTable vtable__filetree_DataItem_MyDataItem = { + unregister_function : & dimplFree__filetree_DataItem_MyDataItem, + message_function : & dimplHandler__filetree_DataItem_MyDataItem +}; + + +static assert( is( MyDataItem : filetree.DataItem.DataItem )); +static assert( is( MyDataItem : org.freedesktop.dbus.Introspectable.Introspectable )); + +// --- USER CONTENT STARTS HERE (do not change this marker line) --- + +import tango.core.Exception; +import tango.io.Stdout; +import tango.io.FilePath; + +class MyDataItem : DBusObject, DataItem, Introspectable { + FilePath file; + + public this( FilePath absPath ){ + super( this.classinfo ); + file = absPath; + //Stdout.formatln( "{} {} {}", __LINE__, __FILE__, file.toUtf8() ); + } + + public char[] Introspect(){ + return buildIntrospect( [DataItem.introspectionXml, Introspectable.introspectionXml ], null ); + } + public DBusObjectPathVTable* getDBusVTable(){ + return &vtable__filetree_DataItem_MyDataItem; + } + public DataItem[] getChilds(){ + //Stdout.formatln( "{} {} ", __LINE__, __FILE__ ); + char[][] names; + try{ + int i; + char[][] list; + void add (char[] path, char[] name, bool dir) { + if( name == "." || name == ".." ){ + return; + } + if (i >= list.length) + list.length = list.length * 2; + + list[i++] = path~name; + } + list = new char[][512]; + file.toList (&add); + names = list [0 .. i]; + } catch( IOException e ){ + // nothing happends + } + + //Stdout.formatln( "{} {} ", __LINE__, __FILE__ ); + DataItem[] res = new DataItem[ names.length ]; + //Stdout.formatln( "{} {} ", __LINE__, __FILE__ ); + for( int i = 0; i < names.length; i++ ){ + char[] path = names[i]; + //Stdout.formatln( "{} {} {}", __LINE__, __FILE__, path ); + res[i] = new MyDataItem( new FilePath( path ) ); + } + //Stdout.formatln( "{} {} ", __LINE__, __FILE__ ); + return res; + } + public char[] getName(){ + return file.file(); + } + public bool isFolder(){ + //Stdout.formatln( "{} {} {}", __LINE__, __FILE__, file.toUtf8() ); + bool res = false; + try{ + res = file.isFolder(); + } catch( IOException e ){ + } + return res; + } + + public bool isDrive(){ + Stdout.formatln( "{} {} ", __LINE__, __FILE__ ); + return false; + } + public override char[] toUtf8(){ + return file.toUtf8(); + } +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbus-d-javatests/jsrc/filetree/DataItem.java Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,11 @@ +package filetree; + +import org.freedesktop.dbus.DBusInterface; + + +public interface DataItem extends DBusInterface { + public DataItem[] getChilds(); + public boolean isFolder(); + public boolean isDrive(); + public String getName(); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbus-d-javatests/jsrc/filetree/FileTree.java Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,157 @@ +package filetree; + +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.PrintWriter; + +import org.eclipse.jface.viewers.TreeViewer; +import org.eclipse.jface.window.ApplicationWindow; +import org.eclipse.swt.SWT; +import org.eclipse.swt.events.SelectionAdapter; +import org.eclipse.swt.events.SelectionEvent; +import org.eclipse.swt.layout.GridData; +import org.eclipse.swt.layout.GridLayout; +import org.eclipse.swt.widgets.Button; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Control; +import org.eclipse.swt.widgets.Display; +import org.eclipse.swt.widgets.Shell; +import org.freedesktop.dbus.DirectConnection; + +import dbus_d_javahelper.ConsoleProcess; + +/** + * This class demonstrates TreeViewer. It shows the drives, directories, and + * files on the system. + */ +public class FileTree extends ApplicationWindow { + private final DataFileSystem fs; + +/** + * FileTree constructor + */ + public FileTree(DataFileSystem fs) { + super(null); + this.fs = fs; + } + + /** + * Runs the application + */ + public void run() { + // Don't return from open() until window closes + setBlockOnOpen(true); + + // Open the main window + open(); + + // Dispose the display + Display.getCurrent().dispose(); + } + + /** + * Configures the shell + * + * @param shell + * the shell + */ + protected void configureShell(Shell shell) { + super.configureShell(shell); + + // Set the title bar text and the size + shell.setText("File Tree"); + shell.setSize(400, 400); + } + + /** + * Creates the main window's contents + * + * @param parent + * the main window + * @return Control + */ + protected Control createContents(Composite parent) { + Composite composite = new Composite(parent, SWT.NONE); + composite.setLayout(new GridLayout(1, false)); + + // Add a checkbox to toggle whether the labels preserve case + Button preserveCase = new Button(composite, SWT.CHECK); + preserveCase.setText("&Preserve case"); + + // Create the tree viewer to display the file tree + final TreeViewer tv = new TreeViewer(composite); + tv.getTree().setLayoutData(new GridData(GridData.FILL_BOTH)); + tv.setContentProvider(new FileTreeContentProvider()); + tv.setLabelProvider(new FileTreeLabelProvider()); + tv.setInput(fs); // pass a non-null that will be ignored + + // When user checks the checkbox, toggle the preserve case attribute + // of the label provider + preserveCase.addSelectionListener(new SelectionAdapter() { + public void widgetSelected(SelectionEvent event) { + boolean preserveCase = ((Button) event.widget).getSelection(); + FileTreeLabelProvider ftlp = (FileTreeLabelProvider) tv + .getLabelProvider(); + ftlp.setPreserveCase(preserveCase); + } + }); + return composite; + } + + /** + * The application entry point + * + * @param args + * the command line arguments + */ + public static void main2(String[] args) { + new FileTree(null).run(); + } + static DirectConnection dc; + static ConsoleProcess process; + + public static void main(String[] args) throws Exception { + final String address = DirectConnection.createDynamicTCPSession(); + // String address = + // "tcp:host=localhost,port=12344,guid="+Transport.genGUID(); + System.err.println("----------------------------"); + System.err.println(address); + System.err.println("----------------------------"); + new Thread() { + @Override + public void run() { + try { + System.err.println("### start D ###"); + process = new ConsoleProcess(new String[] { + "./dsrc/DHelper", address }, null, null, + System.out, System.err); + System.err.println("### started D ###"); + process.join(); + } catch (InterruptedException e) { + e.printStackTrace(); + } catch (IOException e) { + e.printStackTrace(); + } + } + }.start(); + + try{ + Thread.sleep( 200 ); + System.err.println("--- starting connection ----"); + dc = new DirectConnection(address + ",listen=true"); + System.err.println("----------------------------"); + + DataFileSystem rem = (DataFileSystem) dc.getRemoteObject( + "/DHelper/MyDataFileSystem/0", DataFileSystem.class); + + new FileTree(rem).run(); + + } + finally{ + dc.disconnect(); + } + } +} + + + \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbus-d-javatests/jsrc/filetree/FileTreeContentProvider.java Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,82 @@ +package filetree; + +import java.io.File; + +import org.eclipse.jface.viewers.ITreeContentProvider; +import org.eclipse.jface.viewers.Viewer; + +/** + * This class provides the content for the tree in FileTree + */ + +class FileTreeContentProvider implements ITreeContentProvider { + /** + * Gets the children of the specified object + * + * @param arg0 + * the parent object + * @return Object[] + */ + public Object[] getChildren(Object arg0) { + // Return the files and subdirectories in this directory + return ((DataItem) arg0).getChilds(); + } + + /** + * Gets the parent of the specified object + * + * @param arg0 + * the object + * @return Object + */ + public Object getParent(Object arg0) { + // Return this file's parent file + return null;//((DataItem) arg0).getParentFile(); + } + + /** + * Returns whether the passed object has children + * + * @param arg0 + * the parent object + * @return boolean + */ + public boolean hasChildren(Object arg0) { + return ((DataItem) arg0).isFolder(); + } + + /** + * Gets the root element(s) of the tree + * + * @param arg0 + * the input data + * @return Object[] + */ + public Object[] getElements(Object arg0) { + // These are the root elements of the tree + // We don't care what arg0 is, because we just want all + // the root nodes in the file system + return ((DataFileSystem)arg0).getRoots(); + } + + /** + * Disposes any created resources + */ + public void dispose() { + // Nothing to dispose + } + + /** + * Called when the input changes + * + * @param arg0 + * the viewer + * @param arg1 + * the old input + * @param arg2 + * the new input + */ + public void inputChanged(Viewer arg0, Object arg1, Object arg2) { + // Nothing to change + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbus-d-javatests/jsrc/filetree/FileTreeLabelProvider.java Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,145 @@ +package filetree; + +import java.io.File; +import java.io.FileInputStream; +import java.io.FileNotFoundException; +import java.util.ArrayList; +import java.util.List; + +import org.eclipse.jface.viewers.ILabelProvider; +import org.eclipse.jface.viewers.ILabelProviderListener; +import org.eclipse.jface.viewers.LabelProviderChangedEvent; +import org.eclipse.swt.graphics.Image; +import org.eclipse.swt.program.Program; + +/** + * This class provides the labels for the file tree + */ + +class FileTreeLabelProvider implements ILabelProvider { + // The listeners + private List<ILabelProviderListener> listeners; + + // Images for tree nodes + private Image file; + + private Image dir; + + // Label provider state: preserve case of file names/directories + boolean preserveCase; + + /** + * Constructs a FileTreeLabelProvider + */ + public FileTreeLabelProvider() { + // Create the list to hold the listeners + listeners = new ArrayList<ILabelProviderListener>(); + + // Create the images + try { + file = new Image(null, new FileInputStream("icons/file_obj.gif")); + dir = new Image(null, new FileInputStream("icons/fldr_obj.gif")); + } catch (FileNotFoundException e) { + // Swallow it; we'll do without images + } + } + + /** + * Sets the preserve case attribute + * + * @param preserveCase + * the preserve case attribute + */ + public void setPreserveCase(boolean preserveCase) { + this.preserveCase = preserveCase; + + // Since this attribute affects how the labels are computed, + // notify all the listeners of the change. + LabelProviderChangedEvent event = new LabelProviderChangedEvent(this); + for (int i = 0, n = listeners.size(); i < n; i++) { + ILabelProviderListener ilpl = (ILabelProviderListener) listeners + .get(i); + ilpl.labelProviderChanged(event); + } + } + + /** + * Gets the image to display for a node in the tree + * + * @param arg0 + * the node + * @return Image + */ + public Image getImage(Object arg0) { + // If the node represents a directory, return the directory image. + // Otherwise, return the file image. +// Program.findProgram(".txt" ).getImageData(); + return ((DataItem) arg0).isFolder() ? dir : file; + } + + /** + * Gets the text to display for a node in the tree + * + * @param arg0 + * the node + * @return String + */ + public String getText(Object arg0) { + // Get the name of the file + String text = ((DataItem) arg0).getName(); + + // If name is blank, get the path + if (text.length() == 0) { + //text = ((DataItem) arg0).getPath(); + } + System.out.println( "Text: "+text ); + // Check the case settings before returning the text + return preserveCase ? text : text.toUpperCase(); + } + + /** + * Adds a listener to this label provider + * + * @param arg0 + * the listener + */ + public void addListener(ILabelProviderListener arg0) { + listeners.add(arg0); + } + + /** + * Called when this LabelProvider is being disposed + */ + public void dispose() { + // Dispose the images + if (dir != null) + dir.dispose(); + if (file != null) + file.dispose(); + } + + /** + * Returns whether changes to the specified property on the specified + * element would affect the label for the element + * + * @param arg0 + * the element + * @param arg1 + * the property + * @return boolean + */ + public boolean isLabelProperty(Object arg0, String arg1) { + return false; + } + + /** + * Removes the listener + * + * @param arg0 + * the listener to remove + */ + public void removeListener(ILabelProviderListener arg0) { + listeners.remove(arg0); + } +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbus-d-javatests/jsrc/testapp/FileBrowserSample.java Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,231 @@ +/******************************************************************************* + * All Right Reserved. Copyright (c) 1998, 2004 Jackwind Li Guojie + * + * Created on Mar 9, 2004 7:07:16 PM by JACK $Id$ + * + ******************************************************************************/ + +package testapp; + +import java.io.File; + +import org.eclipse.jface.action.Action; +import org.eclipse.jface.action.ToolBarManager; +import org.eclipse.jface.resource.ImageRegistry; +import org.eclipse.swt.SWT; +import org.eclipse.swt.custom.TreeEditor; +import org.eclipse.swt.events.SelectionEvent; +import org.eclipse.swt.events.SelectionListener; +import org.eclipse.swt.events.TreeEvent; +import org.eclipse.swt.events.TreeListener; +import org.eclipse.swt.graphics.Image; +import org.eclipse.swt.graphics.ImageData; +import org.eclipse.swt.graphics.Point; +import org.eclipse.swt.layout.GridData; +import org.eclipse.swt.layout.GridLayout; +import org.eclipse.swt.program.Program; +import org.eclipse.swt.widgets.DirectoryDialog; +import org.eclipse.swt.widgets.Display; +import org.eclipse.swt.widgets.Event; +import org.eclipse.swt.widgets.Listener; +import org.eclipse.swt.widgets.Shell; +import org.eclipse.swt.widgets.Text; +import org.eclipse.swt.widgets.ToolBar; +import org.eclipse.swt.widgets.Tree; +import org.eclipse.swt.widgets.TreeItem; + +public class FileBrowserSample { + Display display = new Display(); + Shell shell = new Shell(display); + + Tree tree; + + File rootDir; + + public FileBrowserSample() { + Action actionSetRootDir = new Action("Set Root Dir") { + public void run() { + DirectoryDialog dialog = new DirectoryDialog(shell); + String path = dialog.open(); + if (path != null) { + setRootDir(new File(path)); + } + } + }; + + + ToolBar toolBar = new ToolBar(shell, SWT.FLAT); + ToolBarManager manager = new ToolBarManager(toolBar); + manager.add(actionSetRootDir); + + manager.update(true); + + shell.setLayout(new GridLayout()); + + tree = new Tree(shell, SWT.BORDER); + tree.setLayoutData(new GridData(GridData.FILL_BOTH)); + + setRootDir(new File("C:/")); + + tree.addTreeListener(new TreeListener() { + public void treeCollapsed(TreeEvent e) { + } + + public void treeExpanded(TreeEvent e) { + TreeItem item = (TreeItem) e.item; + TreeItem[] children = item.getItems(); + + for (int i = 0; i < children.length; i++) + if (children[i].getData() == null) + children[i].dispose(); + else // Child files already added to the tree. + return; + + File[] files = ((File) item.getData()).listFiles(); + for (int i = 0; files != null && i < files.length; i++) + addFileToTree(item, files[i]); + } + }); + + tree.addSelectionListener(new SelectionListener() { + public void widgetSelected(SelectionEvent e) { + } + // Gets called when a tree item is double-clicked. + public void widgetDefaultSelected(SelectionEvent e) { + TreeItem item = (TreeItem) e.item; + File file = (File) item.getData(); + if (Program.launch(file.getAbsolutePath())) { + System.out.println("File has been launched: " + file); + } else { + System.out.println("Unable to launch file: " + file); + } + } + }); + + shell.setSize(400, 260); + shell.open(); + //textUser.forceFocus(); + + // Set up the event loop. + while (!shell.isDisposed()) { + if (!display.readAndDispatch()) { + // If no more entries in event queue + display.sleep(); + } + } + + display.dispose(); + } + + /** + * Sets the root directory to browse from. + * + * @param root + */ + private void setRootDir(File root) { + // validates the root first. + if( (!root.isDirectory()) || (!root.exists())) + throw new IllegalArgumentException("Invalid root: " + root); + + this.rootDir = root; + shell.setText("Now browsing: " + root.getAbsolutePath()); + + // Remove all the items in the tree. + if (tree.getItemCount() > 0) { + TreeItem[] items = tree.getItems(); + for (int i = 0; i < items.length; i++) { + items[i].dispose(); + // Dispose itself and all of its descendants. + } + } + + // Adds files under the root to the tree. + File[] files = root.listFiles(); + for(int i=0; files != null && i < files.length; i++) + addFileToTree(tree, files[i]); + } + + /** + * Adds the given file to the tree. + * + * @param parent + * @param file + */ + private void addFileToTree(Object parent, File file) { + TreeItem item = null; + + if (parent instanceof Tree) + item = new TreeItem((Tree) parent, SWT.NULL); + else if (parent instanceof TreeItem) + item = new TreeItem((TreeItem) parent, SWT.NULL); + else + throw new IllegalArgumentException( + "parent should be a tree or a tree item: " + parent); + + item.setText(file.getName()); + item.setImage(getIcon(file)); + + item.setData(file); + + if (file.isDirectory()) { + // // recursively adds all the children of this file. + // File[] files = file.listFiles(); + // for(int i=0; i<files.length; i++) + // buildTree(item, files[i]); + if (file.list() != null && file.list().length > 0) + new TreeItem(item, SWT.NULL); + } + } + + private ImageRegistry imageRegistry; + Image iconFolder = new Image(shell.getDisplay(), "icons/java2s.gif"); + Image iconFile = new Image(shell.getDisplay(), "icons/java2s.gif"); + + /** + * Returns an icon representing the specified file. + * + * @param file + * @return + */ + private Image getIcon(File file) { + if (file.isDirectory()) + return iconFolder; + + int lastDotPos = file.getName().indexOf('.'); + if (lastDotPos == -1) + return iconFile; + + Image image = getIcon(file.getName().substring(lastDotPos + 1)); + return image == null ? iconFile : image; + } + + /** + * Returns the icon for the file type with the specified extension. + * + * @param extension + * @return + */ + private Image getIcon(String extension) { + if (imageRegistry == null) + imageRegistry = new ImageRegistry(); + Image image = imageRegistry.get(extension); + if (image != null) + return image; + + Program program = Program.findProgram(extension); + ImageData imageData = (program == null ? null : program.getImageData()); + if (imageData != null) { + image = new Image(shell.getDisplay(), imageData); + imageRegistry.put(extension, image); + } else { + image = iconFile; + } + + return image; + } + + public static void main(String[] args) { + new FileBrowserSample(); + } +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbus-d/.classpath Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,6 @@ +<?xml version="1.0" encoding="UTF-8"?> +<classpath> + <classpathentry kind="src" path="dsrc"/> + <classpathentry kind="con" path="descent.launching.JRE_CONTAINER"/> + <classpathentry kind="output" path="bin"/> +</classpath>
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbus-d/.project Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,17 @@ +<?xml version="1.0" encoding="UTF-8"?> +<projectDescription> + <name>dbus-d</name> + <comment></comment> + <projects> + </projects> + <buildSpec> + <buildCommand> + <name>descent.core.dbuilder</name> + <arguments> + </arguments> + </buildCommand> + </buildSpec> + <natures> + <nature>descent.core.dnature</nature> + </natures> +</projectDescription>
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbus-d/dsrc/dsss.conf Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,22 @@ +[test/client/DClient.d] +version(linux){ + buildflags+=-I~/tango + buildflags+=-L-ldbus-1 +} +version(Windows){ + buildflags+=-S..\libs + buildflags+=-ll"libdbus-1" + buildflags+=-L/SUBSYSTEM:console:5 +} +target=DClient.exe + +[org/freedesktop/dbus/tool/CreateInterface.d] +target=../bin/dbus-createinterface +buildflags+=-I/Dater/ext/tango +buildflags+=-I/Dater/ext +buildflags+=/Dater/ext/flectioned/flectioned.d + + + + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbus-d/dsrc/org/freedesktop/dbus/DBus.d Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,1107 @@ +/* + * Copyright (C) 2007 Frank Benoit + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ +module org.freedesktop.dbus.DBus; + +import tango.io.Stdout; +import tango.core.Exception; +import tango.core.Thread; +import tango.core.Traits; +import tango.text.convert.Integer; +import tango.text.Util; + +public import tango.stdc.stringz : fromUtf8z; +//public import tango.core.Tuple; +//public import org.freedesktop.dbus.DBusInterface; + +import org.freedesktop.dbus.c.Connection; +import org.freedesktop.dbus.c.Errors; +import org.freedesktop.dbus.c.Message; +import org.freedesktop.dbus.c.Bus; +import org.freedesktop.dbus.c.PendingCall; +import org.freedesktop.dbus.c.Shared; +import org.freedesktop.dbus.c.Protocol; +import org.freedesktop.dbus.c.Types; +import org.freedesktop.dbus.c.Memory : dbus_free; +import org.freedesktop.dbus.Struct; +import org.freedesktop.dbus.Variant; + +//version=CD; + +typedef char[] DBusObjPath; +typedef char[] DBusSignature; + +private void notImplemented( char[] msg = null ){ + throw new TracedException( "not yet implemented " ~ msg ); +} + +private void ensure( bool cond, char[][] msg ... ){ + if( !cond ){ + char[200] buf; + char[] formattedMsg = layout( buf, msg ); + throw new TracedException( "ensure failed: "~formattedMsg ); + } +} + +private void ensureDBus( dbus_bool_t cond ){ + if( !cond ){ + throw new TracedException( "ensureDBus" ); + } +} + + +alias DBusHandlerResult + function( + DBusConnection* conn, + DBusMessage* message, + void* user_data ) + DBusHandler; + + +char[] [ ClassInfo ] registeredIntrospectionData; +DBusHandler[ ClassInfo ] registeredHandlers; + +public void registerIntrospectionData( ClassInfo ci, char[] data ){ + registeredIntrospectionData[ ci ] = data; +} +public void registerHandler( ClassInfo ci, DBusHandler handler ){ + registeredHandlers[ ci ] = handler; +} + +public class DBusObjectImpl { + static uint sInstCounter = 0; + char[] instName; + this(){ + //Stdout.formatln( "DBusObject ctor" ); + int cnt; + synchronized{ + cnt = sInstCounter++; + } + instName = '/' ~ replace( this.classinfo.name.dup, '.', '/' ) ~ '/' ~ .toUtf8( cnt ); + //Stdout.formatln( "DBusObject instname={}", instName ); + } + + public char[] getDBusInstanceName(){ + return instName; + } + + public char[] Introspect(){ + char[] res = "<!DOCTYPE node PUBLIC \"-//freedesktop//DTD D-BUS Object Introspection 1.0//EN\"\n" + "\"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd\">\n" + "<node>\n"; + bool[ ClassInfo ] all; + void appendInterfaces( Interface[] intfs ){ + foreach( intf; intfs ){ + if( intf.classinfo.interfaces.length > 0 ){ + appendInterfaces( intf.classinfo.interfaces ); + } + all[ intf.classinfo ] = true; + } + } + appendInterfaces( this.classinfo.interfaces ); + foreach( intf; all.keys ){ + char[]* intro = intf in registeredIntrospectionData; + if( intro !is null ){ + res ~= *intro; + } + } + DBusObjectImpl[] childs = getChildNodes(); + foreach( child; childs ){ + res ~= " <node name=\""~child.instName~"\"/>\n"; + } + res ~= "</node>\n"; + //Stdout.formatln( "DBus.d:{} Introspect: {}", __LINE__, res ); + return res; + } + + public DBusObjectImpl[] getChildNodes(){ + return null; + } + + private static extern(C) DBusHandlerResult VTableMessageFunction( + DBusConnection* conn, + DBusMessage* message, + void* user_data ) + { + char[METHOD_SIG_MAXLENGTH] buf; + DBusObjectImpl o = cast(DBusObjectImpl)cast(Object)user_data; + + // find all interfaces ... + bool[ ClassInfo ] all; + void findAllInterfaces( Interface[] intfs ){ + foreach( intf; intfs ){ + findAllInterfaces( intf.classinfo.interfaces ); + all[ intf.classinfo ] = true; + } + } + ClassInfo oci = o.classinfo; + do{ + findAllInterfaces( oci.interfaces ); + oci = oci.base; + } while( oci !is null ); + + // call all existing handlers until message handled + foreach( intf; all.keys ){ + DBusHandler* handler = intf in registeredHandlers; + if( handler !is null ){ + DBusHandlerResult res = + (*handler)( conn, message, user_data ); + if( res == DBusHandlerResult.DBUS_HANDLER_RESULT_HANDLED ){ + return DBusHandlerResult.DBUS_HANDLER_RESULT_HANDLED; + } + } + } + return DBusHandlerResult.DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + } + + private static extern(C) void VTableUnregisterFunction( + DBusConnection *connection, + void* user_data ) + { + DBusObjectImpl o = cast(DBusObjectImpl)cast(Object)user_data; + objectLocker.remove( o ); + } + + private static DBusObjectPathVTable dbusObjectPathVTable = { + message_function : & VTableMessageFunction, + unregister_function : & VTableUnregisterFunction + }; + + public void registerDBusObject( DBusConnection * conn ){ + ensureDBus( dbus_connection_register_object_path( + conn, + XtoUtf8z( getDBusInstanceName() ), + & dbusObjectPathVTable, + cast(void*)cast(Object)this )); + objectLocker[ this ] = true; + } + +} + +bool[ DBusObjectImpl ] objectLocker; + + +class DBusConnectionImpl { + DBusConnection* conn; + + public this( char[] addr ){ + DBusError err; + int trial = 0; + while( true ){ + trial++; + dbus_error_init(&err); + + scope(exit) + if( dbus_error_is_set(&err) ){ + dbus_error_free(&err); + } + + conn = dbus_connection_open_private( XtoUtf8z(addr), & err ); + + if( !dbus_error_is_set(&err) && conn !is null ){ + return; + } + if( trial > 10 ){ + if( dbus_error_is_set(&err) ){ + Stdout.formatln( "Connect Error ({})\n", fromUtf8z( err.message)); + throw new Exception(""); + } + if( conn is null ){ + throw new IOException("connecting not successful"); + } + } + else{ + Thread.sleep( 0.1 ); + } + } + } + +/+ public DBusInterface getRemoteObject( char[] path ){ + return null; + }+/ + public void mainLoop(){ + //Stdout.formatln( " D mainloop starting" ); + while (dbus_connection_read_write_dispatch (conn, -1)){ + //Stdout.formatln( " D mainloop" ); + // empty loop body + } + //Stdout.formatln( " D mainloop stop" ); + return; + + DBusError err; + dbus_error_init(&err); + //CBus.dbus_bus_request_name(conn, XtoUtf8z("test.method.caller"), DBUS_NAME_FLAG_REPLACE_EXISTING , &err); + if( dbus_error_is_set(&err) ){ + Stdout.formatln( "Name Error ({})\n", fromUtf8z( err.message)); + dbus_error_free(&err); + throw new Exception(""); + } + } + public void disconnect(){ + if( conn !is null ){ + dbus_connection_close( conn ); + } + } +} + +class DirectConnection : DBusConnectionImpl { + public this( char[] addr ){ + super( addr ); + } +} + + + +class DBusExecutionException : TracedException { + public this( char[] msg ){ + super( msg ); + } +} + +template isDBusSimpleType(T){ + const bool isDBusSimpleType = + is( T == bool ) || + is( T == byte ) || + is( T == short ) || + is( T == ushort ) || + is( T == int ) || + is( T == uint ) || + is( T == long ) || + is( T == ulong ) || + is( T == double ); +} + + +private void getCallValue( T )( DBusMessageIter* iter, out T t ){ + version(CD) pragma( msg, "getCallValue: "~T.stringof ); + + void testType( int type ){ + int expected = dbus_message_iter_get_arg_type( iter ); + ensure( expected == type, "getCallType(%0) type does not match %1 '%2' != %3 '%4'", T.stringof, toUtf8(type), [cast(char)type], toUtf8(expected), [cast(char)expected] ); + } + + static if( false ){} + else static if( isAssocArrayType!(T) ){ + version(CD) pragma( msg, "getCallValue: assic "~typeof(T).stringof ); + testType( DBUS_TYPE_ARRAY ); + DBusMessageIter sub; + dbus_message_iter_recurse( iter, &sub ); + dbus_message_iter_next( iter ); + + typeof(T.keys [0]) key; + typeof(T.values[0]) value; + while( dbus_message_iter_get_arg_type( &sub ) != DBUS_TYPE_INVALID ){ + ensure( dbus_message_iter_get_arg_type( &sub ) == DBUS_TYPE_DICT_ENTRY, "getCallType type does not match for Assoc" ); + DBusMessageIter entry; + dbus_message_iter_recurse( &sub, &entry ); + dbus_message_iter_next( &sub ); + + getCallValue( &entry, key ); + getCallValue( &entry, value ); + t[ key ] = value; + } + } + else static if( is( T == char[] )){ // char[] nicht als dyn array, sondern als String + testType( DBUS_TYPE_STRING ); + char* ptr; + dbus_message_iter_get_basic( iter, & ptr ); + dbus_message_iter_next( iter ); + t = fromUtf8z( ptr ); + } + else static if( isDynamicArrayType!(T) ){ + testType( DBUS_TYPE_ARRAY ); + DBusMessageIter sub; + dbus_message_iter_recurse( iter, &sub ); + dbus_message_iter_next( iter ); + static if( is( typeof(T[0]) == bool )) { + version(CD) pragma( msg, "getCallValue: basic type "~typeof(T[0]).stringof ); + if( dbus_message_iter_get_arg_type( &sub ) != DBUS_TYPE_INVALID ){ + // special processing because of dbus bools are 4bytes vs. D bool is 1byte. + dbus_bool_t* ptr; + int n_elements; + dbus_message_iter_get_fixed_array( & sub, &ptr, & n_elements ); + t.length = n_elements; + foreach( idx, v; ptr[ 0 .. n_elements ] ){ + t[ idx ] = ( v != 0 ); + } + } + } + else static if( isDBusSimpleType!( typeof(T[0]) )) { + version(CD) pragma( msg, "getCallValue: basic type "~typeof(T[0]).stringof ); + if( dbus_message_iter_get_arg_type( &sub ) != DBUS_TYPE_INVALID ){ + typeof(T[0])* ptr; + int n_elements; + dbus_message_iter_get_fixed_array( & sub, &ptr, & n_elements ); + t = ptr[ 0 .. n_elements ].dup; + } + } + else{ + version(CD) pragma( msg, "getCallValue: composed type "~typeof(T[0]).stringof ); + uint idx = 0; + while( dbus_message_iter_get_arg_type( &sub ) != DBUS_TYPE_INVALID ){ + t.length = t.length +1; + getCallValue( &sub, t[idx] ); + // dbus_message_iter_next( &sub ) : is done in getCallValue for element. + idx++; + } + } + } + else static if( isDBusSimpleType!(T) ) { + testType( DBusTypeIdFromDType!(T) ); + dbus_message_iter_get_basic( iter, & t ); + dbus_message_iter_next( iter ); + } + else static if( is( T : DBusObjectImpl )){ + testType( DBusTypeIdFromDType!(T) ); + static assert( false ); + } + else static if( is( T == DBusVariant ) ){ + DBusMessageIter sub; + dbus_message_iter_recurse( iter, &sub ); + dbus_message_iter_next( iter ); + char* sig = dbus_message_iter_get_signature( &sub ); + scope(exit) dbus_free( sig ); + char[] sigText = fromUtf8z( sig ); + t = createDBusVariant( &sub, sigText ); + } + else static if( is( T == Struct!(typeof(T.t)) ) ){ + // Stdout.formatln( "DBus getCallValue {}", __LINE__ ); + DBusMessageIter sub; + dbus_message_iter_recurse( iter, &sub ); + dbus_message_iter_next( iter ); + foreach( idx, el; t.t ){ + getCallValue( & sub, t.t[idx] ); + } + } + else{ + pragma( msg, "getCallValue: "~typeof(t).stringof ); + static assert(false, typeof(t).stringof ); + } +} + +public Struct!(T) getCallValues( T... )( DBusMessage* message ){ + version(CD) pragma( msg, "getCallValues: "~T.stringof ); + Struct!(T) res; + DBusMessageIter args; + dbus_message_iter_init( message, &args); + foreach( idx, t; T ){ + getCallValue( &args, res.t[idx] ); + } + return res; +} + + +private void _appendMsgParam( DBusMessageIter* iter, int type, void* ptr ){ + if ( !dbus_message_iter_append_basic( iter, type, ptr ) ) { + throw new TracedException( "Cannot append argument to iterator" ); + } +} + + +void appendMsgParam( DBusConnection* conn, DBusMessageIter* iter, bool value ){ + dbus_bool_t val = value; + _appendMsgParam( iter, DBUS_TYPE_BOOLEAN, &val ); +} +void appendMsgParam( DBusConnection* conn, DBusMessageIter* iter, byte value ){ + dbus_bool_t val = value; + _appendMsgParam( iter, DBUS_TYPE_BYTE, &val ); +} +void appendMsgParam( DBusConnection* conn, DBusMessageIter* iter, short value ){ + dbus_int16_t val = value; + _appendMsgParam( iter, DBUS_TYPE_INT16, &val ); +} +void appendMsgParam( DBusConnection* conn, DBusMessageIter* iter, ushort value ){ + dbus_uint16_t val = value; + _appendMsgParam( iter, DBUS_TYPE_UINT16, &val ); +} +void appendMsgParam( DBusConnection* conn, DBusMessageIter* iter, int value ){ + dbus_int32_t val = value; + _appendMsgParam( iter, DBUS_TYPE_INT32, &val ); +} +void appendMsgParam( DBusConnection* conn, DBusMessageIter* iter, uint value ){ + dbus_int32_t val = value; + _appendMsgParam( iter, DBUS_TYPE_UINT32, &val ); +} +void appendMsgParam( DBusConnection* conn, DBusMessageIter* iter, long value ){ + dbus_int64_t val = value; + _appendMsgParam( iter, DBUS_TYPE_INT64, &val ); +} +void appendMsgParam( DBusConnection* conn, DBusMessageIter* iter, ulong value ){ + dbus_uint64_t val = value; + _appendMsgParam( iter, DBUS_TYPE_UINT64, &val ); +} +void appendMsgParam( DBusConnection* conn, DBusMessageIter* iter, double value ){ + double val = value; + _appendMsgParam( iter, DBUS_TYPE_DOUBLE, &val ); +} + + + +private const char[] nullChar = "\0"; +char* XtoUtf8z (char[] s) { + if (s.length == 0) + return nullChar.ptr; + if (s[$-1] == '\0') + return s.ptr; + s ~= '\0'; + return s.ptr; +} + +void appendMsgParam( DBusConnection* conn, DBusMessageIter* iter, char[] value ){ + //toUtf8z( value ); // toUtf8z return null for a null char[], but a valid ptr is needed. + char* val = XtoUtf8z( value ); + _appendMsgParam( iter, DBUS_TYPE_STRING, &val ); +} + +void appendMsgParamObject( DBusConnection* conn, DBusMessageIter* iter, DBusObjectImpl value ){ + value.registerDBusObject( conn ); + char* path = XtoUtf8z( value.getDBusInstanceName()); + _appendMsgParam( iter, DBUS_TYPE_OBJECT_PATH, &path ); +} + +void appendMsgParamVariant( DBusConnection* conn, DBusMessageIter* iter, DBusVariant value ){ + DBusMessageIter sub; + ensureDBus( dbus_message_iter_open_container( iter, DBUS_TYPE_VARIANT, XtoUtf8z( value.getSig() ), &sub )); + if( DBusVariantValueBool v = cast(DBusVariantValueBool)value ){ + appendMsgParam( conn, &sub, v.value ); + } + else if( DBusVariantValueByte v = cast(DBusVariantValueByte)value ){ + appendMsgParam( conn, &sub, v.value ); + } + else if( DBusVariantValueShort v = cast(DBusVariantValueShort)value ){ + appendMsgParam( conn, &sub, v.value ); + } + else if( DBusVariantValueUShort v = cast(DBusVariantValueUShort)value ){ + appendMsgParam( conn, &sub, v.value ); + } + else if( DBusVariantValueInt v = cast(DBusVariantValueInt)value ){ + appendMsgParam( conn, &sub, v.value ); + } + else if( DBusVariantValueUInt v = cast(DBusVariantValueUInt)value ){ + appendMsgParam( conn, &sub, v.value ); + } + else if( DBusVariantValueLong v = cast(DBusVariantValueLong)value ){ + appendMsgParam( conn, &sub, v.value ); + } + else if( DBusVariantValueULong v = cast(DBusVariantValueULong)value ){ + appendMsgParam( conn, &sub, v.value ); + } + else if( DBusVariantValueDouble v = cast(DBusVariantValueDouble)value ){ + appendMsgParam( conn, &sub, v.value ); + } + else if( DBusVariantValueString v = cast(DBusVariantValueString)value ){ + appendMsgParam( conn, &sub, v.value ); + } + + else if( DBusVariantStruct v = cast(DBusVariantStruct)value ){ + DBusMessageIter sub2; + ensureDBus( dbus_message_iter_open_container( &sub, DBUS_TYPE_STRUCT, XtoUtf8z( v.getSig() ), &sub2 )); + foreach( el; v.values ){ + appendMsgParamVariant( conn, &sub2, el ); + } + ensureDBus( dbus_message_iter_close_container( &sub, &sub2 )); + } + else if( DBusVariantArray v = cast(DBusVariantArray)value ){ + DBusMessageIter sub2; + ensureDBus( dbus_message_iter_open_container( &sub, DBUS_TYPE_ARRAY, XtoUtf8z( v.getSig() ), &sub2 )); + foreach( el; v.values ){ + appendMsgParamVariant( conn, &sub2, el ); + } + ensureDBus( dbus_message_iter_close_container( &sub, &sub2 )); + } + else if( DBusVariantMap v = cast(DBusVariantMap)value ){ + DBusMessageIter sub2; + ensureDBus( dbus_message_iter_open_container( &sub, DBUS_TYPE_ARRAY, XtoUtf8z( v.getSig() ), &sub2 )); + foreach( entry; v.values ){ + DBusMessageIter el; + ensureDBus( dbus_message_iter_open_container( &sub2, DBUS_TYPE_DICT_ENTRY, null, &el )); + appendMsgParamVariant( conn, &el, entry.key ); + appendMsgParamVariant( conn, &el, entry.value ); + ensureDBus( dbus_message_iter_close_container( &sub2, &el )); + } + ensureDBus( dbus_message_iter_close_container( &sub, &sub2 )); + } + else{ + Stdout.formatln( "appendMsgParamVariant not handled case for sig: {}", value.getSig() ).flush(); + ensure( false, "appendMsgParamVariant not handled case for sig: %0", value.getSig() ); + } + ensureDBus( dbus_message_iter_close_container( iter, &sub )); +} + +void appendMsgParamArray( T )( DBusConnection* conn, DBusMessageIter* iter, T[] value ){ + //pragma( msg, "appendMsgParamArray: "~typeof(T).stringof ); + DBusMessageIter sub; + //Stderr.formatln( "DBus {} {}", __LINE__,createDBusSignature!(T) ).flush; + ensureDBus( dbus_message_iter_open_container( iter, DBUS_TYPE_ARRAY, XtoUtf8z( createDBusSignature!(T)), &sub )); + foreach( item; value ){ + appendItem!( typeof( item ))( conn, &sub, item ); + } + ensureDBus( dbus_message_iter_close_container( iter, &sub )); +} + +void appendMsgParamStruct( T... )( DBusConnection* conn, DBusMessageIter* iter, T t ){ + //pragma( msg, "appendMsgParamStruct: "~typeof(T).stringof ); + DBusMessageIter sub; + ensureDBus( dbus_message_iter_open_container( iter, DBUS_TYPE_STRUCT, XtoUtf8z( createDBusSignature!(T)), &sub )); + foreach( item; t ){ + appendItem( conn, &sub, item ); + } + ensureDBus( dbus_message_iter_close_container( iter, &sub )); +} + +void appendMsgParamAssoc( K, V )( DBusConnection* conn, DBusMessageIter* iter, V[K] map ){ + //pragma( msg, "appendMsgParamAssoc: key="~typeof(K).stringof~" value="~typeof(V).stringof ); + DBusMessageIter sub; + ensureDBus( dbus_message_iter_open_container( iter, DBUS_TYPE_ARRAY, + XtoUtf8z( createDBusSignature!(V[K])[1..$] ), // "{ss}" this is without the leading 'a' for the array. + &sub )); + foreach( key, value; map ){ + DBusMessageIter el; + ensureDBus( dbus_message_iter_open_container( &sub, DBUS_TYPE_DICT_ENTRY, null, &el )); + appendItem!( K )( conn, &el, key ); + appendItem!( V )( conn, &el, value ); + ensureDBus( dbus_message_iter_close_container( &sub, &el )); + } + ensureDBus( dbus_message_iter_close_container( iter, &sub )); +} + +template createDBusSignature(T...){ + //pragma( msg, "createDBusSignature(T) : T="~typeof(T).stringof ); + static if( T.length > 1 ){ + //pragma( msg, "R.length>1" ); + const char[] createDBusSignature = createDBusSignature!(T[0]) ~ createDBusSignature!(T[1..$]); + } + else static if( isAssocArrayType!(T[0]) ){ + //pragma( msg, "createDBusSignature: key="~typeof(T.keys[0] ).stringof~" value="~typeof(T.values[0] ).stringof ); + const char[] createDBusSignature = + DBUS_TYPE_ARRAY_AS_STRING ~ + DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING ~ + createDBusSignature!( typeof(T[0].keys[0] )) ~ + createDBusSignature!( typeof(T[0].values[0] )) ~ + DBUS_DICT_ENTRY_END_CHAR_AS_STRING; + } + else static if( isDynamicArrayType!(T[0]) ){ + //pragma( msg, "createDBusSignature: arr="~typeof(T[0]).stringof ); + static if( is( T[0] == char[] ) ){ + const char[] createDBusSignature = DBUS_TYPE_STRING_AS_STRING; + } + else{ + const char[] createDBusSignature = DBUS_TYPE_ARRAY_AS_STRING ~ createDBusSignature!(typeof(T[0][0])); + } + } + else static if( is( T[0] == bool ) ){ const char[] createDBusSignature = DBUS_TYPE_BOOLEAN_AS_STRING; } + else static if( is( T[0] == byte ) ){ const char[] createDBusSignature = DBUS_TYPE_BYTE_AS_STRING; } + else static if( is( T[0] == short ) ){ const char[] createDBusSignature = DBUS_TYPE_INT16_AS_STRING; } + else static if( is( T[0] == ushort ) ){ const char[] createDBusSignature = DBUS_TYPE_UINT16_AS_STRING; } + else static if( is( T[0] == int ) ){ const char[] createDBusSignature = DBUS_TYPE_INT32_AS_STRING; } + else static if( is( T[0] == uint ) ){ const char[] createDBusSignature = DBUS_TYPE_UINT32_AS_STRING; } + else static if( is( T[0] == long ) ){ const char[] createDBusSignature = DBUS_TYPE_INT64_AS_STRING; } + else static if( is( T[0] == ulong ) ){ const char[] createDBusSignature = DBUS_TYPE_UINT64_AS_STRING; } + else static if( is( T[0] == double ) ){ const char[] createDBusSignature = DBUS_TYPE_DOUBLE_AS_STRING; } + else static if( is( T[0] : DBusObjectImpl ) ){ const char[] createDBusSignature = DBUS_TYPE_OBJECT_PATH_AS_STRING; } + else static if( is( T[0] == DBusVariant ) ){ const char[] createDBusSignature = DBUS_TYPE_VARIANT_AS_STRING; } + else static if( is( T[0] == Struct!(typeof(T[0].t)) )){ + //pragma( msg, "createDBusSignature Struct: t="~typeof(T[0].t).stringof ); + const char[] createDBusSignature = + DBUS_STRUCT_BEGIN_CHAR_AS_STRING ~ + createDBusSignature!( typeof(T[0].t) ) ~ + DBUS_STRUCT_END_CHAR_AS_STRING; + } + else { + pragma( msg, "createDBusSignature(T) : T="~typeof(T).stringof ); + static assert( false ); + } +} + +template DBusTypeIdFromDType(T){ + //pragma( msg, "DBusTypeIdFromDType: "~typeof(T).stringof ); + static if(false){} + else static if( is( T == char[] ) ){ const int DBusTypeIdFromDType = DBUS_TYPE_STRING; } + else static if( isDynamicArrayType!(T) ){ const int DBusTypeIdFromDType = DBUS_TYPE_ARRAY; } + else static if( is( T == bool ) ){ const int DBusTypeIdFromDType = DBUS_TYPE_BOOLEAN; } + else static if( is( T == byte ) ){ const int DBusTypeIdFromDType = DBUS_TYPE_BYTE; } + else static if( is( T == short ) ){ const int DBusTypeIdFromDType = DBUS_TYPE_INT16; } + else static if( is( T == ushort ) ){ const int DBusTypeIdFromDType = DBUS_TYPE_UINT16; } + else static if( is( T == int ) ){ const int DBusTypeIdFromDType = DBUS_TYPE_INT32; } + else static if( is( T == uint ) ){ const int DBusTypeIdFromDType = DBUS_TYPE_UINT32; } + else static if( is( T == long ) ){ const int DBusTypeIdFromDType = DBUS_TYPE_INT64; } + else static if( is( T == ulong ) ){ const int DBusTypeIdFromDType = DBUS_TYPE_UINT64; } + else static if( is( T == double ) ){ const int DBusTypeIdFromDType = DBUS_TYPE_DOUBLE; } + else static if( is( T : DBusObjectImpl ) ){ const int DBusTypeIdFromDType = DBUS_TYPE_OBJECT_PATH; } + else static if( is( T == DBusVariant ) ){ const int DBusTypeIdFromDType = DBUS_TYPE_OBJECT_PATH; } + else static if( is( T == Struct!(typeof(T.t)) ) ){ const int DBusTypeIdFromDType = DBUS_TYPE_OBJECT_PATH; } + else static assert(false); +} + +void appendItem( T... )( DBusConnection* conn, DBusMessageIter * args, T t ){ + //pragma( msg, ">>>appendItem input: "~typeof(t).stringof ); + //Stderr.formatln( "DBus {} {}", __LINE__,T[0].stringof ).flush; + static if( T.length > 1 ){ + //pragma( msg, "T.length>1" ); + appendItem(T[0])( conn, args, t[0] ); + appendItem(T[1..$])( conn, args, t[1..$] ); + } + else static if( isAssocArrayType!(T[0]) ){ + //pragma( msg, ">>> appendItem: assoc" ); + //Stdout.formatln( "DBus {}", __LINE__ ); + appendMsgParamAssoc( conn, args, t[0] ); + } + else static if( is( T[0] == char[] )){ // char[] nicht als dyn array, sondern als String + //pragma( msg, ">>> appendItem: char[]" ); + appendMsgParam( conn, args, t[0]); + } + else static if( isDynamicArrayType!(T[0]) ){ + //pragma( msg, ">>> appendItem: []" ); + //Stdout.formatln( "DBus {}", __LINE__ ); + appendMsgParamArray( conn, args, t[0] ); + } + else static if( isDBusSimpleType!( T[0] ) ) { + //pragma( msg, ">>> appendItem: integral" ); + appendMsgParam( conn, args, t[0] ); + } + else static if( is( T[0] : DBusObjectImpl )){ + //pragma( msg, ">>> appendItem: interface/class" ); + appendMsgParamObject( conn, args, cast(DBusObjectImpl)t[0]); + } + else static if( is( T[0] == DBusVariant ) ){ + appendMsgParamVariant( conn, args, t[0]); + } + else static if( is( T[0] == DBusObjPath ) ){ + //pragma( msg, ">>> appendItem: path" ); + Stdout.formatln( "DBus {}", __LINE__ ); + notImplemented(); + } + else static if( is( T[0] == DBusSignature ) ){ + //pragma( msg, ">>> appendItem: sig" ); + Stdout.formatln( "DBus {}", __LINE__ ); + notImplemented(); + } + else static if( is( T[0] == Struct!(typeof(T[0].t)) ) ){ + //pragma( msg, ">>> appendItem: struct" ); + appendMsgParamStruct( conn, args, t[0].t ); + //pragma( msg, "struct: "~typeof(t).stringof ); + } + else{ + pragma( msg, "appendItem: "~typeof(t).stringof ); + static assert(false, typeof(t).stringof ); + } +} + +void sendReply( DBusConnection* conn, DBusMessage* message ){ + + Stdout.flush(); + Stderr.flush(); + + DBusMessage* reply = dbus_message_new_method_return(message); + scope(exit){ + dbus_message_unref(reply); + } + dbus_bool_t res = dbus_connection_send(conn, reply, null ); + dbus_connection_flush(conn); + if( !res ){ + throw new TracedException( "Cannot send. Out of memory." ); + } +} + +void sendReplyData( T... )( DBusConnection* conn, DBusMessage* message, Struct!(T) t ){ + + Stdout.flush(); + Stderr.flush(); + + //Stdout.formatln( "DBus {}", __LINE__ ); + DBusMessage* reply = dbus_message_new_method_return(message); + scope(exit){ + dbus_message_unref(reply); + } + //Stdout.formatln( "DBus {}", __LINE__ ); + + static if( t.t.length > 0 ){ + DBusMessageIter args; + dbus_message_iter_init_append( reply, &args); + foreach( t_item; t.t ){ + //Stdout.formatln( "DBus {}", __LINE__ ); + //pragma( msg, "sendReply t: "~typeof(t).stringof ); + //pragma( msg, "sendReply t_item: "~typeof(t_item).stringof ); + appendItem( conn, & args, t_item ); + //pragma( msg, "sendReply OK" ); + } + } + //Stdout.formatln( "DBus {}", __LINE__ ); + //Stdout.formatln( "reply sig : {}", fromUtf8z(dbus_message_get_signature(reply))); + dbus_bool_t res = dbus_connection_send(conn, reply, null ); + dbus_connection_flush(conn); + if( !res ){ + throw new TracedException( "Cannot send. Out of memory." ); + } +} + +void sendException( DBusConnection* conn, DBusMessage* message, Exception e ){ + + Stdout.flush(); + Stderr.flush(); + + char* type; + char[] msg = e.msg; + if( IOException e2 = cast(IOException)e ){ + type = XtoUtf8z(DBUS_ERROR_IO_ERROR); + msg = "IOException " ~ msg; + } + else{ + type = XtoUtf8z(DBUS_ERROR_FAILED); + } + if( TracedException te = cast(TracedException)e ){ + foreach( m; te ){ + msg ~= m ~ \n; + } + } + + DBusMessage* reply = + dbus_message_new_error(message, type, XtoUtf8z("D Exception: " ~ msg) ); + scope(exit){ + dbus_message_unref(reply); + } + dbus_bool_t res = dbus_connection_send(conn, reply, null ); + dbus_connection_flush(conn); + if( !res ){ + throw new TracedException( "Cannot send. Out of dbus-memory." ); + } +} + +bool checkIntf( char[] intfName, DBusMessage* message ){ + char[] namedInterface = fromUtf8z( dbus_message_get_interface(message)); + if( namedInterface.length == 0 ){ + return true; // no interface named in call, so lets try + } + return namedInterface == intfName; +} + +public const int METHOD_SIG_MAXLENGTH = 100; + +char[] methodSignature( DBusMessage* message, char[] buf = null ){ + char[] name = fromUtf8z( dbus_message_get_member(message)); + if( buf.length < name.length ){ + buf.length = name.length; + } + buf[ 0 .. name.length ] = name; + + char[] sig = fromUtf8z( dbus_message_get_signature(message)); + int sz = name.length+sig.length+1; + if( buf.length < sz ){ + buf.length= sz; + } + int type = dbus_message_get_type( message ); + switch( type ){ + case DBUS_MESSAGE_TYPE_METHOD_CALL: + buf[name.length] = '|'; + break; + case DBUS_MESSAGE_TYPE_SIGNAL: + buf[name.length] = '>'; + break; + case DBUS_MESSAGE_TYPE_METHOD_RETURN: + case DBUS_MESSAGE_TYPE_ERROR: + case DBUS_MESSAGE_TYPE_INVALID: + default: + ensure( false, "methodSignature for unknown type %0", toUtf8(type) ); + } + buf[name.length+1 .. sz ] = sig; + return buf[0..sz]; +} + +char[] nextSingleCompleteTypeSig( char[] sigText, inout int ate = 0 ){ + if( sigText.length > ate || sigText.length == 0 ){ + return null; + } + char[] sig = sigText[ ate .. $ ]; + + switch( sig[0] ){ + case 'y': + case 'b': + case 'n': + case 'q': + case 'i': + case 'u': + case 'x': + case 't': + case 'd': + case 's': + case 'o': + case 'g': + case 'v': + ate = 1; + return sig[0..1]; + default: + ensure( sig.length > 1, "nextSingleCompleteTypeSig found %0 as a single type sig, which is unknown", sig[0..1] ); + } + + if( sig[0] == 'a' ){ + if( sig[ 1 ] == '{' ){ + int idx = 2; + nextSingleCompleteTypeSig( sig, idx ); + nextSingleCompleteTypeSig( sig, idx ); + ensure( sig.length > idx, "nextSingleCompleteTypeSig 2" ); + ensure( sig[ idx ] == '}', "nextSingleCompleteTypeSig 3" ); + idx++; + ate += idx; + return sig[ 0 .. idx ]; + } + else{ + int idx = 1; + nextSingleCompleteTypeSig( sig, idx ); + ate += idx; + return sig[ 0 .. idx ]; + } + } + else if( sig[0] == '(' ){ + int idx = 1; + ensure( sig.length > idx, "nextSingleCompleteTypeSig 4" ); + while( sig[ idx ] != ')' ){ + nextSingleCompleteTypeSig( sig, idx ); + ensure( sig.length > idx, "nextSingleCompleteTypeSig 5" ); + } + idx++; + ate += idx; + return sig[ 0 .. idx ]; + } + assert(false); +} + +DBusVariant createDBusVariant( DBusMessageIter * iter, char[] sigText ){ + if( sigText.length == 0 ){ + return null; + } + + void getBasic( void* ptr ){ + dbus_message_iter_get_basic( iter, ptr ); + dbus_message_iter_next( iter ); + } + + switch( sigText[0] ){ + case 'y': + { + DBusVariantValueByte res = new DBusVariantValueByte(); + getBasic( & res.value ); + return res; + } + case 'b': + { + DBusVariantValueBool res = new DBusVariantValueBool(); + getBasic( & res.value ); + return res; + } + case 'n': + { + DBusVariantValueShort res = new DBusVariantValueShort(); + getBasic( & res.value ); + return res; + } + case 'q': + { + DBusVariantValueUShort res = new DBusVariantValueUShort(); + getBasic( & res.value ); + return res; + } + case 'i': + { + DBusVariantValueInt res = new DBusVariantValueInt(); + getBasic( & res.value ); + return res; + } + case 'u': + { + DBusVariantValueUInt res = new DBusVariantValueUInt(); + getBasic( & res.value ); + return res; + } + case 'x': + { + DBusVariantValueLong res = new DBusVariantValueLong(); + getBasic( & res.value ); + return res; + } + case 't': + { + DBusVariantValueULong res = new DBusVariantValueULong(); + getBasic( & res.value ); + return res; + } + case 'd': + { + DBusVariantValueDouble res = new DBusVariantValueDouble(); + getBasic( & res.value ); + return res; + } + case 's': + { + DBusVariantValueString res = new DBusVariantValueString(); + char* ptr; + getBasic( & ptr ); + res.value = fromUtf8z( ptr ); + return res; + } + case 'v': + { + DBusVariantValueVariant res = new DBusVariantValueVariant(); + DBusMessageIter subIter; + dbus_message_iter_recurse( iter, &subIter ); + dbus_message_iter_next( iter ); + res.value = createDBusVariant( & subIter, sigText[1..$] ); + return res; + } + case 'o': //"DBusObject" + assert(false); + case 'g': //"DBusSignature" + assert(false); + default: + break; + } + if( sigText[0] == 'a' ){ + if( sigText.length > 1 && sigText[ 1 ] == '{' ){ + int idx = 2; + char[] sigKey = nextSingleCompleteTypeSig( sigText, idx ); + char[] sigValue = nextSingleCompleteTypeSig( sigText, idx ); + DBusVariantMap res = new DBusVariantMap( sigKey, sigValue ); + + DBusMessageIter subIter; + dbus_message_iter_recurse( iter, &subIter ); + dbus_message_iter_next( iter ); + + while( dbus_message_iter_get_arg_type( &subIter ) != DBUS_TYPE_INVALID ){ + ensure( dbus_message_iter_get_arg_type( &subIter ) == DBUS_TYPE_DICT_ENTRY, "createDBusVariant 1" ); + DBusMessageIter entry; + dbus_message_iter_recurse( &subIter, &entry ); + dbus_message_iter_next( &subIter ); + + DBusVariantMapItem item; + item.key = createDBusVariant( & subIter, sigKey ); + item.value = createDBusVariant( & subIter, sigValue ); + res.values ~= item; + } + return res; + } + else{ + int idx = 1; + char[] sigElement = nextSingleCompleteTypeSig( sigText, idx ); + DBusVariantArray res = new DBusVariantArray( sigElement ); + + DBusMessageIter subIter; + dbus_message_iter_recurse( iter, &subIter ); + dbus_message_iter_next( iter ); + + while( dbus_message_iter_get_arg_type( &subIter ) != DBUS_TYPE_INVALID ){ + DBusMessageIter entry; + dbus_message_iter_recurse( &subIter, &entry ); + dbus_message_iter_next( &subIter ); + res.values ~= createDBusVariant( & subIter, sigElement ); + } + return res; + } + } + else if( sigText[0] == '(' ){ + + DBusVariantStruct res = new DBusVariantStruct(); + + int idx = 1; + ensure( sigText.length > idx, "createDBusVariant 2" ); + + DBusMessageIter subIter; + dbus_message_iter_recurse( iter, &subIter ); + dbus_message_iter_next( iter ); + + while( sigText[ idx ] != ')' ){ + char[] sigElement = nextSingleCompleteTypeSig( sigText, idx ); + ensure( sigText.length > idx, "createDBusVariant 3" ); + res.values ~= createDBusVariant( & subIter, sigElement ); + } + return res; + } + assert(false); +} + +T getVariantAsKnownType( T )( DBusVariant var ){ + T res; + static if( false ){} + else static if( isAssocArrayType!(T) ){ + version(CD) pragma( msg, "getVariantAsKnownType: assoc "~typeof(T).stringof ); + DBusVariantMap map = cast(DBusVariantMap)var; + ensure( map !is null, "getVariantAsKnownType map is null" ); + typeof(T.keys [0]) k; + typeof(T.values[0]) v; + foreach( value; map.values ){ + k = getVariantAsKnownType!( typeof(T.keys [0]) )( value.key ); + v = getVariantAsKnownType!( typeof(T.values[0]) )( value.value ); + res[ k ] = v; + } + } + else static if( is( T == char[] )){ // char[] nicht als dyn array, sondern als String + version(CD) pragma( msg, "getVariantAsKnownType: string "~typeof(T).stringof ); + DBusVariantValueString str = cast(DBusVariantValueString)var; + ensure( str !is null, "getVariantAsKnownType string is null" ); + res = str.value; + } + else static if( isDynamicArrayType!(T) ){ + version(CD) pragma( msg, "getVariantAsKnownType: [] "~typeof(T).stringof ); + DBusVariantArray arr = cast(DBusVariantArray)var; + ensure( arr !is null, "getVariantAsKnownType array is null" ); + res = new typeof(T[0])[ arr.values.length ]; + foreach( idx, value; arr.values ){ + res[ idx ] = getVariantAsKnownType!( typeof(T[0]) )( value ); + } + } + else static if( isDBusSimpleType!(T) ) { + DBusVariantValue!(T) v = cast(DBusVariantValue!(T))var; + ensure( v !is null, "getVariantAsKnownType value is null" ); + res = v.value; + } + else static if( is( T : DBusObjectImpl )){ + static assert( false ); + } + else static if( is( T == DBusVariant ) ){ + res = var; + } + else static if( is( T == Struct!(typeof(T.t)) ) ){ + DBusVariantStruct v = cast(DBusVariantStruct)var; + ensure( v !is null, "getVariantAsKnownType isnull" ); + foreach( idx, item; res.t ){ + res.t[idx] = getVariantAsKnownType!( typeof(item) )( v.values[idx] ); + } + } + else{ + pragma( msg, "appendItem: "~typeof(t).stringof ); + static assert(false, typeof(t).stringof ); + } + return res; +} + + + + +void testTemplateCompilation(){ + getCallValues!( int[] )( null ); + getCallValues!( int[ char[] ] )( null ); + getCallValues!( DBusVariant[ DBusVariant ] )( null ); + getCallValues!( Struct!( int[], long, char[], Struct!( bool ) ) )( null ); + + getVariantAsKnownType!( int[] )( null ); + getVariantAsKnownType!( int[ char[] ] )( null ); + getVariantAsKnownType!( DBusVariant[ DBusVariant ] )( null ); + getVariantAsKnownType!( Struct!( int[], long, char[], Struct!( bool ) ) )( null ); +} + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbus-d/dsrc/org/freedesktop/dbus/Struct.d Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,29 @@ +/* + * Copyright (C) 2007 Frank Benoit + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ +module org.freedesktop.dbus.Struct; + + + +template Struct(T...){ + struct Struct{ + T t; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbus-d/dsrc/org/freedesktop/dbus/Variant.d Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,117 @@ +/* + * Copyright (C) 2007 Frank Benoit + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ +module org.freedesktop.dbus.Variant; + +//import tango.core.Variant; +import org.freedesktop.dbus.c.Protocol; +import org.freedesktop.dbus.Struct; +//alias Variant DBusVariant; + +abstract class DBusVariant { + abstract public char[] getSig(); +} + +template DBusTypeIdFromDType(T){ + //pragma( msg, "DBusTypeIdFromDType: "~typeof(T).stringof ); + static if(false){} + else static if( is( T == char[] ) ){ const int DBusTypeIdFromDType = DBUS_TYPE_STRING; } + else static if( is( T == bool ) ){ const int DBusTypeIdFromDType = DBUS_TYPE_BOOLEAN; } + else static if( is( T == byte ) ){ const int DBusTypeIdFromDType = DBUS_TYPE_BYTE; } + else static if( is( T == short ) ){ const int DBusTypeIdFromDType = DBUS_TYPE_INT16; } + else static if( is( T == ushort ) ){ const int DBusTypeIdFromDType = DBUS_TYPE_UINT16; } + else static if( is( T == int ) ){ const int DBusTypeIdFromDType = DBUS_TYPE_INT32; } + else static if( is( T == uint ) ){ const int DBusTypeIdFromDType = DBUS_TYPE_UINT32; } + else static if( is( T == long ) ){ const int DBusTypeIdFromDType = DBUS_TYPE_INT64; } + else static if( is( T == ulong ) ){ const int DBusTypeIdFromDType = DBUS_TYPE_UINT64; } + else static if( is( T == double ) ){ const int DBusTypeIdFromDType = DBUS_TYPE_DOUBLE; } + else static if( is( T : DBusVariant ) ){ const int DBusTypeIdFromDType = DBUS_TYPE_VARIANT; } + else static assert(false); +} + +class DBusVariantValue( T ) : DBusVariant { + public T value; + static const char sig = DBusTypeIdFromDType!(T); + public char[] getSig(){ + return [sig]; + } +} + +alias DBusVariantValue!( bool ) DBusVariantValueBool; +alias DBusVariantValue!( byte ) DBusVariantValueByte; +alias DBusVariantValue!( short ) DBusVariantValueShort; +alias DBusVariantValue!( ushort ) DBusVariantValueUShort; +alias DBusVariantValue!( int ) DBusVariantValueInt; +alias DBusVariantValue!( uint ) DBusVariantValueUInt; +alias DBusVariantValue!( long ) DBusVariantValueLong; +alias DBusVariantValue!( ulong ) DBusVariantValueULong; +alias DBusVariantValue!( double ) DBusVariantValueDouble; +alias DBusVariantValue!( char[] ) DBusVariantValueString; +alias DBusVariantValue!( DBusVariant ) DBusVariantValueVariant; + +class DBusVariantStruct : DBusVariant { + public DBusVariant[] values; + public this(){ + } + public char[] getSig(){ + char[] res = DBUS_STRUCT_BEGIN_CHAR_AS_STRING; + foreach( value; values ){ + res ~= value.getSig(); + } + res ~= DBUS_STRUCT_END_CHAR_AS_STRING; + return res; + } +} + +class DBusVariantArray : DBusVariant { + private char[] sig; + public DBusVariant[] values; + public this( char[] sig ){ + this.sig = DBUS_TYPE_ARRAY_AS_STRING ~ sig; + } + public char[] getSig(){ + return sig; + } +} + +struct DBusVariantMapItem{ + DBusVariant key; + DBusVariant value; +} + +class DBusVariantMap : DBusVariant { + public DBusVariantMapItem[] values; + private char[] sig; + public this( char[] sigKey, char[] sigValue ){ + sig = DBUS_TYPE_ARRAY_AS_STRING ~ DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING ~ + sigKey ~ sigValue ~ DBUS_DICT_ENTRY_END_CHAR_AS_STRING; + } + public char[] getSig(){ + return sig; + } +} + + + + + + + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbus-d/dsrc/org/freedesktop/dbus/c/Address.d Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,53 @@ +/* -*- mode: C; c-file-style: "gnu" -*- */ +/* dbus-address.h Server address parser. + * + * Copyright (C) 2003 CodeFactory AB + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ +module org.freedesktop.dbus.c.Address; + +import org.freedesktop.dbus.c.Types; +import org.freedesktop.dbus.c.Errors; + +extern(C): + +/** + * @addtogroup DBusAddress + * @{ + */ + +/** Opaque type representing one of the semicolon-separated items in an address */ +struct DBusAddressEntry {}; + +dbus_bool_t dbus_parse_address (char *address, + DBusAddressEntry ***entry, + int *array_len, + DBusError *error); +char *dbus_address_entry_get_value (DBusAddressEntry *entry, + char *key); +char *dbus_address_entry_get_method (DBusAddressEntry *entry); +void dbus_address_entries_free (DBusAddressEntry **entries); + +char* dbus_address_escape_value (char *value); +char* dbus_address_unescape_value (char *value, + DBusError *error); + +/** @} */ + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbus-d/dsrc/org/freedesktop/dbus/c/Bus.d Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,77 @@ +/* -*- mode: C; c-file-style: "gnu" -*- */ +/* dbus-bus.h Convenience functions for communicating with the bus. + * + * Copyright (C) 2003 CodeFactory AB + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ +module org.freedesktop.dbus.c.Bus; + +import org.freedesktop.dbus.c.Connection; +import org.freedesktop.dbus.c.Shared; +import org.freedesktop.dbus.c.Types; +import org.freedesktop.dbus.c.Errors; + +extern(C): +/** + * @addtogroup DBusBus + * @{ + */ +//struct DBusError {}; + +DBusConnection *dbus_bus_get (DBusBusType type, + DBusError *error); +DBusConnection *dbus_bus_get_private (DBusBusType type, + DBusError *error); + +dbus_bool_t dbus_bus_register (DBusConnection *connection, + DBusError *error); +dbus_bool_t dbus_bus_set_unique_name (DBusConnection *connection, + char *unique_name); +char* dbus_bus_get_unique_name (DBusConnection *connection); +uint dbus_bus_get_unix_user (DBusConnection *connection, + char *name, + DBusError *error); +char* dbus_bus_get_id (DBusConnection *connection, + DBusError *error); +int dbus_bus_request_name (DBusConnection *connection, + char *name, + uint flags, + DBusError *error); +int dbus_bus_release_name (DBusConnection *connection, + char *name, + DBusError *error); +dbus_bool_t dbus_bus_name_has_owner (DBusConnection *connection, + char *name, + DBusError *error); + +dbus_bool_t dbus_bus_start_service_by_name (DBusConnection *connection, + char *name, + dbus_uint32_t flags, + dbus_uint32_t *reply, + DBusError *error); + +void dbus_bus_add_match (DBusConnection *connection, + char *rule, + DBusError *error); +void dbus_bus_remove_match (DBusConnection *connection, + char *rule, + DBusError *error); + +/** @} */ +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbus-d/dsrc/org/freedesktop/dbus/c/Connection.d Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,380 @@ +/* -*- mode: C; c-file-style: "gnu" -*- */ +/* dbus-connection.h DBusConnection object + * + * Copyright (C) 2002, 2003 Red Hat Inc. + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ +module org.freedesktop.dbus.c.Connection; + +import org.freedesktop.dbus.c.Errors; +import org.freedesktop.dbus.c.Memory; +import org.freedesktop.dbus.c.Message; +import org.freedesktop.dbus.c.Shared; +import org.freedesktop.dbus.c.Types; + +extern(C): +/** + * @addtogroup DBusConnection + * @{ + */ + +/* documented in dbus-watch.c */ +struct DBusWatch {}; +/* documented in dbus-timeout.c */ +struct DBusTimeout {}; +/** Opaque type representing preallocated resources so a message can be sent without further memory allocation. */ +struct DBusPreallocatedSend {}; +/** Opaque type representing a method call that has not yet received a reply. */ +struct DBusPendingCall {}; +/** Opaque type representing a connection to a remote application and associated incoming/outgoing message queues. */ +struct DBusConnection {}; +/** Set of functions that must be implemented to handle messages sent to a particular object path. */ +//struct DBusObjectPathVTable {}; + +/** + * Indicates the status of a #DBusWatch. + */ +enum DBusWatchFlags{ + DBUS_WATCH_READABLE = 1 << 0, /**< As in POLLIN */ + DBUS_WATCH_WRITABLE = 1 << 1, /**< As in POLLOUT */ + DBUS_WATCH_ERROR = 1 << 2, /**< As in POLLERR (can't watch for + * this, but can be present in + * current state passed to + * dbus_watch_handle()). + */ + DBUS_WATCH_HANGUP = 1 << 3 /**< As in POLLHUP (can't watch for + * it, but can be present in current + * state passed to + * dbus_watch_handle()). + */ +} + +/** + * Indicates the status of incoming data on a #DBusConnection. This determines whether + * dbus_connection_dispatch() needs to be called. + */ +enum DBusDispatchStatus{ + DBUS_DISPATCH_DATA_REMAINS, /**< There is more data to potentially convert to messages. */ + DBUS_DISPATCH_COMPLETE, /**< All currently available data has been processed. */ + DBUS_DISPATCH_NEED_MEMORY /**< More memory is needed to continue. */ +} ; + +/** Called when libdbus needs a new watch to be monitored by the main + * loop. Returns #FALSE if it lacks enough memory to add the + * watch. Set by dbus_connection_set_watch_functions() or + * dbus_server_set_watch_functions(). + */ +alias dbus_bool_t (* DBusAddWatchFunction) (DBusWatch *watch, + void *data); +/** Called when dbus_watch_get_enabled() may return a different value + * than it did before. Set by dbus_connection_set_watch_functions() + * or dbus_server_set_watch_functions(). + */ +alias void (* DBusWatchToggledFunction) (DBusWatch *watch, + void *data); +/** Called when libdbus no longer needs a watch to be monitored by the + * main loop. Set by dbus_connection_set_watch_functions() or + * dbus_server_set_watch_functions(). + */ +alias void (* DBusRemoveWatchFunction) (DBusWatch *watch, + void *data); +/** Called when libdbus needs a new timeout to be monitored by the main + * loop. Returns #FALSE if it lacks enough memory to add the + * watch. Set by dbus_connection_set_timeout_functions() or + * dbus_server_set_timeout_functions(). + */ +alias dbus_bool_t (* DBusAddTimeoutFunction) (DBusTimeout *timeout, + void *data); +/** Called when dbus_timeout_get_enabled() may return a different + * value than it did before. + * Set by dbus_connection_set_timeout_functions() or + * dbus_server_set_timeout_functions(). + */ +alias void (* DBusTimeoutToggledFunction) (DBusTimeout *timeout, + void *data); +/** Called when libdbus no longer needs a timeout to be monitored by the + * main loop. Set by dbus_connection_set_timeout_functions() or + * dbus_server_set_timeout_functions(). + */ +alias void (* DBusRemoveTimeoutFunction) (DBusTimeout *timeout, + void *data); +/** Called when the return value of dbus_connection_get_dispatch_status() + * may have changed. Set with dbus_connection_set_dispatch_status_function(). + */ +alias void (* DBusDispatchStatusFunction) (DBusConnection *connection, + DBusDispatchStatus new_status, + void *data); +/** + * Called when the main loop's thread should be notified that there's now work + * to do. Set with dbus_connection_set_wakeup_main_function(). + */ +alias void (* DBusWakeupMainFunction) (void *data); + +/** + * Called during authentication to check whether the given UNIX user + * ID is allowed to connect, if the client tried to auth as a UNIX + * user ID. Normally on Windows this would never happen. Set with + * dbus_connection_set_unix_user_function(). + */ +alias dbus_bool_t (* DBusAllowUnixUserFunction) (DBusConnection *connection, + uint uid, + void *data); + +/** + * Called during authentication to check whether the given Windows user + * ID is allowed to connect, if the client tried to auth as a Windows + * user ID. Normally on UNIX this would never happen. Set with + * dbus_connection_set_windows_user_function(). + */ +alias dbus_bool_t (* DBusAllowWindowsUserFunction) (DBusConnection *connection, + char *user_sid, + void *data); + + +/** + * Called when a pending call now has a reply available. Set with + * dbus_pending_call_set_notify(). + */ +alias void (* DBusPendingCallNotifyFunction) (DBusPendingCall *pending, + void *user_data); + +/** + * Called when a message needs to be handled. The result indicates whether or + * not more handlers should be run. Set with dbus_connection_add_filter(). + */ +alias DBusHandlerResult (* DBusHandleMessageFunction) (DBusConnection *connection, + DBusMessage *message, + void *user_data); + +DBusConnection* dbus_connection_open (char *address, + DBusError *error); +DBusConnection* dbus_connection_open_private (char *address, + DBusError *error); +DBusConnection* dbus_connection_ref (DBusConnection *connection); +void dbus_connection_unref (DBusConnection *connection); +void dbus_connection_close (DBusConnection *connection); +dbus_bool_t dbus_connection_get_is_connected (DBusConnection *connection); +dbus_bool_t dbus_connection_get_is_authenticated (DBusConnection *connection); +dbus_bool_t dbus_connection_get_is_anonymous (DBusConnection *connection); +char* dbus_connection_get_server_id (DBusConnection *connection); +void dbus_connection_set_exit_on_disconnect (DBusConnection *connection, + dbus_bool_t exit_on_disconnect); +void dbus_connection_flush (DBusConnection *connection); +dbus_bool_t dbus_connection_read_write_dispatch (DBusConnection *connection, + int timeout_milliseconds); +dbus_bool_t dbus_connection_read_write (DBusConnection *connection, + int timeout_milliseconds); +DBusMessage* dbus_connection_borrow_message (DBusConnection *connection); +void dbus_connection_return_message (DBusConnection *connection, + DBusMessage *message); +void dbus_connection_steal_borrowed_message (DBusConnection *connection, + DBusMessage *message); +DBusMessage* dbus_connection_pop_message (DBusConnection *connection); +DBusDispatchStatus dbus_connection_get_dispatch_status (DBusConnection *connection); +DBusDispatchStatus dbus_connection_dispatch (DBusConnection *connection); +dbus_bool_t dbus_connection_has_messages_to_send (DBusConnection *connection); +dbus_bool_t dbus_connection_send (DBusConnection *connection, + DBusMessage *message, + dbus_uint32_t *client_serial); +dbus_bool_t dbus_connection_send_with_reply (DBusConnection *connection, + DBusMessage *message, + DBusPendingCall **pending_return, + int timeout_milliseconds); +DBusMessage * dbus_connection_send_with_reply_and_block (DBusConnection *connection, + DBusMessage *message, + int timeout_milliseconds, + DBusError *error); +dbus_bool_t dbus_connection_set_watch_functions (DBusConnection *connection, + DBusAddWatchFunction add_function, + DBusRemoveWatchFunction remove_function, + DBusWatchToggledFunction toggled_function, + void *data, + DBusFreeFunction free_data_function); +dbus_bool_t dbus_connection_set_timeout_functions (DBusConnection *connection, + DBusAddTimeoutFunction add_function, + DBusRemoveTimeoutFunction remove_function, + DBusTimeoutToggledFunction toggled_function, + void *data, + DBusFreeFunction free_data_function); +void dbus_connection_set_wakeup_main_function (DBusConnection *connection, + DBusWakeupMainFunction wakeup_main_function, + void *data, + DBusFreeFunction free_data_function); +void dbus_connection_set_dispatch_status_function (DBusConnection *connection, + DBusDispatchStatusFunction function_, + void *data, + DBusFreeFunction free_data_function); +dbus_bool_t dbus_connection_get_unix_user (DBusConnection *connection, + uint *uid); +dbus_bool_t dbus_connection_get_unix_process_id (DBusConnection *connection, + uint *pid); +void dbus_connection_set_unix_user_function (DBusConnection *connection, + DBusAllowUnixUserFunction function_, + void *data, + DBusFreeFunction free_data_function); +dbus_bool_t dbus_connection_get_windows_user (DBusConnection *connection, + char **windows_sid_p); +void dbus_connection_set_windows_user_function (DBusConnection *connection, + DBusAllowWindowsUserFunction function_, + void *data, + DBusFreeFunction free_data_function); +void dbus_connection_set_allow_anonymous (DBusConnection *connection, + dbus_bool_t value); +void dbus_connection_set_route_peer_messages (DBusConnection *connection, + dbus_bool_t value); + + +/* Filters */ + +dbus_bool_t dbus_connection_add_filter (DBusConnection *connection, + DBusHandleMessageFunction function_, + void *user_data, + DBusFreeFunction free_data_function); +void dbus_connection_remove_filter (DBusConnection *connection, + DBusHandleMessageFunction function_, + void *user_data); + + +/* Other */ +dbus_bool_t dbus_connection_allocate_data_slot (dbus_int32_t *slot_p); +void dbus_connection_free_data_slot (dbus_int32_t *slot_p); +dbus_bool_t dbus_connection_set_data (DBusConnection *connection, + dbus_int32_t slot, + void *data, + DBusFreeFunction free_data_func); +void* dbus_connection_get_data (DBusConnection *connection, + dbus_int32_t slot); + +void dbus_connection_set_change_sigpipe (dbus_bool_t will_modify_sigpipe); + +void dbus_connection_set_max_message_size (DBusConnection *connection, + long size); +long dbus_connection_get_max_message_size (DBusConnection *connection); +void dbus_connection_set_max_received_size (DBusConnection *connection, + long size); +long dbus_connection_get_max_received_size (DBusConnection *connection); +long dbus_connection_get_outgoing_size (DBusConnection *connection); + +DBusPreallocatedSend* dbus_connection_preallocate_send (DBusConnection *connection); +void dbus_connection_free_preallocated_send (DBusConnection *connection, + DBusPreallocatedSend *preallocated); +void dbus_connection_send_preallocated (DBusConnection *connection, + DBusPreallocatedSend *preallocated, + DBusMessage *message, + dbus_uint32_t *client_serial); + + +/* Object tree functionality */ + +/** + * Called when a #DBusObjectPathVTable is unregistered (or its connection is freed). + * Found in #DBusObjectPathVTable. + */ +alias void (* DBusObjectPathUnregisterFunction) (DBusConnection *connection, + void *user_data); +/** + * Called when a message is sent to a registered object path. Found in + * #DBusObjectPathVTable which is registered with dbus_connection_register_object_path() + * or dbus_connection_register_fallback(). + */ +alias DBusHandlerResult (* DBusObjectPathMessageFunction) (DBusConnection *connection, + DBusMessage *message, + void *user_data); + +/** + * Virtual table that must be implemented to handle a portion of the + * object path hierarchy. Attach the vtable to a particular path using + * dbus_connection_register_object_path() or + * dbus_connection_register_fallback(). + */ +struct DBusObjectPathVTable { + DBusObjectPathUnregisterFunction unregister_function; /**< Function to unregister this handler */ + DBusObjectPathMessageFunction message_function; /**< Function to handle messages */ + + void (* dbus_internal_pad1) (void *); /**< Reserved for future expansion */ + void (* dbus_internal_pad2) (void *); /**< Reserved for future expansion */ + void (* dbus_internal_pad3) (void *); /**< Reserved for future expansion */ + void (* dbus_internal_pad4) (void *); /**< Reserved for future expansion */ +} + +dbus_bool_t dbus_connection_register_object_path (DBusConnection *connection, + char *path, + DBusObjectPathVTable *vtable, + void *user_data); +dbus_bool_t dbus_connection_register_fallback (DBusConnection *connection, + char *path, + DBusObjectPathVTable *vtable, + void *user_data); +dbus_bool_t dbus_connection_unregister_object_path (DBusConnection *connection, + char *path); + +dbus_bool_t dbus_connection_get_object_path_data (DBusConnection *connection, + char *path, + void **data_p); + +dbus_bool_t dbus_connection_list_registered (DBusConnection *connection, + char *parent_path, + char ***child_entries); + +dbus_bool_t dbus_connection_get_unix_fd (DBusConnection *connection, + int *fd); +dbus_bool_t dbus_connection_get_socket (DBusConnection *connection, + int *fd); + +/** @} */ + + +/** + * @addtogroup DBusWatch + * @{ + */ +version( DBUS_DISABLE_DEPRECATED){} +else{ + deprecated int dbus_watch_get_fd (DBusWatch *watch); +} + +int dbus_watch_get_unix_fd (DBusWatch *watch); +int dbus_watch_get_socket (DBusWatch *watch); + +uint dbus_watch_get_flags (DBusWatch *watch); +void* dbus_watch_get_data (DBusWatch *watch); +void dbus_watch_set_data (DBusWatch *watch, + void *data, + DBusFreeFunction free_data_function); +dbus_bool_t dbus_watch_handle (DBusWatch *watch, + uint flags); +dbus_bool_t dbus_watch_get_enabled (DBusWatch *watch); + +/** @} */ + +/** + * @addtogroup DBusTimeout + * @{ + */ + +int dbus_timeout_get_interval (DBusTimeout *timeout); +void* dbus_timeout_get_data (DBusTimeout *timeout); +void dbus_timeout_set_data (DBusTimeout *timeout, + void *data, + DBusFreeFunction free_data_function); +dbus_bool_t dbus_timeout_handle (DBusTimeout *timeout); +dbus_bool_t dbus_timeout_get_enabled (DBusTimeout *timeout); + +/** @} */ +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbus-d/dsrc/org/freedesktop/dbus/c/DBus.d Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,94 @@ +/* -*- mode: C; c-file-style: "gnu" -*- */ +/* org.freedesktop.dbus.c.h Convenience header including all other headers + * + * Copyright (C) 2002, 2003 Red Hat Inc. + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ +module org.freedesktop.dbus.c.DBus; + +public import org.freedesktop.dbus.c.Address; +public import org.freedesktop.dbus.c.Bus; +public import org.freedesktop.dbus.c.Connection; +public import org.freedesktop.dbus.c.Errors; +public import org.freedesktop.dbus.c.Message; +public import org.freedesktop.dbus.c.PendingCall; +public import org.freedesktop.dbus.c.Protocol; +public import org.freedesktop.dbus.c.Server; +public import org.freedesktop.dbus.c.Shared; +public import org.freedesktop.dbus.c.Signature; +public import org.freedesktop.dbus.c.Threads; +public import org.freedesktop.dbus.c.Types; + + +/** + * @defgroup DBus D-Bus low-level public API + * @brief The low-level public API of the D-Bus library + * + * libdbus provides a low-level C API intended primarily for use by + * bindings to specific object systems and languages. D-Bus is most + * convenient when used with the GLib bindings, Python bindings, Qt + * bindings, Mono bindings, and so forth. This low-level API has a + * lot of complexity useful only for bindings. + * + * @{ + */ + +/** @} */ + +/** + * @mainpage + * + * This manual documents the <em>low-level</em> D-Bus C API. <b>If you use + * this low-level API directly, you're signing up for some pain.</b> + * + * Caveats aside, you might get started learning the low-level API by reading + * about @ref DBusConnection and @ref DBusMessage. + * + * There are several other places to look for D-Bus information, such + * as the tutorial and the specification; those can be found at <a + * href="http://www.freedesktop.org/wiki/Software/dbus">the D-Bus + * website</a>. If you're interested in a sysadmin or package + * maintainer's perspective on the dbus-daemon itself and its + * configuration, be sure to check out the man pages as well. + * + * The low-level API documented in this manual deliberately lacks + * most convenience functions - those are left up to higher-level libraries + * based on frameworks such as GLib, Qt, Python, Mono, Java, + * etc. These higher-level libraries (often called "D-Bus bindings") + * have features such as object systems and main loops that allow a + * <em>much</em> more convenient API. + * + * The low-level API also contains plenty of clutter to support + * integration with arbitrary object systems, languages, main loops, + * and so forth. These features add a lot of noise to the API that you + * probably don't care about unless you're coding a binding. + * + * This manual also contains docs for @ref DBusInternals "D-Bus internals", + * so you can use it to get oriented to the D-Bus source code if you're + * interested in patching the code. You should also read the + * file HACKING which comes with the source code if you plan to contribute to + * D-Bus. + * + * As you read the code, you can identify internal D-Bus functions + * because they start with an underscore ('_') character. Also, any + * identifier or macro that lacks a DBus, dbus_, or DBUS_ namepace + * prefix is internal, with a couple of exceptions such as #NULL, + * #TRUE, and #FALSE. + */ +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbus-d/dsrc/org/freedesktop/dbus/c/Errors.d Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,61 @@ +/* -*- mode: C; c-file-style: "gnu" -*- */ +/* dbus-errors.h Error reporting + * + * Copyright (C) 2002 Red Hat Inc. + * Copyright (C) 2003 CodeFactory AB + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ +module org.freedesktop.dbus.c.Errors; + +import org.freedesktop.dbus.c.Types; + +extern(C): +/** + * @addtogroup DBusErrors + * @{ + */ + +/** + * Object representing an exception. + */ +struct DBusError { + char *name; /**< public error name field */ + char *message; /**< public error message field */ + + uint dummy_bits; /**< placeholder */ + void *padding1; /**< placeholder */ +} + +void dbus_error_init (DBusError *error); +void dbus_error_free (DBusError *error); +void dbus_set_error (DBusError *error, + char *name, + char *message, + ...); +void dbus_set_error_const (DBusError *error, + char *name, + char *message); +void dbus_move_error (DBusError *src, + DBusError *dest); +dbus_bool_t dbus_error_has_name (DBusError *error, + char *name); +dbus_bool_t dbus_error_is_set (DBusError *error); + +/** @} */ +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbus-d/dsrc/org/freedesktop/dbus/c/Memory.d Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,52 @@ +/* -*- mode: C; c-file-style: "gnu" -*- */ +/* dbus-memory.h D-Bus memory handling + * + * Copyright (C) 2002 Red Hat Inc. + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ +module org.freedesktop.dbus.c.Memory; + +extern(C): +/** + * @addtogroup DBusMemory + * @{ + */ + +void* dbus_malloc (size_t bytes); +void* dbus_malloc0 (size_t bytes); +void* dbus_realloc (void *memory, + size_t bytes); +void dbus_free (void *memory); + +T* dbus_new(T)( count){ + return cast(T*)dbus_malloc (T.sizeof * count); +} + +T* dbus_new0(T)( count){ + return cast(T*)dbus_malloc0 (T.sizeof* count); +} + +void dbus_free_string_array (char **str_array); + +alias void (* DBusFreeFunction) (void *memory); + +void dbus_shutdown (); + +/** @} */ +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbus-d/dsrc/org/freedesktop/dbus/c/Message.d Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,217 @@ +/* -*- mode: C; c-file-style: "gnu" -*- */ +/* dbus-message.h DBusMessage object + * + * Copyright (C) 2002, 2003, 2005 Red Hat Inc. + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ +module org.freedesktop.dbus.c.Message; + +import org.freedesktop.dbus.c.Types; +import org.freedesktop.dbus.c.Memory; +import org.freedesktop.dbus.c.Errors; + +extern(C): + +/** + * @addtogroup DBusMessage + * @{ + */ + +struct DBusMessage {}; + +/** + * DBusMessageIter struct; contains no public fields. + */ +struct DBusMessageIter { + void *dummy1; /**< Don't use this */ + void *dummy2; /**< Don't use this */ + dbus_uint32_t dummy3; /**< Don't use this */ + int dummy4; /**< Don't use this */ + int dummy5; /**< Don't use this */ + int dummy6; /**< Don't use this */ + int dummy7; /**< Don't use this */ + int dummy8; /**< Don't use this */ + int dummy9; /**< Don't use this */ + int dummy10; /**< Don't use this */ + int dummy11; /**< Don't use this */ + int pad1; /**< Don't use this */ + int pad2; /**< Don't use this */ + void *pad3; /**< Don't use this */ +}; + +DBusMessage* dbus_message_new (int message_type); +DBusMessage* dbus_message_new_method_call (char *bus_name, + char *path, + char *interface_, + char *method); +DBusMessage* dbus_message_new_method_return (DBusMessage *method_call); +DBusMessage* dbus_message_new_signal (char *path, + char *interface_, + char *name); +DBusMessage* dbus_message_new_error (DBusMessage *reply_to, + char *error_name, + char *error_message); +DBusMessage* dbus_message_new_error_printf (DBusMessage *reply_to, + char *error_name, + char *error_format, + ...); + +DBusMessage* dbus_message_copy (DBusMessage *message); + +DBusMessage* dbus_message_ref (DBusMessage *message); +void dbus_message_unref (DBusMessage *message); +int dbus_message_get_type (DBusMessage *message); +dbus_bool_t dbus_message_set_path (DBusMessage *message, + char *object_path); +char* dbus_message_get_path (DBusMessage *message); +dbus_bool_t dbus_message_has_path (DBusMessage *message, + char *object_path); +dbus_bool_t dbus_message_set_interface (DBusMessage *message, + char *interface_); +char* dbus_message_get_interface (DBusMessage *message); +dbus_bool_t dbus_message_has_interface (DBusMessage *message, + char *interface_); +dbus_bool_t dbus_message_set_member (DBusMessage *message, + char *member); +char* dbus_message_get_member (DBusMessage *message); +dbus_bool_t dbus_message_has_member (DBusMessage *message, + char *member); +dbus_bool_t dbus_message_set_error_name (DBusMessage *message, + char *name); +char* dbus_message_get_error_name (DBusMessage *message); +dbus_bool_t dbus_message_set_destination (DBusMessage *message, + char *destination); +char* dbus_message_get_destination (DBusMessage *message); +dbus_bool_t dbus_message_set_sender (DBusMessage *message, + char *sender); +char* dbus_message_get_sender (DBusMessage *message); +char* dbus_message_get_signature (DBusMessage *message); +void dbus_message_set_no_reply (DBusMessage *message, + dbus_bool_t no_reply); +dbus_bool_t dbus_message_get_no_reply (DBusMessage *message); +dbus_bool_t dbus_message_is_method_call (DBusMessage *message, + char *interface_, + char *method); +dbus_bool_t dbus_message_is_signal (DBusMessage *message, + char *interface_, + char *signal_name); +dbus_bool_t dbus_message_is_error (DBusMessage *message, + char *error_name); +dbus_bool_t dbus_message_has_destination (DBusMessage *message, + char *bus_name); +dbus_bool_t dbus_message_has_sender (DBusMessage *message, + char *unique_bus_name); +dbus_bool_t dbus_message_has_signature (DBusMessage *message, + char *signature); +dbus_uint32_t dbus_message_get_serial (DBusMessage *message); +dbus_bool_t dbus_message_set_reply_serial (DBusMessage *message, + dbus_uint32_t reply_serial); +dbus_uint32_t dbus_message_get_reply_serial (DBusMessage *message); + +void dbus_message_set_auto_start (DBusMessage *message, + dbus_bool_t auto_start); +dbus_bool_t dbus_message_get_auto_start (DBusMessage *message); + +dbus_bool_t dbus_message_get_path_decomposed (DBusMessage *message, + char ***path); + +dbus_bool_t dbus_message_append_args (DBusMessage *message, + int first_arg_type, + ...); +dbus_bool_t dbus_message_append_args_valist (DBusMessage *message, + int first_arg_type, + //va_list var_args); + void* var_args); +dbus_bool_t dbus_message_get_args (DBusMessage *message, + DBusError *error, + int first_arg_type, + ...); +dbus_bool_t dbus_message_get_args_valist (DBusMessage *message, + DBusError *error, + int first_arg_type, + //va_list var_args); + void* var_args); + + +dbus_bool_t dbus_message_iter_init (DBusMessage *message, + DBusMessageIter *iter); +dbus_bool_t dbus_message_iter_has_next (DBusMessageIter *iter); +dbus_bool_t dbus_message_iter_next (DBusMessageIter *iter); +char* dbus_message_iter_get_signature (DBusMessageIter *iter); +int dbus_message_iter_get_arg_type (DBusMessageIter *iter); +int dbus_message_iter_get_element_type (DBusMessageIter *iter); +void dbus_message_iter_recurse (DBusMessageIter *iter, + DBusMessageIter *sub); +void dbus_message_iter_get_basic (DBusMessageIter *iter, + void *value); +version(DBUS_DISABLE_DEPRECATED){} +else{ + /* This function returns the wire protocol size of the array in bytes, + * you do not want to know that probably + */ + deprecated int dbus_message_iter_get_array_len (DBusMessageIter *iter); +} + +void dbus_message_iter_get_fixed_array (DBusMessageIter *iter, + void *value, + int *n_elements); + + +void dbus_message_iter_init_append (DBusMessage *message, + DBusMessageIter *iter); +dbus_bool_t dbus_message_iter_append_basic (DBusMessageIter *iter, + int type, + void *value); +dbus_bool_t dbus_message_iter_append_fixed_array (DBusMessageIter *iter, + int element_type, + void *value, + int n_elements); +dbus_bool_t dbus_message_iter_open_container (DBusMessageIter *iter, + int type, + char *contained_signature, + DBusMessageIter *sub); +dbus_bool_t dbus_message_iter_close_container (DBusMessageIter *iter, + DBusMessageIter *sub); + + +dbus_bool_t dbus_set_error_from_message (DBusError *error, + DBusMessage *message); + + +dbus_bool_t dbus_message_allocate_data_slot (dbus_int32_t *slot_p); +void dbus_message_free_data_slot (dbus_int32_t *slot_p); +dbus_bool_t dbus_message_set_data (DBusMessage *message, + dbus_int32_t slot, + void *data, + DBusFreeFunction free_data_func); +void* dbus_message_get_data (DBusMessage *message, + dbus_int32_t slot); + +int dbus_message_type_from_string (char *type_str); +char * dbus_message_type_to_string (int type); + +dbus_bool_t dbus_message_marshal (DBusMessage *msg, + char **marshalled_data_p, + int *len_p); +DBusMessage* dbus_message_demarshal (char *str, + int len, + DBusError *error); + +/** @} */ +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbus-d/dsrc/org/freedesktop/dbus/c/PendingCall.d Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,58 @@ +/* -*- mode: C; c-file-style: "gnu" -*- */ +/* dbus-pending-call.h Object representing a call in progress. + * + * Copyright (C) 2002, 2003 Red Hat Inc. + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ +module org.freedesktop.dbus.c.PendingCall; + +import org.freedesktop.dbus.c.Types; +import org.freedesktop.dbus.c.Connection; +import org.freedesktop.dbus.c.Memory : DBusFreeFunction; +import org.freedesktop.dbus.c.Message : DBusMessage; + +extern(C): + +/** + * @addtogroup DBusPendingCall + * @{ + */ + +DBusPendingCall* dbus_pending_call_ref (DBusPendingCall *pending); +void dbus_pending_call_unref (DBusPendingCall *pending); +dbus_bool_t dbus_pending_call_set_notify (DBusPendingCall *pending, + DBusPendingCallNotifyFunction _function, + void *user_data, + DBusFreeFunction free_user_data); +void dbus_pending_call_cancel (DBusPendingCall *pending); +dbus_bool_t dbus_pending_call_get_completed (DBusPendingCall *pending); +DBusMessage* dbus_pending_call_steal_reply (DBusPendingCall *pending); +void dbus_pending_call_block (DBusPendingCall *pending); + +dbus_bool_t dbus_pending_call_allocate_data_slot (dbus_int32_t *slot_p); +void dbus_pending_call_free_data_slot (dbus_int32_t *slot_p); +dbus_bool_t dbus_pending_call_set_data (DBusPendingCall *pending, + dbus_int32_t slot, + void *data, + DBusFreeFunction free_data_func); +void* dbus_pending_call_get_data (DBusPendingCall *pending, + dbus_int32_t slot); + +/** @} */ +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbus-d/dsrc/org/freedesktop/dbus/c/Protocol.d Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,403 @@ +/* -*- mode: C; c-file-style: "gnu" -*- */ +/* dbus-protocol.h D-Bus protocol constants + * + * Copyright (C) 2002, 2003 CodeFactory AB + * Copyright (C) 2004, 2005 Red Hat, Inc. + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +module org.freedesktop.dbus.c.Protocol; + +extern(C): + +/* Normally docs are in .c files, but there isn't a .c file for this. */ +/** + * @defgroup DBusProtocol Protocol constants + * @ingroup DBus + * + * @brief Defines constants which are part of the D-Bus protocol + * + * This header is intended for use by any library, not only libdbus. + * + * @{ + */ + + +/* Message byte order */ +const dchar DBUS_LITTLE_ENDIAN ='l'; /**< Code marking LSB-first byte order in the wire protocol. */ +const dchar DBUS_BIG_ENDIAN ='B'; /**< Code marking MSB-first byte order in the wire protocol. */ + +/** Protocol version. */ +const int DBUS_MAJOR_PROTOCOL_VERSION =1; + +/** Type code that is never equal to a legitimate type code */ +const int DBUS_TYPE_INVALID = '\0'; +/** #DBUS_TYPE_INVALID as a string literal instead of a int literal */ +const char[] DBUS_TYPE_INVALID_AS_STRING = "\0"; + +/* Primitive types */ +/** Type code marking an 8-bit unsigned integer */ +const int DBUS_TYPE_BYTE = 'y'; +/** #DBUS_TYPE_BYTE as a string literal instead of a int literal */ +const char[] DBUS_TYPE_BYTE_AS_STRING ="y"; +/** Type code marking a boolean */ +const int DBUS_TYPE_BOOLEAN = 'b'; +/** #DBUS_TYPE_BOOLEAN as a string literal instead of a int literal */ +const char[] DBUS_TYPE_BOOLEAN_AS_STRING ="b"; +/** Type code marking a 16-bit signed integer */ +const int DBUS_TYPE_INT16 = 'n'; +/** #DBUS_TYPE_INT16 as a string literal instead of a int literal */ +const char[] DBUS_TYPE_INT16_AS_STRING ="n"; +/** Type code marking a 16-bit unsigned integer */ +const int DBUS_TYPE_UINT16 = 'q'; +/** #DBUS_TYPE_UINT16 as a string literal instead of a int literal */ +const char[] DBUS_TYPE_UINT16_AS_STRING ="q"; +/** Type code marking a 32-bit signed integer */ +const int DBUS_TYPE_INT32 = 'i'; +/** #DBUS_TYPE_INT32 as a string literal instead of a int literal */ +const char[] DBUS_TYPE_INT32_AS_STRING ="i"; +/** Type code marking a 32-bit unsigned integer */ +const int DBUS_TYPE_UINT32 = 'u'; +/** #DBUS_TYPE_UINT32 as a string literal instead of a int literal */ +const char[] DBUS_TYPE_UINT32_AS_STRING ="u"; +/** Type code marking a 64-bit signed integer */ +const int DBUS_TYPE_INT64 = 'x'; +/** #DBUS_TYPE_INT64 as a string literal instead of a int literal */ +const char[] DBUS_TYPE_INT64_AS_STRING ="x"; +/** Type code marking a 64-bit unsigned integer */ +const int DBUS_TYPE_UINT64 = 't'; +/** #DBUS_TYPE_UINT64 as a string literal instead of a int literal */ +const char[] DBUS_TYPE_UINT64_AS_STRING ="t"; +/** Type code marking an 8-byte double in IEEE 754 format */ +const int DBUS_TYPE_DOUBLE = 'd'; +/** #DBUS_TYPE_DOUBLE as a string literal instead of a int literal */ +const char[] DBUS_TYPE_DOUBLE_AS_STRING ="d"; +/** Type code marking a UTF-8 encoded, nul-terminated Unicode string */ +const int DBUS_TYPE_STRING = 's'; +/** #DBUS_TYPE_STRING as a string literal instead of a int literal */ +const char[] DBUS_TYPE_STRING_AS_STRING ="s"; +/** Type code marking a D-Bus object path */ +const int DBUS_TYPE_OBJECT_PATH = 'o'; +/** #DBUS_TYPE_OBJECT_PATH as a string literal instead of a int literal */ +const char[] DBUS_TYPE_OBJECT_PATH_AS_STRING ="o"; +/** Type code marking a D-Bus type signature */ +const int DBUS_TYPE_SIGNATURE = 'g'; +/** #DBUS_TYPE_SIGNATURE as a string literal instead of a int literal */ +const char[] DBUS_TYPE_SIGNATURE_AS_STRING ="g"; + +/* Compound types */ +/** Type code marking a D-Bus array type */ +const int DBUS_TYPE_ARRAY = 'a'; +/** #DBUS_TYPE_ARRAY as a string literal instead of a int literal */ +const char[] DBUS_TYPE_ARRAY_AS_STRING ="a"; +/** Type code marking a D-Bus variant type */ +const int DBUS_TYPE_VARIANT = 'v'; +/** #DBUS_TYPE_VARIANT as a string literal instead of a int literal */ +const char[] DBUS_TYPE_VARIANT_AS_STRING ="v"; + +/** STRUCT and DICT_ENTRY are sort of special since their codes can't + * appear in a type string, instead + * DBUS_STRUCT_BEGIN_CHAR/DBUS_DICT_ENTRY_BEGIN_CHAR have to appear + */ +/** Type code used to represent a struct; however, this type code does not appear + * in type signatures, instead #DBUS_STRUCT_BEGIN_CHAR and #DBUS_STRUCT_END_CHAR will + * appear in a signature. + */ +const int DBUS_TYPE_STRUCT = 'r'; +/** #DBUS_TYPE_STRUCT as a string literal instead of a int literal */ +const char[] DBUS_TYPE_STRUCT_AS_STRING ="r"; +/** Type code used to represent a dict entry; however, this type code does not appear + * in type signatures, instead #DBUS_DICT_ENTRY_BEGIN_CHAR and #DBUS_DICT_ENTRY_END_CHAR will + * appear in a signature. + */ +const int DBUS_TYPE_DICT_ENTRY = 'e'; +/** #DBUS_TYPE_DICT_ENTRY as a string literal instead of a int literal */ +const char[] DBUS_TYPE_DICT_ENTRY_AS_STRING = "e"; + +/** Does not include #DBUS_TYPE_INVALID, #DBUS_STRUCT_BEGIN_CHAR, #DBUS_STRUCT_END_CHAR, + * #DBUS_DICT_ENTRY_BEGIN_CHAR, or #DBUS_DICT_ENTRY_END_CHAR - i.e. it is the number of + * valid types, not the number of distinct characters that may appear in a type signature. + */ +const int DBUS_NUMBER_OF_TYPES = (16); + +/* characters other than typecodes that appear in type signatures */ + +/** Code marking the start of a struct type in a type signature */ +const int DBUS_STRUCT_BEGIN_CHAR = '('; +/** #DBUS_STRUCT_BEGIN_CHAR as a string literal instead of a int literal */ +const char[] DBUS_STRUCT_BEGIN_CHAR_AS_STRING = "("; +/** Code marking the end of a struct type in a type signature */ +const int DBUS_STRUCT_END_CHAR = ')'; +/** #DBUS_STRUCT_END_CHAR a string literal instead of a int literal */ +const char[] DBUS_STRUCT_END_CHAR_AS_STRING = ")"; +/** Code marking the start of a dict entry type in a type signature */ +const int DBUS_DICT_ENTRY_BEGIN_CHAR = '{'; +/** #DBUS_DICT_ENTRY_BEGIN_CHAR as a string literal instead of a int literal */ +const char[] DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING = "{"; +/** Code marking the end of a dict entry type in a type signature */ +const int DBUS_DICT_ENTRY_END_CHAR = '}'; +/** #DBUS_DICT_ENTRY_END_CHAR as a string literal instead of a int literal */ +const char[] DBUS_DICT_ENTRY_END_CHAR_AS_STRING = "}"; + +/** Max length in bytes of a bus name, interface, or member (not object + * path, paths are unlimited). This is limited because lots of stuff + * is O(n) in this number, plus it would be obnoxious to type in a + * paragraph-long method name so most likely something like that would + * be an exploit. + */ +const int DBUS_MAXIMUM_NAME_LENGTH =255; + +/** This one is 255 so it fits in a byte */ +const int DBUS_MAXIMUM_SIGNATURE_LENGTH =255; + +/** Max length of a match rule string; to keep people from hosing the + * daemon with some huge rule + */ +const int DBUS_MAXIMUM_MATCH_RULE_LENGTH =1024; + +/** Max arg number you can match on in a match rule, e.g. + * arg0='hello' is OK, arg3489720987='hello' is not + */ +const int DBUS_MAXIMUM_MATCH_RULE_ARG_NUMBER =63; + +/** Max length of a marshaled array in bytes (64M, 2^26) We use signed + * int for lengths so must be INT_MAX or less. We need something a + * bit smaller than INT_MAX because the array is inside a message with + * header info, etc. so an INT_MAX array wouldn't allow the message + * overhead. The 64M number is an attempt at a larger number than + * we'd reasonably ever use, but small enough that your bus would chew + * through it fairly quickly without locking up forever. If you have + * data that's likely to be larger than this, you should probably be + * sending it in multiple incremental messages anyhow. + */ +const int DBUS_MAXIMUM_ARRAY_LENGTH =(67108864); +/** Number of bits you need in an unsigned to store the max array size */ +const int DBUS_MAXIMUM_ARRAY_LENGTH_BITS =26; + +/** The maximum total message size including header and body; similar + * rationale to max array size. + */ +const int DBUS_MAXIMUM_MESSAGE_LENGTH =(DBUS_MAXIMUM_ARRAY_LENGTH * 2); +/** Number of bits you need in an unsigned to store the max message size */ +const int DBUS_MAXIMUM_MESSAGE_LENGTH_BITS =27; + +/** Depth of recursion in the type tree. This is automatically limited + * to DBUS_MAXIMUM_SIGNATURE_LENGTH since you could only have an array + * of array of array of ... that fit in the max signature. But that's + * probably a bit too large. + */ +const int DBUS_MAXIMUM_TYPE_RECURSION_DEPTH =32; + +/* Types of message */ + +/** This value is never a valid message type, see dbus_message_get_type() */ +const int DBUS_MESSAGE_TYPE_INVALID =0; +/** Message type of a method call message, see dbus_message_get_type() */ +const int DBUS_MESSAGE_TYPE_METHOD_CALL =1; +/** Message type of a method return message, see dbus_message_get_type() */ +const int DBUS_MESSAGE_TYPE_METHOD_RETURN =2; +/** Message type of an error reply message, see dbus_message_get_type() */ +const int DBUS_MESSAGE_TYPE_ERROR =3; +/** Message type of a signal message, see dbus_message_get_type() */ +const int DBUS_MESSAGE_TYPE_SIGNAL =4; + +/* Header flags */ + +/** If set, this flag means that the sender of a message does not care about getting + * a reply, so the recipient need not send one. See dbus_message_set_no_reply(). + */ +const int DBUS_HEADER_FLAG_NO_REPLY_EXPECTED =0x1; +/** + * If set, this flag means that even if the message bus knows how to start an owner for + * the destination bus name (see dbus_message_set_destination()), it should not + * do so. If this flag is not set, the bus may launch a program to process the + * message. + */ +const int DBUS_HEADER_FLAG_NO_AUTO_START =0x2; + +/* Header fields */ + +/** Not equal to any valid header field code */ +const int DBUS_HEADER_FIELD_INVALID =0; +/** Header field code for the path - the path is the object emitting a signal or the object receiving a method call. + * See dbus_message_set_path(). + */ +const int DBUS_HEADER_FIELD_PATH =1; +/** Header field code for the interface containing a member (method or signal). + * See dbus_message_set_interface(). + */ +const int DBUS_HEADER_FIELD_INTERFACE =2; +/** Header field code for a member (method or signal). See dbus_message_set_member(). */ +const int DBUS_HEADER_FIELD_MEMBER =3; +/** Header field code for an error name (found in #DBUS_MESSAGE_TYPE_ERROR messages). + * See dbus_message_set_error_name(). + */ +const int DBUS_HEADER_FIELD_ERROR_NAME =4; +/** Header field code for a reply serial, used to match a #DBUS_MESSAGE_TYPE_METHOD_RETURN message with the + * message that it's a reply to. See dbus_message_set_reply_serial(). + */ +const int DBUS_HEADER_FIELD_REPLY_SERIAL =5; +/** + * Header field code for the destination bus name of a message. See dbus_message_set_destination(). + */ +const int DBUS_HEADER_FIELD_DESTINATION =6; +/** + * Header field code for the sender of a message; usually initialized by the message bus. + * See dbus_message_set_sender(). + */ +const int DBUS_HEADER_FIELD_SENDER =7; +/** + * Header field code for the type signature of a message. + */ +const int DBUS_HEADER_FIELD_SIGNATURE =8; + +/** + * Value of the highest-numbered header field code, can be used to determine + * the size of an array indexed by header field code. Remember though + * that unknown codes must be ignored, so check for that before + * indexing the array. + */ +const int DBUS_HEADER_FIELD_LAST = DBUS_HEADER_FIELD_SIGNATURE; + +/** Header format is defined as a signature: + * byte byte order + * byte message type ID + * byte flags + * byte protocol version + * uint32 body length + * uint32 serial + * array of struct (byte,variant) (field name, value) + * + * The length of the header can be computed as the + * fixed size of the initial data, plus the length of + * the array at the end, plus padding to an 8-boundary. + */ +const char[] DBUS_HEADER_SIGNATURE = + DBUS_TYPE_BYTE_AS_STRING ~ + DBUS_TYPE_BYTE_AS_STRING ~ + DBUS_TYPE_BYTE_AS_STRING ~ + DBUS_TYPE_BYTE_AS_STRING ~ + DBUS_TYPE_UINT32_AS_STRING ~ + DBUS_TYPE_UINT32_AS_STRING ~ + DBUS_TYPE_ARRAY_AS_STRING ~ + DBUS_STRUCT_BEGIN_CHAR_AS_STRING ~ + DBUS_TYPE_BYTE_AS_STRING ~ + DBUS_TYPE_VARIANT_AS_STRING ~ + DBUS_STRUCT_END_CHAR_AS_STRING ; + + +/** + * The smallest header size that can occur. (It won't be valid due to + * missing required header fields.) This is 4 bytes, two uint32, an + * array length. This isn't any kind of resource limit, just the + * necessary/logical outcome of the header signature. + */ +const int DBUS_MINIMUM_HEADER_SIZE =16; + +/* Errors */ +/* WARNING these get autoconverted to an enum in dbus-glib.h. Thus, + * if you change the order it breaks the ABI. Keep them in order. + * Also, don't change the formatting since that will break the sed + * script. + */ +/** A generic error; "something went wrong" - see the error message for more. */ +const char[] DBUS_ERROR_FAILED ="org.freedesktop.DBus.Error.Failed"; +/** There was not enough memory to complete an operation. */ +const char[] DBUS_ERROR_NO_MEMORY ="org.freedesktop.DBus.Error.NoMemory"; +/** The bus doesn't know how to launch a service to supply the bus name you wanted. */ +const char[] DBUS_ERROR_SERVICE_UNKNOWN ="org.freedesktop.DBus.Error.ServiceUnknown"; +/** The bus name you referenced doesn't exist (i.e. no application owns it). */ +const char[] DBUS_ERROR_NAME_HAS_NO_OWNER ="org.freedesktop.DBus.Error.NameHasNoOwner"; +/** No reply to a message expecting one, usually means a timeout occurred. */ +const char[] DBUS_ERROR_NO_REPLY ="org.freedesktop.DBus.Error.NoReply"; +/** Something went wrong reading or writing to a socket, for example. */ +const char[] DBUS_ERROR_IO_ERROR ="org.freedesktop.DBus.Error.IOError"; +/** A D-Bus bus address was malformed. */ +const char[] DBUS_ERROR_BAD_ADDRESS ="org.freedesktop.DBus.Error.BadAddress"; +/** Requested operation isn't supported (like ENOSYS on UNIX). */ +const char[] DBUS_ERROR_NOT_SUPPORTED ="org.freedesktop.DBus.Error.NotSupported"; +/** Some limited resource is exhausted. */ +const char[] DBUS_ERROR_LIMITS_EXCEEDED ="org.freedesktop.DBus.Error.LimitsExceeded"; +/** Security restrictions don't allow doing what you're trying to do. */ +const char[] DBUS_ERROR_ACCESS_DENIED ="org.freedesktop.DBus.Error.AccessDenied"; +/** Authentication didn't work. */ +const char[] DBUS_ERROR_AUTH_FAILED ="org.freedesktop.DBus.Error.AuthFailed"; +/** Unable to connect to server (probably caused by ECONNREFUSED on a socket). */ +const char[] DBUS_ERROR_NO_SERVER ="org.freedesktop.DBus.Error.NoServer"; +/** Certain timeout errors, possibly ETIMEDOUT on a socket. + * Note that #DBUS_ERROR_NO_REPLY is used for message reply timeouts. + * @warning this is confusingly-named given that #DBUS_ERROR_TIMED_OUT also exists. We can't fix + * it for compatibility reasons so just be careful. + */ +const char[] DBUS_ERROR_TIMEOUT ="org.freedesktop.DBus.Error.Timeout"; +/** No network access (probably ENETUNREACH on a socket). */ +const char[] DBUS_ERROR_NO_NETWORK ="org.freedesktop.DBus.Error.NoNetwork"; +/** Can't bind a socket since its address is in use (i.e. EADDRINUSE). */ +const char[] DBUS_ERROR_ADDRESS_IN_USE ="org.freedesktop.DBus.Error.AddressInUse"; +/** The connection is disconnected and you're trying to use it. */ +const char[] DBUS_ERROR_DISCONNECTED ="org.freedesktop.DBus.Error.Disconnected"; +/** Invalid arguments passed to a method call. */ +const char[] DBUS_ERROR_INVALID_ARGS ="org.freedesktop.DBus.Error.InvalidArgs"; +/** Missing file. */ +const char[] DBUS_ERROR_FILE_NOT_FOUND ="org.freedesktop.DBus.Error.FileNotFound"; +/** Existing file and the operation you're using does not silently overwrite. */ +const char[] DBUS_ERROR_FILE_EXISTS ="org.freedesktop.DBus.Error.FileExists"; +/** Method name you invoked isn't known by the object you invoked it on. */ +const char[] DBUS_ERROR_UNKNOWN_METHOD ="org.freedesktop.DBus.Error.UnknownMethod"; +/** Certain timeout errors, e.g. while starting a service. + * @warning this is confusingly-named given that #DBUS_ERROR_TIMEOUT also exists. We can't fix + * it for compatibility reasons so just be careful. + */ +const char[] DBUS_ERROR_TIMED_OUT ="org.freedesktop.DBus.Error.TimedOut"; +/** Tried to remove or modify a match rule that didn't exist. */ +const char[] DBUS_ERROR_MATCH_RULE_NOT_FOUND ="org.freedesktop.DBus.Error.MatchRuleNotFound"; +/** The match rule isn't syntactically valid. */ +const char[] DBUS_ERROR_MATCH_RULE_INVALID ="org.freedesktop.DBus.Error.MatchRuleInvalid"; +/** While starting a new process, the exec() call failed. */ +const char[] DBUS_ERROR_SPAWN_EXEC_FAILED ="org.freedesktop.DBus.Error.Spawn.ExecFailed"; +/** While starting a new process, the fork() call failed. */ +const char[] DBUS_ERROR_SPAWN_FORK_FAILED ="org.freedesktop.DBus.Error.Spawn.ForkFailed"; +/** While starting a new process, the child exited with a status code. */ +const char[] DBUS_ERROR_SPAWN_CHILD_EXITED ="org.freedesktop.DBus.Error.Spawn.ChildExited"; +/** While starting a new process, the child exited on a signal. */ +const char[] DBUS_ERROR_SPAWN_CHILD_SIGNALED ="org.freedesktop.DBus.Error.Spawn.ChildSignaled"; +/** While starting a new process, something went wrong. */ +const char[] DBUS_ERROR_SPAWN_FAILED ="org.freedesktop.DBus.Error.Spawn.Failed"; +/** Tried to get a UNIX process ID and it wasn't available. */ +const char[] DBUS_ERROR_UNIX_PROCESS_ID_UNKNOWN ="org.freedesktop.DBus.Error.UnixProcessIdUnknown"; +/** A type signature is not valid. */ +const char[] DBUS_ERROR_INVALID_SIGNATURE ="org.freedesktop.DBus.Error.InvalidSignature"; +/** A file contains invalid syntax or is otherwise broken. */ +const char[] DBUS_ERROR_INVALID_FILE_CONTENT ="org.freedesktop.DBus.Error.InvalidFileContent"; +/** Asked for SELinux security context and it wasn't available. */ +const char[] DBUS_ERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN ="org.freedesktop.DBus.Error.SELinuxSecurityContextUnknown"; + +/* XML introspection format */ + +/** XML namespace of the introspection format version 1.0 */ +const char[] DBUS_INTROSPECT_1_0_XML_NAMESPACE ="http://www.freedesktop.org/standards/dbus"; +/** XML public identifier of the introspection format version 1.0 */ +const char[] DBUS_INTROSPECT_1_0_XML_PUBLIC_IDENTIFIER ="-//freedesktop//DTD D-BUS Object Introspection 1.0//EN"; +/** XML system identifier of the introspection format version 1.0 */ +const char[] DBUS_INTROSPECT_1_0_XML_SYSTEM_IDENTIFIER ="http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd"; +/** XML document type declaration of the introspection format version 1.0 */ +const char[] DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE ="<!DOCTYPE node PUBLIC \""~DBUS_INTROSPECT_1_0_XML_PUBLIC_IDENTIFIER~"\"\n\""~DBUS_INTROSPECT_1_0_XML_SYSTEM_IDENTIFIER~"\">\n"; + +/** @} */ +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbus-d/dsrc/org/freedesktop/dbus/c/Server.d Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,86 @@ +/* -*- mode: C; c-file-style: "gnu" -*- */ +/* dbus-server.h DBusServer object + * + * Copyright (C) 2002, 2003 Red Hat Inc. + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ +module org.freedesktop.dbus.c.Server; + + +import org.freedesktop.dbus.c.Errors; +import org.freedesktop.dbus.c.Message; +import org.freedesktop.dbus.c.Connection; +import org.freedesktop.dbus.c.Protocol; +import org.freedesktop.dbus.c.Types; +import org.freedesktop.dbus.c.Memory : DBusFreeFunction; + +extern(C): + +/** + * @addtogroup DBusServer + * @{ + */ + +struct DBusServer {}; + +/** Called when a new connection to the server is available. Must reference and save the new + * connection, or close the new connection. Set with dbus_server_set_new_connection_function(). + */ +alias void (* DBusNewConnectionFunction) (DBusServer *server, + DBusConnection *new_connection, + void *data); + +DBusServer* dbus_server_listen (char *address, + DBusError *error); +DBusServer* dbus_server_ref (DBusServer *server); +void dbus_server_unref (DBusServer *server); +void dbus_server_disconnect (DBusServer *server); +dbus_bool_t dbus_server_get_is_connected (DBusServer *server); +char* dbus_server_get_address (DBusServer *server); +char* dbus_server_get_id (DBusServer *server); +void dbus_server_set_new_connection_function (DBusServer *server, + DBusNewConnectionFunction function_, + void *data, + DBusFreeFunction free_data_function); +dbus_bool_t dbus_server_set_watch_functions (DBusServer *server, + DBusAddWatchFunction add_function, + DBusRemoveWatchFunction remove_function, + DBusWatchToggledFunction toggled_function, + void *data, + DBusFreeFunction free_data_function); +dbus_bool_t dbus_server_set_timeout_functions (DBusServer *server, + DBusAddTimeoutFunction add_function, + DBusRemoveTimeoutFunction remove_function, + DBusTimeoutToggledFunction toggled_function, + void *data, + DBusFreeFunction free_data_function); +dbus_bool_t dbus_server_set_auth_mechanisms (DBusServer *server, + char **mechanisms); + +dbus_bool_t dbus_server_allocate_data_slot (dbus_int32_t *slot_p); +void dbus_server_free_data_slot (dbus_int32_t *slot_p); +dbus_bool_t dbus_server_set_data (DBusServer *server, + int slot, + void *data, + DBusFreeFunction free_data_func); +void* dbus_server_get_data (DBusServer *server, + int slot); + +/** @} */ +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbus-d/dsrc/org/freedesktop/dbus/c/Shared.d Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,108 @@ +/* -*- mode: C; c-file-style: "gnu" -*- */ +/* dbus-shared.h Stuff used by both dbus/org.freedesktop.dbus.c.h low-level and C/C++ binding APIs + * + * Copyright (C) 2004 Red Hat, Inc. + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ +module org.freedesktop.dbus.c.Shared; +extern(C): +/* Normally docs are in .c files, but there isn't a .c file for this. */ +/** + * @defgroup DBusShared Shared constants + * @ingroup DBus + * + * @brief Shared header included by both libdbus and C/C++ bindings such as the GLib bindings. + * + * Usually a C/C++ binding such as the GLib or Qt binding won't want to include org.freedesktop.dbus.c.h in its + * public headers. However, a few constants and macros may be useful to include; those are + * found here and in dbus-protocol.h + * + * @{ + */ + + +/** + * Well-known bus types. See dbus_bus_get(). + */ +enum DBusBusType { + DBUS_BUS_SESSION, /**< The login session bus */ + DBUS_BUS_SYSTEM, /**< The systemwide bus */ + DBUS_BUS_STARTER /**< The bus that started us, if any */ +} ; + +/** + * Results that a message handler can return. + */ +enum DBusHandlerResult { + DBUS_HANDLER_RESULT_HANDLED, /**< Message has had its effect - no need to run more handlers. */ + DBUS_HANDLER_RESULT_NOT_YET_HANDLED, /**< Message has not had any effect - see if other handlers want it. */ + DBUS_HANDLER_RESULT_NEED_MEMORY /**< Need more memory in order to return #DBUS_HANDLER_RESULT_HANDLED or #DBUS_HANDLER_RESULT_NOT_YET_HANDLED. Please try again later with more memory. */ +} ; + +/* Bus names */ + +/** The bus name used to talk to the bus itself. */ +const char[] DBUS_SERVICE_DBUS = "org.freedesktop.DBus"; + +/* Paths */ +/** The object path used to talk to the bus itself. */ +const char[] DBUS_PATH_DBUS = "/org/freedesktop/DBus"; +/** The object path used in local/in-process-generated messages. */ +const char[] DBUS_PATH_LOCAL = "/org/freedesktop/DBus/Local"; + +/* Interfaces, these #define don't do much other than + * catch typos at compile time + */ +/** The interface exported by the object with #DBUS_SERVICE_DBUS and #DBUS_PATH_DBUS */ +const char[] DBUS_INTERFACE_DBUS = "org.freedesktop.DBus"; +/** The interface supported by introspectable objects */ +const char[] DBUS_INTERFACE_INTROSPECTABLE = "org.freedesktop.DBus.Introspectable"; +/** The interface supported by objects with properties */ +const char[] DBUS_INTERFACE_PROPERTIES = "org.freedesktop.DBus.Properties"; +/** The interface supported by most dbus peers */ +const char[] DBUS_INTERFACE_PEER = "org.freedesktop.DBus.Peer"; + +/** This is a special interface whose methods can only be invoked + * by the local implementation (messages from remote apps aren't + * allowed to specify this interface). + */ +const char[] DBUS_INTERFACE_LOCAL = "org.freedesktop.DBus.Local"; + +/* Owner flags */ +const uint DBUS_NAME_FLAG_ALLOW_REPLACEMENT = 0x1; /**< Allow another service to become the primary owner if requested */ +const uint DBUS_NAME_FLAG_REPLACE_EXISTING = 0x2; /**< Request to replace the current primary owner */ +const uint DBUS_NAME_FLAG_DO_NOT_QUEUE = 0x4; /**< If we can not become the primary owner do not place us in the queue */ + +/* Replies to request for a name */ +const int DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER = 1; /**< Service has become the primary owner of the requested name */ +const int DBUS_REQUEST_NAME_REPLY_IN_QUEUE = 2; /**< Service could not become the primary owner and has been placed in the queue */ +const int DBUS_REQUEST_NAME_REPLY_EXISTS = 3; /**< Service is already in the queue */ +const int DBUS_REQUEST_NAME_REPLY_ALREADY_OWNER = 4; /**< Service is already the primary owner */ + +/* Replies to releasing a name */ +const int DBUS_RELEASE_NAME_REPLY_RELEASED = 1; /**< Service was released from the given name */ +const int DBUS_RELEASE_NAME_REPLY_NON_EXISTENT = 2; /**< The given name does not exist on the bus */ +const int DBUS_RELEASE_NAME_REPLY_NOT_OWNER = 3; /**< Service is not an owner of the given name */ + +/* Replies to service starts */ +const int DBUS_START_REPLY_SUCCESS = 1; /**< Service was auto started */ +const int DBUS_START_REPLY_ALREADY_RUNNING = 2; /**< Service was already running */ + +/** @} */ +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbus-d/dsrc/org/freedesktop/dbus/c/Signature.d Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,70 @@ +/* -*- mode: C; c-file-style: "gnu" -*- */ +/* dbus-signatures.h utility functions for D-Bus types + * + * Copyright (C) 2005 Red Hat Inc. + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ +module org.freedesktop.dbus.c.Signature; + +import org.freedesktop.dbus.c.Types; +import org.freedesktop.dbus.c.Errors; + +extern(C): +/** + * @addtogroup DBusSignature + * @{ + */ + +/** + * DBusSignatureIter struct; contains no public fields + */ +struct DBusSignatureIter { + void *dummy1; /**< Don't use this */ + void *dummy2; /**< Don't use this */ + dbus_uint32_t dummy8; /**< Don't use this */ + int dummy12; /**< Don't use this */ + int dummy17; /**< Don't use this */ +} ; + +void dbus_signature_iter_init (DBusSignatureIter *iter, + char *signature); + +int dbus_signature_iter_get_current_type (DBusSignatureIter *iter); + +char * dbus_signature_iter_get_signature (DBusSignatureIter *iter); + +int dbus_signature_iter_get_element_type (DBusSignatureIter *iter); + +dbus_bool_t dbus_signature_iter_next (DBusSignatureIter *iter); + +void dbus_signature_iter_recurse (DBusSignatureIter *iter, + DBusSignatureIter *subiter); + +dbus_bool_t dbus_signature_validate (char *signature, + DBusError *error); + +dbus_bool_t dbus_signature_validate_single (char *signature, + DBusError *error); + +dbus_bool_t dbus_type_is_basic (int typecode); +dbus_bool_t dbus_type_is_container (int typecode); +dbus_bool_t dbus_type_is_fixed (int typecode); + +/** @} */ +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbus-d/dsrc/org/freedesktop/dbus/c/Threads.d Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,184 @@ +/* -*- mode: C; c-file-style: "gnu" -*- */ +/* dbus-threads.h D-Bus threads handling + * + * Copyright (C) 2002 Red Hat Inc. + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ +module org.freedesktop.dbus.c.Threads; + +import org.freedesktop.dbus.c.Types; + +extern(C): +/** + * @addtogroup DBusThreads + * @{ + */ + +/** An opaque mutex type provided by the #DBusThreadFunctions implementation installed by dbus_threads_init(). */ +struct DBusMutex {}; +/** An opaque condition variable type provided by the #DBusThreadFunctions implementation installed by dbus_threads_init(). */ +struct DBusCondVar {}; + +/** Deprecated, provide DBusRecursiveMutexNewFunction instead. */ +alias DBusMutex* (* DBusMutexNewFunction) (); +/** Deprecated, provide DBusRecursiveMutexFreeFunction instead. */ +alias void (* DBusMutexFreeFunction) (DBusMutex *mutex); +/** Deprecated, provide DBusRecursiveMutexLockFunction instead. Return value is lock success, but gets ignored in practice. */ +alias dbus_bool_t (* DBusMutexLockFunction) (DBusMutex *mutex); +/** Deprecated, provide DBusRecursiveMutexUnlockFunction instead. Return value is unlock success, but gets ignored in practice. */ +alias dbus_bool_t (* DBusMutexUnlockFunction) (DBusMutex *mutex); + +/** Creates a new recursively-lockable mutex, or returns #NULL if not + * enough memory. Can only fail due to lack of memory. Found in + * #DBusThreadFunctions. Do not just use PTHREAD_MUTEX_RECURSIVE for + * this, because it does not save/restore the recursion count when + * waiting on a condition. libdbus requires the Java-style behavior + * where the mutex is fully unlocked to wait on a condition. + */ +alias DBusMutex* (* DBusRecursiveMutexNewFunction) (); +/** Frees a recursively-lockable mutex. Found in #DBusThreadFunctions. + */ +alias void (* DBusRecursiveMutexFreeFunction) (DBusMutex *mutex); +/** Locks a recursively-lockable mutex. Found in #DBusThreadFunctions. + * Can only fail due to lack of memory. + */ +alias void (* DBusRecursiveMutexLockFunction) (DBusMutex *mutex); +/** Unlocks a recursively-lockable mutex. Found in #DBusThreadFunctions. + * Can only fail due to lack of memory. + */ +alias void (* DBusRecursiveMutexUnlockFunction) (DBusMutex *mutex); + +/** Creates a new condition variable. Found in #DBusThreadFunctions. + * Can only fail (returning #NULL) due to lack of memory. + */ +alias DBusCondVar* (* DBusCondVarNewFunction) (); +/** Frees a condition variable. Found in #DBusThreadFunctions. + */ +alias void (* DBusCondVarFreeFunction) (DBusCondVar *cond); + +/** Waits on a condition variable. Found in + * #DBusThreadFunctions. Must work with either a recursive or + * nonrecursive mutex, whichever the thread implementation + * provides. Note that PTHREAD_MUTEX_RECURSIVE does not work with + * condition variables (does not save/restore the recursion count) so + * don't try using simply pthread_cond_wait() and a + * PTHREAD_MUTEX_RECURSIVE to implement this, it won't work right. + * + * Has no error conditions. Must succeed if it returns. + */ +alias void (* DBusCondVarWaitFunction) (DBusCondVar *cond, + DBusMutex *mutex); + +/** Waits on a condition variable with a timeout. Found in + * #DBusThreadFunctions. Returns #TRUE if the wait did not + * time out, and #FALSE if it did. + * + * Has no error conditions. Must succeed if it returns. + */ +alias dbus_bool_t (* DBusCondVarWaitTimeoutFunction) (DBusCondVar *cond, + DBusMutex *mutex, + int timeout_milliseconds); +/** Wakes one waiting thread on a condition variable. Found in #DBusThreadFunctions. + * + * Has no error conditions. Must succeed if it returns. + */ +alias void (* DBusCondVarWakeOneFunction) (DBusCondVar *cond); + +/** Wakes all waiting threads on a condition variable. Found in #DBusThreadFunctions. + * + * Has no error conditions. Must succeed if it returns. + */ +alias void (* DBusCondVarWakeAllFunction) (DBusCondVar *cond); + +/** + * Flags indicating which functions are present in #DBusThreadFunctions. Used to allow + * the library to detect older callers of dbus_threads_init() if new possible functions + * are added to #DBusThreadFunctions. + */ +enum DBusThreadFunctionsMask{ + DBUS_THREAD_FUNCTIONS_MUTEX_NEW_MASK = 1 << 0, + DBUS_THREAD_FUNCTIONS_MUTEX_FREE_MASK = 1 << 1, + DBUS_THREAD_FUNCTIONS_MUTEX_LOCK_MASK = 1 << 2, + DBUS_THREAD_FUNCTIONS_MUTEX_UNLOCK_MASK = 1 << 3, + DBUS_THREAD_FUNCTIONS_CONDVAR_NEW_MASK = 1 << 4, + DBUS_THREAD_FUNCTIONS_CONDVAR_FREE_MASK = 1 << 5, + DBUS_THREAD_FUNCTIONS_CONDVAR_WAIT_MASK = 1 << 6, + DBUS_THREAD_FUNCTIONS_CONDVAR_WAIT_TIMEOUT_MASK = 1 << 7, + DBUS_THREAD_FUNCTIONS_CONDVAR_WAKE_ONE_MASK = 1 << 8, + DBUS_THREAD_FUNCTIONS_CONDVAR_WAKE_ALL_MASK = 1 << 9, + DBUS_THREAD_FUNCTIONS_RECURSIVE_MUTEX_NEW_MASK = 1 << 10, + DBUS_THREAD_FUNCTIONS_RECURSIVE_MUTEX_FREE_MASK = 1 << 11, + DBUS_THREAD_FUNCTIONS_RECURSIVE_MUTEX_LOCK_MASK = 1 << 12, + DBUS_THREAD_FUNCTIONS_RECURSIVE_MUTEX_UNLOCK_MASK = 1 << 13, + DBUS_THREAD_FUNCTIONS_ALL_MASK = (1 << 14) - 1 +} ; + +/** + * Functions that must be implemented to make the D-Bus library + * thread-aware. The recursive mutex functions should be specified + * rather than the old, deprecated nonrecursive ones. + * + * The condition variable functions have to work with recursive + * mutexes if you provide those, or with nonrecursive mutexes if you + * provide those. + * + * If implementing threads using pthreads, be aware that + * PTHREAD_MUTEX_RECURSIVE is broken in combination with condition + * variables. libdbus relies on the Java-style behavior that when + * waiting on a condition, the recursion count is saved and restored, + * and the mutex is completely unlocked, not just decremented one + * level of recursion. + * + * Thus with pthreads you probably have to roll your own emulated + * recursive mutexes, you can't use PTHREAD_MUTEX_RECURSIVE. This is + * what dbus_threads_init_default() does on platforms that use + * pthreads. + */ +struct DBusThreadFunctions{ + uint mask; /**< Mask indicating which functions are present. */ + + DBusMutexNewFunction mutex_new; /**< Function to create a mutex; optional and deprecated. */ + DBusMutexFreeFunction mutex_free; /**< Function to free a mutex; optional and deprecated. */ + DBusMutexLockFunction mutex_lock; /**< Function to lock a mutex; optional and deprecated. */ + DBusMutexUnlockFunction mutex_unlock; /**< Function to unlock a mutex; optional and deprecated. */ + + DBusCondVarNewFunction condvar_new; /**< Function to create a condition variable */ + DBusCondVarFreeFunction condvar_free; /**< Function to free a condition variable */ + DBusCondVarWaitFunction condvar_wait; /**< Function to wait on a condition */ + DBusCondVarWaitTimeoutFunction condvar_wait_timeout; /**< Function to wait on a condition with a timeout */ + DBusCondVarWakeOneFunction condvar_wake_one; /**< Function to wake one thread waiting on the condition */ + DBusCondVarWakeAllFunction condvar_wake_all; /**< Function to wake all threads waiting on the condition */ + + DBusRecursiveMutexNewFunction recursive_mutex_new; /**< Function to create a recursive mutex */ + DBusRecursiveMutexFreeFunction recursive_mutex_free; /**< Function to free a recursive mutex */ + DBusRecursiveMutexLockFunction recursive_mutex_lock; /**< Function to lock a recursive mutex */ + DBusRecursiveMutexUnlockFunction recursive_mutex_unlock; /**< Function to unlock a recursive mutex */ + + void (* padding1) (); /**< Reserved for future expansion */ + void (* padding2) (); /**< Reserved for future expansion */ + void (* padding3) (); /**< Reserved for future expansion */ + void (* padding4) (); /**< Reserved for future expansion */ + +} ; + +dbus_bool_t dbus_threads_init (DBusThreadFunctions *functions); +dbus_bool_t dbus_threads_init_default (); + +/** @} */ +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbus-d/dsrc/org/freedesktop/dbus/c/Types.d Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,137 @@ +/* -*- mode: C; c-file-style: "gnu" -*- */ +/* dbus-types.h types such as dbus_bool_t + * + * Copyright (C) 2002 Red Hat Inc. + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ +module org.freedesktop.dbus.c.Types; + +extern(System): +alias short dbus_int16_t; +alias ushort dbus_uint16_t; +alias int dbus_int32_t; +alias uint dbus_uint32_t; +alias long dbus_int64_t; +alias ulong dbus_uint64_t; +alias dbus_uint32_t dbus_unichar_t; +/* boolean size must be fixed at 4 bytes due to wire protocol! */ +alias dbus_uint32_t dbus_bool_t; + +/* Normally docs are in .c files, but there isn't a .c file for this. */ +/** + * @defgroup DBusTypes Basic types + * @ingroup DBus + * @brief dbus_bool_t, dbus_int32_t, etc. + * + * Typedefs for common primitive types. + * + * @{ + */ + +/** + * @typedef dbus_bool_t + * + * A boolean, valid values are #TRUE and #FALSE. + */ + +/** + * @typedef dbus_uint32_t + * + * A 32-bit unsigned integer on all platforms. + */ + +/** + * @typedef dbus_int32_t + * + * A 32-bit signed integer on all platforms. + */ + +/** + * @typedef dbus_uint16_t + * + * A 16-bit unsigned integer on all platforms. + */ + +/** + * @typedef dbus_int16_t + * + * A 16-bit signed integer on all platforms. + */ + + +/** + * @typedef dbus_uint64_t + * + * A 64-bit unsigned integer on all platforms that support it. + * If supported, #DBUS_HAVE_INT64 will be defined. + * + * C99 requires a 64-bit type and most likely all interesting + * compilers support one. GLib for example flat-out requires + * a 64-bit type. + * + * You probably want to just assume #DBUS_HAVE_INT64 is always defined. + */ + +/** + * @typedef dbus_int64_t + * + * A 64-bit signed integer on all platforms that support it. + * If supported, #DBUS_HAVE_INT64 will be defined. + * + * C99 requires a 64-bit type and most likely all interesting + * compilers support one. GLib for example flat-out requires + * a 64-bit type. + * + * You probably want to just assume #DBUS_HAVE_INT64 is always defined. + */ + +/** + * @def DBUS_HAVE_INT64 + * + * Defined if 64-bit integers are available. Will be defined + * on any platform you care about, unless you care about + * some truly ancient UNIX, or some bizarre embedded platform. + * + * C99 requires a 64-bit type and most likely all interesting + * compilers support one. GLib for example flat-out requires + * a 64-bit type. + * + * You should feel comfortable ignoring this macro and just using + * int64 unconditionally. + * + */ + +/** + * @def DBUS_INT64_CONSTANT + * + * Declare a 64-bit signed integer constant. The macro + * adds the necessary "LL" or whatever after the integer, + * giving a literal such as "325145246765LL" + */ + +/** + * @def DBUS_UINT64_CONSTANT + * + * Declare a 64-bit unsigned integer constant. The macro + * adds the necessary "ULL" or whatever after the integer, + * giving a literal such as "325145246765ULL" + */ + +/** @} */ +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbus-d/dsrc/org/freedesktop/dbus/c/Version.txt Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,3 @@ +20-Aug-2007 +based on windbus -r760 +https://windbus.svn.sourceforge.net/svnroot/windbus/trunk
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbus-d/dsrc/org/freedesktop/dbus/tool/CreateInterface.d Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,1006 @@ +/* + * Copyright (C) 2007 Frank Benoit + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ +module org.freedesktop.dbus.tool.CreateInterface; + +import tango.io.Stdout; +import tango.io.Print; +import tango.text.convert.Integer : toUtf8; +import tango.text.Util : layout, split, join, replace; +import tango.net.Uri; // make dsss and linker happy :( +import tango.core.Exception : TracedException; + +import org.freedesktop.dbus.tool.XmlSupport; + +class TerminateException : TracedException { + int code; + this( int code ){ + super( null ); + this.code = code; + } +} +const char[] ID_NODE = "node"; +const char[] ID_INTF = "interface"; +const char[] ID_METH = "method"; +const char[] ID_SIGN = "signal"; +const char[] ID_PROP = "property"; +const char[] ID_ANNO = "annotation"; +const char[] ID_ARGU = "arg"; +const char[] ID_DIRECTION = "direction"; +const char[] ID_DIRECTION_IN = "in"; +const char[] ID_DIRECTION_OUT = "out"; +const char[] ID_TYPE = "type"; +const char[] ANNO_RETURNS = "org.dsource.tiolink.Returns"; +IntfTree intfTree; + +//----------------------------------------- + +private void createStdInterfaces() { + DefInterface intf; + DefMethod meth; + DefArgument argu; + + intfTree.add( intf = new DefInterface( "org.freedesktop.DBus.Peer" )); + { + intf.addMethod( meth = new DefMethod( "Ping" )); + meth.complete(); + + intf.addMethod( meth = new DefMethod( "GetMachineId" )); + meth.addArgument( argu = new DefArgument( "machine_uuid", "s", DefArgument.EDir.DIR_OUT)); + meth.addAnnotation( ANNO_RETURNS, "machine_uuid" ); + meth.complete(); + } + + intfTree.add( intf = new DefInterface( "org.freedesktop.DBus.Introspectable" )); + { + intf.addMethod( meth = new DefMethod( "Introspect" )); + meth.addArgument( argu = new DefArgument( "xml_data", "s", DefArgument.EDir.DIR_OUT)); + meth.addAnnotation( ANNO_RETURNS, "xml_data" ); + meth.complete(); + } + + intfTree.add( intf = new DefInterface( "org.freedesktop.DBus.Properties" )); + { + intf.addMethod( meth = new DefMethod( "Get" )); + meth.addArgument( argu = new DefArgument( "intf_name", "s", DefArgument.EDir.DIR_IN )); + meth.addArgument( argu = new DefArgument( "prop_name", "s", DefArgument.EDir.DIR_IN )); + meth.addArgument( argu = new DefArgument( "prop" , "v", DefArgument.EDir.DIR_OUT)); + meth.addAnnotation( ANNO_RETURNS, "prop" ); + meth.complete(); + + intf.addMethod( meth = new DefMethod( "Set" )); + meth.addArgument( argu = new DefArgument( "intf_name", "s", DefArgument.EDir.DIR_IN )); + meth.addArgument( argu = new DefArgument( "prop_name", "s", DefArgument.EDir.DIR_IN )); + meth.addArgument( argu = new DefArgument( "prop" , "v", DefArgument.EDir.DIR_IN )); + meth.complete(); + + intf.addMethod( meth = new DefMethod( "GetAll" )); + meth.addArgument( argu = new DefArgument( "intf_name", "s" , DefArgument.EDir.DIR_IN )); + meth.addArgument( argu = new DefArgument( "allprops" , "a{sv}", DefArgument.EDir.DIR_OUT)); + meth.addAnnotation( ANNO_RETURNS, "allprops" ); + meth.complete(); + } +} + + +alias char[] DBusObjPath; +alias void function() DBusHandler; + +struct DBusVariant{ + byte type; + union{ + byte v_byte; + bool v_bool; + } +} + + + +class IntfTree{ + class Node{ + char[] mName; + DefInterface mValue; + Node[] mChilds; + } + + Node mRoot; + char[][] allInterfaces; + + public this(){ + mRoot = new Node(); + } + + public void add( DefInterface intf ){ + allInterfaces ~= intf.mName; + char[][] parts = split( intf.mName, "." ); + + Node findNode( char[][] names ){ + if( names.length == 0 ){ + return mRoot; + } + Node par = findNode( names[ 0 .. $-1 ] ); + foreach( child; par.mChilds ){ + if( child.mName == names[ $-1 ] ){ + return child; + } + } + auto child = new Node; + child.mName = names[ $-1 ].dup; + par.mChilds ~= child; + return child; + } + + Node node = findNode( parts ); + node.mValue = intf; + } + + public DefInterface getInterface( char[] intfName ){ + char[][] parts = split( intfName, "." ); + + Node findNode( char[][] names ){ + if( names.length == 0 ){ + return mRoot; + } + Node par = findNode( names[ 0 .. $-1 ] ); + foreach( child; par.mChilds ){ + if( child.mName == names[ $-1 ] ){ + return child; + } + } + return null; + } + Node node = findNode( parts ); + if( node is null ){ + return null; + } + return node.mValue; + } + + public char[][] getChildNames( char[] parentName ){ + char[][] parts = split( parentName, "." ); + + Node findNode( char[][] names ){ + if( names.length == 0 ){ + return mRoot; + } + Node par = findNode( names[ 0 .. $-1 ] ); + foreach( child; par.mChilds ){ + if( child.mName == names[ $-1 ] ){ + return child; + } + } + return null; + } + Node node = findNode( parts ); + if( node is null ){ + return null; + } + char[][] res; + foreach( idx, child; node.mChilds ){ + char[] txt; + if( parentName.length > 0 ){ + res ~= parentName ~ '.' ~ child.mName; + } + else{ + res ~= child.mName; + } + } + return res; + } +} + +class DefInterface{ + char[] mName; + + DefMethod[] mMethods; + DefSignal[] mSignals; + DefProperty[] mProperties; + char[][ char[] ] mAnnotations; + + public this( char[] aName ){ + mName = aName.dup; + } + + public void addMethod( DefMethod meth ){ + mMethods ~= meth; + } + + public void addSignal( DefSignal sign ){ + mSignals ~= sign; + } + + public void addProperty( DefProperty prop ){ + mProperties ~= prop; + } + + public void addAnnotation( char[] name, char[] value ){ + mAnnotations[ name.dup ] = value.dup; + } +} + +class DefSignal : ArgumentContainer { + + char[] mName; + DefArgument[] mArguments; + char[][ char[] ] mAnnotations; + public this( char[] aName ){ + mName = aName.dup; + } + + public void addArgument( DefArgument aArg ){ + mArguments ~= aArg; + } + public void addAnnotation( char[] name, char[] value ){ + mAnnotations[ name.dup ] = value.dup; + } +} + +class DefProperty { + + char[] mName; + public this( char[] aName ){ + mName = aName.dup; + } + +} + +class DefMethod : ArgumentContainer { + char[] mName; + DefArgument[] mArguments; + char[][ char[] ] mAnnotations; + + DefArgument mDRetArgument; + DefArgument[] mDArguments; + + public this( char[] aName ){ + mName = aName.dup; + } + public void addArgument( DefArgument aArg ){ + mArguments ~= aArg; + } + public void addAnnotation( char[] name, char[] value ){ + mAnnotations[ name.dup ] = value.dup; + } + + public void complete(){ + char[]* retArgName = ANNO_RETURNS in mAnnotations; + if( retArgName !is null ){ + int idx = 0; + bool found = false; + foreach( arg; mArguments ){ + if( *retArgName == arg.mName && arg.mDirection == DefArgument.EDir.DIR_OUT ){ + if( found ){ + error( "there are two or more out arguements in the same method" ); + } + found = true; + mDRetArgument = arg; + } + else{ + mDArguments ~= arg; + } + } + } + else{ + mDRetArgument = null; + mDArguments = mArguments; + } + } + + +} + +interface ArgumentContainer{ + public void addArgument( DefArgument aPar ); +} + +class DefArgument{ + + enum EDir{ + DIR_IN, DIR_OUT + } + + EDir mDirection; + char[] mName; + char[] mType; + + public this( char[] aName, char[] aType, EDir aDir ){ + mName = aName.dup; + mType = aType.dup; + mDirection = aDir; + } + + char[] toDType(){ + char[] rem; + char[] res = signatureToDType( mType, rem ); + if( rem.length > 0 ){ + error( "not a complete type %0 %1", mType, rem ); + } + return res; + } + + private char[] signatureToDType( char[] sigText, out char[] remainingSigText ){ + + remainingSigText = null; + if( sigText.length == 0 ){ + return null; + } + + remainingSigText = sigText[ 1.. $ ]; + + switch( sigText[0] ){ + case 'y': return "byte"; + case 'b': return "bool"; + case 'n': return "short"; + case 'q': return "ushort"; + case 'i': return "int"; + case 'u': return "uint"; + case 'x': return "long"; + case 't': return "ulong"; + case 'd': return "double"; + case 's': return "char[]"; + case 'o': return "DBusObject"; + case 'g': return "DBusSignature"; + case 'v': return "DBusVariant"; + default: + break; + } + if( sigText[0] == 'a' ){ + if( sigText.length > 1 && sigText[ 1 ] == '{' ){ + char[] rem; + char[] tkey = signatureToDType( sigText[2..$], rem ); + char[] rem2; + char[] tval = signatureToDType( rem, rem2 ); + char[] res = tval ~ "[ "~ tkey ~" ]"; + if( rem2.length == 0 || rem2[0] != '}' ){ + error( "no valid closing bracket for dict Entry" ); + } + remainingSigText = rem2[ 1 .. $ ]; + return res; + } + else{ + return signatureToDType( sigText[1..$], remainingSigText ) ~ "[]"; + } + } + else if( sigText[0] == '(' ){ + char[][] flds; + char[] rem = sigText[ 1 .. $ ]; + do{ + char[] rem2; + flds ~= signatureToDType( rem, rem2 ); + rem = rem2; + } + while( rem.length > 0 && rem[ 0 ] != ')' ); + remainingSigText = ( rem.length > 0 ) ? rem[ 1 .. $ ] : null; + return "Struct!( " ~ join( flds, ", " ) ~ " )"; + } + error( "unknown type "~sigText ); + assert(false); + } + + +} + + + + + +// array Attt_ AttAtt_i_ alles bis zum abschließenden _ +// map Mtt zwei typen nach M + +// BYTE 121 (ASCII 'y') 8-bit unsigned integer +// BOOLEAN 98 (ASCII 'b') Boolean value, 0 is FALSE and 1 is TRUE. Everything else is invalid. +// INT16 110 (ASCII 'n') 16-bit signed integer +// UINT16 113 (ASCII 'q') 16-bit unsigned integer +// INT32 105 (ASCII 'i') 32-bit signed integer +// UINT32 117 (ASCII 'u') 32-bit unsigned integer +// INT64 120 (ASCII 'x') 64-bit signed integer +// UINT64 116 (ASCII 't') 64-bit unsigned integer +// DOUBLE 100 (ASCII 'd') IEEE 754 double +// STRING 115 (ASCII 's') UTF-8 string (must be valid UTF-8). Must be nul terminated and contain no other nul bytes. +// OBJECT_PATH 111 (ASCII 'o') Name of an object instance +// SIGNATURE 103 (ASCII 'g') A type signature +// ARRAY 97 (ASCII 'a') Array +// STRUCT 114 (ASCII 'r'), 40 (ASCII '('), 41 (ASCII ')') Struct +// VARIANT 118 (ASCII 'v') Variant type (the type of the value is part of the value itself) +// DICT_ENTRY 101 (ASCII 'e'), 123 (ASCII '{'), 125 (ASCII '}') Entry in a dict or map (array of key-value pairs) +// + + +void parseNode( Element el ){ + + el.checkAllowedChilds( ID_INTF, ID_NODE ); + + foreach( intf; el.getChilds( ID_INTF )){ + auto defIntf = parseInterface( intf ); + intfTree.add( defIntf ); + } + foreach( node; el.getChilds( ID_NODE )){ + parseNode( node ); + } +} + +void unknownElement( char[][] msg ... ){ + char[200] buf; + Stderr( layout( buf, msg ) ).newline; +} + +DefInterface parseInterface( Element intf ){ + + char[] elname = intf.getAttribute( "name" ); + auto defIntf = new DefInterface( elname ); + + foreach( child; intf.getChilds() ){ + switch( child.getName() ){ + case ID_METH: + defIntf.addMethod( parseMethod( child )); + break; + case ID_SIGN: + defIntf.addSignal( parseSignal( child )); + break; + case ID_PROP: + defIntf.addProperty( parseProperty( child )); + break; + case ID_ANNO: + char[] name = child.getAttribute( "name" ); + char[] value = child.getAttribute( "value" ); + defIntf.addAnnotation( name, value ); + break; + default: + unknownElement( "Warning: found unknown nodetype %0 in interface", child.getName() ); + break; + } + } + return defIntf; +} + +DefMethod parseMethod( Element meth ){ + + char[] methName = meth.getAttribute( "name" ); + auto defMeth = new DefMethod( methName ); + + foreach( child; meth.getChilds() ){ + switch( child.getName() ){ + case ID_ARGU: + defMeth.addArgument( parseArgument( child, true )); + break; + case ID_ANNO: + char[] name = child.getAttribute( "name" ); + char[] value = child.getAttribute( "value" ); + defMeth.addAnnotation( name, value ); + break; + default: + unknownElement( "Warning: found unknown nodetype %0 in interface", child.getName() ); + break; + } + } + defMeth.complete(); + return defMeth; +} + +DefSignal parseSignal( Element sign ){ + char[] name = sign.getAttribute( "name" ); + auto defSign = new DefSignal( name ); + foreach( child; sign.getChilds() ){ + switch( child.getName() ){ + case ID_ARGU: + defSign.addArgument( parseArgument( child, false )); + break; + case ID_ANNO: + char[] annoName = child.getAttribute( "name" ); + char[] annoValue = child.getAttribute( "value" ); + defSign.addAnnotation( annoName, annoValue ); + break; + default: + unknownElement( "Warning: found unknown nodetype %0 in interface", child.getName() ); + break; + } + } + return defSign; +} +DefProperty parseProperty( Element prop ){ + char[] name = prop.getAttribute( "name" ); + auto res = new DefProperty( name ); + return res; +} + + +DefArgument parseArgument( Element arg, bool dirDefIn ){ + char[] name = arg.getAttribute( "name" ); + DefArgument.EDir dir = dirDefIn ? DefArgument.EDir.DIR_IN : DefArgument.EDir.DIR_OUT; + if( arg.hasAttribute( ID_DIRECTION )){ + char[] dirtxt = arg.getAttribute( ID_DIRECTION ); + switch( dirtxt ){ + case ID_DIRECTION_OUT: + dir = DefArgument.EDir.DIR_OUT; + break; + case ID_DIRECTION_IN: + dir = DefArgument.EDir.DIR_IN; + break; + default: + unknownElement( "Warning: direction attribute has unknown value %0", dirtxt ); + break; + } + } + char[] typetxt = arg.getAttribute( ID_TYPE ); + auto res = new DefArgument( name, typetxt, dir ); + return res; +} + +char[] getIndent( int indent ){ + static char[] spaces = " "; + int count = indent*4; + assert( count >= 0 ); + assert( count < spaces.length ); + return spaces[0..count]; +} + +//char[][ char[] ] introspection = [ `sdklf`:`ldkfj`]; + +void writeIntrospectionData( Print!(char) p ){ + char[200] buf; + char[] getArgIntrospectionData( DefArgument arg ){ + char[] res = ` <arg `; + res ~= layout( buf, ` name=\"%0\"`, arg.mName ).dup; + res ~= layout( buf, ` type=\"%0\"`, arg.mType ).dup; + res ~= layout( buf, ` direction=\"%0\"`, arg.mDirection == DefArgument.EDir.DIR_IN ? ID_DIRECTION_IN : ID_DIRECTION_OUT ).dup; + res ~= ` />\\n`; + return res; + } + char[] getAnnotationIntrospectionData( char[] name, char[] value, int indent ){ + return layout( buf, `%2<annotation name=\"%0\" value=\"%1\" />\\n`, name, value, getIndent( indent ) ).dup; + } + char[][] getMethodIntrospectionData( DefMethod meth ){ + char[][] res; + res ~= layout( buf, ` <method name=\"%0\">\\n`, meth.mName ).dup; + foreach( key, value ; meth.mAnnotations ){ + res ~= getAnnotationIntrospectionData( key, value, 2 ); + } + foreach( argu ; meth.mArguments ){ + res ~= getArgIntrospectionData( argu ); + } + res ~= ` </method>\\n`.dup; + return res; + } + char[][] getIntrospectionData( DefInterface intf ){ + char[][] res; + res ~= layout( buf, `<interface name=\"%0\">\\n`, intf.mName ).dup; + foreach( meth; intf.mMethods ){ + res ~= getMethodIntrospectionData( meth ); + } + res ~= `</interface>\\n`.dup; + return res; + } + p.formatln( "private void init_introspectionData(){{" ); + foreach( intfIdx, intf; intfTree.allInterfaces ){ + p.formatln( " registerIntrospectionData(" ); + p.formatln( " DBusInterface.{}.classinfo,", intf ); + char[][] data = getIntrospectionData( intfTree.getInterface( intf ) ); + foreach( idx, line; data ){ + if( idx < data.length-1 ){ + p.formatln( " \"{}\"", line ); + } + else{ + p.formatln( " \"{}\");", line, (intfIdx<intfTree.allInterfaces.length-1)?",":"" ); + } + } + } + p.formatln( "}" ); +} + +void error( char[][] msg... ){ + char[200] buf; + throw new TracedException( layout( buf, msg )); +} + +void writeInterfaceMethod( Print!(char) p, DefMethod meth, int indent ){ + DefArgument retArg = meth.mDRetArgument; + DefArgument[] args = meth.mDArguments; + char[] retType = ( retArg is null ) ? "void" : retArg.toDType(); + char[] argList; + foreach( idx, arg; args ){ + if( idx > 0 ){ + argList ~= ","; + } + argList ~= " "; + argList ~= (arg.mDirection == DefArgument.EDir.DIR_OUT) ? "out" : "in"; + argList ~= " "; + argList ~= arg.toDType(); + argList ~= " "; + argList ~= ( arg.mName.length == 0 ) ? "arg_" ~ toUtf8(idx) : arg.mName; + } + if( argList.length > 0 ){ + argList ~= " "; + } + p.formatln( "{}public {} {}({});", getIndent(indent), retType, meth.mName, argList ); +} + +void writeInterfaceSignal( Print!(char) p, DefSignal sign, int indent ){ + char[] argList; + foreach( idx, arg; sign.mArguments ){ + if( idx > 0 ){ + argList ~= ","; + } + argList ~= " "; + argList ~= arg.toDType(); + } + if( argList.length > 0 ){ + argList ~= " "; + } + p.formatln( "{}public tango.core.Signal.Signal!({})* {}();", getIndent(indent), argList, sign.mName ); +} + +void writeInterface( Print!(char) p, char[] name, int indent ){ + p.formatln( "{}// {}", getIndent(indent), name ); + char[] nodeName = split( name, "." )[ $-1 ]; + p.formatln( "{}public interface {} {{", getIndent(indent), nodeName ); + DefInterface intf = intfTree.getInterface( name ); + if( intf !is null ){ + foreach( meth; intf.mMethods ){ + writeInterfaceMethod( p, meth, indent+1 ); + } + foreach( sign; intf.mSignals ){ + writeInterfaceSignal( p, sign, indent+1 ); + } + } + foreach( child; intfTree.getChildNames( name ) ){ + writeInterface( p, child, indent +1 ); + } + p.formatln( "{}}", getIndent(indent) ); +} + +void writeHeader( Print!(char) p, char[] modName ){ + static char[] HEADER = + "/**\n" + " * Generated with TioLink\n" + " * TioLink was written by Frank Benoit <benoit@tionex.de>\n" + " * http://www.dsource.org/projects/tiolink\n" + " *\n" + " * File type: D programming language source code\n" + " */\n"; + p(HEADER); + p.formatln( "module {};", modName ); + p.newline; + p.formatln( "public import org.freedesktop.dbus.Struct;" ); + p.formatln( "public import org.freedesktop.dbus.Variant;" ); + p.newline; + p.formatln( "import tango.core.Signal;" ); + p.formatln( "import org.freedesktop.dbus.DBus;" ); + p.formatln( "import org.freedesktop.dbus.c.Connection : DBusConnection;" ); + p.formatln( "import org.freedesktop.dbus.c.Message : DBusMessage;" ); + p.formatln( "import org.freedesktop.dbus.c.Shared : DBusHandlerResult;" ); + p.newline; + p.newline; +} + +void writeInterfaces( Print!(char) p ){ + + p.formatln( "// DBus interfaces" ); + p.formatln( "public interface DBusInterface {{" ); + foreach( child; intfTree.getChildNames( "" ) ){ + writeInterface( p, child, 1 ); + } + p.formatln( "}" ); + p.newline; + p.newline; + +} + +void writePeerMethod( Print!(char) p, DefMethod mth, int indent ){ + DefArgument retArg = mth.mDRetArgument; + DefArgument[] args = mth.mDArguments; + char[] retType = ( retArg is null ) ? "void" : retArg.toDType(); + char[] argList; + foreach( idx, arg; args ){ + if( idx > 0 ){ + argList ~= ","; + } + argList ~= " "; + argList ~= (arg.mDirection == DefArgument.EDir.DIR_OUT) ? "out" : "in"; + argList ~= " "; + argList ~= arg.toDType(); + argList ~= " "; + argList ~= ( arg.mName.length == 0 ) ? "arg_" ~ toUtf8(idx) : arg.mName; + } + if( argList.length > 0 ){ + argList ~= " "; + } + p.formatln( "{}public {} {}({}){{", getIndent(indent), retType, mth.mName, argList ); + p.formatln( "{}}", getIndent(indent) ); +} + +void writePeerSignal( Print!(char) p, DefSignal sig, int indent ){ +} + +void writePeerImpl( Print!(char) p, char[] name, int indent ){ + p.formatln( "{}// {}", getIndent(indent), name ); + char[] nodeName = split( name, "." )[ $-1 ]; + p.formatln( "{}public class {} : DBusPeerObject, DBusInterface.{} {{", getIndent(indent), nodeName, name ); + DefInterface intf = intfTree.getInterface( name ); + if( intf !is null ){ + foreach( meth; intf.mMethods ){ + writePeerMethod( p, meth, indent+1 ); + } + foreach( sign; intf.mSignals ){ + writePeerSignal( p, sign, indent+1 ); + } + } + foreach( child; intfTree.getChildNames( name ) ){ + writePeerImpl( p, child, indent +1 ); + } + p.formatln( "{}}", getIndent(indent) ); +} +void writePeerImpls( Print!(char) p ){ + + p.formatln( "// Peer implementations" ); + p.formatln( "public interface DBusPeers {{" ); + foreach( child; intfTree.getChildNames( "" ) ){ + writePeerImpl( p, child, 1 ); + } + p.formatln( "}" ); + p.newline; + p.newline; + +} + +void writeDBusObject( Print!(char) p ){ + p.formatln( "// DBusObject" ); + p.formatln( "public class DBusObject : DBusObjectImpl, DBusInterface.org.freedesktop.DBus.Introspectable {{" ); + p.formatln( " this(){{" ); + p.formatln( " super();" ); + p.formatln( " }" ); + p.formatln( " public char[] Introspect(){{" ); + p.formatln( " return super.Introspect();" ); + p.formatln( " }" ); + p.formatln( "}" ); + p.newline; + p.newline; +} +void writeDBusPeerObject( Print!(char) p ){ + p.formatln( "// DBusPeerObject" ); + p.formatln( "public class DBusPeerObject {{" ); + p.formatln( "}" ); + p.newline; + p.newline; +} +class TextList { + + private char[] separator; + private char[] sb; + private char[] prefix; + private char[] postfix; + private bool completed = false; + + public this( char[] separator ){ + this.separator = separator; + this.prefix = ""; + this.postfix = ""; + } + public this( char[] prefix, char[] separator, char[] postfix ){ + this.prefix = prefix; + this.separator = separator; + this.postfix = postfix; + } + + public static TextList createParameterList(){ + return new TextList( " ", ", ", " " ); + } + + public void add( char[] value ){ + if( sb.length == 0 ){ + sb ~= prefix; + } + else{ + sb ~= separator; + } + sb ~= value; + } + public char[] toUtf8(){ + if( !completed ){ + if( sb.length > 0 ){ + sb ~= postfix; + } + completed = true; + } + return sb; + } +} + +void writeHandlerInterfaceMethod( Print!(char) p, DefMethod mth ){ + char[] sig = mth.mName ~ "|"; + foreach( arg; mth.mArguments ){ + if( arg.mDirection == DefArgument.EDir.DIR_IN ){ + sig ~= arg.mType; + } + } + + DefArgument retArg = mth.mDRetArgument; + DefArgument[] args = mth.mDArguments; + + p.formatln(" case \"{}\":", sig ); + p.formatln(" {{" ); + TextList callParams = TextList.createParameterList(); + TextList callTypes = TextList.createParameterList(); + TextList callInTypes = TextList.createParameterList(); + TextList callOutTypes = TextList.createParameterList(); + int idxi, idxo; + char[] retAssign = ""; + char[] retVar = ""; + bool hasOutputs = false; + bool hasInputs = false; + foreach( idx, arg; mth.mArguments ){ + callTypes.add( arg.toDType()); + if( arg.mDirection == DefArgument.EDir.DIR_IN ){ + hasInputs = true; + callInTypes.add( arg.toDType()); + callParams.add( "pi.t["~toUtf8(idxi)~"]" ); + idxi++; + } + else{ + hasOutputs = true; + callOutTypes.add( arg.toDType()); + + char[] outArg = "po.t["~toUtf8(idxo)~"]"; + idxo++; + if( arg is mth.mDRetArgument ){ + retVar = outArg; + retAssign = retVar~" = "; + } + else{ + callParams.add( outArg ); + } + } + } + if( hasInputs ){ + p.formatln(" Struct!({0}) pi = getCallValues!({0})( message );", callInTypes.toUtf8() ); + } + if( hasOutputs ){ + p.formatln(" Struct!({0}) po;" , callOutTypes.toUtf8() ); + } + p.formatln(" {}o.{}({});", retAssign, mth.mName, callParams.toUtf8() ); + if( hasOutputs ){ + p.formatln(" sendReplyData!({})( conn, message, po );", callOutTypes.toUtf8() ); + } + else{ + p.formatln(" sendReply( conn, message );" ); + } + p.formatln(" }" ); + p.formatln(" break;" ); + + +} +void writeHandlerInterfaceSignal( Print!(char) p, DefSignal sig ){ + char[] signature = sig.mName ~ ">"; + foreach( arg; sig.mArguments ){ + signature ~= arg.mType; + } + + DefArgument[] args = sig.mArguments; + + p.formatln(" case \"{}\":", signature ); + p.formatln(" {{" ); + TextList callParams = TextList.createParameterList(); + TextList callInTypes = TextList.createParameterList(); + int idxi; + char[] retAssign = ""; + char[] retVar = ""; + bool hasInputs = false; + foreach( idx, arg; sig.mArguments ){ + hasInputs = true; + callInTypes.add( arg.toDType()); + callParams.add( "pi.t["~toUtf8(idxi)~"]" ); + idxi++; + } + if( hasInputs ){ + p.formatln(" Struct!({0}) pi = getCallValues!({0})( message );", callInTypes.toUtf8() ); + } + p.formatln(" o.{}().opCall({});", sig.mName, callParams.toUtf8() ); + p.formatln(" }" ); + p.formatln(" break;" ); + + +} +void writeHandlerInterface( Print!(char) p, DefInterface intf ){ + p.formatln("private DBusHandlerResult intfHandler__{}( " + "DBusConnection* conn, DBusMessage* message, void* user_data ){{", + replace( intf.mName.dup, '.', '_') ); + p.formatln(" DBusInterface.{} o = cast(DBusInterface.{0})cast(Object)user_data;", intf.mName ); + p.formatln(" if( o is null || !checkIntf( \"{}\", message) )", intf.mName ); + p.formatln(" return DBusHandlerResult.DBUS_HANDLER_RESULT_NOT_YET_HANDLED;" ); + p.formatln(""); + p.formatln(" try{{"); + p.formatln(" char[METHOD_SIG_MAXLENGTH] buf;"); + p.formatln(" switch( methodSignature( message, buf ) ){{"); + foreach( DefMethod mth ; intf.mMethods ){ + writeHandlerInterfaceMethod( p, mth ); + } + foreach( DefSignal sig ; intf.mSignals ){ + writeHandlerInterfaceSignal( p, sig ); + } + p.formatln(" default:" ); + p.formatln(" return DBusHandlerResult.DBUS_HANDLER_RESULT_NOT_YET_HANDLED;"); + p.formatln(" }"); + p.formatln(" }"); + p.formatln(" catch( Exception e ){{"); + p.formatln(" sendException( conn, message, e );" ); + p.formatln(" }"); + p.formatln(" return DBusHandlerResult.DBUS_HANDLER_RESULT_HANDLED;"); + p.formatln("}"); + p.newline; +} +void writeHandlers( Print!(char) p ){ + + + foreach( intfIdx, intf; intfTree.allInterfaces ){ + writeHandlerInterface( p, intfTree.getInterface( intf )); + } + + p.formatln( "private void init_handlers(){{" ); + foreach( intfIdx, intf; intfTree.allInterfaces ){ + p.formatln( " registerHandler(" ); + p.formatln( " DBusInterface.{}.classinfo,", intf ); + p.formatln( " & intfHandler__{} );", replace( intf.dup, '.', '_' )); + } + p.formatln( "}" ); + p.newline; + +} +void writeStaticInit( Print!(char) p ){ + p.formatln( "static this(){{" ); + p.formatln( " init_introspectionData();" ); + p.formatln( " init_handlers();" ); + p.formatln( "}" ); + p.newline; +} + +int main(char[][] args) { + try{ + if( args.length != 3 ){ + printSyntax(); + throw new TerminateException(1); + } + char[] introxml = args[1]; + char[] modname = args[2]; + intfTree = new IntfTree(); + auto root = parse( introxml ); + createStdInterfaces(); + parseNode( root ); + Print!(char) output = Stdout; + writeHeader( output, modname ); + writeInterfaces( output ); + //writePeerImpls( output ); + writeDBusObject( output ); + //writeDBusPeerObject( output ); + writeIntrospectionData( output ); + writeHandlers( output ); + writeStaticInit( output ); + } + catch( TerminateException e ){ + return e.code; + } + return(0); +} + + +void printSyntax() { + Stdout.formatln("dbus-createinterface <introspectionsdata.xml> <modulename>"); +} + + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbus-d/dsrc/org/freedesktop/dbus/tool/XmlSupport.d Sat Oct 20 18:07:18 2007 +0200 @@ -0,0 +1,209 @@ +/** + * Author: Frank Benoit + * License: Public domain + * File type: D programming language + */ +module org.freedesktop.dbus.tool.XmlSupport; + +import tango.core.Array; +import tango.io.FileConduit; + +import tango.text.Util; +import tango.util.collection.LinkSeq; +import mango.xml.sax.DefaultSAXHandler; +import mango.xml.sax.parser.teqXML; + +class Element { + char[] mName; + Element[] mChilds; + char[][char[]] mAttributes; + char[] mText; + Element mParent; + + public this( char[] aName, Element aParent ){ + mName = aName.dup; + mParent = aParent; + mText = ""; + if( aParent ){ + aParent.addChild( this ); + } + } + + protected void addChild( Element aChild ){ + mChilds ~= aChild; + } + public Element createChildElement( char[] aName ){ + Element result = new Element( aName, this ); + return result; + } + public void completeChildElement( char[] aName, Element aChild ){ + } + public void completeYourself(){ + mText = Text.trim( mText ); + } + public char[] getText(){ + return mText; + } + public char[] getName(){ + return mName; + } + public void setText( char[] aText ){ + mText = aText.dup; + } + public void addAttribute(char[] key, char[] value){ + mAttributes[ key.dup ] = value.dup; + } + public bool hasAttribute( char[] aName ){ + return cast(bool)( aName in mAttributes ); + } + public bool hasChild( char[] aName ){ + foreach( Element child; mChilds ){ + if( child.mName == aName ){ + return true; + } + } + + return false; + } + public Element tryGetChild( char[] aName ){ + foreach( Element child; mChilds ){ + if( child.mName == aName ){ + return child; + } + } + + return null; + } + public Element getChild( char[] aName ){ + Element result = tryGetChild( aName ); + check( result !is null, "Element.getChild mName=%0, aName=%1", mName, aName ); + return result; + } + public Element[] getChilds(){ + return mChilds.dup; + } + public Element[] getChilds( char[] aName ){ + Element[] result; + foreach( Element child; mChilds ){ + if( child.mName == aName ){ + result ~= child; + } + } + + return result; + } + public Element tryFindChild( bool delegate( Element aChild ) aDg ){ + foreach( Element child; mChilds ){ + if( aDg( child ) ){ + return child; + } + } + + return null; + } + public Element findChild( bool delegate( Element aChild ) aDg ){ + Element result = tryFindChild( aDg ); + check( result !is null, "Element.findChild mName=%0, not found", mName ); + return result; + } + public char[] getAttribute( char[] aKey ){ + check( cast(bool)(aKey in mAttributes), "Element %0 does not contain the attribute %1", mName, aKey ); + return mAttributes[ aKey ].dup; + } + + public void checkAllowedChilds( char[][] names... ){ + foreach( Element child; mChilds ){ + check( tango.core.Array.find( names, child.mName ) != names.length, + "in element %0, a not allowed child node name exist %1", mName, child.mName ); + } + } +} + +class Document { + private Element mElement; + public Element createRootElement( char[] aName ){ + mElement = new Element( aName, null ); + return mElement; + } + public void completeRootElement( char[] aName, Element aChild ){ + } + public void setRoot( Element aRoot ){ + mElement = aRoot; + } + public Element getRoot(){ + return mElement; + } +} + +public class DomConstructionSaxHandler : DefaultSAXHandler!( char ) { + Document mDocument; + alias LinkSeq!(Element) TElementList; + TElementList mElements; + + public this( Document aDocument ){ + mElements = new TElementList(); + mDocument = aDocument; + } + void startDocument() { + //Stdout( "startDocument" ).newline; + } + void endDocument() { + //Stdout( "endDocument" ).newline; + } + void processingInstruction(char[] target, char[] data) { + //Stdout( "processingInstruction" ).newline; + } + void startElement(char[] name) { + if( mElements.size() > 0 ){ + //Stdout.format( "startElement {0} {1} ", name.utf8, mElements.size() ).newline; + Element el = mElements.head().createChildElement( name ); + mElements.prepend( el ); + } + else{ + //Stdout( "startRootElement" ~ name.utf8 ).newline; + Element el = mDocument.createRootElement( name ); + mElements.prepend( el ); + } + + //Stdout( "startElement" ).newline; + } + void addAttribute(char[] key, char[] value) { + Element el = mElements.head(); + el.addAttribute( key, value ); + //Stdout( "addAttribute" ).newline; + } + void endElement(char[] name) { + Element child = mElements.take(); + child.completeYourself(); + if( mElements.size() > 0 ){ + Element el = mElements.head(); + el.completeChildElement( name, child ); + } + else{ + mDocument.completeRootElement( name, child ); + } + + //Stdout( "endElement" ).newline; + } + void comment(char[] text) { + //Stdout( "comment" ).newline; + } +} + +void check( bool aCondition, char[][] aMessage ... ){ + if( !aCondition ){ + char[200] buf; + throw new Exception( layout( buf, aMessage )); + } +} + +Element parse(char[] aFileName){ + auto parser = new XMLReader!(char) (); + auto doc = new Document(); + auto handler = new DomConstructionSaxHandler( doc ); + parser.parse( new FileConduit( aFileName ), handler); + return doc.getRoot(); +} + + +