[libnet-dbus-perl] 38/335: Large update to deal with new recursive types APIs
Intrigeri
intrigeri at moszumanska.debian.org
Sat Mar 21 01:07:18 UTC 2015
This is an automated email from the git hooks/post-receive script.
intrigeri pushed a commit to branch experimental
in repository libnet-dbus-perl.
commit 3f57750f010604da5d1abf619bcddb848a19c960
Author: Daniel P. Berrange <dan at berrange.com>
Date: Mon Feb 21 00:10:06 2005 +0000
Large update to deal with new recursive types APIs
---
DBus.xs | 354 +++++++--------------------------------
lib/Net/DBus.pm | 22 +--
lib/Net/DBus/Binding/Bus.pm | 4 +-
lib/Net/DBus/Binding/Iterator.pm | 252 +++++++++++++++++++---------
lib/Net/DBus/Binding/Message.pm | 7 +-
lib/Net/DBus/Callback.pm | 4 +-
lib/Net/DBus/Object.pm | 6 +-
lib/Net/DBus/RemoteObject.pm | 2 +-
lib/Net/DBus/Service.pm | 2 +-
9 files changed, 262 insertions(+), 391 deletions(-)
diff --git a/DBus.xs b/DBus.xs
index d43a4aa..b296de8 100644
--- a/DBus.xs
+++ b/DBus.xs
@@ -322,20 +322,20 @@ BOOT:
constants = perl_get_hv("Net::DBus::Binding::Bus::_constants", TRUE);
REGISTER_CONSTANT(DBUS_BUS_SYSTEM, SYSTEM);
REGISTER_CONSTANT(DBUS_BUS_SESSION, SESSION);
- REGISTER_CONSTANT(DBUS_BUS_ACTIVATION, ACTIVATION);
+ REGISTER_CONSTANT(DBUS_BUS_STARTER, STARTER);
constants = perl_get_hv("Net::DBus::Binding::Message::_constants", TRUE);
REGISTER_CONSTANT(DBUS_TYPE_ARRAY, TYPE_ARRAY);
REGISTER_CONSTANT(DBUS_TYPE_BOOLEAN, TYPE_BOOLEAN);
REGISTER_CONSTANT(DBUS_TYPE_BYTE, TYPE_BYTE);
- REGISTER_CONSTANT(DBUS_TYPE_CUSTOM, TYPE_CUSTOM);
- REGISTER_CONSTANT(DBUS_TYPE_DICT, TYPE_DICT);
REGISTER_CONSTANT(DBUS_TYPE_DOUBLE, TYPE_DOUBLE);
REGISTER_CONSTANT(DBUS_TYPE_INT32, TYPE_INT32);
REGISTER_CONSTANT(DBUS_TYPE_INT64, TYPE_INT64);
REGISTER_CONSTANT(DBUS_TYPE_INVALID, TYPE_INVALID);
- REGISTER_CONSTANT(DBUS_TYPE_NIL, TYPE_NIL);
+ REGISTER_CONSTANT(DBUS_TYPE_STRUCT, TYPE_STRUCT);
+ REGISTER_CONSTANT(DBUS_TYPE_SIGNATURE, TYPE_SIGNATURE);
REGISTER_CONSTANT(DBUS_TYPE_OBJECT_PATH, TYPE_OBJECT_PATH);
+ REGISTER_CONSTANT(DBUS_TYPE_DICT_ENTRY, TYPE_DICT_ENTRY);
REGISTER_CONSTANT(DBUS_TYPE_STRING, TYPE_STRING);
REGISTER_CONSTANT(DBUS_TYPE_UINT32, TYPE_UINT32);
REGISTER_CONSTANT(DBUS_TYPE_UINT64, TYPE_UINT64);
@@ -543,7 +543,7 @@ dbus_bus_add_match(con, rule)
int
-dbus_bus_aquire_service(con, service_name)
+dbus_bus_request_name(con, service_name)
DBusConnection *con;
char *service_name;
PREINIT:
@@ -551,7 +551,7 @@ dbus_bus_aquire_service(con, service_name)
int reply;
CODE:
dbus_error_init(&error);
- if (!(reply = dbus_bus_acquire_service(con, service_name, 0, &error))) {
+ if (!(reply = dbus_bus_request_name(con, service_name, 0, &error))) {
croak(error.message);
}
RETVAL = reply;
@@ -561,6 +561,9 @@ DESTROY(con)
DBusConnection *con;
CODE:
PD_DEBUG("Destroying connection %x\n", con);
+ if (dbus_connection_get_is_connected(con)) {
+ dbus_connection_disconnect(con);
+ }
dbus_connection_unref(con);
@@ -703,25 +706,24 @@ set_no_reply(msg, status)
CODE:
dbus_message_set_no_reply(msg, status);
-void
-set_auto_activation(msg, status)
+
+
+DBusMessageIter *
+_iterator_append(msg)
DBusMessage *msg;
- dbus_bool_t status;
CODE:
- dbus_message_set_auto_activation(msg, status);
+ RETVAL = dbus_new(DBusMessageIter, 1);
+ dbus_message_iter_init_append(msg, RETVAL);
+ OUTPUT:
+ RETVAL
DBusMessageIter *
_iterator(msg)
DBusMessage *msg;
- PREINIT:
- DBusMessageIter *iter;
- SV *h_sv;
CODE:
- iter = dbus_new(DBusMessageIter, 1);
-
- dbus_message_iter_init(msg, iter);
- RETVAL = iter;
+ RETVAL = dbus_new(DBusMessageIter, 1);
+ dbus_message_iter_init(msg, RETVAL);
OUTPUT:
RETVAL
@@ -960,64 +962,62 @@ set_data(timeout, data)
MODULE = Net::DBus::Binding::Iterator PACKAGE = Net::DBus::Binding::Iterator
-int
-get_arg_type(iter)
+DBusMessageIter *
+_recurse(iter)
DBusMessageIter *iter;
CODE:
- RETVAL = dbus_message_iter_get_arg_type(iter);
+ RETVAL = dbus_new(DBusMessageIter, 1);
+ dbus_message_iter_recurse(iter, RETVAL);
OUTPUT:
RETVAL
-dbus_bool_t
-has_next(iter)
+DBusMessageIter *
+_open_container(iter, type, sig)
DBusMessageIter *iter;
+ int type;
+ char *sig;
CODE:
- RETVAL = dbus_message_iter_has_next(iter);
+ RETVAL = dbus_new(DBusMessageIter, 1);
+ dbus_message_iter_open_container(iter, type, sig, RETVAL);
OUTPUT:
RETVAL
-dbus_bool_t
-next(iter)
+void
+_close_container(iter, sub_iter)
DBusMessageIter *iter;
+ DBusMessageIter *sub_iter;
CODE:
- RETVAL = dbus_message_iter_next(iter);
+ dbus_message_iter_close_container(iter, sub_iter);
+
+int
+get_arg_type(iter)
+ DBusMessageIter *iter;
+ CODE:
+ RETVAL = dbus_message_iter_get_arg_type(iter);
OUTPUT:
RETVAL
-
-DBusMessageIter *
-get_array_iter(iter)
+int
+get_element_type(iter)
DBusMessageIter *iter;
- PREINIT:
- DBusMessageIter *array_iter;
- int type;
CODE:
- array_iter = dbus_new(DBusMessageIter, 1);
- dbus_message_iter_init_array_iterator(iter, array_iter, &type);
- RETVAL = array_iter;
+ RETVAL = dbus_message_iter_get_element_type(iter);
OUTPUT:
RETVAL
-DBusMessageIter *
-get_dict_iter(iter)
+dbus_bool_t
+has_next(iter)
DBusMessageIter *iter;
- PREINIT:
- DBusMessageIter *dict_iter;
CODE:
- dict_iter = dbus_new(DBusMessageIter, 1);
- dbus_message_iter_init_dict_iterator(iter, dict_iter);
- RETVAL = dict_iter;
+ RETVAL = dbus_message_iter_has_next(iter);
OUTPUT:
RETVAL
-char *
-get_dict_key(iter)
+dbus_bool_t
+next(iter)
DBusMessageIter *iter;
- PREINIT:
- char *key;
CODE:
- key = dbus_message_iter_get_dict_key(iter);
- RETVAL = key;
+ RETVAL = dbus_message_iter_next(iter);
OUTPUT:
RETVAL
@@ -1025,7 +1025,7 @@ dbus_bool_t
get_boolean(iter)
DBusMessageIter *iter;
CODE:
- RETVAL = dbus_message_iter_get_boolean(iter);
+ dbus_message_iter_get_basic(iter, &RETVAL);
OUTPUT:
RETVAL
@@ -1033,7 +1033,7 @@ unsigned char
get_byte(iter)
DBusMessageIter *iter;
CODE:
- RETVAL = dbus_message_iter_get_byte(iter);
+ dbus_message_iter_get_basic(iter, &RETVAL);
OUTPUT:
RETVAL
@@ -1041,7 +1041,7 @@ dbus_int32_t
get_int32(iter)
DBusMessageIter *iter;
CODE:
- RETVAL = dbus_message_iter_get_int32(iter);
+ dbus_message_iter_get_basic(iter, &RETVAL);
OUTPUT:
RETVAL
@@ -1049,7 +1049,7 @@ dbus_uint32_t
get_uint32(iter)
DBusMessageIter *iter;
CODE:
- RETVAL = dbus_message_iter_get_uint32(iter);
+ dbus_message_iter_get_basic(iter, &RETVAL);
OUTPUT:
RETVAL
@@ -1057,7 +1057,7 @@ dbus_int64_t
_get_int64(iter)
DBusMessageIter *iter;
CODE:
- RETVAL = dbus_message_iter_get_int64(iter);
+ dbus_message_iter_get_basic(iter, &RETVAL);
OUTPUT:
RETVAL
@@ -1065,7 +1065,7 @@ dbus_uint64_t
_get_uint64(iter)
DBusMessageIter *iter;
CODE:
- RETVAL = dbus_message_iter_get_uint64(iter);
+ dbus_message_iter_get_basic(iter, &RETVAL);
OUTPUT:
RETVAL
@@ -1073,7 +1073,7 @@ double
get_double(iter)
DBusMessageIter *iter;
CODE:
- RETVAL = dbus_message_iter_get_double(iter);
+ dbus_message_iter_get_basic(iter, &RETVAL);
OUTPUT:
RETVAL
@@ -1081,25 +1081,17 @@ char *
get_string(iter)
DBusMessageIter *iter;
CODE:
- RETVAL = dbus_message_iter_get_string(iter);
+ dbus_message_iter_get_basic(iter, &RETVAL);
OUTPUT:
RETVAL
void
-append_nil(iter)
- DBusMessageIter *iter;
- CODE:
- if (!dbus_message_iter_append_nil(iter)) {
- croak("cannot append nill");
- }
-
-void
append_boolean(iter, val)
DBusMessageIter *iter;
dbus_bool_t val;
CODE:
- if (!dbus_message_iter_append_boolean(iter, val)) {
+ if (!dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN, &val)) {
croak("cannot append boolean");
}
@@ -1108,7 +1100,7 @@ append_byte(iter, val)
DBusMessageIter *iter;
unsigned char val;
CODE:
- if (!dbus_message_iter_append_byte(iter, val)) {
+ if (!dbus_message_iter_append_basic(iter, DBUS_TYPE_BYTE, &val)) {
croak("cannot append byte");
}
@@ -1117,7 +1109,7 @@ append_int32(iter, val)
DBusMessageIter *iter;
dbus_int32_t val;
CODE:
- if (!dbus_message_iter_append_int32(iter, val)) {
+ if (!dbus_message_iter_append_basic(iter, DBUS_TYPE_INT32, &val)) {
croak("cannot append int32");
}
@@ -1126,7 +1118,7 @@ append_uint32(iter, val)
DBusMessageIter *iter;
dbus_uint32_t val;
CODE:
- if (!dbus_message_iter_append_uint32(iter, val)) {
+ if (!dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32, &val)) {
croak("cannot append uint32");
}
@@ -1135,7 +1127,7 @@ _append_int64(iter, val)
DBusMessageIter *iter;
dbus_int64_t val;
CODE:
- if (!dbus_message_iter_append_int64(iter, val)) {
+ if (!dbus_message_iter_append_basic(iter, DBUS_TYPE_INT64, &val)) {
croak("cannot append int64");
}
@@ -1144,7 +1136,7 @@ _append_uint64(iter, val)
DBusMessageIter *iter;
dbus_uint64_t val;
CODE:
- if (!dbus_message_iter_append_uint64(iter, val)) {
+ if (!dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT64, &val)) {
croak("cannot append uint64");
}
@@ -1153,7 +1145,7 @@ append_double(iter, val)
DBusMessageIter *iter;
double val;
CODE:
- if (!dbus_message_iter_append_double(iter, val)) {
+ if (!dbus_message_iter_append_basic(iter, DBUS_TYPE_DOUBLE, &val)) {
croak("cannot append double");
}
@@ -1162,229 +1154,11 @@ append_string(iter, val)
DBusMessageIter *iter;
char *val;
CODE:
- if (!dbus_message_iter_append_string(iter, val)) {
+ if (!dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &val)) {
croak("cannot append string");
}
-void
-append_boolean_array(iter, ref)
- DBusMessageIter *iter;
- SV *ref;
- PREINIT:
- AV *val;
- I32 len;
- I32 i;
- char *vals;
- dbus_bool_t res;
- CODE:
- val = (AV*)SvRV(ref);
- len = val ? av_len(val)+1 : 0;
- New(1, vals, len, char);
- for (i = 0 ; i < len ; i++) {
- SV **el = av_fetch(val,i,0);
- char *str = el ? SvPVbyte_nolen(*el) : NULL;
- vals[i] = str && str[0] ? 0x1: 0x0;
- }
- res = dbus_message_iter_append_boolean_array(iter, vals, len);
- Safefree(vals);
- if (!res) {
- croak("Cannot append array");
- }
-
-void
-append_byte_array(iter, ref)
- DBusMessageIter *iter;
- SV *ref;
- PREINIT:
- AV *val;
- I32 len;
- I32 i;
- char *vals;
- dbus_bool_t res;
- CODE:
- val = (AV*)SvRV(ref);
- len = val ? av_len(val)+1 : 0;
- New(1, vals, len, char);
- for (i = 0 ; i < len ; i++) {
- SV **el = av_fetch(val,i,0);
- char *str = el ? SvPVbyte_nolen(*el) : NULL;
- vals[i] = str ? str[0] : '0';
- }
- res = dbus_message_iter_append_byte_array(iter, vals, len);
- Safefree(vals);
- if (!res) {
- croak("Cannot append array");
- }
-
-void
-append_string_array(iter, ref)
- DBusMessageIter *iter;
- SV *ref;
- PREINIT:
- AV *val;
- I32 len;
- I32 i;
- const char **vals;
- dbus_bool_t res;
- CODE:
- val = (AV*)SvRV(ref);
- len = val ? av_len(val)+1 : 0;
- New(1, vals, len, const char*);
- for (i = 0 ; i < len ; i++) {
- SV **el = av_fetch(val,i,0);
- vals[i] = el ? SvPV_nolen(*el) : NULL;
- }
- res = dbus_message_iter_append_string_array(iter, vals, len);
- Safefree(vals);
- if (!res) {
- croak("Cannot append array");
- }
-
-void
-append_int32_array(iter, ref)
- DBusMessageIter *iter;
- SV *ref;
- PREINIT:
- AV *val;
- I32 len;
- I32 i;
- dbus_int32_t *vals;
- dbus_bool_t res;
- CODE:
- val = (AV*)SvRV(ref);
- len = val ? av_len(val)+1 : 0;
- New(1, vals, len, dbus_int32_t);
- for (i = 0 ; i < len ; i++) {
- SV **el = av_fetch(val,i,0);
- vals[i] = el ? SvIV(*el) : 0;
- }
- res = dbus_message_iter_append_int32_array(iter, vals, len);
- Safefree(vals);
- if (!res) {
- croak("Cannot append array");
- }
-
-void
-append_uint32_array(iter, ref)
- DBusMessageIter *iter;
- SV *ref;
- PREINIT:
- AV *val;
- I32 len;
- I32 i;
- dbus_uint32_t *vals;
- dbus_bool_t res;
- CODE:
- val = (AV*)SvRV(ref);
- len = val ? av_len(val)+1 : 0;
- New(1, vals, len, dbus_uint32_t);
- for (i = 0 ; i < len ; i++) {
- SV **el = av_fetch(val,i,0);
- vals[i] = el ? SvIV(*el) : 0;
- }
- res = dbus_message_iter_append_uint32_array(iter, vals, len);
- Safefree(vals);
- if (!res) {
- croak("Cannot append array");
- }
-
-void
-append_int64_array(iter, ref)
- DBusMessageIter *iter;
- SV *ref;
- PREINIT:
- AV *val;
- I32 len;
- I32 i;
- dbus_int64_t *vals;
- dbus_bool_t res;
- CODE:
- val = (AV*)SvRV(ref);
- len = val ? av_len(val)+1 : 0;
- New(1, vals, len, dbus_int64_t);
- for (i = 0 ; i < len ; i++) {
- SV **el = av_fetch(val,i,0);
- vals[i] = el ? SvIV(*el) : 0;
- }
- res = dbus_message_iter_append_int64_array(iter, vals, len);
- Safefree(vals);
- if (!res) {
- croak("Cannot append array");
- }
-
-void
-append_uint64_array(iter, ref)
- DBusMessageIter *iter;
- SV *ref;
- PREINIT:
- AV *val;
- I32 len;
- I32 i;
- dbus_uint64_t *vals;
- dbus_bool_t res;
- CODE:
- val = (AV*)SvRV(ref);
- len = val ? av_len(val)+1 : 0;
- New(1, vals, len, dbus_uint64_t);
- for (i = 0 ; i < len ; i++) {
- SV **el = av_fetch(val,i,0);
- vals[i] = el ? SvIV(*el) : 0;
- }
- res = dbus_message_iter_append_uint64_array(iter, vals, len);
- Safefree(vals);
- if (!res) {
- croak("Cannot append array");
- }
-
-void
-append_double_array(iter, ref)
- DBusMessageIter *iter;
- SV *ref;
- PREINIT:
- AV *val;
- I32 len;
- I32 i;
- double *vals;
- dbus_bool_t res;
- CODE:
- val = (AV*)SvRV(ref);
- len = val ? av_len(val)+1 : 0;
- New(1, vals, len, double);
- for (i = 0 ; i < len ; i++) {
- SV **el = av_fetch(val,i,0);
- vals[i] = el ? SvNV(*el) : 0.0;
- }
- res = dbus_message_iter_append_double_array(iter, vals, len);
- Safefree(vals);
- if (!res) {
- croak("Cannot append array");
- }
-
-void
-append_dict_key(iter, val)
- DBusMessageIter *iter;
- char *val;
- CODE:
- if (!dbus_message_iter_append_dict_key(iter, val)) {
- croak("Cannot append dict key");
- }
-
-DBusMessageIter *
-append_dict(iter)
- DBusMessageIter *iter;
- PREINIT:
- DBusMessageIter *diter;
- CODE:
- diter = dbus_new(DBusMessageIter, 1);
-
- if (!dbus_message_iter_append_dict(iter, diter)) {
- dbus_free(diter);
- croak("Cannot append dict");
- }
- RETVAL = iter;
- OUTPUT:
- RETVAL
void
DESTROY(iter)
diff --git a/lib/Net/DBus.pm b/lib/Net/DBus.pm
index c4c3073..47043cd 100644
--- a/lib/Net/DBus.pm
+++ b/lib/Net/DBus.pm
@@ -20,7 +20,7 @@ use vars qw(@EXPORT);
@EXPORT = qw(dboolean dbyte dstring dint32
duint32 dint64 duint64 ddouble
- dpack);
+ dstruct dpack);
require XSLoader;
XSLoader::load('Net::DBus', $VERSION);
@@ -132,7 +132,7 @@ sub _match_rule {
my $bus_service = $self->get_service("org.freedesktop.DBus");
my $bus_object = $bus_service->get_object('/org/freedesktop/DBus',
'org.freedesktop.DBus');
- $service = $bus_object->GetServiceOwner($service);
+ $service = $bus_object->GetNameOwner($service);
}
$rule .= ",sender='$service'";
}
@@ -252,6 +252,12 @@ sub ddouble {
$value);
}
+sub dstruct {
+ my $value = shift;
+ return Net::DBus::Binding::Value->new(&Net::DBus::Binding::Message::TYPE_STRUCT,
+ $value);
+}
+
our %flags = (
'o' => &Net::DBus::Binding::Message::TYPE_BOOLEAN,
'b' => &Net::DBus::Binding::Message::TYPE_BYTE,
@@ -302,14 +308,10 @@ DBus provides a Perl API for the DBus message system.
=head1 DESCRIPTION
DBus provides a Perl API for the DBus message system.
-There is no need to access this module directly. It is
-used by other Net::DBus::* module to trigger the autoloading
-of the XS module containing the interface to the DBus
-API. The DBus Perl interface was written against version
-0.21 of dbus, and has had rudimentary testing against the
-development branch that will become 0.22. The two modules
-of main interest will be L<Net::DBus::Connection> and
-L<Net::DBus::Server>.
+The DBus Perl interface is currently operating against
+the 0.30 development version of DBus. See the programs
+in the examples/ subdirectory for example of how to
+use the APIs
=head1 SEE ALSO
diff --git a/lib/Net/DBus/Binding/Bus.pm b/lib/Net/DBus/Binding/Bus.pm
index 7acc098..a6d2218 100644
--- a/lib/Net/DBus/Binding/Bus.pm
+++ b/lib/Net/DBus/Binding/Bus.pm
@@ -34,11 +34,11 @@ sub new {
}
-sub acquire_service {
+sub request_name {
my $self = shift;
my $service_name = shift;
- $self->{connection}->dbus_bus_aquire_service($service_name);
+ $self->{connection}->dbus_bus_request_name($service_name);
}
sub add_match {
diff --git a/lib/Net/DBus/Binding/Iterator.pm b/lib/Net/DBus/Binding/Iterator.pm
index fe8ff16..7543174 100644
--- a/lib/Net/DBus/Binding/Iterator.pm
+++ b/lib/Net/DBus/Binding/Iterator.pm
@@ -166,9 +166,8 @@ sub append_uint64 {
sub get {
- my $self = shift;
-
- my $type = $self->get_arg_type;
+ my $self = shift;
+ my $type = @_ ? shift : $self->get_arg_type;
if ($type == &Net::DBus::Binding::Message::TYPE_STRING) {
return $self->get_string;
@@ -187,101 +186,192 @@ sub get {
} elsif ($type == &Net::DBus::Binding::Message::TYPE_DOUBLE) {
return $self->get_double;
} elsif ($type == &Net::DBus::Binding::Message::TYPE_ARRAY) {
- my $iter = $self->get_array_iter();
- my @value;
- do {
- push @value, $iter->get();
- } while ($iter->next());
- return \@value;
- } elsif ($type == &Net::DBus::Binding::Message::TYPE_DICT) {
- my $iter = $self->get_dict_iter();
- my %value;
- do {
- $value{$iter->get_dict_key} = $iter->get;
- } while ($iter->next());
- return \%value;
- } elsif ($type == &Net::DBus::Binding::Message::TYPE_NIL) {
- return undef;
- } elsif ($type == &Net::DBus::Binding::Message::TYPE_CUSTOM) {
- confess "cannot handle Net::DBus::Binding::Message::TYPE_CUSTOM";
+ my $array_type = $self->get_element_type();
+ if ($array_type == &Net::DBus::Binding::Message::TYPE_DICT_ENTRY) {
+ return $self->get_dict();
+ } else {
+ return $self->get_array($array_type);
+ }
+ } elsif ($type == &Net::DBus::Binding::Message::TYPE_STRUCT) {
+ return $self->get_struct();
+ } elsif ($type == &Net::DBus::Binding::Message::TYPE_DICT_ENTRY) {
+ confess "dictionary can only occur as part of an array type";
} elsif ($type == &Net::DBus::Binding::Message::TYPE_INVALID) {
confess "cannot handle Net::DBus::Binding::Message::TYPE_INVALID";
} elsif ($type == &Net::DBus::Binding::Message::TYPE_OBJECT_PATH) {
- confess "cannot handle Net::DBus::Binding::Message::TYPE_OBJECT_PATH";
+ my $path = $self->get_string();
+ bless $path, "Net::DBus::Binding::ObjectPath";
+ return $path;
+ } elsif ($type == &Net::DBus::Binding::Message::TYPE_SIGNATURE) {
+ my $sig = $self->get_string();
+ bless $sig, "Net::DBus::Binding::Signature";
+ return $sig;
+ } else {
+ confess "unknown argument type '" . chr($type) . "' ($type)";
+ }
+}
+
+
+sub get_dict {
+ my $self = shift;
+
+ my $iter = $self->_recurse();
+ my $type = $iter->get_arg_type();
+ my $dict = {};
+ while ($type == &Net::DBus::Binding::Message::TYPE_DICT_ENTRY) {
+ my $entry = $iter->get_struct();
+ if ($#{$entry} != 1) {
+ confess "Dictionary entries must be structs of 2 elements. This entry has " . ($#{$entry}+1) ." elements";
+ }
+
+ $dict->{$entry->[0]} = $entry->[1];
+ $iter->next();
+ $type = $iter->get_arg_type();
+ }
+ return $dict;
+}
+
+sub get_array {
+ my $self = shift;
+ my $array_type = shift;
+
+ my $iter = $self->_recurse();
+ my $type = $iter->get_arg_type();
+ my $array = [];
+ while ($type != &Net::DBus::Binding::Message::TYPE_INVALID) {
+ if ($type != $array_type) {
+ confess "Element $type not of array type $array_type";
+ }
+
+ my $value = $iter->get($type);
+ push @{$array}, $value;
+ $iter->next();
+ $type = $iter->get_arg_type();
}
+ return $array;
+}
+
+sub get_variant {
+ my $self = shift;
+
+ my $iter = $self->_recurse();
+ return $iter->get();
+}
+
+sub get_struct {
+ my $self = shift;
+
+ my $iter = $self->_recurse();
+ my $type = $iter->get_arg_type();
+ my $struct = [];
+ while ($type != &Net::DBus::Binding::Message::TYPE_INVALID) {
+ my $value = $iter->get($type);
+ push @{$struct}, $value;
+ $iter->next();
+ $type = $iter->get_arg_type();
+ }
+ return $struct;
}
sub append {
my $self = shift;
my $value = shift;
+ my $type;
+ if (@_) {
+ $type = shift;
+ } elsif (ref($value) eq "Net::DBus::Binding::Value") {
+ $type = $value->type;
+ $value = $value->value;
+ } else {
+ $type = &Net::DBus::Binding::Message::TYPE_STRING;
+ }
+
+ #warn "Type $type value $value\n";
+
if (ref($value)) {
- if (ref($value) eq "Net::DBus::Binding::Value") {
- my $raw = $value->value;
-
- if ($value->type == &Net::DBus::Binding::Message::TYPE_BOOLEAN) {
- if (ref($raw) && ref($raw) eq "ARRAY") {
- $self->append_boolean_array($raw);
- } else {
- $self->append_boolean($raw);
- }
- } elsif ($value->type == &Net::DBus::Binding::Message::TYPE_BYTE) {
- if (ref($raw) && ref($raw) eq "ARRAY") {
- $self->append_byte_array($raw);
- } else {
- $self->append_byte($raw);
- }
- } elsif ($value->type == &Net::DBus::Binding::Message::TYPE_STRING) {
- if (ref($raw) && ref($raw) eq "ARRAY") {
- $self->append_string_array($raw);
- } else {
- $self->append_string($raw);
- }
- } elsif ($value->type == &Net::DBus::Binding::Message::TYPE_INT32) {
- if (ref($raw) && ref($raw) eq "ARRAY") {
- $self->append_int32_array($raw);
- } else {
- $self->append_int32($raw);
- }
- } elsif ($value->type == &Net::DBus::Binding::Message::TYPE_UINT32) {
- if (ref($raw) && ref($raw) eq "ARRAY") {
- $self->append_uint32_array($raw);
- } else {
- $self->append_uint32($raw);
- }
- } elsif ($value->type == &Net::DBus::Binding::Message::TYPE_INT64) {
- if (ref($raw) && ref($raw) eq "ARRAY") {
- $self->append_int64_array($raw);
- } else {
- $self->append_int64($raw);
- }
- } elsif ($value->type == &Net::DBus::Binding::Message::TYPE_UINT64) {
- if (ref($raw) && ref($raw) eq "ARRAY") {
- $self->append_uint64_array($raw);
- } else {
- $self->append_uint64($raw);
- }
- } elsif ($value->type == &Net::DBus::Binding::Message::TYPE_DOUBLE) {
- if (ref($raw) && ref($raw) eq "ARRAY") {
- $self->append_double_array($raw);
- } else {
- $self->append_double($raw);
- }
- }
- } elsif (ref($value) eq "HASH") {
- my $iter = $self->append_dict();
- foreach my $key (keys %{$value}) {
- $iter->append_dict_key($key);
- $iter->append($value->{$key});
- }
+ if (ref($value) eq "HASH") {
+ $self->append_dict($value);
} elsif (ref($value) eq "ARRAY") {
- $self->append_string_array($value);
+ if ($type == &Net::DBus::Binding::Message::TYPE_STRUCT) {
+ $self->append_struct($value);
+ } else {
+ $self->append_array($value, $type);
+ }
} else {
confess "Unsupported reference type ", ref($value);
}
} else {
- $self->append_string($value);
+ if ($type == &Net::DBus::Binding::Message::TYPE_BOOLEAN) {
+ $self->append_boolean($value);
+ } elsif ($type == &Net::DBus::Binding::Message::TYPE_BYTE) {
+ $self->append_byte($value);
+ } elsif ($type == &Net::DBus::Binding::Message::TYPE_STRING) {
+ $self->append_string($value);
+ } elsif ($type == &Net::DBus::Binding::Message::TYPE_INT32) {
+ $self->append_int32($value);
+ } elsif ($type == &Net::DBus::Binding::Message::TYPE_UINT32) {
+ $self->append_uint32($value);
+ } elsif ($type == &Net::DBus::Binding::Message::TYPE_INT64) {
+ $self->append_int64($value);
+ } elsif ($type == &Net::DBus::Binding::Message::TYPE_UINT64) {
+ $self->append_uint64($value);
+ } elsif ($type == &Net::DBus::Binding::Message::TYPE_DOUBLE) {
+ $self->append_double($value);
+ } else {
+ $self->append_string($value);
+ }
+ }
+}
+
+
+sub append_array {
+ my $self = shift;
+ my $array = shift;
+ my $type = shift;
+
+ my $sig = chr($type);
+ my $iter = $self->_open_container(&Net::DBus::Binding::Message::TYPE_ARRAY, $sig);
+
+ foreach my $value (@{$array}) {
+ $iter->append($value, $type);
+ }
+
+ $self->_close_container($iter);
+}
+
+
+sub append_struct {
+ my $self = shift;
+ my $struct = shift;
+
+ my $iter = $self->_open_container(&Net::DBus::Binding::Message::TYPE_STRUCT, undef);
+
+ foreach my $value (@{$struct}) {
+ $iter->append($value);
+ }
+
+ $self->_close_container($iter);
+}
+
+
+sub append_dict {
+ my $self = shift;
+ my $hash = shift;
+
+ # XXX don't hardcode me - cf Python bindings
+ my $sig = "{ss}";
+ my $iter = $self->_open_container(&Net::DBus::Binding::Message::TYPE_ARRAY, $sig);
+
+ foreach my $key (keys %{$hash}) {
+ my $value = $hash->{$key};
+
+ my $entry = $iter->_open_container(&Net::DBus::Binding::Message::TYPE_DICT_ENTRY, $sig);
+ $entry->append($key);
+ $entry->append($value);
+ $iter->_close_container($entry);
}
+ $self->_close_container($iter);
}
1;
diff --git a/lib/Net/DBus/Binding/Message.pm b/lib/Net/DBus/Binding/Message.pm
index 8c08bd6..7c4fbe5 100644
--- a/lib/Net/DBus/Binding/Message.pm
+++ b/lib/Net/DBus/Binding/Message.pm
@@ -131,8 +131,13 @@ an instance of the C<Net::DBus::Binding::Iterator> class.
sub iterator {
my $self = shift;
+ my $append = @_ ? shift : 0;
- return Net::DBus::Binding::Message::_iterator($self->{message});
+ if ($append) {
+ return Net::DBus::Binding::Message::_iterator_append($self->{message});
+ } else {
+ return Net::DBus::Binding::Message::_iterator($self->{message});
+ }
}
diff --git a/lib/Net/DBus/Callback.pm b/lib/Net/DBus/Callback.pm
index 56a243a..7fc0cd8 100644
--- a/lib/Net/DBus/Callback.pm
+++ b/lib/Net/DBus/Callback.pm
@@ -29,11 +29,11 @@ sub invoke {
if ($self->{object}) {
my $obj = $self->{object};
my $method = $self->{method};
-
+
$obj->$method(@{$self->{args}});
} else {
my $method = $self->{method};
-
+
&$method(@{$self->{args}});
}
}
diff --git a/lib/Net/DBus/Object.pm b/lib/Net/DBus/Object.pm
index a9aa21b..1ee77dc 100644
--- a/lib/Net/DBus/Object.pm
+++ b/lib/Net/DBus/Object.pm
@@ -42,7 +42,7 @@ sub emit_signal {
my $signal = Net::DBus::Binding::Message::Signal->new(object_path => $self->{object_path},
interface => $interface,
signal_name => $signal_name);
- my $iter = $signal->iterator;
+ my $iter = $signal->iterator(1);
foreach my $ret (@_) {
$iter->append($ret);
}
@@ -69,10 +69,10 @@ sub _dispatch {
} else {
$reply = Net::DBus::Binding::Message::MethodReturn->new(call => $message);
if (@ret == 1) {
- my $iter = $reply->iterator;
+ my $iter = $reply->iterator(1);
$iter->append(shift @ret);
} elsif (@ret > 1) {
- my $iter = $reply->iterator;
+ my $iter = $reply->iterator(1);
foreach my $ret (@ret) {
$iter->append($ret);
}
diff --git a/lib/Net/DBus/RemoteObject.pm b/lib/Net/DBus/RemoteObject.pm
index 6715f49..78ffbca 100644
--- a/lib/Net/DBus/RemoteObject.pm
+++ b/lib/Net/DBus/RemoteObject.pm
@@ -54,7 +54,7 @@ sub AUTOLOAD {
method_name => $method,
interface => $self->{interface});
- my $iter = $call->iterator;
+ my $iter = $call->iterator(1);
foreach my $arg (@_) {
$iter->append($arg);
}
diff --git a/lib/Net/DBus/Service.pm b/lib/Net/DBus/Service.pm
index 9de04ec..6ddd253 100644
--- a/lib/Net/DBus/Service.pm
+++ b/lib/Net/DBus/Service.pm
@@ -10,7 +10,7 @@ sub new {
bless $self, $class;
- $self->{bus}->get_connection()->acquire_service($self->{service_name});
+ $self->{bus}->get_connection()->request_name($self->{service_name});
return $self;
}
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-perl/packages/libnet-dbus-perl.git
More information about the Pkg-perl-cvs-commits
mailing list