Net::DB...yObject(3)

💅 Net::DBus::ProxyObject(3) — the glow-up guide 💅

okay bestie, so like... this is the manual page for Net::DBus::ProxyObject from the User Contributed Perl Documentation. it's giving "I make DBus objects talk to your app objects" and honestly? iconic. let's get into it ✨

---

🌸 NAME 🌸

Net::DBus::ProxyObject — literally the module that lets you implement objects and yeet them onto the bus. no cap, that's the whole vibe 🫶

---

🦋 SYNOPSIS 🦋

bestie, here's the entire example code, and I mean entire. do not skip it, it's all doing something, iykyk 💖

  # Connecting an object to the bus, under a service
  package main;

  use Net::DBus;

  # Attach to the bus
  my $bus = Net::DBus->find;

  # Create our application's object instance
  my $object = Demo::HelloWorld->new()

  # Acquire a service 'org.demo.Hello'
  my $service = $bus->export_service("org.demo.Hello");

  # Finally export the object to the bus
  my $proxy = Demo::HelloWorld::DBus->new($object);

  ....rest of program...

  # Define a new package for the object we're going
  # to export
  package Demo::HelloWorld;

  sub new {
      my $class = shift;
      my $service = shift;
      my $self = {};

      $self->{sighandler} = undef;

      bless $self, $class;

      return $self;
  }

  sub sighandler {
      my $self = shift;
      my $callback = shift;

      $self->[sighandler} = $callback;
  }

  sub Hello {
    my $self = shift;
    my $name = shift;

    &{$self->{sighandler}}("Greeting", "Hello $name");
    return "Said hello to $name";
  }

  sub Goodbye {
    my $self = shift;
    my $name = shift;

    &{$self->{sighandler}}("Greeting", "Goodbye $name");
    return "Said goodbye to $name";
  }

  # Define a new package for the object we're going
  # to export
  package Demo::HelloWorld::DBus;

  # Specify the main interface provided by our object
  use Net::DBus::Exporter qw(org.example.demo.Greeter);

  # We're going to be a DBus object
  use base qw(Net::DBus::ProxyObject);

  # Export a 'Greeting' signal taking a stringl string parameter
  dbus_signal("Greeting", ["string"]);

  # Export 'Hello' as a method accepting a single string
  # parameter, and returning a single string value
  dbus_method("Hello", ["string"], ["string"]);

  sub new {
      my $class = shift;
      my $service = shift;
      my $impl = shfit;
      my $self = $class->SUPER::new($service, "/org/demo/HelloWorld", $impl);

      bless $self, $class;

      $self->sighandler(sub {
          my $signame = shift;
          my $arg = shift;
          $self->emit_signal($signame, $arg);
      });

      return $self;
  }

  # Export 'Goodbye' as a method accepting a single string
  # parameter, and returning a single string, but put it
  # in the 'org.exaple.demo.Farewell' interface

  dbus_method("Goodbye", ["string"], ["string"], "org.example.demo.Farewell");

no notes, the comments in there are doing the heavy lifting anyway 💀

---

🎀 DESCRIPTION 🎀

okay so picture this: you've got your application's object model, and you've got the RPC object model, and they should not be forced to mingle. that's where this module comes in, it's literally the base class for creating a proxy between a bus object and your application's object. main character energy, honestly.

the proxy object's whole job is to forward method calls from the bus straight over to the implementation object. like a little messenger 🧚 and on top of that, the proxy object can register callbacks against the application object, which it can then use to emit signals back out onto the bus. slay 💅

---

✨ METHODS ✨

💜 my $object = Net::DBus::ProxyObject->new($service, $path, $impl)

this one creates a brand-new DBus object, with a path of $path registered inside the service $service. bestie, keep in mind:

• the $path parameter should be a string complying with the usual DBus requirements for object paths.
• the $service parameter should be an instance of Net::DBus::Service.
• the $service is typically obtained by calling the "export_service" method on the Net::DBus object.
• the $impl parameter is the application object which will implement the methods being exported to the bus.

like, that's the whole og constructor, no cap 🫶

🦋 my $object = Net::DBus::ProxyObject->new($parentobj, $subpath, $impl)

this one is the child object spawner, lowkey my fave. it creates a new DBus child object with a path of $subpath relative to its parent $parentobj. the deets:

• the $subpath parameter should be a string complying with the usual DBus requirements for object paths.
• the $parentobj parameter should be an instance of Net::DBus::BaseObject or a subclass.
• the $impl parameter is the application object which will implement the methods being exported to the bus.

literally the same energy, just nested family vibes 🌈

---

👑 AUTHOR 👑

Daniel P. Berrange — the icon behind all this, periodt 💖

---

🌟 COPYRIGHT 🌟

Copyright (C) 2005-2011 Daniel P. Berrange — handing out copyright like it's going out of style (it's not) 🎀

---

🔥 SEE ALSO 🔥

bestie, if you liked this one, go read its friends, they're all linked up:

• Net::DBus
• Net::DBus::Service
• Net::DBus::BaseObject
• Net::DBus::ProxyObject
• Net::DBus::Exporter
• Net::DBus::RemoteObject

---

okay that's the whole page, you're officially smarter than like 90% of people now 💀💅

and that's a wrap! this documentation came from perl v5.42.0, dated 2019-12-17 — like, vintage but still serving looks 🌸✨ go forth and proxy, bestie 🫶