From a4cadd50e661871c819f9f253f3595cfba647aed Mon Sep 17 00:00:00 2001 From: Mika Laitio Date: Sat, 2 Oct 2010 13:49:53 +0300 Subject: [PATCH 1/1] initial version --- .cproject | 210 ++++++ .project | 78 +++ AUTHORS | 1 + COPYING | 165 +++++ ChangeLog | 0 INSTALL | 365 ++++++++++ LICENSE.txt | 5 + Makefile.am | 27 + NEWS | 0 README | 30 + autobuild.sh | 12 + configure.ac | 33 + libplpbus.pc.in | 11 + src/Makefile.am | 15 + src/idl/RequestResponseBus.hh | 625 +++++++++++++++++ src/idl/RequestResponseBus.idl | 40 ++ src/idl/RequestResponseBusDynSK.cc | 270 ++++++++ src/idl/RequestResponseBusSK.cc | 1012 ++++++++++++++++++++++++++++ src/plpbus/BusClient.cc | 242 +++++++ src/plpbus/BusClient.hh | 54 ++ src/plpbus/BusMessage.cc | 223 ++++++ src/plpbus/BusMessage.hh | 36 + src/plpbus/BusMessageInternal.cc | 19 + src/plpbus/BusMessageInternal.hh | 22 + src/plpbus/BusServer.cc | 43 ++ src/plpbus/BusServer.hh | 25 + src/plpbus/ClientServerCommon.cc | 21 + src/plpbus/ClientServerCommon.hh | 30 + src/plpbus/IClientListener.hh | 26 + src/plpbus/IServerListener.hh | 24 + src/plpbus/OrbServerImpl.cc | 351 ++++++++++ src/plpbus/OrbServerImpl.hh | 60 ++ src/plpbus/RequestResponseBus.hh | 625 +++++++++++++++++ src/plpbus/RequestResponseBusSK.cc | 1012 ++++++++++++++++++++++++++++ src/plpbus/ServerEventThread.cc | 42 ++ src/plpbus/ServerEventThread.hh | 34 + src_test/Makefile.am | 16 + src_test/test_admin.cc | 21 + src_test/test_client.cc | 90 +++ src_test/test_server.cc | 46 ++ 40 files changed, 5961 insertions(+) create mode 100644 .cproject create mode 100644 .project create mode 100644 AUTHORS create mode 100644 COPYING create mode 100644 ChangeLog create mode 100644 INSTALL create mode 100644 LICENSE.txt create mode 100644 Makefile.am create mode 100644 NEWS create mode 100644 README create mode 100755 autobuild.sh create mode 100644 configure.ac create mode 100644 libplpbus.pc.in create mode 100644 src/Makefile.am create mode 100644 src/idl/RequestResponseBus.hh create mode 100644 src/idl/RequestResponseBus.idl create mode 100644 src/idl/RequestResponseBusDynSK.cc create mode 100644 src/idl/RequestResponseBusSK.cc create mode 100644 src/plpbus/BusClient.cc create mode 100644 src/plpbus/BusClient.hh create mode 100644 src/plpbus/BusMessage.cc create mode 100644 src/plpbus/BusMessage.hh create mode 100644 src/plpbus/BusMessageInternal.cc create mode 100644 src/plpbus/BusMessageInternal.hh create mode 100644 src/plpbus/BusServer.cc create mode 100644 src/plpbus/BusServer.hh create mode 100644 src/plpbus/ClientServerCommon.cc create mode 100644 src/plpbus/ClientServerCommon.hh create mode 100644 src/plpbus/IClientListener.hh create mode 100644 src/plpbus/IServerListener.hh create mode 100644 src/plpbus/OrbServerImpl.cc create mode 100644 src/plpbus/OrbServerImpl.hh create mode 100644 src/plpbus/RequestResponseBus.hh create mode 100644 src/plpbus/RequestResponseBusSK.cc create mode 100644 src/plpbus/ServerEventThread.cc create mode 100644 src/plpbus/ServerEventThread.hh create mode 100644 src_test/Makefile.am create mode 100644 src_test/test_admin.cc create mode 100644 src_test/test_client.cc create mode 100644 src_test/test_server.cc diff --git a/.cproject b/.cproject new file mode 100644 index 0000000..516feb4 --- /dev/null +++ b/.cproject @@ -0,0 +1,210 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/.project b/.project new file mode 100644 index 0000000..f3fc707 --- /dev/null +++ b/.project @@ -0,0 +1,78 @@ + + + libplpbus + + + + + + org.eclipse.cdt.managedbuilder.core.genmakebuilder + clean,full,incremental, + + + ?name? + + + + org.eclipse.cdt.make.core.append_environment + true + + + org.eclipse.cdt.make.core.autoBuildTarget + all + + + org.eclipse.cdt.make.core.buildArguments + + + + org.eclipse.cdt.make.core.buildCommand + make + + + org.eclipse.cdt.make.core.cleanBuildTarget + clean + + + org.eclipse.cdt.make.core.contents + org.eclipse.cdt.make.core.activeConfigSettings + + + org.eclipse.cdt.make.core.enableAutoBuild + false + + + org.eclipse.cdt.make.core.enableCleanBuild + true + + + org.eclipse.cdt.make.core.enableFullBuild + true + + + org.eclipse.cdt.make.core.fullBuildTarget + all + + + org.eclipse.cdt.make.core.stopOnError + true + + + org.eclipse.cdt.make.core.useDefaultBuildCmd + true + + + + + org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder + + + + + + org.eclipse.cdt.core.cnature + org.eclipse.cdt.core.ccnature + org.eclipse.cdt.managedbuilder.core.managedBuildNature + org.eclipse.cdt.managedbuilder.core.ScannerConfigNature + + diff --git a/AUTHORS b/AUTHORS new file mode 100644 index 0000000..0af34e6 --- /dev/null +++ b/AUTHORS @@ -0,0 +1 @@ +Mika Laitio diff --git a/COPYING b/COPYING new file mode 100644 index 0000000..b2f02dd --- /dev/null +++ b/COPYING @@ -0,0 +1,165 @@ + GNU LESSER GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + + This version of the GNU Lesser General Public License incorporates +the terms and conditions of version 3 of the GNU General Public +License, supplemented by the additional permissions listed below. + + 0. Additional Definitions. + + As used herein, "this License" refers to version 3 of the GNU Lesser +General Public License, and the "GNU GPL" refers to version 3 of the GNU +General Public License. + + "The Library" refers to a covered work governed by this License, +other than an Application or a Combined Work as defined below. + + An "Application" is any work that makes use of an interface provided +by the Library, but which is not otherwise based on the Library. +Defining a subclass of a class defined by the Library is deemed a mode +of using an interface provided by the Library. + + A "Combined Work" is a work produced by combining or linking an +Application with the Library. The particular version of the Library +with which the Combined Work was made is also called the "Linked +Version". + + The "Minimal Corresponding Source" for a Combined Work means the +Corresponding Source for the Combined Work, excluding any source code +for portions of the Combined Work that, considered in isolation, are +based on the Application, and not on the Linked Version. + + The "Corresponding Application Code" for a Combined Work means the +object code and/or source code for the Application, including any data +and utility programs needed for reproducing the Combined Work from the +Application, but excluding the System Libraries of the Combined Work. + + 1. Exception to Section 3 of the GNU GPL. + + You may convey a covered work under sections 3 and 4 of this License +without being bound by section 3 of the GNU GPL. + + 2. Conveying Modified Versions. + + If you modify a copy of the Library, and, in your modifications, a +facility refers to a function or data to be supplied by an Application +that uses the facility (other than as an argument passed when the +facility is invoked), then you may convey a copy of the modified +version: + + a) under this License, provided that you make a good faith effort to + ensure that, in the event an Application does not supply the + function or data, the facility still operates, and performs + whatever part of its purpose remains meaningful, or + + b) under the GNU GPL, with none of the additional permissions of + this License applicable to that copy. + + 3. Object Code Incorporating Material from Library Header Files. + + The object code form of an Application may incorporate material from +a header file that is part of the Library. You may convey such object +code under terms of your choice, provided that, if the incorporated +material is not limited to numerical parameters, data structure +layouts and accessors, or small macros, inline functions and templates +(ten or fewer lines in length), you do both of the following: + + a) Give prominent notice with each copy of the object code that the + Library is used in it and that the Library and its use are + covered by this License. + + b) Accompany the object code with a copy of the GNU GPL and this license + document. + + 4. Combined Works. + + You may convey a Combined Work under terms of your choice that, +taken together, effectively do not restrict modification of the +portions of the Library contained in the Combined Work and reverse +engineering for debugging such modifications, if you also do each of +the following: + + a) Give prominent notice with each copy of the Combined Work that + the Library is used in it and that the Library and its use are + covered by this License. + + b) Accompany the Combined Work with a copy of the GNU GPL and this license + document. + + c) For a Combined Work that displays copyright notices during + execution, include the copyright notice for the Library among + these notices, as well as a reference directing the user to the + copies of the GNU GPL and this license document. + + d) Do one of the following: + + 0) Convey the Minimal Corresponding Source under the terms of this + License, and the Corresponding Application Code in a form + suitable for, and under terms that permit, the user to + recombine or relink the Application with a modified version of + the Linked Version to produce a modified Combined Work, in the + manner specified by section 6 of the GNU GPL for conveying + Corresponding Source. + + 1) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (a) uses at run time + a copy of the Library already present on the user's computer + system, and (b) will operate properly with a modified version + of the Library that is interface-compatible with the Linked + Version. + + e) Provide Installation Information, but only if you would otherwise + be required to provide such information under section 6 of the + GNU GPL, and only to the extent that such information is + necessary to install and execute a modified version of the + Combined Work produced by recombining or relinking the + Application with a modified version of the Linked Version. (If + you use option 4d0, the Installation Information must accompany + the Minimal Corresponding Source and Corresponding Application + Code. If you use option 4d1, you must provide the Installation + Information in the manner specified by section 6 of the GNU GPL + for conveying Corresponding Source.) + + 5. Combined Libraries. + + You may place library facilities that are a work based on the +Library side by side in a single library together with other library +facilities that are not Applications and are not covered by this +License, and convey such a combined library under terms of your +choice, if you do both of the following: + + a) Accompany the combined library with a copy of the same work based + on the Library, uncombined with any other library facilities, + conveyed under the terms of this License. + + b) Give prominent notice with the combined library that part of it + is a work based on the Library, and explaining where to find the + accompanying uncombined form of the same work. + + 6. Revised Versions of the GNU Lesser General Public License. + + The Free Software Foundation may publish revised and/or new versions +of the GNU Lesser General Public License from time to time. Such new +versions will be similar in spirit to the present version, but may +differ in detail to address new problems or concerns. + + Each version is given a distinguishing version number. If the +Library as you received it specifies that a certain numbered version +of the GNU Lesser General Public License "or any later version" +applies to it, you have the option of following the terms and +conditions either of that published version or of any later version +published by the Free Software Foundation. If the Library as you +received it does not specify a version number of the GNU Lesser +General Public License, you may choose any version of the GNU Lesser +General Public License ever published by the Free Software Foundation. + + If the Library as you received it specifies that a proxy can decide +whether future versions of the GNU Lesser General Public License shall +apply, that proxy's public statement of acceptance of any version is +permanent authorization for you to choose that version for the +Library. diff --git a/ChangeLog b/ChangeLog new file mode 100644 index 0000000..e69de29 diff --git a/INSTALL b/INSTALL new file mode 100644 index 0000000..7d1c323 --- /dev/null +++ b/INSTALL @@ -0,0 +1,365 @@ +Installation Instructions +************************* + +Copyright (C) 1994, 1995, 1996, 1999, 2000, 2001, 2002, 2004, 2005, +2006, 2007, 2008, 2009 Free Software Foundation, Inc. + + Copying and distribution of this file, with or without modification, +are permitted in any medium without royalty provided the copyright +notice and this notice are preserved. This file is offered as-is, +without warranty of any kind. + +Basic Installation +================== + + Briefly, the shell commands `./configure; make; make install' should +configure, build, and install this package. The following +more-detailed instructions are generic; see the `README' file for +instructions specific to this package. Some packages provide this +`INSTALL' file but do not implement all of the features documented +below. The lack of an optional feature in a given package is not +necessarily a bug. More recommendations for GNU packages can be found +in *note Makefile Conventions: (standards)Makefile Conventions. + + The `configure' shell script attempts to guess correct values for +various system-dependent variables used during compilation. It uses +those values to create a `Makefile' in each directory of the package. +It may also create one or more `.h' files containing system-dependent +definitions. Finally, it creates a shell script `config.status' that +you can run in the future to recreate the current configuration, and a +file `config.log' containing compiler output (useful mainly for +debugging `configure'). + + It can also use an optional file (typically called `config.cache' +and enabled with `--cache-file=config.cache' or simply `-C') that saves +the results of its tests to speed up reconfiguring. Caching is +disabled by default to prevent problems with accidental use of stale +cache files. + + If you need to do unusual things to compile the package, please try +to figure out how `configure' could check whether to do them, and mail +diffs or instructions to the address given in the `README' so they can +be considered for the next release. If you are using the cache, and at +some point `config.cache' contains results you don't want to keep, you +may remove or edit it. + + The file `configure.ac' (or `configure.in') is used to create +`configure' by a program called `autoconf'. You need `configure.ac' if +you want to change it or regenerate `configure' using a newer version +of `autoconf'. + + The simplest way to compile this package is: + + 1. `cd' to the directory containing the package's source code and type + `./configure' to configure the package for your system. + + Running `configure' might take a while. While running, it prints + some messages telling which features it is checking for. + + 2. Type `make' to compile the package. + + 3. Optionally, type `make check' to run any self-tests that come with + the package, generally using the just-built uninstalled binaries. + + 4. Type `make install' to install the programs and any data files and + documentation. When installing into a prefix owned by root, it is + recommended that the package be configured and built as a regular + user, and only the `make install' phase executed with root + privileges. + + 5. Optionally, type `make installcheck' to repeat any self-tests, but + this time using the binaries in their final installed location. + This target does not install anything. Running this target as a + regular user, particularly if the prior `make install' required + root privileges, verifies that the installation completed + correctly. + + 6. You can remove the program binaries and object files from the + source code directory by typing `make clean'. To also remove the + files that `configure' created (so you can compile the package for + a different kind of computer), type `make distclean'. There is + also a `make maintainer-clean' target, but that is intended mainly + for the package's developers. If you use it, you may have to get + all sorts of other programs in order to regenerate files that came + with the distribution. + + 7. Often, you can also type `make uninstall' to remove the installed + files again. In practice, not all packages have tested that + uninstallation works correctly, even though it is required by the + GNU Coding Standards. + + 8. Some packages, particularly those that use Automake, provide `make + distcheck', which can by used by developers to test that all other + targets like `make install' and `make uninstall' work correctly. + This target is generally not run by end users. + +Compilers and Options +===================== + + Some systems require unusual options for compilation or linking that +the `configure' script does not know about. Run `./configure --help' +for details on some of the pertinent environment variables. + + You can give `configure' initial values for configuration parameters +by setting variables in the command line or in the environment. Here +is an example: + + ./configure CC=c99 CFLAGS=-g LIBS=-lposix + + *Note Defining Variables::, for more details. + +Compiling For Multiple Architectures +==================================== + + You can compile the package for more than one kind of computer at the +same time, by placing the object files for each architecture in their +own directory. To do this, you can use GNU `make'. `cd' to the +directory where you want the object files and executables to go and run +the `configure' script. `configure' automatically checks for the +source code in the directory that `configure' is in and in `..'. This +is known as a "VPATH" build. + + With a non-GNU `make', it is safer to compile the package for one +architecture at a time in the source code directory. After you have +installed the package for one architecture, use `make distclean' before +reconfiguring for another architecture. + + On MacOS X 10.5 and later systems, you can create libraries and +executables that work on multiple system types--known as "fat" or +"universal" binaries--by specifying multiple `-arch' options to the +compiler but only a single `-arch' option to the preprocessor. Like +this: + + ./configure CC="gcc -arch i386 -arch x86_64 -arch ppc -arch ppc64" \ + CXX="g++ -arch i386 -arch x86_64 -arch ppc -arch ppc64" \ + CPP="gcc -E" CXXCPP="g++ -E" + + This is not guaranteed to produce working output in all cases, you +may have to build one architecture at a time and combine the results +using the `lipo' tool if you have problems. + +Installation Names +================== + + By default, `make install' installs the package's commands under +`/usr/local/bin', include files under `/usr/local/include', etc. You +can specify an installation prefix other than `/usr/local' by giving +`configure' the option `--prefix=PREFIX', where PREFIX must be an +absolute file name. + + You can specify separate installation prefixes for +architecture-specific files and architecture-independent files. If you +pass the option `--exec-prefix=PREFIX' to `configure', the package uses +PREFIX as the prefix for installing programs and libraries. +Documentation and other data files still use the regular prefix. + + In addition, if you use an unusual directory layout you can give +options like `--bindir=DIR' to specify different values for particular +kinds of files. Run `configure --help' for a list of the directories +you can set and what kinds of files go in them. In general, the +default for these options is expressed in terms of `${prefix}', so that +specifying just `--prefix' will affect all of the other directory +specifications that were not explicitly provided. + + The most portable way to affect installation locations is to pass the +correct locations to `configure'; however, many packages provide one or +both of the following shortcuts of passing variable assignments to the +`make install' command line to change installation locations without +having to reconfigure or recompile. + + The first method involves providing an override variable for each +affected directory. For example, `make install +prefix=/alternate/directory' will choose an alternate location for all +directory configuration variables that were expressed in terms of +`${prefix}'. Any directories that were specified during `configure', +but not in terms of `${prefix}', must each be overridden at install +time for the entire installation to be relocated. The approach of +makefile variable overrides for each directory variable is required by +the GNU Coding Standards, and ideally causes no recompilation. +However, some platforms have known limitations with the semantics of +shared libraries that end up requiring recompilation when using this +method, particularly noticeable in packages that use GNU Libtool. + + The second method involves providing the `DESTDIR' variable. For +example, `make install DESTDIR=/alternate/directory' will prepend +`/alternate/directory' before all installation names. The approach of +`DESTDIR' overrides is not required by the GNU Coding Standards, and +does not work on platforms that have drive letters. On the other hand, +it does better at avoiding recompilation issues, and works well even +when some directory options were not specified in terms of `${prefix}' +at `configure' time. + +Optional Features +================= + + If the package supports it, you can cause programs to be installed +with an extra prefix or suffix on their names by giving `configure' the +option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'. + + Some packages pay attention to `--enable-FEATURE' options to +`configure', where FEATURE indicates an optional part of the package. +They may also pay attention to `--with-PACKAGE' options, where PACKAGE +is something like `gnu-as' or `x' (for the X Window System). The +`README' should mention any `--enable-' and `--with-' options that the +package recognizes. + + For packages that use the X Window System, `configure' can usually +find the X include and library files automatically, but if it doesn't, +you can use the `configure' options `--x-includes=DIR' and +`--x-libraries=DIR' to specify their locations. + + Some packages offer the ability to configure how verbose the +execution of `make' will be. For these packages, running `./configure +--enable-silent-rules' sets the default to minimal output, which can be +overridden with `make V=1'; while running `./configure +--disable-silent-rules' sets the default to verbose, which can be +overridden with `make V=0'. + +Particular systems +================== + + On HP-UX, the default C compiler is not ANSI C compatible. If GNU +CC is not installed, it is recommended to use the following options in +order to use an ANSI C compiler: + + ./configure CC="cc -Ae -D_XOPEN_SOURCE=500" + +and if that doesn't work, install pre-built binaries of GCC for HP-UX. + + On OSF/1 a.k.a. Tru64, some versions of the default C compiler cannot +parse its `' header file. The option `-nodtk' can be used as +a workaround. If GNU CC is not installed, it is therefore recommended +to try + + ./configure CC="cc" + +and if that doesn't work, try + + ./configure CC="cc -nodtk" + + On Solaris, don't put `/usr/ucb' early in your `PATH'. This +directory contains several dysfunctional programs; working variants of +these programs are available in `/usr/bin'. So, if you need `/usr/ucb' +in your `PATH', put it _after_ `/usr/bin'. + + On Haiku, software installed for all users goes in `/boot/common', +not `/usr/local'. It is recommended to use the following options: + + ./configure --prefix=/boot/common + +Specifying the System Type +========================== + + There may be some features `configure' cannot figure out +automatically, but needs to determine by the type of machine the package +will run on. Usually, assuming the package is built to be run on the +_same_ architectures, `configure' can figure that out, but if it prints +a message saying it cannot guess the machine type, give it the +`--build=TYPE' option. TYPE can either be a short name for the system +type, such as `sun4', or a canonical name which has the form: + + CPU-COMPANY-SYSTEM + +where SYSTEM can have one of these forms: + + OS + KERNEL-OS + + See the file `config.sub' for the possible values of each field. If +`config.sub' isn't included in this package, then this package doesn't +need to know the machine type. + + If you are _building_ compiler tools for cross-compiling, you should +use the option `--target=TYPE' to select the type of system they will +produce code for. + + If you want to _use_ a cross compiler, that generates code for a +platform different from the build platform, you should specify the +"host" platform (i.e., that on which the generated programs will +eventually be run) with `--host=TYPE'. + +Sharing Defaults +================ + + If you want to set default values for `configure' scripts to share, +you can create a site shell script called `config.site' that gives +default values for variables like `CC', `cache_file', and `prefix'. +`configure' looks for `PREFIX/share/config.site' if it exists, then +`PREFIX/etc/config.site' if it exists. Or, you can set the +`CONFIG_SITE' environment variable to the location of the site script. +A warning: not all `configure' scripts look for a site script. + +Defining Variables +================== + + Variables not defined in a site shell script can be set in the +environment passed to `configure'. However, some packages may run +configure again during the build, and the customized values of these +variables may be lost. In order to avoid this problem, you should set +them in the `configure' command line, using `VAR=value'. For example: + + ./configure CC=/usr/local2/bin/gcc + +causes the specified `gcc' to be used as the C compiler (unless it is +overridden in the site shell script). + +Unfortunately, this technique does not work for `CONFIG_SHELL' due to +an Autoconf bug. Until the bug is fixed you can use this workaround: + + CONFIG_SHELL=/bin/bash /bin/bash ./configure CONFIG_SHELL=/bin/bash + +`configure' Invocation +====================== + + `configure' recognizes the following options to control how it +operates. + +`--help' +`-h' + Print a summary of all of the options to `configure', and exit. + +`--help=short' +`--help=recursive' + Print a summary of the options unique to this package's + `configure', and exit. The `short' variant lists options used + only in the top level, while the `recursive' variant lists options + also present in any nested packages. + +`--version' +`-V' + Print the version of Autoconf used to generate the `configure' + script, and exit. + +`--cache-file=FILE' + Enable the cache: use and save the results of the tests in FILE, + traditionally `config.cache'. FILE defaults to `/dev/null' to + disable caching. + +`--config-cache' +`-C' + Alias for `--cache-file=config.cache'. + +`--quiet' +`--silent' +`-q' + Do not print messages saying which checks are being made. To + suppress all normal output, redirect it to `/dev/null' (any error + messages will still be shown). + +`--srcdir=DIR' + Look for the package's source code in directory DIR. Usually + `configure' can determine that directory automatically. + +`--prefix=DIR' + Use DIR as the installation prefix. *note Installation Names:: + for more details, including other options available for fine-tuning + the installation locations. + +`--no-create' +`-n' + Run the configure checks, but stop before creating any output + files. + +`configure' also accepts some other, not widely useful, options. Run +`configure --help' for more details. + diff --git a/LICENSE.txt b/LICENSE.txt new file mode 100644 index 0000000..e180e8f --- /dev/null +++ b/LICENSE.txt @@ -0,0 +1,5 @@ +libplpbus is library for communication between processes in one or many different devices +Copyright (C) 2010 Mika Laitio +You can redistribute it and/or modify it under either the terms of the LGPL version 3 +(see COPYING.txt file), or by obtaining the license from the author. + diff --git a/Makefile.am b/Makefile.am new file mode 100644 index 0000000..b8e09b9 --- /dev/null +++ b/Makefile.am @@ -0,0 +1,27 @@ +SUBDIRS = src \ + src_test +pkgconfigdir = $(libdir)/pkgconfig +pkgconfig_DATA = libplpbus.pc +EXTRA_DIST = libplpbus.pc.in +DISTCLEANFILES = \ + aclocal.m4 \ + config.h \ + config.h.in \ + config.log \ + config.status \ + config.cache \ + config.guess \ + config.sub \ + configure \ + depcomp \ + install-sh \ + libtool \ + ltmain.sh \ + Makefile.in \ + Makefile \ + missing \ + stamp-h \ + stamp-h1 \ + compile \ + autom4te.cache \ + $(pkgconfig_DATA) \ No newline at end of file diff --git a/NEWS b/NEWS new file mode 100644 index 0000000..e69de29 diff --git a/README b/README new file mode 100644 index 0000000..8a1931b --- /dev/null +++ b/README @@ -0,0 +1,30 @@ +License +------- +GNU LESSER GENERAL PUBLIC LICENSE (lgpl) version 3, for details see the COPYING file + +Requirements +------------ +- install omniORB and omniORB development libraries (version 4.1.4 used while developing the initial version) +- start omniNames name server (if problems try to edit /etc/omniorb/omniORB.cfg + +Build, install and clean +------------------------ +- build with command: ./autobuild.sh (generates required autoconf files) +- install with command: make install +- clean source code from generated build files: make distclean + +howto run test application +-------------------------- +1) start omniOrb name service + #omniNames & +2) run server + src_test/test_server +2) run client + src_test/test_client + +howto build new version from idl +-------------------------------- +#cd src/idl +#omniidl -bcxx -Wba -Wbtp RequestResponseBus.idl +#copy generated files to src/plpbus directory + diff --git a/autobuild.sh b/autobuild.sh new file mode 100755 index 0000000..c318591 --- /dev/null +++ b/autobuild.sh @@ -0,0 +1,12 @@ +#!/bin/sh + +if ! [ -e Makefile ] ; +then + echo "No Makefile available, generating it." + libtoolize --automake --force --copy + autoreconf --force --install + PKG_CONFIG_PATH=/usr/local/lib/pkgconfig ./configure --prefix=/usr/local +else + echo "Makefile found, no need to generate it." +fi +make diff --git a/configure.ac b/configure.ac new file mode 100644 index 0000000..e3655ff --- /dev/null +++ b/configure.ac @@ -0,0 +1,33 @@ +AC_INIT(src/plpbus/BusServer.cc) +AM_CONFIG_HEADER(config.h) +AC_CONFIG_MACRO_DIR([m4]) + +PACKAGE=libplpbus +VERSION=1.0.0 + +CFLAGS="$CFLAGS -g -Wall -Werror" +LDFLAGS="$LDFLAGS" +AC_SUBST(CFLAGS) +AC_SUBST(LDFLAGS) +AC_MSG_NOTICE([objective c Makefile]) + +AM_INIT_AUTOMAKE($PACKAGE, $VERSION) + +AC_PROG_CXX +AC_STDC_HEADERS +AC_PROG_LIBTOOL +AC_PROG_INSTALL +AM_PROG_CC_C_O + +PKG_PROG_PKG_CONFIG() + +PKG_CHECK_MODULES(SRC, omniDynamic4) +AC_SUBST(SRC_CFLAGS) +AC_SUBST(SRC_LIBS) + +AC_OUTPUT([ +libplpbus.pc +Makefile +src/Makefile +src_test/Makefile +]) diff --git a/libplpbus.pc.in b/libplpbus.pc.in new file mode 100644 index 0000000..967a8af --- /dev/null +++ b/libplpbus.pc.in @@ -0,0 +1,11 @@ +prefix=@prefix@ +exec_prefix=@exec_prefix@ +libdir=@libdir@ +includedir=@includedir@ + +Name: libplpbus +Description: pilppa communication bus library +Version: @VERSION@ +Requires: +Cflags: -I${includedir} -I${includedir}/libplpbus +Libs: -L${libdir} diff --git a/src/Makefile.am b/src/Makefile.am new file mode 100644 index 0000000..2bb16d4 --- /dev/null +++ b/src/Makefile.am @@ -0,0 +1,15 @@ +lib_LTLIBRARIES = libplpbus.la +libplpbus_la_SOURCES = \ + idl/RequestResponseBusSK.cc idl/RequestResponseBus.hh \ + plpbus/BusMessage.cc plpbus/BusMessage.hh \ + plpbus/BusMessageInternal.cc plpbus/BusMessageInternal.hh \ + plpbus/ServerEventThread.cc plpbus/ServerEventThread.hh \ + plpbus/OrbServerImpl.cc plpbus/OrbServerImpl.hh \ + plpbus/BusServer.cc plpbus/BusServer.hh \ + plpbus/BusClient.cc plpbus/BusClient.hh \ + plpbus/IClientListener.hh \ + plpbus/IServerListener.hh +libplpbus_la_LDFLAGS = $(SRC_LIBS) $(all_libraries) -version-info 1:0:0 -no-undefined +AM_CPPFLAGS = $(SRC_CFLAGS) + +DISTCLEANFILES = Makefile.in diff --git a/src/idl/RequestResponseBus.hh b/src/idl/RequestResponseBus.hh new file mode 100644 index 0000000..ddebb17 --- /dev/null +++ b/src/idl/RequestResponseBus.hh @@ -0,0 +1,625 @@ +// This file is generated by omniidl (C++ backend)- omniORB_4_1. Do not edit. +#ifndef __RequestResponseBus_hh__ +#define __RequestResponseBus_hh__ + +#ifndef __CORBA_H_EXTERNAL_GUARD__ +#include +#endif + +#ifndef USE_stub_in_nt_dll +# define USE_stub_in_nt_dll_NOT_DEFINED_RequestResponseBus +#endif +#ifndef USE_core_stub_in_nt_dll +# define USE_core_stub_in_nt_dll_NOT_DEFINED_RequestResponseBus +#endif +#ifndef USE_dyn_stub_in_nt_dll +# define USE_dyn_stub_in_nt_dll_NOT_DEFINED_RequestResponseBus +#endif + + + + + + +#ifdef USE_stub_in_nt_dll +# ifndef USE_core_stub_in_nt_dll +# define USE_core_stub_in_nt_dll +# endif +# ifndef USE_dyn_stub_in_nt_dll +# define USE_dyn_stub_in_nt_dll +# endif +#endif + +#ifdef _core_attr +# error "A local CPP macro _core_attr has already been defined." +#else +# ifdef USE_core_stub_in_nt_dll +# define _core_attr _OMNIORB_NTDLL_IMPORT +# else +# define _core_attr +# endif +#endif + +#ifdef _dyn_attr +# error "A local CPP macro _dyn_attr has already been defined." +#else +# ifdef USE_dyn_stub_in_nt_dll +# define _dyn_attr _OMNIORB_NTDLL_IMPORT +# else +# define _dyn_attr +# endif +#endif + + + + + +_CORBA_MODULE plpbus_orb + +_CORBA_MODULE_BEG + + struct DataItem { + typedef _CORBA_ConstrType_Variable_Var _var_type; + + + ::CORBA::String_member name; + + ::CORBA::Any value; + + + + void operator>>= (cdrStream &) const; + void operator<<= (cdrStream &); + }; + + typedef DataItem::_var_type DataItem_var; + + typedef _CORBA_ConstrType_Variable_OUT_arg< DataItem,DataItem_var > DataItem_out; + + _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DataItem; + + _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DataItemSequence; + + class DataItemSequence_var; + + class DataItemSequence : public _CORBA_Unbounded_Sequence< DataItem > { + public: + typedef DataItemSequence_var _var_type; + inline DataItemSequence() {} + inline DataItemSequence(const DataItemSequence& _s) + : _CORBA_Unbounded_Sequence< DataItem > (_s) {} + + inline DataItemSequence(_CORBA_ULong _max) + : _CORBA_Unbounded_Sequence< DataItem > (_max) {} + inline DataItemSequence(_CORBA_ULong _max, _CORBA_ULong _len, DataItem* _val, _CORBA_Boolean _rel=0) + : _CORBA_Unbounded_Sequence< DataItem > (_max, _len, _val, _rel) {} + + + + inline DataItemSequence& operator = (const DataItemSequence& _s) { + _CORBA_Unbounded_Sequence< DataItem > ::operator=(_s); + return *this; + } + }; + + class DataItemSequence_out; + + class DataItemSequence_var { + public: + inline DataItemSequence_var() : _pd_seq(0) {} + inline DataItemSequence_var(DataItemSequence* _s) : _pd_seq(_s) {} + inline DataItemSequence_var(const DataItemSequence_var& _s) { + if( _s._pd_seq ) _pd_seq = new DataItemSequence(*_s._pd_seq); + else _pd_seq = 0; + } + inline ~DataItemSequence_var() { if( _pd_seq ) delete _pd_seq; } + + inline DataItemSequence_var& operator = (DataItemSequence* _s) { + if( _pd_seq ) delete _pd_seq; + _pd_seq = _s; + return *this; + } + inline DataItemSequence_var& operator = (const DataItemSequence_var& _s) { + if( _s._pd_seq ) { + if( !_pd_seq ) _pd_seq = new DataItemSequence; + *_pd_seq = *_s._pd_seq; + } else if( _pd_seq ) { + delete _pd_seq; + _pd_seq = 0; + } + return *this; + } + inline DataItem& operator [] (_CORBA_ULong _s) { + return (*_pd_seq)[_s]; + } + + + + inline DataItemSequence* operator -> () { return _pd_seq; } + inline const DataItemSequence* operator -> () const { return _pd_seq; } +#if defined(__GNUG__) + inline operator DataItemSequence& () const { return *_pd_seq; } +#else + inline operator const DataItemSequence& () const { return *_pd_seq; } + inline operator DataItemSequence& () { return *_pd_seq; } +#endif + + inline const DataItemSequence& in() const { return *_pd_seq; } + inline DataItemSequence& inout() { return *_pd_seq; } + inline DataItemSequence*& out() { + if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; } + return _pd_seq; + } + inline DataItemSequence* _retn() { DataItemSequence* tmp = _pd_seq; _pd_seq = 0; return tmp; } + + friend class DataItemSequence_out; + + private: + DataItemSequence* _pd_seq; + }; + + class DataItemSequence_out { + public: + inline DataItemSequence_out(DataItemSequence*& _s) : _data(_s) { _data = 0; } + inline DataItemSequence_out(DataItemSequence_var& _s) + : _data(_s._pd_seq) { _s = (DataItemSequence*) 0; } + inline DataItemSequence_out(const DataItemSequence_out& _s) : _data(_s._data) {} + inline DataItemSequence_out& operator = (const DataItemSequence_out& _s) { + _data = _s._data; + return *this; + } + inline DataItemSequence_out& operator = (DataItemSequence* _s) { + _data = _s; + return *this; + } + inline operator DataItemSequence*&() { return _data; } + inline DataItemSequence*& ptr() { return _data; } + inline DataItemSequence* operator->() { return _data; } + + inline DataItem& operator [] (_CORBA_ULong _i) { + return (*_data)[_i]; + } + + + + DataItemSequence*& _data; + + private: + DataItemSequence_out(); + DataItemSequence_out& operator=(const DataItemSequence_var&); + }; + +#ifndef __plpbus__orb_mOrbClient__ +#define __plpbus__orb_mOrbClient__ + + class OrbClient; + class _objref_OrbClient; + class _impl_OrbClient; + + typedef _objref_OrbClient* OrbClient_ptr; + typedef OrbClient_ptr OrbClientRef; + + class OrbClient_Helper { + public: + typedef OrbClient_ptr _ptr_type; + + static _ptr_type _nil(); + static _CORBA_Boolean is_nil(_ptr_type); + static void release(_ptr_type); + static void duplicate(_ptr_type); + static void marshalObjRef(_ptr_type, cdrStream&); + static _ptr_type unmarshalObjRef(cdrStream&); + }; + + typedef _CORBA_ObjRef_Var<_objref_OrbClient, OrbClient_Helper> OrbClient_var; + typedef _CORBA_ObjRef_OUT_arg<_objref_OrbClient,OrbClient_Helper > OrbClient_out; + +#endif + + // interface OrbClient + class OrbClient { + public: + // Declarations for this interface type. + typedef OrbClient_ptr _ptr_type; + typedef OrbClient_var _var_type; + + static _ptr_type _duplicate(_ptr_type); + static _ptr_type _narrow(::CORBA::Object_ptr); + static _ptr_type _unchecked_narrow(::CORBA::Object_ptr); + + static _ptr_type _nil(); + + static inline void _marshalObjRef(_ptr_type, cdrStream&); + + static inline _ptr_type _unmarshalObjRef(cdrStream& s) { + omniObjRef* o = omniObjRef::_unMarshal(_PD_repoId,s); + if (o) + return (_ptr_type) o->_ptrToObjRef(_PD_repoId); + else + return _nil(); + } + + static _core_attr const char* _PD_repoId; + + // Other IDL defined within this scope. + + }; + + class _objref_OrbClient : + public virtual ::CORBA::Object, + public virtual omniObjRef + { + public: + void receive_event_message(const char* event_param); + void receive_event_dataitem_sequence(const ::plpbus_orb::DataItemSequence& event_param); + void receive_response_message(const char* msg_rsp_param); + void receive_response_dataitem_sequence(const ::plpbus_orb::DataItemSequence& msg_rsp_param); + + inline _objref_OrbClient() { _PR_setobj(0); } // nil + _objref_OrbClient(omniIOR*, omniIdentity*); + + protected: + virtual ~_objref_OrbClient(); + + + private: + virtual void* _ptrToObjRef(const char*); + + _objref_OrbClient(const _objref_OrbClient&); + _objref_OrbClient& operator = (const _objref_OrbClient&); + // not implemented + + friend class OrbClient; + }; + + class _pof_OrbClient : public _OMNI_NS(proxyObjectFactory) { + public: + inline _pof_OrbClient() : _OMNI_NS(proxyObjectFactory)(OrbClient::_PD_repoId) {} + virtual ~_pof_OrbClient(); + + virtual omniObjRef* newObjRef(omniIOR*,omniIdentity*); + virtual _CORBA_Boolean is_a(const char*) const; + }; + + class _impl_OrbClient : + public virtual omniServant + { + public: + virtual ~_impl_OrbClient(); + + virtual void receive_event_message(const char* event_param) = 0; + virtual void receive_event_dataitem_sequence(const ::plpbus_orb::DataItemSequence& event_param) = 0; + virtual void receive_response_message(const char* msg_rsp_param) = 0; + virtual void receive_response_dataitem_sequence(const ::plpbus_orb::DataItemSequence& msg_rsp_param) = 0; + + public: // Really protected, workaround for xlC + virtual _CORBA_Boolean _dispatch(omniCallHandle&); + + private: + virtual void* _ptrToInterface(const char*); + virtual const char* _mostDerivedRepoId(); + + }; + + + _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_OrbClient; + +#ifndef __plpbus__orb_mOrbServer__ +#define __plpbus__orb_mOrbServer__ + + class OrbServer; + class _objref_OrbServer; + class _impl_OrbServer; + + typedef _objref_OrbServer* OrbServer_ptr; + typedef OrbServer_ptr OrbServerRef; + + class OrbServer_Helper { + public: + typedef OrbServer_ptr _ptr_type; + + static _ptr_type _nil(); + static _CORBA_Boolean is_nil(_ptr_type); + static void release(_ptr_type); + static void duplicate(_ptr_type); + static void marshalObjRef(_ptr_type, cdrStream&); + static _ptr_type unmarshalObjRef(cdrStream&); + }; + + typedef _CORBA_ObjRef_Var<_objref_OrbServer, OrbServer_Helper> OrbServer_var; + typedef _CORBA_ObjRef_OUT_arg<_objref_OrbServer,OrbServer_Helper > OrbServer_out; + +#endif + + // interface OrbServer + class OrbServer { + public: + // Declarations for this interface type. + typedef OrbServer_ptr _ptr_type; + typedef OrbServer_var _var_type; + + static _ptr_type _duplicate(_ptr_type); + static _ptr_type _narrow(::CORBA::Object_ptr); + static _ptr_type _unchecked_narrow(::CORBA::Object_ptr); + + static _ptr_type _nil(); + + static inline void _marshalObjRef(_ptr_type, cdrStream&); + + static inline _ptr_type _unmarshalObjRef(cdrStream& s) { + omniObjRef* o = omniObjRef::_unMarshal(_PD_repoId,s); + if (o) + return (_ptr_type) o->_ptrToObjRef(_PD_repoId); + else + return _nil(); + } + + static _core_attr const char* _PD_repoId; + + // Other IDL defined within this scope. + + }; + + class _objref_OrbServer : + public virtual ::CORBA::Object, + public virtual omniObjRef + { + public: + void send_message_and_request_response(::plpbus_orb::OrbClient_ptr response_listener_param, const char* msg_param); + void send_dataitem_message_and_request_response(::plpbus_orb::OrbClient_ptr response_listener_param, const ::plpbus_orb::DataItemSequence& req_seq_param); + char* send_message_and_wait_response(const char* msg_req_param, ::CORBA::Long& err_flg); + ::CORBA::Long send_dataitem_message_and_wait_response(const ::plpbus_orb::DataItemSequence& req_seq_param, ::plpbus_orb::DataItemSequence_out rsp_seq_param); + void add_event_listener(::plpbus_orb::OrbClient_ptr callback_client_param, const char* msg_param, ::CORBA::UShort period_secs); + void shutdown(); + + inline _objref_OrbServer() { _PR_setobj(0); } // nil + _objref_OrbServer(omniIOR*, omniIdentity*); + + protected: + virtual ~_objref_OrbServer(); + + + private: + virtual void* _ptrToObjRef(const char*); + + _objref_OrbServer(const _objref_OrbServer&); + _objref_OrbServer& operator = (const _objref_OrbServer&); + // not implemented + + friend class OrbServer; + }; + + class _pof_OrbServer : public _OMNI_NS(proxyObjectFactory) { + public: + inline _pof_OrbServer() : _OMNI_NS(proxyObjectFactory)(OrbServer::_PD_repoId) {} + virtual ~_pof_OrbServer(); + + virtual omniObjRef* newObjRef(omniIOR*,omniIdentity*); + virtual _CORBA_Boolean is_a(const char*) const; + }; + + class _impl_OrbServer : + public virtual omniServant + { + public: + virtual ~_impl_OrbServer(); + + virtual void send_message_and_request_response(::plpbus_orb::OrbClient_ptr response_listener_param, const char* msg_param) = 0; + virtual void send_dataitem_message_and_request_response(::plpbus_orb::OrbClient_ptr response_listener_param, const ::plpbus_orb::DataItemSequence& req_seq_param) = 0; + virtual char* send_message_and_wait_response(const char* msg_req_param, ::CORBA::Long& err_flg) = 0; + virtual ::CORBA::Long send_dataitem_message_and_wait_response(const ::plpbus_orb::DataItemSequence& req_seq_param, ::plpbus_orb::DataItemSequence_out rsp_seq_param) = 0; + virtual void add_event_listener(::plpbus_orb::OrbClient_ptr callback_client_param, const char* msg_param, ::CORBA::UShort period_secs) = 0; + virtual void shutdown() = 0; + + public: // Really protected, workaround for xlC + virtual _CORBA_Boolean _dispatch(omniCallHandle&); + + private: + virtual void* _ptrToInterface(const char*); + virtual const char* _mostDerivedRepoId(); + + }; + + + _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_OrbServer; + +_CORBA_MODULE_END + + + +_CORBA_MODULE POA_plpbus_orb +_CORBA_MODULE_BEG + + class OrbClient : + public virtual plpbus_orb::_impl_OrbClient, + public virtual ::PortableServer::ServantBase + { + public: + virtual ~OrbClient(); + + inline ::plpbus_orb::OrbClient_ptr _this() { + return (::plpbus_orb::OrbClient_ptr) _do_this(::plpbus_orb::OrbClient::_PD_repoId); + } + }; + + template + class OrbClient_tie : public virtual OrbClient + { + public: + OrbClient_tie(_omniT& t) + : pd_obj(&t), pd_poa(0), pd_rel(0) {} + OrbClient_tie(_omniT& t, ::PortableServer::POA_ptr p) + : pd_obj(&t), pd_poa(p), pd_rel(0) {} + OrbClient_tie(_omniT* t, _CORBA_Boolean r=1) + : pd_obj(t), pd_poa(0), pd_rel(r) {} + OrbClient_tie(_omniT* t, ::PortableServer::POA_ptr p,_CORBA_Boolean r=1) + : pd_obj(t), pd_poa(p), pd_rel(r) {} + ~OrbClient_tie() { + if( pd_poa ) ::CORBA::release(pd_poa); + if( pd_rel ) delete pd_obj; + } + + _omniT* _tied_object() { return pd_obj; } + + void _tied_object(_omniT& t) { + if( pd_rel ) delete pd_obj; + pd_obj = &t; + pd_rel = 0; + } + + void _tied_object(_omniT* t, _CORBA_Boolean r=1) { + if( pd_rel ) delete pd_obj; + pd_obj = t; + pd_rel = r; + } + + _CORBA_Boolean _is_owner() { return pd_rel; } + void _is_owner(_CORBA_Boolean io) { pd_rel = io; } + + ::PortableServer::POA_ptr _default_POA() { + if( !pd_poa ) return ::PortableServer::POA::_the_root_poa(); + else return ::PortableServer::POA::_duplicate(pd_poa); + } + + void receive_event_message(const char* event_param) { pd_obj->receive_event_message(event_param); } + void receive_event_dataitem_sequence(const plpbus_orb::DataItemSequence& event_param) { pd_obj->receive_event_dataitem_sequence(event_param); } + void receive_response_message(const char* msg_rsp_param) { pd_obj->receive_response_message(msg_rsp_param); } + void receive_response_dataitem_sequence(const plpbus_orb::DataItemSequence& msg_rsp_param) { pd_obj->receive_response_dataitem_sequence(msg_rsp_param); } + + + private: + _omniT* pd_obj; + ::PortableServer::POA_ptr pd_poa; + _CORBA_Boolean pd_rel; + }; + + class OrbServer : + public virtual plpbus_orb::_impl_OrbServer, + public virtual ::PortableServer::ServantBase + { + public: + virtual ~OrbServer(); + + inline ::plpbus_orb::OrbServer_ptr _this() { + return (::plpbus_orb::OrbServer_ptr) _do_this(::plpbus_orb::OrbServer::_PD_repoId); + } + }; + + template + class OrbServer_tie : public virtual OrbServer + { + public: + OrbServer_tie(_omniT& t) + : pd_obj(&t), pd_poa(0), pd_rel(0) {} + OrbServer_tie(_omniT& t, ::PortableServer::POA_ptr p) + : pd_obj(&t), pd_poa(p), pd_rel(0) {} + OrbServer_tie(_omniT* t, _CORBA_Boolean r=1) + : pd_obj(t), pd_poa(0), pd_rel(r) {} + OrbServer_tie(_omniT* t, ::PortableServer::POA_ptr p,_CORBA_Boolean r=1) + : pd_obj(t), pd_poa(p), pd_rel(r) {} + ~OrbServer_tie() { + if( pd_poa ) ::CORBA::release(pd_poa); + if( pd_rel ) delete pd_obj; + } + + _omniT* _tied_object() { return pd_obj; } + + void _tied_object(_omniT& t) { + if( pd_rel ) delete pd_obj; + pd_obj = &t; + pd_rel = 0; + } + + void _tied_object(_omniT* t, _CORBA_Boolean r=1) { + if( pd_rel ) delete pd_obj; + pd_obj = t; + pd_rel = r; + } + + _CORBA_Boolean _is_owner() { return pd_rel; } + void _is_owner(_CORBA_Boolean io) { pd_rel = io; } + + ::PortableServer::POA_ptr _default_POA() { + if( !pd_poa ) return ::PortableServer::POA::_the_root_poa(); + else return ::PortableServer::POA::_duplicate(pd_poa); + } + + void send_message_and_request_response(plpbus_orb::OrbClient_ptr response_listener_param, const char* msg_param) { pd_obj->send_message_and_request_response(response_listener_param, msg_param); } + void send_dataitem_message_and_request_response(plpbus_orb::OrbClient_ptr response_listener_param, const plpbus_orb::DataItemSequence& req_seq_param) { pd_obj->send_dataitem_message_and_request_response(response_listener_param, req_seq_param); } + char* send_message_and_wait_response(const char* msg_req_param, ::CORBA::Long& err_flg) { return pd_obj->send_message_and_wait_response(msg_req_param, err_flg); } + ::CORBA::Long send_dataitem_message_and_wait_response(const plpbus_orb::DataItemSequence& req_seq_param, plpbus_orb::DataItemSequence_out rsp_seq_param) { return pd_obj->send_dataitem_message_and_wait_response(req_seq_param, rsp_seq_param); } + void add_event_listener(plpbus_orb::OrbClient_ptr callback_client_param, const char* msg_param, ::CORBA::UShort period_secs) { pd_obj->add_event_listener(callback_client_param, msg_param, period_secs); } + void shutdown() { pd_obj->shutdown(); } + + + private: + _omniT* pd_obj; + ::PortableServer::POA_ptr pd_poa; + _CORBA_Boolean pd_rel; + }; + +_CORBA_MODULE_END + + + +_CORBA_MODULE OBV_plpbus_orb +_CORBA_MODULE_BEG + +_CORBA_MODULE_END + + + + + +#undef _core_attr +#undef _dyn_attr + +extern void operator<<=(::CORBA::Any& _a, const plpbus_orb::DataItem& _s); +extern void operator<<=(::CORBA::Any& _a, plpbus_orb::DataItem* _sp); +extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, plpbus_orb::DataItem*& _sp); +extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const plpbus_orb::DataItem*& _sp); + +void operator<<=(::CORBA::Any& _a, const plpbus_orb::DataItemSequence& _s); +void operator<<=(::CORBA::Any& _a, plpbus_orb::DataItemSequence* _sp); +_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, plpbus_orb::DataItemSequence*& _sp); +_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const plpbus_orb::DataItemSequence*& _sp); + +void operator<<=(::CORBA::Any& _a, plpbus_orb::OrbClient_ptr _s); +void operator<<=(::CORBA::Any& _a, plpbus_orb::OrbClient_ptr* _s); +_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, plpbus_orb::OrbClient_ptr& _s); + +void operator<<=(::CORBA::Any& _a, plpbus_orb::OrbServer_ptr _s); +void operator<<=(::CORBA::Any& _a, plpbus_orb::OrbServer_ptr* _s); +_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, plpbus_orb::OrbServer_ptr& _s); + + + +inline void +plpbus_orb::OrbClient::_marshalObjRef(::plpbus_orb::OrbClient_ptr obj, cdrStream& s) { + omniObjRef::_marshal(obj->_PR_getobj(),s); +} + + +inline void +plpbus_orb::OrbServer::_marshalObjRef(::plpbus_orb::OrbServer_ptr obj, cdrStream& s) { + omniObjRef::_marshal(obj->_PR_getobj(),s); +} + + + + +#ifdef USE_stub_in_nt_dll_NOT_DEFINED_RequestResponseBus +# undef USE_stub_in_nt_dll +# undef USE_stub_in_nt_dll_NOT_DEFINED_RequestResponseBus +#endif +#ifdef USE_core_stub_in_nt_dll_NOT_DEFINED_RequestResponseBus +# undef USE_core_stub_in_nt_dll +# undef USE_core_stub_in_nt_dll_NOT_DEFINED_RequestResponseBus +#endif +#ifdef USE_dyn_stub_in_nt_dll_NOT_DEFINED_RequestResponseBus +# undef USE_dyn_stub_in_nt_dll +# undef USE_dyn_stub_in_nt_dll_NOT_DEFINED_RequestResponseBus +#endif + +#endif // __RequestResponseBus_hh__ + diff --git a/src/idl/RequestResponseBus.idl b/src/idl/RequestResponseBus.idl new file mode 100644 index 0000000..cf5f9fe --- /dev/null +++ b/src/idl/RequestResponseBus.idl @@ -0,0 +1,40 @@ +#ifndef __ECHO_CALLBACK_IDL__ +#define __ECHO_CALLBACK_IDL__ + +module plpbus_orb { + struct DataItem { + string name; + any value; + }; + + typedef sequence DataItemSequence; + + + interface OrbClient { + // send event to orb client + void receive_event_message(in string event_param); + void receive_event_dataitem_sequence(in DataItemSequence event_param); + // send message to orb client + void receive_response_message(in string msg_rsp_param); + void receive_response_dataitem_sequence(in DataItemSequence msg_rsp_param); + }; + + interface OrbServer { + // send message to server and then call back to client + void send_message_and_request_response(in OrbClient response_listener_param, in string msg_param); + void send_dataitem_message_and_request_response(in OrbClient response_listener_param, in DataItemSequence req_seq_param); + + // send message to server and wait response + string send_message_and_wait_response(in string msg_req_param, out long err_flg); + long send_dataitem_message_and_wait_response(in DataItemSequence req_seq_param, out DataItemSequence rsp_seq_param); + + // register listening events periodically + void add_event_listener(in OrbClient callback_client_param, + in string msg_param, + in unsigned short period_secs); + // send shutdown request to server + void shutdown(); + }; +}; + +#endif diff --git a/src/idl/RequestResponseBusDynSK.cc b/src/idl/RequestResponseBusDynSK.cc new file mode 100644 index 0000000..bfd2be9 --- /dev/null +++ b/src/idl/RequestResponseBusDynSK.cc @@ -0,0 +1,270 @@ +// This file is generated by omniidl (C++ backend) - omniORB_4_1. Do not edit. + +#include "RequestResponseBus.hh" + +OMNI_USING_NAMESPACE(omni) + +static const char* _0RL_dyn_library_version = omniORB_4_1_dyn; + +static ::CORBA::TypeCode::_Tracker _0RL_tcTrack(__FILE__); + +static CORBA::PR_structMember _0RL_structmember_plpbus__orb_mDataItem[] = { + {"name", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)}, + {"value", CORBA::TypeCode::PR_any_tc()} +}; + +#ifdef _0RL_tc_plpbus__orb_mDataItem +# undef _0RL_tc_plpbus__orb_mDataItem +#endif +static CORBA::TypeCode_ptr _0RL_tc_plpbus__orb_mDataItem = CORBA::TypeCode::PR_struct_tc("IDL:plpbus_orb/DataItem:1.0", "DataItem", _0RL_structmember_plpbus__orb_mDataItem, 2, &_0RL_tcTrack); + +#if defined(HAS_Cplusplus_Namespace) && defined(_MSC_VER) +// MSVC++ does not give the constant external linkage otherwise. +namespace plpbus_orb { + const ::CORBA::TypeCode_ptr _tc_DataItem = _0RL_tc_plpbus__orb_mDataItem; +} +#else +const ::CORBA::TypeCode_ptr plpbus_orb::_tc_DataItem = _0RL_tc_plpbus__orb_mDataItem; +#endif + + + + + + +static CORBA::TypeCode_ptr _0RL_tc_plpbus__orb_mDataItemSequence = CORBA::TypeCode::PR_alias_tc("IDL:plpbus_orb/DataItemSequence:1.0", "DataItemSequence", CORBA::TypeCode::PR_sequence_tc(0, _0RL_tc_plpbus__orb_mDataItem, &_0RL_tcTrack), &_0RL_tcTrack); + + +#if defined(HAS_Cplusplus_Namespace) && defined(_MSC_VER) +// MSVC++ does not give the constant external linkage otherwise. +namespace plpbus_orb { + const ::CORBA::TypeCode_ptr _tc_DataItemSequence = _0RL_tc_plpbus__orb_mDataItemSequence; +} +#else +const ::CORBA::TypeCode_ptr plpbus_orb::_tc_DataItemSequence = _0RL_tc_plpbus__orb_mDataItemSequence; +#endif + +#if defined(HAS_Cplusplus_Namespace) && defined(_MSC_VER) +// MSVC++ does not give the constant external linkage otherwise. +namespace plpbus_orb { + const ::CORBA::TypeCode_ptr _tc_OrbClient = CORBA::TypeCode::PR_interface_tc("IDL:plpbus_orb/OrbClient:1.0", "OrbClient", &_0RL_tcTrack); +} +#else +const ::CORBA::TypeCode_ptr plpbus_orb::_tc_OrbClient = CORBA::TypeCode::PR_interface_tc("IDL:plpbus_orb/OrbClient:1.0", "OrbClient", &_0RL_tcTrack); +#endif + +#if defined(HAS_Cplusplus_Namespace) && defined(_MSC_VER) +// MSVC++ does not give the constant external linkage otherwise. +namespace plpbus_orb { + const ::CORBA::TypeCode_ptr _tc_OrbServer = CORBA::TypeCode::PR_interface_tc("IDL:plpbus_orb/OrbServer:1.0", "OrbServer", &_0RL_tcTrack); +} +#else +const ::CORBA::TypeCode_ptr plpbus_orb::_tc_OrbServer = CORBA::TypeCode::PR_interface_tc("IDL:plpbus_orb/OrbServer:1.0", "OrbServer", &_0RL_tcTrack); +#endif + +static void _0RL_plpbus__orb_mDataItem_marshal_fn(cdrStream& _s, void* _v) +{ + plpbus_orb::DataItem* _p = (plpbus_orb::DataItem*)_v; + *_p >>= _s; +} +static void _0RL_plpbus__orb_mDataItem_unmarshal_fn(cdrStream& _s, void*& _v) +{ + plpbus_orb::DataItem* _p = new plpbus_orb::DataItem; + *_p <<= _s; + _v = _p; +} +static void _0RL_plpbus__orb_mDataItem_destructor_fn(void* _v) +{ + plpbus_orb::DataItem* _p = (plpbus_orb::DataItem*)_v; + delete _p; +} + +void operator<<=(::CORBA::Any& _a, const plpbus_orb::DataItem& _s) +{ + plpbus_orb::DataItem* _p = new plpbus_orb::DataItem(_s); + _a.PR_insert(_0RL_tc_plpbus__orb_mDataItem, + _0RL_plpbus__orb_mDataItem_marshal_fn, + _0RL_plpbus__orb_mDataItem_destructor_fn, + _p); +} +void operator<<=(::CORBA::Any& _a, plpbus_orb::DataItem* _sp) +{ + _a.PR_insert(_0RL_tc_plpbus__orb_mDataItem, + _0RL_plpbus__orb_mDataItem_marshal_fn, + _0RL_plpbus__orb_mDataItem_destructor_fn, + _sp); +} + +::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, plpbus_orb::DataItem*& _sp) +{ + return _a >>= (const plpbus_orb::DataItem*&) _sp; +} +::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const plpbus_orb::DataItem*& _sp) +{ + void* _v; + if (_a.PR_extract(_0RL_tc_plpbus__orb_mDataItem, + _0RL_plpbus__orb_mDataItem_unmarshal_fn, + _0RL_plpbus__orb_mDataItem_marshal_fn, + _0RL_plpbus__orb_mDataItem_destructor_fn, + _v)) { + _sp = (const plpbus_orb::DataItem*)_v; + return 1; + } + return 0; +} + +static void _0RL_plpbus__orb_mDataItemSequence_marshal_fn(cdrStream& _s, void* _v) +{ + plpbus_orb::DataItemSequence* _p = (plpbus_orb::DataItemSequence*)_v; + *_p >>= _s; +} +static void _0RL_plpbus__orb_mDataItemSequence_unmarshal_fn(cdrStream& _s, void*& _v) +{ + plpbus_orb::DataItemSequence* _p = new plpbus_orb::DataItemSequence; + *_p <<= _s; + _v = _p; +} +static void _0RL_plpbus__orb_mDataItemSequence_destructor_fn(void* _v) +{ + plpbus_orb::DataItemSequence* _p = (plpbus_orb::DataItemSequence*)_v; + delete _p; +} + +void operator<<=(::CORBA::Any& _a, const plpbus_orb::DataItemSequence& _s) +{ + plpbus_orb::DataItemSequence* _p = new plpbus_orb::DataItemSequence(_s); + _a.PR_insert(_0RL_tc_plpbus__orb_mDataItemSequence, + _0RL_plpbus__orb_mDataItemSequence_marshal_fn, + _0RL_plpbus__orb_mDataItemSequence_destructor_fn, + _p); +} +void operator<<=(::CORBA::Any& _a, plpbus_orb::DataItemSequence* _sp) +{ + _a.PR_insert(_0RL_tc_plpbus__orb_mDataItemSequence, + _0RL_plpbus__orb_mDataItemSequence_marshal_fn, + _0RL_plpbus__orb_mDataItemSequence_destructor_fn, + _sp); +} + +::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, plpbus_orb::DataItemSequence*& _sp) +{ + return _a >>= (const plpbus_orb::DataItemSequence*&) _sp; +} +::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const plpbus_orb::DataItemSequence*& _sp) +{ + void* _v; + if (_a.PR_extract(_0RL_tc_plpbus__orb_mDataItemSequence, + _0RL_plpbus__orb_mDataItemSequence_unmarshal_fn, + _0RL_plpbus__orb_mDataItemSequence_marshal_fn, + _0RL_plpbus__orb_mDataItemSequence_destructor_fn, + _v)) { + _sp = (const plpbus_orb::DataItemSequence*)_v; + return 1; + } + return 0; +} + +static void _0RL_plpbus__orb_mOrbClient_marshal_fn(cdrStream& _s, void* _v) +{ + omniObjRef* _o = (omniObjRef*)_v; + omniObjRef::_marshal(_o, _s); +} +static void _0RL_plpbus__orb_mOrbClient_unmarshal_fn(cdrStream& _s, void*& _v) +{ + omniObjRef* _o = omniObjRef::_unMarshal(plpbus_orb::OrbClient::_PD_repoId, _s); + _v = _o; +} +static void _0RL_plpbus__orb_mOrbClient_destructor_fn(void* _v) +{ + omniObjRef* _o = (omniObjRef*)_v; + if (_o) + omni::releaseObjRef(_o); +} + +void operator<<=(::CORBA::Any& _a, plpbus_orb::OrbClient_ptr _o) +{ + plpbus_orb::OrbClient_ptr _no = plpbus_orb::OrbClient::_duplicate(_o); + _a.PR_insert(plpbus_orb::_tc_OrbClient, + _0RL_plpbus__orb_mOrbClient_marshal_fn, + _0RL_plpbus__orb_mOrbClient_destructor_fn, + _no->_PR_getobj()); +} +void operator<<=(::CORBA::Any& _a, plpbus_orb::OrbClient_ptr* _op) +{ + _a.PR_insert(plpbus_orb::_tc_OrbClient, + _0RL_plpbus__orb_mOrbClient_marshal_fn, + _0RL_plpbus__orb_mOrbClient_destructor_fn, + (*_op)->_PR_getobj()); + *_op = plpbus_orb::OrbClient::_nil(); +} + +::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, plpbus_orb::OrbClient_ptr& _o) +{ + void* _v; + if (_a.PR_extract(plpbus_orb::_tc_OrbClient, + _0RL_plpbus__orb_mOrbClient_unmarshal_fn, + _0RL_plpbus__orb_mOrbClient_marshal_fn, + _0RL_plpbus__orb_mOrbClient_destructor_fn, + _v)) { + omniObjRef* _r = (omniObjRef*)_v; + if (_r) + _o = (plpbus_orb::OrbClient_ptr)_r->_ptrToObjRef(plpbus_orb::OrbClient::_PD_repoId); + else + _o = plpbus_orb::OrbClient::_nil(); + return 1; + } + return 0; +} + +static void _0RL_plpbus__orb_mOrbServer_marshal_fn(cdrStream& _s, void* _v) +{ + omniObjRef* _o = (omniObjRef*)_v; + omniObjRef::_marshal(_o, _s); +} +static void _0RL_plpbus__orb_mOrbServer_unmarshal_fn(cdrStream& _s, void*& _v) +{ + omniObjRef* _o = omniObjRef::_unMarshal(plpbus_orb::OrbServer::_PD_repoId, _s); + _v = _o; +} +static void _0RL_plpbus__orb_mOrbServer_destructor_fn(void* _v) +{ + omniObjRef* _o = (omniObjRef*)_v; + if (_o) + omni::releaseObjRef(_o); +} + +void operator<<=(::CORBA::Any& _a, plpbus_orb::OrbServer_ptr _o) +{ + plpbus_orb::OrbServer_ptr _no = plpbus_orb::OrbServer::_duplicate(_o); + _a.PR_insert(plpbus_orb::_tc_OrbServer, + _0RL_plpbus__orb_mOrbServer_marshal_fn, + _0RL_plpbus__orb_mOrbServer_destructor_fn, + _no->_PR_getobj()); +} +void operator<<=(::CORBA::Any& _a, plpbus_orb::OrbServer_ptr* _op) +{ + _a.PR_insert(plpbus_orb::_tc_OrbServer, + _0RL_plpbus__orb_mOrbServer_marshal_fn, + _0RL_plpbus__orb_mOrbServer_destructor_fn, + (*_op)->_PR_getobj()); + *_op = plpbus_orb::OrbServer::_nil(); +} + +::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, plpbus_orb::OrbServer_ptr& _o) +{ + void* _v; + if (_a.PR_extract(plpbus_orb::_tc_OrbServer, + _0RL_plpbus__orb_mOrbServer_unmarshal_fn, + _0RL_plpbus__orb_mOrbServer_marshal_fn, + _0RL_plpbus__orb_mOrbServer_destructor_fn, + _v)) { + omniObjRef* _r = (omniObjRef*)_v; + if (_r) + _o = (plpbus_orb::OrbServer_ptr)_r->_ptrToObjRef(plpbus_orb::OrbServer::_PD_repoId); + else + _o = plpbus_orb::OrbServer::_nil(); + return 1; + } + return 0; +} + diff --git a/src/idl/RequestResponseBusSK.cc b/src/idl/RequestResponseBusSK.cc new file mode 100644 index 0000000..9877936 --- /dev/null +++ b/src/idl/RequestResponseBusSK.cc @@ -0,0 +1,1012 @@ +// This file is generated by omniidl (C++ backend)- omniORB_4_1. Do not edit. + +#include "RequestResponseBus.hh" +#include +#include +#include +#include +#include + + +OMNI_USING_NAMESPACE(omni) + +static const char* _0RL_library_version = omniORB_4_1; + + + +void +plpbus_orb::DataItem::operator>>= (cdrStream &_n) const +{ + _n.marshalString(name,0); + (const ::CORBA::Any&) value >>= _n; + +} + +void +plpbus_orb::DataItem::operator<<= (cdrStream &_n) +{ + name = _n.unmarshalString(0); + (::CORBA::Any&)value <<= _n; + +} + +plpbus_orb::OrbClient_ptr plpbus_orb::OrbClient_Helper::_nil() { + return ::plpbus_orb::OrbClient::_nil(); +} + +::CORBA::Boolean plpbus_orb::OrbClient_Helper::is_nil(::plpbus_orb::OrbClient_ptr p) { + return ::CORBA::is_nil(p); + +} + +void plpbus_orb::OrbClient_Helper::release(::plpbus_orb::OrbClient_ptr p) { + ::CORBA::release(p); +} + +void plpbus_orb::OrbClient_Helper::marshalObjRef(::plpbus_orb::OrbClient_ptr obj, cdrStream& s) { + ::plpbus_orb::OrbClient::_marshalObjRef(obj, s); +} + +plpbus_orb::OrbClient_ptr plpbus_orb::OrbClient_Helper::unmarshalObjRef(cdrStream& s) { + return ::plpbus_orb::OrbClient::_unmarshalObjRef(s); +} + +void plpbus_orb::OrbClient_Helper::duplicate(::plpbus_orb::OrbClient_ptr obj) { + if( obj && !obj->_NP_is_nil() ) omni::duplicateObjRef(obj); +} + +plpbus_orb::OrbClient_ptr +plpbus_orb::OrbClient::_duplicate(::plpbus_orb::OrbClient_ptr obj) +{ + if( obj && !obj->_NP_is_nil() ) omni::duplicateObjRef(obj); + return obj; +} + +plpbus_orb::OrbClient_ptr +plpbus_orb::OrbClient::_narrow(::CORBA::Object_ptr obj) +{ + if( !obj || obj->_NP_is_nil() || obj->_NP_is_pseudo() ) return _nil(); + _ptr_type e = (_ptr_type) obj->_PR_getobj()->_realNarrow(_PD_repoId); + return e ? e : _nil(); +} + + +plpbus_orb::OrbClient_ptr +plpbus_orb::OrbClient::_unchecked_narrow(::CORBA::Object_ptr obj) +{ + if( !obj || obj->_NP_is_nil() || obj->_NP_is_pseudo() ) return _nil(); + _ptr_type e = (_ptr_type) obj->_PR_getobj()->_uncheckedNarrow(_PD_repoId); + return e ? e : _nil(); +} + +plpbus_orb::OrbClient_ptr +plpbus_orb::OrbClient::_nil() +{ +#ifdef OMNI_UNLOADABLE_STUBS + static _objref_OrbClient _the_nil_obj; + return &_the_nil_obj; +#else + static _objref_OrbClient* _the_nil_ptr = 0; + if( !_the_nil_ptr ) { + omni::nilRefLock().lock(); + if( !_the_nil_ptr ) { + _the_nil_ptr = new _objref_OrbClient; + registerNilCorbaObject(_the_nil_ptr); + } + omni::nilRefLock().unlock(); + } + return _the_nil_ptr; +#endif +} + +const char* plpbus_orb::OrbClient::_PD_repoId = "IDL:plpbus_orb/OrbClient:1.0"; + + +plpbus_orb::_objref_OrbClient::~_objref_OrbClient() { + +} + + +plpbus_orb::_objref_OrbClient::_objref_OrbClient(omniIOR* ior, omniIdentity* id) : + omniObjRef(::plpbus_orb::OrbClient::_PD_repoId, ior, id, 1) + + +{ + _PR_setobj(this); +} + +void* +plpbus_orb::_objref_OrbClient::_ptrToObjRef(const char* id) +{ + if( id == ::plpbus_orb::OrbClient::_PD_repoId ) + return (::plpbus_orb::OrbClient_ptr) this; + + if( id == ::CORBA::Object::_PD_repoId ) + return (::CORBA::Object_ptr) this; + + if( omni::strMatch(id, ::plpbus_orb::OrbClient::_PD_repoId) ) + return (::plpbus_orb::OrbClient_ptr) this; + + if( omni::strMatch(id, ::CORBA::Object::_PD_repoId) ) + return (::CORBA::Object_ptr) this; + + return 0; +} + +// Proxy call descriptor class. Mangled signature: +// void_i_cstring +class _0RL_cd_00d6793dc2c2a80c_00000000 + : public omniCallDescriptor +{ +public: + inline _0RL_cd_00d6793dc2c2a80c_00000000(LocalCallFn lcfn,const char* op_,size_t oplen,_CORBA_Boolean upcall=0): + omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 0, upcall) + { + + } + + void marshalArguments(cdrStream&); + void unmarshalArguments(cdrStream&); + + + + static const char* const _user_exns[]; + + ::CORBA::String_var arg_0_; + const char* arg_0; +}; + +void _0RL_cd_00d6793dc2c2a80c_00000000::marshalArguments(cdrStream& _n) +{ + _n.marshalString(arg_0,0); + +} + +void _0RL_cd_00d6793dc2c2a80c_00000000::unmarshalArguments(cdrStream& _n) +{ + arg_0_ = _n.unmarshalString(0); + arg_0 = arg_0_.in(); + +} + +const char* const _0RL_cd_00d6793dc2c2a80c_00000000::_user_exns[] = { + 0 +}; + +// Local call call-back function. +static void +_0RL_lcfn_00d6793dc2c2a80c_10000000(omniCallDescriptor* cd, omniServant* svnt) +{ + _0RL_cd_00d6793dc2c2a80c_00000000* tcd = (_0RL_cd_00d6793dc2c2a80c_00000000*)cd; + plpbus_orb::_impl_OrbClient* impl = (plpbus_orb::_impl_OrbClient*) svnt->_ptrToInterface(plpbus_orb::OrbClient::_PD_repoId); + impl->receive_event_message(tcd->arg_0); + + +} + +void plpbus_orb::_objref_OrbClient::receive_event_message(const char* event_param) +{ + _0RL_cd_00d6793dc2c2a80c_00000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_10000000, "receive_event_message", 22); + _call_desc.arg_0 = event_param; + + _invoke(_call_desc); + + + +} +// Proxy call descriptor class. Mangled signature: +// void_i_cplpbus__orb_mDataItemSequence +class _0RL_cd_00d6793dc2c2a80c_20000000 + : public omniCallDescriptor +{ +public: + inline _0RL_cd_00d6793dc2c2a80c_20000000(LocalCallFn lcfn,const char* op_,size_t oplen,_CORBA_Boolean upcall=0): + omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 0, upcall) + { + + } + + void marshalArguments(cdrStream&); + void unmarshalArguments(cdrStream&); + + + + static const char* const _user_exns[]; + + plpbus_orb::DataItemSequence_var arg_0_; + const plpbus_orb::DataItemSequence* arg_0; +}; + +void _0RL_cd_00d6793dc2c2a80c_20000000::marshalArguments(cdrStream& _n) +{ + (const plpbus_orb::DataItemSequence&) *arg_0 >>= _n; + +} + +void _0RL_cd_00d6793dc2c2a80c_20000000::unmarshalArguments(cdrStream& _n) +{ + arg_0_ = new plpbus_orb::DataItemSequence; + (plpbus_orb::DataItemSequence&)arg_0_ <<= _n; + arg_0 = &arg_0_.in(); + +} + +const char* const _0RL_cd_00d6793dc2c2a80c_20000000::_user_exns[] = { + 0 +}; + +// Local call call-back function. +static void +_0RL_lcfn_00d6793dc2c2a80c_30000000(omniCallDescriptor* cd, omniServant* svnt) +{ + _0RL_cd_00d6793dc2c2a80c_20000000* tcd = (_0RL_cd_00d6793dc2c2a80c_20000000*)cd; + plpbus_orb::_impl_OrbClient* impl = (plpbus_orb::_impl_OrbClient*) svnt->_ptrToInterface(plpbus_orb::OrbClient::_PD_repoId); + impl->receive_event_dataitem_sequence(*tcd->arg_0); + + +} + +void plpbus_orb::_objref_OrbClient::receive_event_dataitem_sequence(const ::plpbus_orb::DataItemSequence& event_param) +{ + _0RL_cd_00d6793dc2c2a80c_20000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_30000000, "receive_event_dataitem_sequence", 32); + _call_desc.arg_0 = &(::plpbus_orb::DataItemSequence&) event_param; + + _invoke(_call_desc); + + + +} +// Local call call-back function. +static void +_0RL_lcfn_00d6793dc2c2a80c_40000000(omniCallDescriptor* cd, omniServant* svnt) +{ + _0RL_cd_00d6793dc2c2a80c_00000000* tcd = (_0RL_cd_00d6793dc2c2a80c_00000000*)cd; + plpbus_orb::_impl_OrbClient* impl = (plpbus_orb::_impl_OrbClient*) svnt->_ptrToInterface(plpbus_orb::OrbClient::_PD_repoId); + impl->receive_response_message(tcd->arg_0); + + +} + +void plpbus_orb::_objref_OrbClient::receive_response_message(const char* msg_rsp_param) +{ + _0RL_cd_00d6793dc2c2a80c_00000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_40000000, "receive_response_message", 25); + _call_desc.arg_0 = msg_rsp_param; + + _invoke(_call_desc); + + + +} +// Local call call-back function. +static void +_0RL_lcfn_00d6793dc2c2a80c_50000000(omniCallDescriptor* cd, omniServant* svnt) +{ + _0RL_cd_00d6793dc2c2a80c_20000000* tcd = (_0RL_cd_00d6793dc2c2a80c_20000000*)cd; + plpbus_orb::_impl_OrbClient* impl = (plpbus_orb::_impl_OrbClient*) svnt->_ptrToInterface(plpbus_orb::OrbClient::_PD_repoId); + impl->receive_response_dataitem_sequence(*tcd->arg_0); + + +} + +void plpbus_orb::_objref_OrbClient::receive_response_dataitem_sequence(const ::plpbus_orb::DataItemSequence& msg_rsp_param) +{ + _0RL_cd_00d6793dc2c2a80c_20000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_50000000, "receive_response_dataitem_sequence", 35); + _call_desc.arg_0 = &(::plpbus_orb::DataItemSequence&) msg_rsp_param; + + _invoke(_call_desc); + + + +} +plpbus_orb::_pof_OrbClient::~_pof_OrbClient() {} + + +omniObjRef* +plpbus_orb::_pof_OrbClient::newObjRef(omniIOR* ior, omniIdentity* id) +{ + return new ::plpbus_orb::_objref_OrbClient(ior, id); +} + + +::CORBA::Boolean +plpbus_orb::_pof_OrbClient::is_a(const char* id) const +{ + if( omni::ptrStrMatch(id, ::plpbus_orb::OrbClient::_PD_repoId) ) + return 1; + + return 0; +} + +const plpbus_orb::_pof_OrbClient _the_pof_plpbus__orb_mOrbClient; + +plpbus_orb::_impl_OrbClient::~_impl_OrbClient() {} + + +::CORBA::Boolean +plpbus_orb::_impl_OrbClient::_dispatch(omniCallHandle& _handle) +{ + const char* op = _handle.operation_name(); + + if( omni::strMatch(op, "receive_event_message") ) { + + _0RL_cd_00d6793dc2c2a80c_00000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_10000000, "receive_event_message", 22, 1); + + _handle.upcall(this,_call_desc); + return 1; + } + + if( omni::strMatch(op, "receive_event_dataitem_sequence") ) { + + _0RL_cd_00d6793dc2c2a80c_20000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_30000000, "receive_event_dataitem_sequence", 32, 1); + + _handle.upcall(this,_call_desc); + return 1; + } + + if( omni::strMatch(op, "receive_response_message") ) { + + _0RL_cd_00d6793dc2c2a80c_00000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_40000000, "receive_response_message", 25, 1); + + _handle.upcall(this,_call_desc); + return 1; + } + + if( omni::strMatch(op, "receive_response_dataitem_sequence") ) { + + _0RL_cd_00d6793dc2c2a80c_20000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_50000000, "receive_response_dataitem_sequence", 35, 1); + + _handle.upcall(this,_call_desc); + return 1; + } + + + return 0; +} + +void* +plpbus_orb::_impl_OrbClient::_ptrToInterface(const char* id) +{ + if( id == ::plpbus_orb::OrbClient::_PD_repoId ) + return (::plpbus_orb::_impl_OrbClient*) this; + + if( id == ::CORBA::Object::_PD_repoId ) + return (void*) 1; + + if( omni::strMatch(id, ::plpbus_orb::OrbClient::_PD_repoId) ) + return (::plpbus_orb::_impl_OrbClient*) this; + + if( omni::strMatch(id, ::CORBA::Object::_PD_repoId) ) + return (void*) 1; + return 0; +} + +const char* +plpbus_orb::_impl_OrbClient::_mostDerivedRepoId() +{ + return ::plpbus_orb::OrbClient::_PD_repoId; +} + +plpbus_orb::OrbServer_ptr plpbus_orb::OrbServer_Helper::_nil() { + return ::plpbus_orb::OrbServer::_nil(); +} + +::CORBA::Boolean plpbus_orb::OrbServer_Helper::is_nil(::plpbus_orb::OrbServer_ptr p) { + return ::CORBA::is_nil(p); + +} + +void plpbus_orb::OrbServer_Helper::release(::plpbus_orb::OrbServer_ptr p) { + ::CORBA::release(p); +} + +void plpbus_orb::OrbServer_Helper::marshalObjRef(::plpbus_orb::OrbServer_ptr obj, cdrStream& s) { + ::plpbus_orb::OrbServer::_marshalObjRef(obj, s); +} + +plpbus_orb::OrbServer_ptr plpbus_orb::OrbServer_Helper::unmarshalObjRef(cdrStream& s) { + return ::plpbus_orb::OrbServer::_unmarshalObjRef(s); +} + +void plpbus_orb::OrbServer_Helper::duplicate(::plpbus_orb::OrbServer_ptr obj) { + if( obj && !obj->_NP_is_nil() ) omni::duplicateObjRef(obj); +} + +plpbus_orb::OrbServer_ptr +plpbus_orb::OrbServer::_duplicate(::plpbus_orb::OrbServer_ptr obj) +{ + if( obj && !obj->_NP_is_nil() ) omni::duplicateObjRef(obj); + return obj; +} + +plpbus_orb::OrbServer_ptr +plpbus_orb::OrbServer::_narrow(::CORBA::Object_ptr obj) +{ + if( !obj || obj->_NP_is_nil() || obj->_NP_is_pseudo() ) return _nil(); + _ptr_type e = (_ptr_type) obj->_PR_getobj()->_realNarrow(_PD_repoId); + return e ? e : _nil(); +} + + +plpbus_orb::OrbServer_ptr +plpbus_orb::OrbServer::_unchecked_narrow(::CORBA::Object_ptr obj) +{ + if( !obj || obj->_NP_is_nil() || obj->_NP_is_pseudo() ) return _nil(); + _ptr_type e = (_ptr_type) obj->_PR_getobj()->_uncheckedNarrow(_PD_repoId); + return e ? e : _nil(); +} + +plpbus_orb::OrbServer_ptr +plpbus_orb::OrbServer::_nil() +{ +#ifdef OMNI_UNLOADABLE_STUBS + static _objref_OrbServer _the_nil_obj; + return &_the_nil_obj; +#else + static _objref_OrbServer* _the_nil_ptr = 0; + if( !_the_nil_ptr ) { + omni::nilRefLock().lock(); + if( !_the_nil_ptr ) { + _the_nil_ptr = new _objref_OrbServer; + registerNilCorbaObject(_the_nil_ptr); + } + omni::nilRefLock().unlock(); + } + return _the_nil_ptr; +#endif +} + +const char* plpbus_orb::OrbServer::_PD_repoId = "IDL:plpbus_orb/OrbServer:1.0"; + + +plpbus_orb::_objref_OrbServer::~_objref_OrbServer() { + +} + + +plpbus_orb::_objref_OrbServer::_objref_OrbServer(omniIOR* ior, omniIdentity* id) : + omniObjRef(::plpbus_orb::OrbServer::_PD_repoId, ior, id, 1) + + +{ + _PR_setobj(this); +} + +void* +plpbus_orb::_objref_OrbServer::_ptrToObjRef(const char* id) +{ + if( id == ::plpbus_orb::OrbServer::_PD_repoId ) + return (::plpbus_orb::OrbServer_ptr) this; + + if( id == ::CORBA::Object::_PD_repoId ) + return (::CORBA::Object_ptr) this; + + if( omni::strMatch(id, ::plpbus_orb::OrbServer::_PD_repoId) ) + return (::plpbus_orb::OrbServer_ptr) this; + + if( omni::strMatch(id, ::CORBA::Object::_PD_repoId) ) + return (::CORBA::Object_ptr) this; + + return 0; +} + +// Proxy call descriptor class. Mangled signature: +// void_i_cplpbus__orb_mOrbClient_i_cstring +class _0RL_cd_00d6793dc2c2a80c_60000000 + : public omniCallDescriptor +{ +public: + inline _0RL_cd_00d6793dc2c2a80c_60000000(LocalCallFn lcfn,const char* op_,size_t oplen,_CORBA_Boolean upcall=0): + omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 0, upcall) + { + + } + + void marshalArguments(cdrStream&); + void unmarshalArguments(cdrStream&); + + + + static const char* const _user_exns[]; + + plpbus_orb::OrbClient_var arg_0_; + plpbus_orb::OrbClient_ptr arg_0; + ::CORBA::String_var arg_1_; + const char* arg_1; +}; + +void _0RL_cd_00d6793dc2c2a80c_60000000::marshalArguments(cdrStream& _n) +{ + plpbus_orb::OrbClient::_marshalObjRef(arg_0,_n); + _n.marshalString(arg_1,0); + +} + +void _0RL_cd_00d6793dc2c2a80c_60000000::unmarshalArguments(cdrStream& _n) +{ + arg_0_ = plpbus_orb::OrbClient::_unmarshalObjRef(_n); + arg_0 = arg_0_.in(); + arg_1_ = _n.unmarshalString(0); + arg_1 = arg_1_.in(); + +} + +const char* const _0RL_cd_00d6793dc2c2a80c_60000000::_user_exns[] = { + 0 +}; + +// Local call call-back function. +static void +_0RL_lcfn_00d6793dc2c2a80c_70000000(omniCallDescriptor* cd, omniServant* svnt) +{ + _0RL_cd_00d6793dc2c2a80c_60000000* tcd = (_0RL_cd_00d6793dc2c2a80c_60000000*)cd; + plpbus_orb::_impl_OrbServer* impl = (plpbus_orb::_impl_OrbServer*) svnt->_ptrToInterface(plpbus_orb::OrbServer::_PD_repoId); + impl->send_message_and_request_response(tcd->arg_0, tcd->arg_1); + + +} + +void plpbus_orb::_objref_OrbServer::send_message_and_request_response(::plpbus_orb::OrbClient_ptr response_listener_param, const char* msg_param) +{ + _0RL_cd_00d6793dc2c2a80c_60000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_70000000, "send_message_and_request_response", 34); + _call_desc.arg_0 = response_listener_param; + _call_desc.arg_1 = msg_param; + + _invoke(_call_desc); + + + +} +// Proxy call descriptor class. Mangled signature: +// void_i_cplpbus__orb_mOrbClient_i_cplpbus__orb_mDataItemSequence +class _0RL_cd_00d6793dc2c2a80c_80000000 + : public omniCallDescriptor +{ +public: + inline _0RL_cd_00d6793dc2c2a80c_80000000(LocalCallFn lcfn,const char* op_,size_t oplen,_CORBA_Boolean upcall=0): + omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 0, upcall) + { + + } + + void marshalArguments(cdrStream&); + void unmarshalArguments(cdrStream&); + + + + static const char* const _user_exns[]; + + plpbus_orb::OrbClient_var arg_0_; + plpbus_orb::OrbClient_ptr arg_0; + plpbus_orb::DataItemSequence_var arg_1_; + const plpbus_orb::DataItemSequence* arg_1; +}; + +void _0RL_cd_00d6793dc2c2a80c_80000000::marshalArguments(cdrStream& _n) +{ + plpbus_orb::OrbClient::_marshalObjRef(arg_0,_n); + (const plpbus_orb::DataItemSequence&) *arg_1 >>= _n; + +} + +void _0RL_cd_00d6793dc2c2a80c_80000000::unmarshalArguments(cdrStream& _n) +{ + arg_0_ = plpbus_orb::OrbClient::_unmarshalObjRef(_n); + arg_0 = arg_0_.in(); + arg_1_ = new plpbus_orb::DataItemSequence; + (plpbus_orb::DataItemSequence&)arg_1_ <<= _n; + arg_1 = &arg_1_.in(); + +} + +const char* const _0RL_cd_00d6793dc2c2a80c_80000000::_user_exns[] = { + 0 +}; + +// Local call call-back function. +static void +_0RL_lcfn_00d6793dc2c2a80c_90000000(omniCallDescriptor* cd, omniServant* svnt) +{ + _0RL_cd_00d6793dc2c2a80c_80000000* tcd = (_0RL_cd_00d6793dc2c2a80c_80000000*)cd; + plpbus_orb::_impl_OrbServer* impl = (plpbus_orb::_impl_OrbServer*) svnt->_ptrToInterface(plpbus_orb::OrbServer::_PD_repoId); + impl->send_dataitem_message_and_request_response(tcd->arg_0, *tcd->arg_1); + + +} + +void plpbus_orb::_objref_OrbServer::send_dataitem_message_and_request_response(::plpbus_orb::OrbClient_ptr response_listener_param, const ::plpbus_orb::DataItemSequence& req_seq_param) +{ + _0RL_cd_00d6793dc2c2a80c_80000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_90000000, "send_dataitem_message_and_request_response", 43); + _call_desc.arg_0 = response_listener_param; + _call_desc.arg_1 = &(::plpbus_orb::DataItemSequence&) req_seq_param; + + _invoke(_call_desc); + + + +} +// Proxy call descriptor class. Mangled signature: +// _cstring_i_cstring_o_clong +class _0RL_cd_00d6793dc2c2a80c_a0000000 + : public omniCallDescriptor +{ +public: + inline _0RL_cd_00d6793dc2c2a80c_a0000000(LocalCallFn lcfn,const char* op_,size_t oplen,_CORBA_Boolean upcall=0): + omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 0, upcall) + { + + } + + void marshalArguments(cdrStream&); + void unmarshalArguments(cdrStream&); + + void unmarshalReturnedValues(cdrStream&); + void marshalReturnedValues(cdrStream&); + + + static const char* const _user_exns[]; + + ::CORBA::String_var arg_0_; + const char* arg_0; + ::CORBA::Long arg_1; + ::CORBA::String_var result; +}; + +void _0RL_cd_00d6793dc2c2a80c_a0000000::marshalArguments(cdrStream& _n) +{ + _n.marshalString(arg_0,0); + +} + +void _0RL_cd_00d6793dc2c2a80c_a0000000::unmarshalArguments(cdrStream& _n) +{ + arg_0_ = _n.unmarshalString(0); + arg_0 = arg_0_.in(); + +} + +void _0RL_cd_00d6793dc2c2a80c_a0000000::marshalReturnedValues(cdrStream& _n) +{ + _n.marshalString(result,0); + arg_1 >>= _n; + +} + +void _0RL_cd_00d6793dc2c2a80c_a0000000::unmarshalReturnedValues(cdrStream& _n) +{ + result = _n.unmarshalString(0); + (::CORBA::Long&)arg_1 <<= _n; + +} + +const char* const _0RL_cd_00d6793dc2c2a80c_a0000000::_user_exns[] = { + 0 +}; + +// Local call call-back function. +static void +_0RL_lcfn_00d6793dc2c2a80c_b0000000(omniCallDescriptor* cd, omniServant* svnt) +{ + _0RL_cd_00d6793dc2c2a80c_a0000000* tcd = (_0RL_cd_00d6793dc2c2a80c_a0000000*)cd; + plpbus_orb::_impl_OrbServer* impl = (plpbus_orb::_impl_OrbServer*) svnt->_ptrToInterface(plpbus_orb::OrbServer::_PD_repoId); + tcd->result = impl->send_message_and_wait_response(tcd->arg_0, tcd->arg_1); + + +} + +char* plpbus_orb::_objref_OrbServer::send_message_and_wait_response(const char* msg_req_param, ::CORBA::Long& err_flg) +{ + _0RL_cd_00d6793dc2c2a80c_a0000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_b0000000, "send_message_and_wait_response", 31); + _call_desc.arg_0 = msg_req_param; + + _invoke(_call_desc); + err_flg = _call_desc.arg_1; + return _call_desc.result._retn(); + + +} +// Proxy call descriptor class. Mangled signature: +// _clong_i_cplpbus__orb_mDataItemSequence_o_cplpbus__orb_mDataItemSequence +class _0RL_cd_00d6793dc2c2a80c_c0000000 + : public omniCallDescriptor +{ +public: + inline _0RL_cd_00d6793dc2c2a80c_c0000000(LocalCallFn lcfn,const char* op_,size_t oplen,_CORBA_Boolean upcall=0): + omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 0, upcall) + { + + } + + void marshalArguments(cdrStream&); + void unmarshalArguments(cdrStream&); + + void unmarshalReturnedValues(cdrStream&); + void marshalReturnedValues(cdrStream&); + + + static const char* const _user_exns[]; + + plpbus_orb::DataItemSequence_var arg_0_; + const plpbus_orb::DataItemSequence* arg_0; + plpbus_orb::DataItemSequence_var arg_1; + ::CORBA::Long result; +}; + +void _0RL_cd_00d6793dc2c2a80c_c0000000::marshalArguments(cdrStream& _n) +{ + (const plpbus_orb::DataItemSequence&) *arg_0 >>= _n; + +} + +void _0RL_cd_00d6793dc2c2a80c_c0000000::unmarshalArguments(cdrStream& _n) +{ + arg_0_ = new plpbus_orb::DataItemSequence; + (plpbus_orb::DataItemSequence&)arg_0_ <<= _n; + arg_0 = &arg_0_.in(); + +} + +void _0RL_cd_00d6793dc2c2a80c_c0000000::marshalReturnedValues(cdrStream& _n) +{ + result >>= _n; + (const plpbus_orb::DataItemSequence&) arg_1 >>= _n; + +} + +void _0RL_cd_00d6793dc2c2a80c_c0000000::unmarshalReturnedValues(cdrStream& _n) +{ + (::CORBA::Long&)result <<= _n; + arg_1 = new plpbus_orb::DataItemSequence; + (plpbus_orb::DataItemSequence&)arg_1 <<= _n; + +} + +const char* const _0RL_cd_00d6793dc2c2a80c_c0000000::_user_exns[] = { + 0 +}; + +// Local call call-back function. +static void +_0RL_lcfn_00d6793dc2c2a80c_d0000000(omniCallDescriptor* cd, omniServant* svnt) +{ + _0RL_cd_00d6793dc2c2a80c_c0000000* tcd = (_0RL_cd_00d6793dc2c2a80c_c0000000*)cd; + plpbus_orb::_impl_OrbServer* impl = (plpbus_orb::_impl_OrbServer*) svnt->_ptrToInterface(plpbus_orb::OrbServer::_PD_repoId); + tcd->result = impl->send_dataitem_message_and_wait_response(*tcd->arg_0, tcd->arg_1.out()); + + +} + +::CORBA::Long plpbus_orb::_objref_OrbServer::send_dataitem_message_and_wait_response(const ::plpbus_orb::DataItemSequence& req_seq_param, ::plpbus_orb::DataItemSequence_out rsp_seq_param) +{ + _0RL_cd_00d6793dc2c2a80c_c0000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_d0000000, "send_dataitem_message_and_wait_response", 40); + _call_desc.arg_0 = &(::plpbus_orb::DataItemSequence&) req_seq_param; + + _invoke(_call_desc); + rsp_seq_param = _call_desc.arg_1._retn(); + return _call_desc.result; + + +} +// Proxy call descriptor class. Mangled signature: +// void_i_cplpbus__orb_mOrbClient_i_cstring_i_cunsigned_pshort +class _0RL_cd_00d6793dc2c2a80c_e0000000 + : public omniCallDescriptor +{ +public: + inline _0RL_cd_00d6793dc2c2a80c_e0000000(LocalCallFn lcfn,const char* op_,size_t oplen,_CORBA_Boolean upcall=0): + omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 0, upcall) + { + + } + + void marshalArguments(cdrStream&); + void unmarshalArguments(cdrStream&); + + + + static const char* const _user_exns[]; + + plpbus_orb::OrbClient_var arg_0_; + plpbus_orb::OrbClient_ptr arg_0; + ::CORBA::String_var arg_1_; + const char* arg_1; + ::CORBA::UShort arg_2; +}; + +void _0RL_cd_00d6793dc2c2a80c_e0000000::marshalArguments(cdrStream& _n) +{ + plpbus_orb::OrbClient::_marshalObjRef(arg_0,_n); + _n.marshalString(arg_1,0); + arg_2 >>= _n; + +} + +void _0RL_cd_00d6793dc2c2a80c_e0000000::unmarshalArguments(cdrStream& _n) +{ + arg_0_ = plpbus_orb::OrbClient::_unmarshalObjRef(_n); + arg_0 = arg_0_.in(); + arg_1_ = _n.unmarshalString(0); + arg_1 = arg_1_.in(); + (::CORBA::UShort&)arg_2 <<= _n; + +} + +const char* const _0RL_cd_00d6793dc2c2a80c_e0000000::_user_exns[] = { + 0 +}; + +// Local call call-back function. +static void +_0RL_lcfn_00d6793dc2c2a80c_f0000000(omniCallDescriptor* cd, omniServant* svnt) +{ + _0RL_cd_00d6793dc2c2a80c_e0000000* tcd = (_0RL_cd_00d6793dc2c2a80c_e0000000*)cd; + plpbus_orb::_impl_OrbServer* impl = (plpbus_orb::_impl_OrbServer*) svnt->_ptrToInterface(plpbus_orb::OrbServer::_PD_repoId); + impl->add_event_listener(tcd->arg_0, tcd->arg_1, tcd->arg_2); + + +} + +void plpbus_orb::_objref_OrbServer::add_event_listener(::plpbus_orb::OrbClient_ptr callback_client_param, const char* msg_param, ::CORBA::UShort period_secs) +{ + _0RL_cd_00d6793dc2c2a80c_e0000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_f0000000, "add_event_listener", 19); + _call_desc.arg_0 = callback_client_param; + _call_desc.arg_1 = msg_param; + _call_desc.arg_2 = period_secs; + + _invoke(_call_desc); + + + +} +// Proxy call descriptor class. Mangled signature: +// void +class _0RL_cd_00d6793dc2c2a80c_01000000 + : public omniCallDescriptor +{ +public: + inline _0RL_cd_00d6793dc2c2a80c_01000000(LocalCallFn lcfn,const char* op_,size_t oplen,_CORBA_Boolean upcall=0): + omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 0, upcall) + { + + } + + + + + static const char* const _user_exns[]; + + +}; + +const char* const _0RL_cd_00d6793dc2c2a80c_01000000::_user_exns[] = { + 0 +}; + +// Local call call-back function. +static void +_0RL_lcfn_00d6793dc2c2a80c_11000000(omniCallDescriptor*, omniServant* svnt) +{ + + plpbus_orb::_impl_OrbServer* impl = (plpbus_orb::_impl_OrbServer*) svnt->_ptrToInterface(plpbus_orb::OrbServer::_PD_repoId); + impl->shutdown(); + + +} + +void plpbus_orb::_objref_OrbServer::shutdown() +{ + _0RL_cd_00d6793dc2c2a80c_01000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_11000000, "shutdown", 9); + + + _invoke(_call_desc); + + + +} +plpbus_orb::_pof_OrbServer::~_pof_OrbServer() {} + + +omniObjRef* +plpbus_orb::_pof_OrbServer::newObjRef(omniIOR* ior, omniIdentity* id) +{ + return new ::plpbus_orb::_objref_OrbServer(ior, id); +} + + +::CORBA::Boolean +plpbus_orb::_pof_OrbServer::is_a(const char* id) const +{ + if( omni::ptrStrMatch(id, ::plpbus_orb::OrbServer::_PD_repoId) ) + return 1; + + return 0; +} + +const plpbus_orb::_pof_OrbServer _the_pof_plpbus__orb_mOrbServer; + +plpbus_orb::_impl_OrbServer::~_impl_OrbServer() {} + + +::CORBA::Boolean +plpbus_orb::_impl_OrbServer::_dispatch(omniCallHandle& _handle) +{ + const char* op = _handle.operation_name(); + + if( omni::strMatch(op, "send_message_and_request_response") ) { + + _0RL_cd_00d6793dc2c2a80c_60000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_70000000, "send_message_and_request_response", 34, 1); + + _handle.upcall(this,_call_desc); + return 1; + } + + if( omni::strMatch(op, "send_dataitem_message_and_request_response") ) { + + _0RL_cd_00d6793dc2c2a80c_80000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_90000000, "send_dataitem_message_and_request_response", 43, 1); + + _handle.upcall(this,_call_desc); + return 1; + } + + if( omni::strMatch(op, "send_message_and_wait_response") ) { + + _0RL_cd_00d6793dc2c2a80c_a0000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_b0000000, "send_message_and_wait_response", 31, 1); + + _handle.upcall(this,_call_desc); + return 1; + } + + if( omni::strMatch(op, "send_dataitem_message_and_wait_response") ) { + + _0RL_cd_00d6793dc2c2a80c_c0000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_d0000000, "send_dataitem_message_and_wait_response", 40, 1); + + _handle.upcall(this,_call_desc); + return 1; + } + + if( omni::strMatch(op, "add_event_listener") ) { + + _0RL_cd_00d6793dc2c2a80c_e0000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_f0000000, "add_event_listener", 19, 1); + + _handle.upcall(this,_call_desc); + return 1; + } + + if( omni::strMatch(op, "shutdown") ) { + + _0RL_cd_00d6793dc2c2a80c_01000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_11000000, "shutdown", 9, 1); + + _handle.upcall(this,_call_desc); + return 1; + } + + + return 0; +} + +void* +plpbus_orb::_impl_OrbServer::_ptrToInterface(const char* id) +{ + if( id == ::plpbus_orb::OrbServer::_PD_repoId ) + return (::plpbus_orb::_impl_OrbServer*) this; + + if( id == ::CORBA::Object::_PD_repoId ) + return (void*) 1; + + if( omni::strMatch(id, ::plpbus_orb::OrbServer::_PD_repoId) ) + return (::plpbus_orb::_impl_OrbServer*) this; + + if( omni::strMatch(id, ::CORBA::Object::_PD_repoId) ) + return (void*) 1; + return 0; +} + +const char* +plpbus_orb::_impl_OrbServer::_mostDerivedRepoId() +{ + return ::plpbus_orb::OrbServer::_PD_repoId; +} + +POA_plpbus_orb::OrbClient::~OrbClient() {} + +POA_plpbus_orb::OrbServer::~OrbServer() {} + diff --git a/src/plpbus/BusClient.cc b/src/plpbus/BusClient.cc new file mode 100644 index 0000000..8c93e1d --- /dev/null +++ b/src/plpbus/BusClient.cc @@ -0,0 +1,242 @@ +/* + * BusClient.cc + * + * Created on: Jun 7, 2010 + * Author: lamikr + */ + +#include "BusClient.hh" +#include "BusMessageInternal.hh" + +using namespace std; +using namespace plpbus; + +class OrbClientImpl : public virtual POA_plpbus_orb::OrbClient +{ + private: + IClientListener *listener; + public: + OrbClientImpl(IClientListener *listener_param) { + listener = listener_param; + } + virtual ~OrbClientImpl() {} + + virtual void receive_event_message(const char *event_param) { + if (listener != NULL) { + listener->event_received(event_param); + } + } + + virtual void receive_event_dataitem_sequence(const ::plpbus_orb::DataItemSequence& event_param) { + BusMessageInternal *bus_msg; + + if (listener != NULL) { + bus_msg = new BusMessageInternal(event_param); + listener->event_received(bus_msg); + } + } + + virtual void receive_response_message(const char *msg_rsp_param) { + if (listener != NULL) { + listener->response_received(msg_rsp_param); + } + } + + virtual void receive_response_dataitem_sequence(const ::plpbus_orb::DataItemSequence& msg_rsp_param) { + BusMessageInternal *bus_msg; + + if (listener != NULL) { + bus_msg = new BusMessageInternal(msg_rsp_param); + listener->response_received(bus_msg); + } + } +}; + +BusClient::BusClient() +{ + cout << "created" << endl; + _orb = NULL; + _poa = NULL; +} + +BusClient::~BusClient() +{ + if (_orb != NULL) { + _orb->destroy(); + _orb = NULL; + } + cout << "destroyed" << endl; +} + +int BusClient::init(const char *server_name) { + int argc; + char **argv; + CORBA::Object_var server_obj; + + argc = 0; + argv = NULL; + cout << "init() started" << endl; + _orb = CORBA::ORB_init(argc, argv); + if (_orb != NULL) { + cout << "ORB_init() done, finding server: " << server_name << endl; + server_obj = find_server_object_by_name(_orb, + CONST_CONTEXT_NAME__PLPBUS, + CONST_CONTEXT_KIND__PLPBUS, + server_name, + CONST_CONTEXT_NAME__PLPBUS); + if (CORBA::is_nil(server_obj) == false) { + _server = plpbus_orb::OrbServer::_narrow(server_obj); + cout << "Server object found: " << server_name << endl; + } + else { + cerr << "Could not find server object: " << server_name << endl; + } + } + return 0; +} + +int BusClient::add_client_listener(IClientListener *listener_param) { + cout << "add_client_listener() started" << endl; + if (_poa == NULL) { + OrbClientImpl *client_cb; + PortableServer::ObjectId_var oid; + + cout << "register_callback() 1" << endl; + _poa = create_poa(_orb); + client_cb = new OrbClientImpl(listener_param); + oid = _poa->activate_object(client_cb); + _client = client_cb->_this(); + client_cb->_remove_ref(); + _server->add_event_listener(_client, "event_message", CONST_DEFAULT_EVENT_INTERVAL); + } + cout << "add_client_listener() done" << endl; + return 0; +} + +int BusClient::send_message_and_request_response(const char *msg_req_param) { + _server->send_message_and_request_response(_client, msg_req_param); + return 0; +} + +int BusClient::send_message_and_wait_response(const char *msg_req_param, char **msg_rsp_param) { + CORBA::Long ret_val; + + *msg_rsp_param = _server->send_message_and_wait_response(msg_req_param, ret_val); + return ret_val; +} + +int BusClient::send_message_and_request_response(BusMessage *msg_req_param) { + _server->send_dataitem_message_and_request_response(_client, msg_req_param->_dataItemSeq); + return 0; +} + +int BusClient::send_message_and_wait_response(BusMessage *msg_req_param, BusMessage **msg_rsp_param) { + plpbus_orb::DataItemSequence *seq_rsp; + + seq_rsp = NULL; + _server->send_dataitem_message_and_wait_response(msg_req_param->_dataItemSeq, seq_rsp); +} + +void BusClient::request_shutdown() { + if (CORBA::is_nil(_server) == false) { + _server->shutdown(); + } +} + +PortableServer::POA_var BusClient::create_poa(CORBA::ORB_var orb) { + PortableServer::POA_var ret_val; + CORBA::Object_var poa_obj; + CORBA::PolicyList policy_list; + CORBA::Any policyVal; + PortableServer::POAManager_var poa_man; + PortableServer::POA_var rootpoa; + + ret_val = NULL; + poa_obj = orb->resolve_initial_references(CONST_ROOT_POA_NAME); + if (poa_obj != NULL) { + rootpoa = PortableServer::POA::_narrow(poa_obj); + if (rootpoa != NULL) { + poa_man = rootpoa->the_POAManager(); + if (poa_man != NULL) { + poa_man->activate(); + // bidirectional policy + policy_list.length(1); + policyVal <<= BiDirPolicy::BOTH; + policy_list[0] = orb->create_policy(BiDirPolicy::BIDIRECTIONAL_POLICY_TYPE, policyVal); + ret_val = rootpoa->create_POA(CONST_ROOT_POA_BIDIR_POLICY_NAME, + poa_man, + policy_list); + } + } + } + else { + cerr << "Failed to create RootPOA." << endl; + } + return ret_val; +} + +CosNaming::NamingContext_var BusClient::get_name_service_context(CORBA::ORB_var orb_param) { + CORBA::Object_var ns_obj; + CosNaming::NamingContext_var ret_val; + + ret_val = NULL; + try { + ns_obj = orb_param->resolve_initial_references(CONST_NAME_SERVICE_NAME); + if (CORBA::is_nil(ns_obj) == false) { + // narrow the object reference + ret_val = CosNaming::NamingContext::_narrow(ns_obj); + } + } + catch (CORBA::ORB::InvalidName&) { + // This should not happen! + cerr << "Could not find name service." << endl; + } + catch(CORBA::TRANSIENT& ex) { + cerr << "Could not find name service, verify that name service is running. " << endl; + } + catch (CORBA::NO_RESOURCES&) { + cerr << "Could not find name service, verify that name service is running. " << endl; + } + catch(CORBA::SystemException& ex) { + cerr << "Could not find name service, unknown reason. " << endl; + } + return ret_val; +} + +CORBA::Object_var BusClient::find_server_object_by_name(CORBA::ORB_var orb_param, + const char *leaf_name_param, + const char *leaf_kind_param, + const char *service_name_param, + const char *service_kind_param) +{ + CORBA::Object_var ret_val; + CosNaming::NamingContext_var ns_root_context; + CosNaming::Name service_data; + + ret_val = CORBA::Object::_nil(); + ns_root_context = get_name_service_context(orb_param); + if (CORBA::is_nil(ns_root_context) == false) { + // define search criteria + service_data.length(2); + service_data[0].id = leaf_name_param; + service_data[0].kind = leaf_kind_param; + service_data[1].id = service_name_param; + service_data[1].kind = service_kind_param; + try { + ret_val = ns_root_context->resolve(service_data); + } + catch(CosNaming::NamingContext::NotFound& ex) { + cerr << "Could not find service from the name server. " << endl; + } + catch(CORBA::TRANSIENT& ex) { + cerr << "Could not find service from the name server. " << endl; + } + catch(CORBA::SystemException& ex) { + cerr << "Could not find service from the name server, unknown error." << endl; + } + } + else { + cerr << "Could not find naming service. " << endl; + } + return ret_val; +} diff --git a/src/plpbus/BusClient.hh b/src/plpbus/BusClient.hh new file mode 100644 index 0000000..a1fe5dc --- /dev/null +++ b/src/plpbus/BusClient.hh @@ -0,0 +1,54 @@ +/* + * BusClient.hh + * + * Created on: Jun 7, 2010 + * Author: lamikr + */ + +#ifndef PLPBUS_CLIENT_HH_ +#define PLPBUS_CLIENT_HH_ + +#include +#include + +#include "RequestResponseBus.hh" +#include "IClientListener.hh" +#include "ClientServerCommon.hh" +#include "BusMessage.hh" + +namespace plpbus { + class BusClient { + public: + BusClient(); + virtual ~BusClient(); + virtual int init(const char *server_name); + virtual int add_client_listener(IClientListener *listener_param); + virtual int send_message_and_request_response(const char *msg_req_param); + virtual int send_message_and_wait_response(const char *msg_req_param, char **msg_rsp_param); + virtual int send_message_and_request_response(BusMessage *msg_req_param); + virtual int send_message_and_wait_response(BusMessage *msg_req_param, BusMessage **msg_rsp_param); + virtual void request_shutdown(); + private: + PortableServer::POA_var _poa; + CORBA::ORB_var _orb; + plpbus_orb::OrbServer_var _server; + plpbus_orb::OrbClient_var _client; + + PortableServer::POA_var create_poa(CORBA::ORB_var orb); + CosNaming::NamingContext_var get_name_service_context(CORBA::ORB_var orb_param); + /** + * Finds server object by it's name by using following keywords: + * name[0].id = (const char *)CONST_LEAF_CONTEXT_NAME__PLPBUS; + * name[0].kind = (const char *)CONST_CONTEXT_KIND__PLPBUS; + * name[1].id = server_name; + * name[1].kind = (const char *)CONST_CONTEXT_KIND__PLPBUS; + */ + CORBA::Object_var find_server_object_by_name(CORBA::ORB_var orb, + const char *leaf_name_param, + const char *leaf_kind_param, + const char *service_name_param, + const char *service_kind_param); + }; +} + +#endif /* PLPBUS_CLIENT_HH_ */ diff --git a/src/plpbus/BusMessage.cc b/src/plpbus/BusMessage.cc new file mode 100644 index 0000000..2e52f1f --- /dev/null +++ b/src/plpbus/BusMessage.cc @@ -0,0 +1,223 @@ +/* + * BusMessage.cpp + * + * Created on: Aug 17, 2010 + * Author: lamikr + */ + +#include "BusMessage.hh" + +using namespace std; +using namespace plpbus_orb; +using namespace plpbus; +using namespace CORBA; + +BusMessage::BusMessage() +{ + _dataItemSeq.length(0); + +} + +BusMessage::BusMessage(const char *name_param, const char *value_param) +{ + DataItem *item; + + if (name_param != NULL) { + item = new DataItem(); + item->name = strdup(name_param); + item->value <<= strdup(value_param); + + _dataItemSeq.length(1); + _dataItemSeq[0] = *item; + } + else { + _dataItemSeq.length(0); + } + +} + +BusMessage::~BusMessage() +{ + // TODO Auto-generated destructor stub +} + +int BusMessage::add_string_parameter(const char *name_param, const char *value_param) +{ + long length; + int ret_val; + DataItem *item; + + ret_val = 0; + if (name_param != NULL) { + length = _dataItemSeq.length(); + item = new DataItem(); + item->name = strdup(name_param); + if (value_param != NULL) { + item->value <<= strdup(value_param); + _dataItemSeq.length(length + 1); + _dataItemSeq[length] = *item; + } + } + else { + _dataItemSeq.length(0); + ret_val = -1; + } + return ret_val; +} + +int BusMessage::add_long_parameter(const char *name_param, long value_param) +{ + long length; + int ret_val; + DataItem *item; + + ret_val = 0; + if (name_param != NULL) { + length = _dataItemSeq.length(); + item = new DataItem(); + item->name = strdup(name_param); + item->value <<= value_param; + + _dataItemSeq.length(length + 1); + _dataItemSeq[length] = *item; + } + else { + _dataItemSeq.length(0); + ret_val = -1; + } + return ret_val; +} + +int BusMessage::add_int_parameter(const char *name_param, int value_param) +{ + long length; + int ret_val; + DataItem *item; + + ret_val = 0; + if (name_param != NULL) { + length = _dataItemSeq.length(); + item = new DataItem(); + item->name = strdup(name_param); + item->value <<= (long)value_param; + + _dataItemSeq.length(length + 1); + _dataItemSeq[length] = *item; + } + else { + _dataItemSeq.length(0); + ret_val = -1; + } + return ret_val; +} + +int BusMessage::add_double_parameter(const char *name_param, double value_param) +{ + long length; + int ret_val; + DataItem *item; + + ret_val = 0; + if (name_param != NULL) { + length = _dataItemSeq.length(); + item = new DataItem(); + item->name = strdup(name_param); + item->value <<= (long)value_param; + + _dataItemSeq.length(length + 1); + _dataItemSeq[length] = *item; + } + else { + _dataItemSeq.length(0); + ret_val = -1; + } + return ret_val; +} + +int BusMessage::add_float_parameter(const char *name_param, float value_param) +{ + long length; + int ret_val; + DataItem *item; + + ret_val = 0; + if (name_param != NULL) { + length = _dataItemSeq.length(); + item = new DataItem(); + item->name = strdup(name_param); + item->value <<= (long)value_param; + + _dataItemSeq.length(length + 1); + _dataItemSeq[length] = *item; + } + else { + _dataItemSeq.length(0); + ret_val = -1; + } + return ret_val; +} + +void BusMessage::printout_dataitem(long index, plpbus_orb::DataItem *item) { + CORBA::TCKind kind; + + if (item != NULL) { + if (item->name != NULL) { + kind = item->value.type()->kind(); + switch(kind) { + case tk_string: + { + const char *val; + + item->value >>= val; + cout << " [" << index << "] name: " << item->name << ", value: " << val << endl; + } + break; + case tk_long: + { + long val; + item->value >>= val; + cout << " [" << index << "] name: " << item->name << ", value: " << val << endl; + //val_str = strdup("long"); + } + break; + case tk_double: + { + double val; + item->value >>= val; + cout << " [" << index << "] name: " << item->name << ", value: " << val << endl; + //val_str = strdup("double"); + } + break; + case tk_float: + { + float val; + item->value >>= val; + cout << " [" << index << "] name: " << item->name << ", value: " << val << endl; + //val_str = strdup("float"); + } + break; + default: + cout << " [" << index << "] name: " << item->name << ", value unknown. " << endl; + } + } + else { + cout << " [" << index << "] Invalid dataItem, name or value NULL." << endl; + } + } + else { + cout << " [" << index << "] dataItem NULL." << endl; + } +} + +void BusMessage::printout() { + long int count; + DataItem item; + + count = _dataItemSeq.length(); + cout << "BusMessage.printout(): parameter count: " << count << endl; + for (long ii = 0; ii < count; ii++) { + item = _dataItemSeq[ii]; + printout_dataitem(ii, &item); + } + cout << "BusMessage.printout() done" << endl; +} diff --git a/src/plpbus/BusMessage.hh b/src/plpbus/BusMessage.hh new file mode 100644 index 0000000..2436d8b --- /dev/null +++ b/src/plpbus/BusMessage.hh @@ -0,0 +1,36 @@ +/* + * BusMessage.h + * + * Created on: Aug 17, 2010 + * Author: lamikr + */ + +#ifndef BUSMESSAGE_H_ +#define BUSMESSAGE_H_ + +#include +#include + +#include "RequestResponseBus.hh" + +namespace plpbus { + class BusMessage + { + public: + plpbus_orb::DataItemSequence _dataItemSeq; + + BusMessage(); + BusMessage(const char *name_param, const char *string_value_param); + virtual ~BusMessage(); + int add_string_parameter(const char *name_param, const char *string_value_param); + int add_long_parameter(const char *name_param, long value_param); + int add_int_parameter(const char *name_param, int value_param); + int add_double_parameter(const char *name_param, double value_param); + int add_float_parameter(const char *name_param, float value_param); + void printout(); + private: + void printout_dataitem(long index, plpbus_orb::DataItem *item); + }; +} + +#endif /* BUSMESSAGE_H_ */ diff --git a/src/plpbus/BusMessageInternal.cc b/src/plpbus/BusMessageInternal.cc new file mode 100644 index 0000000..6839f79 --- /dev/null +++ b/src/plpbus/BusMessageInternal.cc @@ -0,0 +1,19 @@ +/* + * BusMessageInternal.cc + * + * Created on: Aug 18, 2010 + * Author: lamikr + */ + +#include "BusMessageInternal.hh" + +namespace plpbus { + BusMessageInternal::BusMessageInternal(plpbus_orb::DataItemSequence seq_param) { + _dataItemSeq = seq_param; + } + + BusMessageInternal::~BusMessageInternal() + { + // TODO Auto-generated destructor stub + } +} diff --git a/src/plpbus/BusMessageInternal.hh b/src/plpbus/BusMessageInternal.hh new file mode 100644 index 0000000..e3fa771 --- /dev/null +++ b/src/plpbus/BusMessageInternal.hh @@ -0,0 +1,22 @@ +/* + * BusMessageInternal.hh + * + * Created on: Aug 18, 2010 + * Author: lamikr + */ + +#ifndef BUSMESSAGEINTERNAL_HH_ +#define BUSMESSAGEINTERNAL_HH_ + +#include "BusMessage.hh" + +namespace plpbus { + class BusMessageInternal: public plpbus::BusMessage + { + public: + BusMessageInternal(plpbus_orb::DataItemSequence seq_param); + virtual ~BusMessageInternal(); + }; +} + +#endif /* BUSMESSAGEINTERNAL_HH_ */ diff --git a/src/plpbus/BusServer.cc b/src/plpbus/BusServer.cc new file mode 100644 index 0000000..44281ed --- /dev/null +++ b/src/plpbus/BusServer.cc @@ -0,0 +1,43 @@ +#include "BusServer.hh" + +using namespace std; +using namespace plpbus; + +BusServer::BusServer() +{ + orbServer = new OrbServerImpl(); +} + +BusServer::~BusServer() +{ + cout << "BusServer() destroyed." << endl; +} + +int BusServer::init() { + int retVal; + + retVal = 0; + orbServer->init(); + return retVal; +} + +int BusServer::launch(const char *server_name) +{ + int retVal; + + retVal = orbServer->launch(server_name); + return retVal; +} + +int BusServer::add_server_listener(IServerListener *listener_param) +{ + int retVal; + + retVal = orbServer->add_server_listener(listener_param); + return retVal; +} + +void BusServer::shutdown() +{ + orbServer->shutdown(); +} diff --git a/src/plpbus/BusServer.hh b/src/plpbus/BusServer.hh new file mode 100644 index 0000000..734ba65 --- /dev/null +++ b/src/plpbus/BusServer.hh @@ -0,0 +1,25 @@ +#ifndef BUSSERVER_HH_ +#define BUSSERVER_HH_ + +#include +#include + +#include "RequestResponseBus.hh" +#include "IServerListener.hh" +#include "OrbServerImpl.hh" + +namespace plpbus { + class BusServer { + public: + BusServer(); + virtual ~BusServer(); + virtual int init(); + virtual int launch(const char *server_name); + virtual int add_server_listener(IServerListener *listener_param); + virtual void shutdown(); + private: + OrbServerImpl *orbServer; + }; +} + +#endif // BUSSERVER_HH_ diff --git a/src/plpbus/ClientServerCommon.cc b/src/plpbus/ClientServerCommon.cc new file mode 100644 index 0000000..355980f --- /dev/null +++ b/src/plpbus/ClientServerCommon.cc @@ -0,0 +1,21 @@ +/* + * ClientServerCommon.cpp + * + * Created on: Sep 7, 2010 + * Author: lamikr + */ + +#include "ClientServerCommon.hh" + +using namespace plpbus; + +ClientServerCommon::ClientServerCommon() +{ + // TODO Auto-generated constructor stub + +} + +ClientServerCommon::~ClientServerCommon() +{ + // TODO Auto-generated destructor stub +} diff --git a/src/plpbus/ClientServerCommon.hh b/src/plpbus/ClientServerCommon.hh new file mode 100644 index 0000000..a8113a1 --- /dev/null +++ b/src/plpbus/ClientServerCommon.hh @@ -0,0 +1,30 @@ +/* + * ClientServerCommon.h + * + * Created on: Sep 7, 2010 + * Author: lamikr + */ + +#ifndef CLIENTSERVERCOMMON_H_ +#define CLIENTSERVERCOMMON_H_ + +#include +#include + +#define CONST_NAME_SERVICE_NAME "NameService" +#define CONST_CONTEXT_NAME__PLPBUS "plpbus" +#define CONST_CONTEXT_KIND__PLPBUS "plpbus" +#define CONST_ROOT_POA_NAME "RootPOA" +#define CONST_ROOT_POA_BIDIR_POLICY_NAME "bidir" +#define CONST_DEFAULT_EVENT_INTERVAL 5 + +namespace plpbus { + class ClientServerCommon + { + public: + ClientServerCommon(); + virtual ~ClientServerCommon(); + }; +} + +#endif /* CLIENTSERVERCOMMON_H_ */ diff --git a/src/plpbus/IClientListener.hh b/src/plpbus/IClientListener.hh new file mode 100644 index 0000000..7989e27 --- /dev/null +++ b/src/plpbus/IClientListener.hh @@ -0,0 +1,26 @@ +/* + * plpbus_server_callback.hh + * + * Created on: Jun 10, 2010 + * Author: lamikr + */ + +#ifndef CLIENTLISTENER_HH_ +#define CLIENTLISTENER_HH_ + +#include "BusMessage.hh" + +namespace plpbus { + class IClientListener { + public: + virtual int response_received(const char *msg_rsp_param) = 0; + virtual int response_received(const BusMessage *msg_rsp_param) = 0; + virtual int event_received(const char *event_param) = 0; + virtual int event_received(const BusMessage *event_param) = 0; + protected: + IClientListener() {}; + virtual ~IClientListener() {}; + }; +} + +#endif /* CLIENTLISTENER_HH_ */ diff --git a/src/plpbus/IServerListener.hh b/src/plpbus/IServerListener.hh new file mode 100644 index 0000000..4ea186d --- /dev/null +++ b/src/plpbus/IServerListener.hh @@ -0,0 +1,24 @@ +/* + * ServerCallbackInterface.hh + * + * Created on: Jun 16, 2010 + * Author: lamikr + */ + +#ifndef ISERVERLISTENER_HH_ +#define ISERVERLISTENER_HH_ + +#include "BusMessage.hh" + +namespace plpbus { + class IServerListener { + public: + virtual int request_received(const char *msg_in, char **msg_out) = 0; + virtual int request_received(const BusMessage *msg_req, BusMessage **msg_rsp) = 0; + protected: + IServerListener() {}; + virtual ~IServerListener() {}; + }; +} + +#endif /* ISERVERLISTENER_HH_ */ diff --git a/src/plpbus/OrbServerImpl.cc b/src/plpbus/OrbServerImpl.cc new file mode 100644 index 0000000..d12846e --- /dev/null +++ b/src/plpbus/OrbServerImpl.cc @@ -0,0 +1,351 @@ +/* + * OrbServerImpl.cc + * + * Created on: Aug 11, 2010 + * Author: lamikr + */ + +#include "ServerEventThread.hh" +#include "OrbServerImpl.hh" +#include "ClientServerCommon.hh" +#include "BusMessageInternal.hh" + +using namespace std; +using namespace plpbus; +using namespace plpbus_orb; + +static omni_mutex server_thread_mutex; +static omni_condition server_thread_shutdown_signal(&server_thread_mutex); + +OrbServerImpl::OrbServerImpl() +{ + _orb = NULL; + _poa = NULL; + _server_thread_count = 0; + _shutdown_pending = 0; + _listener = NULL; +} + +OrbServerImpl::~OrbServerImpl() +{ + cout << "OrbServerImpl destroyed." << endl; +} + +void OrbServerImpl::send_message_and_request_response(OrbClient_ptr response_listener_param, + const char* msg_req) +{ + char *msg_rsp; + + msg_rsp = NULL; + if (CORBA::is_nil(response_listener_param) == false) { + if (_listener != NULL) { + cout << "send_message_and_request_response(): " << msg_req << ", server_callback != NULL" << endl; + _listener->request_received(msg_req, &msg_rsp); + response_listener_param->receive_response_message(msg_rsp); + } + else { + cout << "send_message_and_request_response() error! " << msg_req << ", server_callback == NULL" << endl; + } + } + else { + cerr << "invalid callback object received.\n"; + } +} + +char *OrbServerImpl::send_message_and_wait_response(const char* msg_req_param, ::CORBA::Long& err_flg) { + char *msg_rsp; + char *ret_val; + + err_flg = 0; + msg_rsp = NULL; + if (_listener != NULL) { + cout << "send_message_and_wait_response(): " << msg_req_param << ", server_callback != NULL" << endl; + _listener->request_received(msg_req_param, &msg_rsp); + } + else { + cout << "send_message_and_wait_response() error! " << msg_req_param << ", server_callback == NULL" << endl; + msg_rsp = strdup(msg_req_param); + err_flg = -1; + } + ret_val = CORBA::string_dup(msg_rsp); + return ret_val; +} + +void OrbServerImpl::send_dataitem_message_and_request_response(OrbClient_ptr response_listener_param, + const ::DataItemSequence& msg_req_param) { + BusMessage *msg_req; + BusMessage *msg_rsp; + + if (CORBA::is_nil(response_listener_param) == false) { + if (_listener != NULL) { + msg_req = new BusMessageInternal(msg_req_param); + cout << "send_dataitem_message_and_request_response(), server_callback != NULL" << endl; + cout << "msg_req:" << endl; + msg_req->printout(); + msg_rsp = NULL; + _listener->request_received(msg_req, &msg_rsp); + cout << "msg_rsp length:" << msg_rsp->_dataItemSeq.length() << endl; + msg_rsp->printout(); + response_listener_param->receive_response_dataitem_sequence(msg_rsp->_dataItemSeq); + } + else { + cout << "send_dataitem_message_and_request_response() error, server_callback == NULL" << endl; + } + } +} + +CORBA::Long OrbServerImpl::send_dataitem_message_and_wait_response(const DataItemSequence& req_seq_param, + DataItemSequence_out rsp_seq_param) { + BusMessage *msg_req; + BusMessage *msg_rsp; + + msg_req = new BusMessageInternal(req_seq_param); + msg_rsp = NULL; + _listener->request_received(msg_req, &msg_rsp); + //rsp_seq_param = new DataItemSequence_out(msg_rsp._dataItemSeq); + rsp_seq_param._data = &(msg_rsp->_dataItemSeq); + + return 0; +} + +void OrbServerImpl::add_event_listener(OrbClient_ptr client_param, + const char *msg, + CORBA::UShort period_secs) +{ + ServerEventThread *srvr_thread; + + if (CORBA::is_nil(client_param) == false) { + cout << "add_event_listener()" << endl; + server_thread_mutex.lock(); + _server_thread_count++; + server_thread_mutex.unlock(); + srvr_thread = new ServerEventThread(client_param, msg, period_secs, this); + srvr_thread->start(); + } + else { + cerr << "Failed to add event listener, listener NULL.\n"; + } +} + +void OrbServerImpl::shutdown() +{ + omni_mutex_lock sync(server_thread_mutex); + if (is_shutdown_pending() == 0) { + cout << "shutdown request received!" << endl; + // Tell the servers to exit, and wait for them to do so. + _shutdown_pending = 1; + while(_server_thread_count > 0) { + server_thread_shutdown_signal.wait(); + } + // Shutdown the ORB (but do not wait for completion). This also + // causes the main thread to unblock from CORBA::ORB::run(). + _orb->shutdown(0); + } +} + +int OrbServerImpl::init() { + int argc; + char **argv; + int retVal; + + argc = -1; + argv = NULL; + retVal = 0; + _orb = CORBA::ORB_init(argc, argv); + if (_orb != NULL) { + _poa = create_poa(_orb); + retVal = 0; + } + else { + cout << "init() failed" << endl; + } + return retVal; +} + +int OrbServerImpl::launch(const char *server_name) +{ + CORBA::Object_var server_ref; + PortableServer::ObjectId_var server_id; + bool ok_flg; + int ret_val; + CosNaming::NamingContext_var naming_context; + + ret_val = -1; + POA_plpbus_orb::OrbServer_tie server_impl(this); + server_id = _poa->activate_object(&server_impl); + server_ref = server_impl._this(); + //this->_remove_ref(); + naming_context = get_service_naming_context(CONST_CONTEXT_NAME__PLPBUS, CONST_CONTEXT_KIND__PLPBUS); + if (naming_context != NULL) { + ok_flg = bind_naming_context_and_service(naming_context, server_ref, server_name, CONST_CONTEXT_KIND__PLPBUS); + if (ok_flg == true) { + cout << "Registered to naming service: " << server_name << endl; + _orb->run(); + ret_val = 0; + } + else { + cout << "Failed to register to naming service: " << server_name << endl; + } + } + return ret_val; +} + +PortableServer::POA_var OrbServerImpl::create_poa(CORBA::ORB_var orb) { + PortableServer::POA_var ret_val; + CORBA::Object_var poa_obj; + CORBA::PolicyList policy_list; + CORBA::Any policyVal; + PortableServer::POAManager_var poa_man; + PortableServer::POA_var rootpoa; + + ret_val = NULL; + poa_obj = orb->resolve_initial_references(CONST_ROOT_POA_NAME); + if (poa_obj != NULL) { + rootpoa = PortableServer::POA::_narrow(poa_obj); + if (rootpoa != NULL) { + poa_man = rootpoa->the_POAManager(); + if (poa_man != NULL) { + poa_man->activate(); + // bidirectional policy + policy_list.length(1); + policyVal <<= BiDirPolicy::BOTH; + policy_list[0] = orb->create_policy(BiDirPolicy::BIDIRECTIONAL_POLICY_TYPE, policyVal); + ret_val = rootpoa->create_POA(CONST_ROOT_POA_BIDIR_POLICY_NAME, + poa_man, + policy_list); + } + } + } + else { + cerr << "Failed to create RootPOA." << endl; + } + return ret_val; +} + +CosNaming::NamingContext_var OrbServerImpl::get_service_naming_context(const char *service_name_param, + const char *service_kind_param) +{ + CosNaming::NamingContext_var ret_val; + CosNaming::NamingContext_var ns_context; + CORBA::Object_var ns_obj; + CORBA::Object_var service_obj; + CosNaming::Name context_data; + + ret_val = NULL; + try { + // get nameservice reference + ns_obj = _orb->resolve_initial_references(CONST_NAME_SERVICE_NAME); + // get nameservice context + ns_context = CosNaming::NamingContext::_narrow(ns_obj); + if (CORBA::is_nil(ns_context) == false) { + context_data.length(1); + context_data[0].id = service_name_param; + context_data[0].kind = service_kind_param; + try { + service_obj = ns_context->resolve(context_data); + if (CORBA::is_nil(service_obj)) { + // not found, try to bind the new context to name service + ret_val = ns_context->bind_new_context(context_data); + if (CORBA::is_nil(ret_val) ) { + cerr << "Failed to create new context to name service for " << service_name_param << "." << endl; + } + } + else { + ret_val = CosNaming::NamingContext::_narrow(service_obj); + if (CORBA::is_nil(ret_val) ) { + cerr << "Failed to get existing context from name service for " << service_name_param << ", narrowing failed." << endl; + } + } + } + catch(CosNaming::NamingContext::AlreadyBound& ex) { + cerr << "Could not get context from nameservice for " << service_name_param << ". Context with same name already existed."<< endl; + } + } + } + catch (CORBA::ORB::InvalidName&) { + // This should not happen! + cerr << "Could not get context from name service for " << service_name_param << ", name service does not exist." << endl; + } + catch(CORBA::TRANSIENT& ex) { + cerr << "Could not get context from name service for " << service_name_param << ", verify that name service is running. " << service_name_param << endl; + } + catch (CORBA::NO_RESOURCES&) { + cerr << "Could not get context from name service for " << service_name_param << ". Name service is not running or has configuration problem." << endl; + } + catch(CORBA::SystemException& ex) { + cerr << "Could not get context from name service for " << service_name_param << ", could not determine reason." << endl; + } + return ret_val; +} + +bool OrbServerImpl::bind_naming_context_and_service(CosNaming::NamingContext_var service_context_param, + CORBA::Object_ptr service_ref_param, + const char *service_name_param, + const char *service_kind_param) +{ + bool retVal; + CosNaming::Name context_data; + + retVal = false; + try { + context_data.length(1); + context_data[0].id = service_name_param; + context_data[0].kind = service_kind_param; + try { + service_context_param->bind(context_data, service_ref_param); + retVal = true; + } + catch(CosNaming::NamingContext::AlreadyBound& ex) { + /** + * service existed already for the naming context with similar description. + * Replace the existing one with a new one. + */ + cout << "service " << service_name_param << " existed, replacing it." << endl; + service_context_param->rebind(context_data, service_ref_param); + retVal = true; + } + } + catch (CosNaming::NamingContext::InvalidName&) { + cerr << "Could not register service to name server, invalid service name." << endl; + } + catch (CosNaming::NamingContext::NotFound&) { + cerr << "Could not register service to name server, service object reference is invalid." << endl; + } + catch (CosNaming::NamingContext::CannotProceed&) { + // This should not happen! + cerr << "Could not register service to name server, unknown error." << endl; + } + catch(CORBA::SystemException& ex) { + cerr << "Could not register service to name server, unknown error." << endl; + } + return retVal; +} + +int OrbServerImpl::add_server_listener(IServerListener *listener_param) +{ + int retVal; + + retVal = 0; + cout << "register_request_received_callback() started" << endl; + _listener = listener_param; + cout << "register_callback() done" << endl; + return retVal; +} + +int OrbServerImpl::is_shutdown_pending() { + return _shutdown_pending; +} + +void OrbServerImpl::server_thread_closed() { + bool send_signal = false; + + server_thread_mutex.lock(); + _server_thread_count--; + if (_server_thread_count == 0) { + send_signal = true; + } + server_thread_mutex.unlock(); + if (send_signal == true) { + server_thread_shutdown_signal.signal(); + } +} diff --git a/src/plpbus/OrbServerImpl.hh b/src/plpbus/OrbServerImpl.hh new file mode 100644 index 0000000..3ca7d7a --- /dev/null +++ b/src/plpbus/OrbServerImpl.hh @@ -0,0 +1,60 @@ +/* + * OrbServerImpl.hh + * + * Created on: Aug 11, 2010 + * Author: lamikr + */ + +#ifndef ORBSERVERIMPL_HH_ +#define ORBSERVERIMPL_HH_ + +#include +#include + +#include "RequestResponseBus.hh" +#include "IServerListener.hh" + +namespace plpbus { + class OrbServerImpl + { + public: + OrbServerImpl(); + virtual ~OrbServerImpl(); + + virtual void send_message_and_request_response(plpbus_orb::OrbClient_ptr response_listener_param, const char* msg_req_param); + virtual void send_dataitem_message_and_request_response(plpbus_orb::OrbClient_ptr response_listener_param, const ::plpbus_orb::DataItemSequence& req_seq_param); + virtual char *send_message_and_wait_response(const char* msg_req_param, ::CORBA::Long& err_flg); + virtual CORBA::Long send_dataitem_message_and_wait_response(const ::plpbus_orb::DataItemSequence& req_seq_param, ::plpbus_orb::DataItemSequence_out rsp_seq_param); + virtual void add_event_listener(plpbus_orb::OrbClient_ptr client_param, + const char *msg, + CORBA::UShort period_secs); + virtual void shutdown(); + virtual int init(); + virtual int launch(const char *server_name); + virtual int is_shutdown_pending(); + virtual void server_thread_closed(); + virtual int add_server_listener(IServerListener *listener_param); + private: + PortableServer::POA_var _poa; + CORBA::ORB_var _orb; + IServerListener *_listener; + int _server_thread_count; + int _shutdown_pending; + virtual PortableServer::POA_var create_poa(CORBA::ORB_var orb); + /** + * Gets naming context from the name service. If the naming context does not yet exist, create it. + */ + CosNaming::NamingContext_var get_service_naming_context(const char *leafcontext_name, + const char *leafcontext_kind); + /** + * Bind service to naming context. + * If service with same name has already been binded, replace the existing service with the new one. + */ + bool bind_naming_context_and_service(CosNaming::NamingContext_var service_context_param, + CORBA::Object_ptr service_ref_param, + const char *service_name_param, + const char *service_kind_param); + }; +} + +#endif /* ORBSERVERIMPL_HH_ */ diff --git a/src/plpbus/RequestResponseBus.hh b/src/plpbus/RequestResponseBus.hh new file mode 100644 index 0000000..ddebb17 --- /dev/null +++ b/src/plpbus/RequestResponseBus.hh @@ -0,0 +1,625 @@ +// This file is generated by omniidl (C++ backend)- omniORB_4_1. Do not edit. +#ifndef __RequestResponseBus_hh__ +#define __RequestResponseBus_hh__ + +#ifndef __CORBA_H_EXTERNAL_GUARD__ +#include +#endif + +#ifndef USE_stub_in_nt_dll +# define USE_stub_in_nt_dll_NOT_DEFINED_RequestResponseBus +#endif +#ifndef USE_core_stub_in_nt_dll +# define USE_core_stub_in_nt_dll_NOT_DEFINED_RequestResponseBus +#endif +#ifndef USE_dyn_stub_in_nt_dll +# define USE_dyn_stub_in_nt_dll_NOT_DEFINED_RequestResponseBus +#endif + + + + + + +#ifdef USE_stub_in_nt_dll +# ifndef USE_core_stub_in_nt_dll +# define USE_core_stub_in_nt_dll +# endif +# ifndef USE_dyn_stub_in_nt_dll +# define USE_dyn_stub_in_nt_dll +# endif +#endif + +#ifdef _core_attr +# error "A local CPP macro _core_attr has already been defined." +#else +# ifdef USE_core_stub_in_nt_dll +# define _core_attr _OMNIORB_NTDLL_IMPORT +# else +# define _core_attr +# endif +#endif + +#ifdef _dyn_attr +# error "A local CPP macro _dyn_attr has already been defined." +#else +# ifdef USE_dyn_stub_in_nt_dll +# define _dyn_attr _OMNIORB_NTDLL_IMPORT +# else +# define _dyn_attr +# endif +#endif + + + + + +_CORBA_MODULE plpbus_orb + +_CORBA_MODULE_BEG + + struct DataItem { + typedef _CORBA_ConstrType_Variable_Var _var_type; + + + ::CORBA::String_member name; + + ::CORBA::Any value; + + + + void operator>>= (cdrStream &) const; + void operator<<= (cdrStream &); + }; + + typedef DataItem::_var_type DataItem_var; + + typedef _CORBA_ConstrType_Variable_OUT_arg< DataItem,DataItem_var > DataItem_out; + + _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DataItem; + + _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DataItemSequence; + + class DataItemSequence_var; + + class DataItemSequence : public _CORBA_Unbounded_Sequence< DataItem > { + public: + typedef DataItemSequence_var _var_type; + inline DataItemSequence() {} + inline DataItemSequence(const DataItemSequence& _s) + : _CORBA_Unbounded_Sequence< DataItem > (_s) {} + + inline DataItemSequence(_CORBA_ULong _max) + : _CORBA_Unbounded_Sequence< DataItem > (_max) {} + inline DataItemSequence(_CORBA_ULong _max, _CORBA_ULong _len, DataItem* _val, _CORBA_Boolean _rel=0) + : _CORBA_Unbounded_Sequence< DataItem > (_max, _len, _val, _rel) {} + + + + inline DataItemSequence& operator = (const DataItemSequence& _s) { + _CORBA_Unbounded_Sequence< DataItem > ::operator=(_s); + return *this; + } + }; + + class DataItemSequence_out; + + class DataItemSequence_var { + public: + inline DataItemSequence_var() : _pd_seq(0) {} + inline DataItemSequence_var(DataItemSequence* _s) : _pd_seq(_s) {} + inline DataItemSequence_var(const DataItemSequence_var& _s) { + if( _s._pd_seq ) _pd_seq = new DataItemSequence(*_s._pd_seq); + else _pd_seq = 0; + } + inline ~DataItemSequence_var() { if( _pd_seq ) delete _pd_seq; } + + inline DataItemSequence_var& operator = (DataItemSequence* _s) { + if( _pd_seq ) delete _pd_seq; + _pd_seq = _s; + return *this; + } + inline DataItemSequence_var& operator = (const DataItemSequence_var& _s) { + if( _s._pd_seq ) { + if( !_pd_seq ) _pd_seq = new DataItemSequence; + *_pd_seq = *_s._pd_seq; + } else if( _pd_seq ) { + delete _pd_seq; + _pd_seq = 0; + } + return *this; + } + inline DataItem& operator [] (_CORBA_ULong _s) { + return (*_pd_seq)[_s]; + } + + + + inline DataItemSequence* operator -> () { return _pd_seq; } + inline const DataItemSequence* operator -> () const { return _pd_seq; } +#if defined(__GNUG__) + inline operator DataItemSequence& () const { return *_pd_seq; } +#else + inline operator const DataItemSequence& () const { return *_pd_seq; } + inline operator DataItemSequence& () { return *_pd_seq; } +#endif + + inline const DataItemSequence& in() const { return *_pd_seq; } + inline DataItemSequence& inout() { return *_pd_seq; } + inline DataItemSequence*& out() { + if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; } + return _pd_seq; + } + inline DataItemSequence* _retn() { DataItemSequence* tmp = _pd_seq; _pd_seq = 0; return tmp; } + + friend class DataItemSequence_out; + + private: + DataItemSequence* _pd_seq; + }; + + class DataItemSequence_out { + public: + inline DataItemSequence_out(DataItemSequence*& _s) : _data(_s) { _data = 0; } + inline DataItemSequence_out(DataItemSequence_var& _s) + : _data(_s._pd_seq) { _s = (DataItemSequence*) 0; } + inline DataItemSequence_out(const DataItemSequence_out& _s) : _data(_s._data) {} + inline DataItemSequence_out& operator = (const DataItemSequence_out& _s) { + _data = _s._data; + return *this; + } + inline DataItemSequence_out& operator = (DataItemSequence* _s) { + _data = _s; + return *this; + } + inline operator DataItemSequence*&() { return _data; } + inline DataItemSequence*& ptr() { return _data; } + inline DataItemSequence* operator->() { return _data; } + + inline DataItem& operator [] (_CORBA_ULong _i) { + return (*_data)[_i]; + } + + + + DataItemSequence*& _data; + + private: + DataItemSequence_out(); + DataItemSequence_out& operator=(const DataItemSequence_var&); + }; + +#ifndef __plpbus__orb_mOrbClient__ +#define __plpbus__orb_mOrbClient__ + + class OrbClient; + class _objref_OrbClient; + class _impl_OrbClient; + + typedef _objref_OrbClient* OrbClient_ptr; + typedef OrbClient_ptr OrbClientRef; + + class OrbClient_Helper { + public: + typedef OrbClient_ptr _ptr_type; + + static _ptr_type _nil(); + static _CORBA_Boolean is_nil(_ptr_type); + static void release(_ptr_type); + static void duplicate(_ptr_type); + static void marshalObjRef(_ptr_type, cdrStream&); + static _ptr_type unmarshalObjRef(cdrStream&); + }; + + typedef _CORBA_ObjRef_Var<_objref_OrbClient, OrbClient_Helper> OrbClient_var; + typedef _CORBA_ObjRef_OUT_arg<_objref_OrbClient,OrbClient_Helper > OrbClient_out; + +#endif + + // interface OrbClient + class OrbClient { + public: + // Declarations for this interface type. + typedef OrbClient_ptr _ptr_type; + typedef OrbClient_var _var_type; + + static _ptr_type _duplicate(_ptr_type); + static _ptr_type _narrow(::CORBA::Object_ptr); + static _ptr_type _unchecked_narrow(::CORBA::Object_ptr); + + static _ptr_type _nil(); + + static inline void _marshalObjRef(_ptr_type, cdrStream&); + + static inline _ptr_type _unmarshalObjRef(cdrStream& s) { + omniObjRef* o = omniObjRef::_unMarshal(_PD_repoId,s); + if (o) + return (_ptr_type) o->_ptrToObjRef(_PD_repoId); + else + return _nil(); + } + + static _core_attr const char* _PD_repoId; + + // Other IDL defined within this scope. + + }; + + class _objref_OrbClient : + public virtual ::CORBA::Object, + public virtual omniObjRef + { + public: + void receive_event_message(const char* event_param); + void receive_event_dataitem_sequence(const ::plpbus_orb::DataItemSequence& event_param); + void receive_response_message(const char* msg_rsp_param); + void receive_response_dataitem_sequence(const ::plpbus_orb::DataItemSequence& msg_rsp_param); + + inline _objref_OrbClient() { _PR_setobj(0); } // nil + _objref_OrbClient(omniIOR*, omniIdentity*); + + protected: + virtual ~_objref_OrbClient(); + + + private: + virtual void* _ptrToObjRef(const char*); + + _objref_OrbClient(const _objref_OrbClient&); + _objref_OrbClient& operator = (const _objref_OrbClient&); + // not implemented + + friend class OrbClient; + }; + + class _pof_OrbClient : public _OMNI_NS(proxyObjectFactory) { + public: + inline _pof_OrbClient() : _OMNI_NS(proxyObjectFactory)(OrbClient::_PD_repoId) {} + virtual ~_pof_OrbClient(); + + virtual omniObjRef* newObjRef(omniIOR*,omniIdentity*); + virtual _CORBA_Boolean is_a(const char*) const; + }; + + class _impl_OrbClient : + public virtual omniServant + { + public: + virtual ~_impl_OrbClient(); + + virtual void receive_event_message(const char* event_param) = 0; + virtual void receive_event_dataitem_sequence(const ::plpbus_orb::DataItemSequence& event_param) = 0; + virtual void receive_response_message(const char* msg_rsp_param) = 0; + virtual void receive_response_dataitem_sequence(const ::plpbus_orb::DataItemSequence& msg_rsp_param) = 0; + + public: // Really protected, workaround for xlC + virtual _CORBA_Boolean _dispatch(omniCallHandle&); + + private: + virtual void* _ptrToInterface(const char*); + virtual const char* _mostDerivedRepoId(); + + }; + + + _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_OrbClient; + +#ifndef __plpbus__orb_mOrbServer__ +#define __plpbus__orb_mOrbServer__ + + class OrbServer; + class _objref_OrbServer; + class _impl_OrbServer; + + typedef _objref_OrbServer* OrbServer_ptr; + typedef OrbServer_ptr OrbServerRef; + + class OrbServer_Helper { + public: + typedef OrbServer_ptr _ptr_type; + + static _ptr_type _nil(); + static _CORBA_Boolean is_nil(_ptr_type); + static void release(_ptr_type); + static void duplicate(_ptr_type); + static void marshalObjRef(_ptr_type, cdrStream&); + static _ptr_type unmarshalObjRef(cdrStream&); + }; + + typedef _CORBA_ObjRef_Var<_objref_OrbServer, OrbServer_Helper> OrbServer_var; + typedef _CORBA_ObjRef_OUT_arg<_objref_OrbServer,OrbServer_Helper > OrbServer_out; + +#endif + + // interface OrbServer + class OrbServer { + public: + // Declarations for this interface type. + typedef OrbServer_ptr _ptr_type; + typedef OrbServer_var _var_type; + + static _ptr_type _duplicate(_ptr_type); + static _ptr_type _narrow(::CORBA::Object_ptr); + static _ptr_type _unchecked_narrow(::CORBA::Object_ptr); + + static _ptr_type _nil(); + + static inline void _marshalObjRef(_ptr_type, cdrStream&); + + static inline _ptr_type _unmarshalObjRef(cdrStream& s) { + omniObjRef* o = omniObjRef::_unMarshal(_PD_repoId,s); + if (o) + return (_ptr_type) o->_ptrToObjRef(_PD_repoId); + else + return _nil(); + } + + static _core_attr const char* _PD_repoId; + + // Other IDL defined within this scope. + + }; + + class _objref_OrbServer : + public virtual ::CORBA::Object, + public virtual omniObjRef + { + public: + void send_message_and_request_response(::plpbus_orb::OrbClient_ptr response_listener_param, const char* msg_param); + void send_dataitem_message_and_request_response(::plpbus_orb::OrbClient_ptr response_listener_param, const ::plpbus_orb::DataItemSequence& req_seq_param); + char* send_message_and_wait_response(const char* msg_req_param, ::CORBA::Long& err_flg); + ::CORBA::Long send_dataitem_message_and_wait_response(const ::plpbus_orb::DataItemSequence& req_seq_param, ::plpbus_orb::DataItemSequence_out rsp_seq_param); + void add_event_listener(::plpbus_orb::OrbClient_ptr callback_client_param, const char* msg_param, ::CORBA::UShort period_secs); + void shutdown(); + + inline _objref_OrbServer() { _PR_setobj(0); } // nil + _objref_OrbServer(omniIOR*, omniIdentity*); + + protected: + virtual ~_objref_OrbServer(); + + + private: + virtual void* _ptrToObjRef(const char*); + + _objref_OrbServer(const _objref_OrbServer&); + _objref_OrbServer& operator = (const _objref_OrbServer&); + // not implemented + + friend class OrbServer; + }; + + class _pof_OrbServer : public _OMNI_NS(proxyObjectFactory) { + public: + inline _pof_OrbServer() : _OMNI_NS(proxyObjectFactory)(OrbServer::_PD_repoId) {} + virtual ~_pof_OrbServer(); + + virtual omniObjRef* newObjRef(omniIOR*,omniIdentity*); + virtual _CORBA_Boolean is_a(const char*) const; + }; + + class _impl_OrbServer : + public virtual omniServant + { + public: + virtual ~_impl_OrbServer(); + + virtual void send_message_and_request_response(::plpbus_orb::OrbClient_ptr response_listener_param, const char* msg_param) = 0; + virtual void send_dataitem_message_and_request_response(::plpbus_orb::OrbClient_ptr response_listener_param, const ::plpbus_orb::DataItemSequence& req_seq_param) = 0; + virtual char* send_message_and_wait_response(const char* msg_req_param, ::CORBA::Long& err_flg) = 0; + virtual ::CORBA::Long send_dataitem_message_and_wait_response(const ::plpbus_orb::DataItemSequence& req_seq_param, ::plpbus_orb::DataItemSequence_out rsp_seq_param) = 0; + virtual void add_event_listener(::plpbus_orb::OrbClient_ptr callback_client_param, const char* msg_param, ::CORBA::UShort period_secs) = 0; + virtual void shutdown() = 0; + + public: // Really protected, workaround for xlC + virtual _CORBA_Boolean _dispatch(omniCallHandle&); + + private: + virtual void* _ptrToInterface(const char*); + virtual const char* _mostDerivedRepoId(); + + }; + + + _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_OrbServer; + +_CORBA_MODULE_END + + + +_CORBA_MODULE POA_plpbus_orb +_CORBA_MODULE_BEG + + class OrbClient : + public virtual plpbus_orb::_impl_OrbClient, + public virtual ::PortableServer::ServantBase + { + public: + virtual ~OrbClient(); + + inline ::plpbus_orb::OrbClient_ptr _this() { + return (::plpbus_orb::OrbClient_ptr) _do_this(::plpbus_orb::OrbClient::_PD_repoId); + } + }; + + template + class OrbClient_tie : public virtual OrbClient + { + public: + OrbClient_tie(_omniT& t) + : pd_obj(&t), pd_poa(0), pd_rel(0) {} + OrbClient_tie(_omniT& t, ::PortableServer::POA_ptr p) + : pd_obj(&t), pd_poa(p), pd_rel(0) {} + OrbClient_tie(_omniT* t, _CORBA_Boolean r=1) + : pd_obj(t), pd_poa(0), pd_rel(r) {} + OrbClient_tie(_omniT* t, ::PortableServer::POA_ptr p,_CORBA_Boolean r=1) + : pd_obj(t), pd_poa(p), pd_rel(r) {} + ~OrbClient_tie() { + if( pd_poa ) ::CORBA::release(pd_poa); + if( pd_rel ) delete pd_obj; + } + + _omniT* _tied_object() { return pd_obj; } + + void _tied_object(_omniT& t) { + if( pd_rel ) delete pd_obj; + pd_obj = &t; + pd_rel = 0; + } + + void _tied_object(_omniT* t, _CORBA_Boolean r=1) { + if( pd_rel ) delete pd_obj; + pd_obj = t; + pd_rel = r; + } + + _CORBA_Boolean _is_owner() { return pd_rel; } + void _is_owner(_CORBA_Boolean io) { pd_rel = io; } + + ::PortableServer::POA_ptr _default_POA() { + if( !pd_poa ) return ::PortableServer::POA::_the_root_poa(); + else return ::PortableServer::POA::_duplicate(pd_poa); + } + + void receive_event_message(const char* event_param) { pd_obj->receive_event_message(event_param); } + void receive_event_dataitem_sequence(const plpbus_orb::DataItemSequence& event_param) { pd_obj->receive_event_dataitem_sequence(event_param); } + void receive_response_message(const char* msg_rsp_param) { pd_obj->receive_response_message(msg_rsp_param); } + void receive_response_dataitem_sequence(const plpbus_orb::DataItemSequence& msg_rsp_param) { pd_obj->receive_response_dataitem_sequence(msg_rsp_param); } + + + private: + _omniT* pd_obj; + ::PortableServer::POA_ptr pd_poa; + _CORBA_Boolean pd_rel; + }; + + class OrbServer : + public virtual plpbus_orb::_impl_OrbServer, + public virtual ::PortableServer::ServantBase + { + public: + virtual ~OrbServer(); + + inline ::plpbus_orb::OrbServer_ptr _this() { + return (::plpbus_orb::OrbServer_ptr) _do_this(::plpbus_orb::OrbServer::_PD_repoId); + } + }; + + template + class OrbServer_tie : public virtual OrbServer + { + public: + OrbServer_tie(_omniT& t) + : pd_obj(&t), pd_poa(0), pd_rel(0) {} + OrbServer_tie(_omniT& t, ::PortableServer::POA_ptr p) + : pd_obj(&t), pd_poa(p), pd_rel(0) {} + OrbServer_tie(_omniT* t, _CORBA_Boolean r=1) + : pd_obj(t), pd_poa(0), pd_rel(r) {} + OrbServer_tie(_omniT* t, ::PortableServer::POA_ptr p,_CORBA_Boolean r=1) + : pd_obj(t), pd_poa(p), pd_rel(r) {} + ~OrbServer_tie() { + if( pd_poa ) ::CORBA::release(pd_poa); + if( pd_rel ) delete pd_obj; + } + + _omniT* _tied_object() { return pd_obj; } + + void _tied_object(_omniT& t) { + if( pd_rel ) delete pd_obj; + pd_obj = &t; + pd_rel = 0; + } + + void _tied_object(_omniT* t, _CORBA_Boolean r=1) { + if( pd_rel ) delete pd_obj; + pd_obj = t; + pd_rel = r; + } + + _CORBA_Boolean _is_owner() { return pd_rel; } + void _is_owner(_CORBA_Boolean io) { pd_rel = io; } + + ::PortableServer::POA_ptr _default_POA() { + if( !pd_poa ) return ::PortableServer::POA::_the_root_poa(); + else return ::PortableServer::POA::_duplicate(pd_poa); + } + + void send_message_and_request_response(plpbus_orb::OrbClient_ptr response_listener_param, const char* msg_param) { pd_obj->send_message_and_request_response(response_listener_param, msg_param); } + void send_dataitem_message_and_request_response(plpbus_orb::OrbClient_ptr response_listener_param, const plpbus_orb::DataItemSequence& req_seq_param) { pd_obj->send_dataitem_message_and_request_response(response_listener_param, req_seq_param); } + char* send_message_and_wait_response(const char* msg_req_param, ::CORBA::Long& err_flg) { return pd_obj->send_message_and_wait_response(msg_req_param, err_flg); } + ::CORBA::Long send_dataitem_message_and_wait_response(const plpbus_orb::DataItemSequence& req_seq_param, plpbus_orb::DataItemSequence_out rsp_seq_param) { return pd_obj->send_dataitem_message_and_wait_response(req_seq_param, rsp_seq_param); } + void add_event_listener(plpbus_orb::OrbClient_ptr callback_client_param, const char* msg_param, ::CORBA::UShort period_secs) { pd_obj->add_event_listener(callback_client_param, msg_param, period_secs); } + void shutdown() { pd_obj->shutdown(); } + + + private: + _omniT* pd_obj; + ::PortableServer::POA_ptr pd_poa; + _CORBA_Boolean pd_rel; + }; + +_CORBA_MODULE_END + + + +_CORBA_MODULE OBV_plpbus_orb +_CORBA_MODULE_BEG + +_CORBA_MODULE_END + + + + + +#undef _core_attr +#undef _dyn_attr + +extern void operator<<=(::CORBA::Any& _a, const plpbus_orb::DataItem& _s); +extern void operator<<=(::CORBA::Any& _a, plpbus_orb::DataItem* _sp); +extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, plpbus_orb::DataItem*& _sp); +extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const plpbus_orb::DataItem*& _sp); + +void operator<<=(::CORBA::Any& _a, const plpbus_orb::DataItemSequence& _s); +void operator<<=(::CORBA::Any& _a, plpbus_orb::DataItemSequence* _sp); +_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, plpbus_orb::DataItemSequence*& _sp); +_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const plpbus_orb::DataItemSequence*& _sp); + +void operator<<=(::CORBA::Any& _a, plpbus_orb::OrbClient_ptr _s); +void operator<<=(::CORBA::Any& _a, plpbus_orb::OrbClient_ptr* _s); +_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, plpbus_orb::OrbClient_ptr& _s); + +void operator<<=(::CORBA::Any& _a, plpbus_orb::OrbServer_ptr _s); +void operator<<=(::CORBA::Any& _a, plpbus_orb::OrbServer_ptr* _s); +_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, plpbus_orb::OrbServer_ptr& _s); + + + +inline void +plpbus_orb::OrbClient::_marshalObjRef(::plpbus_orb::OrbClient_ptr obj, cdrStream& s) { + omniObjRef::_marshal(obj->_PR_getobj(),s); +} + + +inline void +plpbus_orb::OrbServer::_marshalObjRef(::plpbus_orb::OrbServer_ptr obj, cdrStream& s) { + omniObjRef::_marshal(obj->_PR_getobj(),s); +} + + + + +#ifdef USE_stub_in_nt_dll_NOT_DEFINED_RequestResponseBus +# undef USE_stub_in_nt_dll +# undef USE_stub_in_nt_dll_NOT_DEFINED_RequestResponseBus +#endif +#ifdef USE_core_stub_in_nt_dll_NOT_DEFINED_RequestResponseBus +# undef USE_core_stub_in_nt_dll +# undef USE_core_stub_in_nt_dll_NOT_DEFINED_RequestResponseBus +#endif +#ifdef USE_dyn_stub_in_nt_dll_NOT_DEFINED_RequestResponseBus +# undef USE_dyn_stub_in_nt_dll +# undef USE_dyn_stub_in_nt_dll_NOT_DEFINED_RequestResponseBus +#endif + +#endif // __RequestResponseBus_hh__ + diff --git a/src/plpbus/RequestResponseBusSK.cc b/src/plpbus/RequestResponseBusSK.cc new file mode 100644 index 0000000..9877936 --- /dev/null +++ b/src/plpbus/RequestResponseBusSK.cc @@ -0,0 +1,1012 @@ +// This file is generated by omniidl (C++ backend)- omniORB_4_1. Do not edit. + +#include "RequestResponseBus.hh" +#include +#include +#include +#include +#include + + +OMNI_USING_NAMESPACE(omni) + +static const char* _0RL_library_version = omniORB_4_1; + + + +void +plpbus_orb::DataItem::operator>>= (cdrStream &_n) const +{ + _n.marshalString(name,0); + (const ::CORBA::Any&) value >>= _n; + +} + +void +plpbus_orb::DataItem::operator<<= (cdrStream &_n) +{ + name = _n.unmarshalString(0); + (::CORBA::Any&)value <<= _n; + +} + +plpbus_orb::OrbClient_ptr plpbus_orb::OrbClient_Helper::_nil() { + return ::plpbus_orb::OrbClient::_nil(); +} + +::CORBA::Boolean plpbus_orb::OrbClient_Helper::is_nil(::plpbus_orb::OrbClient_ptr p) { + return ::CORBA::is_nil(p); + +} + +void plpbus_orb::OrbClient_Helper::release(::plpbus_orb::OrbClient_ptr p) { + ::CORBA::release(p); +} + +void plpbus_orb::OrbClient_Helper::marshalObjRef(::plpbus_orb::OrbClient_ptr obj, cdrStream& s) { + ::plpbus_orb::OrbClient::_marshalObjRef(obj, s); +} + +plpbus_orb::OrbClient_ptr plpbus_orb::OrbClient_Helper::unmarshalObjRef(cdrStream& s) { + return ::plpbus_orb::OrbClient::_unmarshalObjRef(s); +} + +void plpbus_orb::OrbClient_Helper::duplicate(::plpbus_orb::OrbClient_ptr obj) { + if( obj && !obj->_NP_is_nil() ) omni::duplicateObjRef(obj); +} + +plpbus_orb::OrbClient_ptr +plpbus_orb::OrbClient::_duplicate(::plpbus_orb::OrbClient_ptr obj) +{ + if( obj && !obj->_NP_is_nil() ) omni::duplicateObjRef(obj); + return obj; +} + +plpbus_orb::OrbClient_ptr +plpbus_orb::OrbClient::_narrow(::CORBA::Object_ptr obj) +{ + if( !obj || obj->_NP_is_nil() || obj->_NP_is_pseudo() ) return _nil(); + _ptr_type e = (_ptr_type) obj->_PR_getobj()->_realNarrow(_PD_repoId); + return e ? e : _nil(); +} + + +plpbus_orb::OrbClient_ptr +plpbus_orb::OrbClient::_unchecked_narrow(::CORBA::Object_ptr obj) +{ + if( !obj || obj->_NP_is_nil() || obj->_NP_is_pseudo() ) return _nil(); + _ptr_type e = (_ptr_type) obj->_PR_getobj()->_uncheckedNarrow(_PD_repoId); + return e ? e : _nil(); +} + +plpbus_orb::OrbClient_ptr +plpbus_orb::OrbClient::_nil() +{ +#ifdef OMNI_UNLOADABLE_STUBS + static _objref_OrbClient _the_nil_obj; + return &_the_nil_obj; +#else + static _objref_OrbClient* _the_nil_ptr = 0; + if( !_the_nil_ptr ) { + omni::nilRefLock().lock(); + if( !_the_nil_ptr ) { + _the_nil_ptr = new _objref_OrbClient; + registerNilCorbaObject(_the_nil_ptr); + } + omni::nilRefLock().unlock(); + } + return _the_nil_ptr; +#endif +} + +const char* plpbus_orb::OrbClient::_PD_repoId = "IDL:plpbus_orb/OrbClient:1.0"; + + +plpbus_orb::_objref_OrbClient::~_objref_OrbClient() { + +} + + +plpbus_orb::_objref_OrbClient::_objref_OrbClient(omniIOR* ior, omniIdentity* id) : + omniObjRef(::plpbus_orb::OrbClient::_PD_repoId, ior, id, 1) + + +{ + _PR_setobj(this); +} + +void* +plpbus_orb::_objref_OrbClient::_ptrToObjRef(const char* id) +{ + if( id == ::plpbus_orb::OrbClient::_PD_repoId ) + return (::plpbus_orb::OrbClient_ptr) this; + + if( id == ::CORBA::Object::_PD_repoId ) + return (::CORBA::Object_ptr) this; + + if( omni::strMatch(id, ::plpbus_orb::OrbClient::_PD_repoId) ) + return (::plpbus_orb::OrbClient_ptr) this; + + if( omni::strMatch(id, ::CORBA::Object::_PD_repoId) ) + return (::CORBA::Object_ptr) this; + + return 0; +} + +// Proxy call descriptor class. Mangled signature: +// void_i_cstring +class _0RL_cd_00d6793dc2c2a80c_00000000 + : public omniCallDescriptor +{ +public: + inline _0RL_cd_00d6793dc2c2a80c_00000000(LocalCallFn lcfn,const char* op_,size_t oplen,_CORBA_Boolean upcall=0): + omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 0, upcall) + { + + } + + void marshalArguments(cdrStream&); + void unmarshalArguments(cdrStream&); + + + + static const char* const _user_exns[]; + + ::CORBA::String_var arg_0_; + const char* arg_0; +}; + +void _0RL_cd_00d6793dc2c2a80c_00000000::marshalArguments(cdrStream& _n) +{ + _n.marshalString(arg_0,0); + +} + +void _0RL_cd_00d6793dc2c2a80c_00000000::unmarshalArguments(cdrStream& _n) +{ + arg_0_ = _n.unmarshalString(0); + arg_0 = arg_0_.in(); + +} + +const char* const _0RL_cd_00d6793dc2c2a80c_00000000::_user_exns[] = { + 0 +}; + +// Local call call-back function. +static void +_0RL_lcfn_00d6793dc2c2a80c_10000000(omniCallDescriptor* cd, omniServant* svnt) +{ + _0RL_cd_00d6793dc2c2a80c_00000000* tcd = (_0RL_cd_00d6793dc2c2a80c_00000000*)cd; + plpbus_orb::_impl_OrbClient* impl = (plpbus_orb::_impl_OrbClient*) svnt->_ptrToInterface(plpbus_orb::OrbClient::_PD_repoId); + impl->receive_event_message(tcd->arg_0); + + +} + +void plpbus_orb::_objref_OrbClient::receive_event_message(const char* event_param) +{ + _0RL_cd_00d6793dc2c2a80c_00000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_10000000, "receive_event_message", 22); + _call_desc.arg_0 = event_param; + + _invoke(_call_desc); + + + +} +// Proxy call descriptor class. Mangled signature: +// void_i_cplpbus__orb_mDataItemSequence +class _0RL_cd_00d6793dc2c2a80c_20000000 + : public omniCallDescriptor +{ +public: + inline _0RL_cd_00d6793dc2c2a80c_20000000(LocalCallFn lcfn,const char* op_,size_t oplen,_CORBA_Boolean upcall=0): + omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 0, upcall) + { + + } + + void marshalArguments(cdrStream&); + void unmarshalArguments(cdrStream&); + + + + static const char* const _user_exns[]; + + plpbus_orb::DataItemSequence_var arg_0_; + const plpbus_orb::DataItemSequence* arg_0; +}; + +void _0RL_cd_00d6793dc2c2a80c_20000000::marshalArguments(cdrStream& _n) +{ + (const plpbus_orb::DataItemSequence&) *arg_0 >>= _n; + +} + +void _0RL_cd_00d6793dc2c2a80c_20000000::unmarshalArguments(cdrStream& _n) +{ + arg_0_ = new plpbus_orb::DataItemSequence; + (plpbus_orb::DataItemSequence&)arg_0_ <<= _n; + arg_0 = &arg_0_.in(); + +} + +const char* const _0RL_cd_00d6793dc2c2a80c_20000000::_user_exns[] = { + 0 +}; + +// Local call call-back function. +static void +_0RL_lcfn_00d6793dc2c2a80c_30000000(omniCallDescriptor* cd, omniServant* svnt) +{ + _0RL_cd_00d6793dc2c2a80c_20000000* tcd = (_0RL_cd_00d6793dc2c2a80c_20000000*)cd; + plpbus_orb::_impl_OrbClient* impl = (plpbus_orb::_impl_OrbClient*) svnt->_ptrToInterface(plpbus_orb::OrbClient::_PD_repoId); + impl->receive_event_dataitem_sequence(*tcd->arg_0); + + +} + +void plpbus_orb::_objref_OrbClient::receive_event_dataitem_sequence(const ::plpbus_orb::DataItemSequence& event_param) +{ + _0RL_cd_00d6793dc2c2a80c_20000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_30000000, "receive_event_dataitem_sequence", 32); + _call_desc.arg_0 = &(::plpbus_orb::DataItemSequence&) event_param; + + _invoke(_call_desc); + + + +} +// Local call call-back function. +static void +_0RL_lcfn_00d6793dc2c2a80c_40000000(omniCallDescriptor* cd, omniServant* svnt) +{ + _0RL_cd_00d6793dc2c2a80c_00000000* tcd = (_0RL_cd_00d6793dc2c2a80c_00000000*)cd; + plpbus_orb::_impl_OrbClient* impl = (plpbus_orb::_impl_OrbClient*) svnt->_ptrToInterface(plpbus_orb::OrbClient::_PD_repoId); + impl->receive_response_message(tcd->arg_0); + + +} + +void plpbus_orb::_objref_OrbClient::receive_response_message(const char* msg_rsp_param) +{ + _0RL_cd_00d6793dc2c2a80c_00000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_40000000, "receive_response_message", 25); + _call_desc.arg_0 = msg_rsp_param; + + _invoke(_call_desc); + + + +} +// Local call call-back function. +static void +_0RL_lcfn_00d6793dc2c2a80c_50000000(omniCallDescriptor* cd, omniServant* svnt) +{ + _0RL_cd_00d6793dc2c2a80c_20000000* tcd = (_0RL_cd_00d6793dc2c2a80c_20000000*)cd; + plpbus_orb::_impl_OrbClient* impl = (plpbus_orb::_impl_OrbClient*) svnt->_ptrToInterface(plpbus_orb::OrbClient::_PD_repoId); + impl->receive_response_dataitem_sequence(*tcd->arg_0); + + +} + +void plpbus_orb::_objref_OrbClient::receive_response_dataitem_sequence(const ::plpbus_orb::DataItemSequence& msg_rsp_param) +{ + _0RL_cd_00d6793dc2c2a80c_20000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_50000000, "receive_response_dataitem_sequence", 35); + _call_desc.arg_0 = &(::plpbus_orb::DataItemSequence&) msg_rsp_param; + + _invoke(_call_desc); + + + +} +plpbus_orb::_pof_OrbClient::~_pof_OrbClient() {} + + +omniObjRef* +plpbus_orb::_pof_OrbClient::newObjRef(omniIOR* ior, omniIdentity* id) +{ + return new ::plpbus_orb::_objref_OrbClient(ior, id); +} + + +::CORBA::Boolean +plpbus_orb::_pof_OrbClient::is_a(const char* id) const +{ + if( omni::ptrStrMatch(id, ::plpbus_orb::OrbClient::_PD_repoId) ) + return 1; + + return 0; +} + +const plpbus_orb::_pof_OrbClient _the_pof_plpbus__orb_mOrbClient; + +plpbus_orb::_impl_OrbClient::~_impl_OrbClient() {} + + +::CORBA::Boolean +plpbus_orb::_impl_OrbClient::_dispatch(omniCallHandle& _handle) +{ + const char* op = _handle.operation_name(); + + if( omni::strMatch(op, "receive_event_message") ) { + + _0RL_cd_00d6793dc2c2a80c_00000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_10000000, "receive_event_message", 22, 1); + + _handle.upcall(this,_call_desc); + return 1; + } + + if( omni::strMatch(op, "receive_event_dataitem_sequence") ) { + + _0RL_cd_00d6793dc2c2a80c_20000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_30000000, "receive_event_dataitem_sequence", 32, 1); + + _handle.upcall(this,_call_desc); + return 1; + } + + if( omni::strMatch(op, "receive_response_message") ) { + + _0RL_cd_00d6793dc2c2a80c_00000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_40000000, "receive_response_message", 25, 1); + + _handle.upcall(this,_call_desc); + return 1; + } + + if( omni::strMatch(op, "receive_response_dataitem_sequence") ) { + + _0RL_cd_00d6793dc2c2a80c_20000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_50000000, "receive_response_dataitem_sequence", 35, 1); + + _handle.upcall(this,_call_desc); + return 1; + } + + + return 0; +} + +void* +plpbus_orb::_impl_OrbClient::_ptrToInterface(const char* id) +{ + if( id == ::plpbus_orb::OrbClient::_PD_repoId ) + return (::plpbus_orb::_impl_OrbClient*) this; + + if( id == ::CORBA::Object::_PD_repoId ) + return (void*) 1; + + if( omni::strMatch(id, ::plpbus_orb::OrbClient::_PD_repoId) ) + return (::plpbus_orb::_impl_OrbClient*) this; + + if( omni::strMatch(id, ::CORBA::Object::_PD_repoId) ) + return (void*) 1; + return 0; +} + +const char* +plpbus_orb::_impl_OrbClient::_mostDerivedRepoId() +{ + return ::plpbus_orb::OrbClient::_PD_repoId; +} + +plpbus_orb::OrbServer_ptr plpbus_orb::OrbServer_Helper::_nil() { + return ::plpbus_orb::OrbServer::_nil(); +} + +::CORBA::Boolean plpbus_orb::OrbServer_Helper::is_nil(::plpbus_orb::OrbServer_ptr p) { + return ::CORBA::is_nil(p); + +} + +void plpbus_orb::OrbServer_Helper::release(::plpbus_orb::OrbServer_ptr p) { + ::CORBA::release(p); +} + +void plpbus_orb::OrbServer_Helper::marshalObjRef(::plpbus_orb::OrbServer_ptr obj, cdrStream& s) { + ::plpbus_orb::OrbServer::_marshalObjRef(obj, s); +} + +plpbus_orb::OrbServer_ptr plpbus_orb::OrbServer_Helper::unmarshalObjRef(cdrStream& s) { + return ::plpbus_orb::OrbServer::_unmarshalObjRef(s); +} + +void plpbus_orb::OrbServer_Helper::duplicate(::plpbus_orb::OrbServer_ptr obj) { + if( obj && !obj->_NP_is_nil() ) omni::duplicateObjRef(obj); +} + +plpbus_orb::OrbServer_ptr +plpbus_orb::OrbServer::_duplicate(::plpbus_orb::OrbServer_ptr obj) +{ + if( obj && !obj->_NP_is_nil() ) omni::duplicateObjRef(obj); + return obj; +} + +plpbus_orb::OrbServer_ptr +plpbus_orb::OrbServer::_narrow(::CORBA::Object_ptr obj) +{ + if( !obj || obj->_NP_is_nil() || obj->_NP_is_pseudo() ) return _nil(); + _ptr_type e = (_ptr_type) obj->_PR_getobj()->_realNarrow(_PD_repoId); + return e ? e : _nil(); +} + + +plpbus_orb::OrbServer_ptr +plpbus_orb::OrbServer::_unchecked_narrow(::CORBA::Object_ptr obj) +{ + if( !obj || obj->_NP_is_nil() || obj->_NP_is_pseudo() ) return _nil(); + _ptr_type e = (_ptr_type) obj->_PR_getobj()->_uncheckedNarrow(_PD_repoId); + return e ? e : _nil(); +} + +plpbus_orb::OrbServer_ptr +plpbus_orb::OrbServer::_nil() +{ +#ifdef OMNI_UNLOADABLE_STUBS + static _objref_OrbServer _the_nil_obj; + return &_the_nil_obj; +#else + static _objref_OrbServer* _the_nil_ptr = 0; + if( !_the_nil_ptr ) { + omni::nilRefLock().lock(); + if( !_the_nil_ptr ) { + _the_nil_ptr = new _objref_OrbServer; + registerNilCorbaObject(_the_nil_ptr); + } + omni::nilRefLock().unlock(); + } + return _the_nil_ptr; +#endif +} + +const char* plpbus_orb::OrbServer::_PD_repoId = "IDL:plpbus_orb/OrbServer:1.0"; + + +plpbus_orb::_objref_OrbServer::~_objref_OrbServer() { + +} + + +plpbus_orb::_objref_OrbServer::_objref_OrbServer(omniIOR* ior, omniIdentity* id) : + omniObjRef(::plpbus_orb::OrbServer::_PD_repoId, ior, id, 1) + + +{ + _PR_setobj(this); +} + +void* +plpbus_orb::_objref_OrbServer::_ptrToObjRef(const char* id) +{ + if( id == ::plpbus_orb::OrbServer::_PD_repoId ) + return (::plpbus_orb::OrbServer_ptr) this; + + if( id == ::CORBA::Object::_PD_repoId ) + return (::CORBA::Object_ptr) this; + + if( omni::strMatch(id, ::plpbus_orb::OrbServer::_PD_repoId) ) + return (::plpbus_orb::OrbServer_ptr) this; + + if( omni::strMatch(id, ::CORBA::Object::_PD_repoId) ) + return (::CORBA::Object_ptr) this; + + return 0; +} + +// Proxy call descriptor class. Mangled signature: +// void_i_cplpbus__orb_mOrbClient_i_cstring +class _0RL_cd_00d6793dc2c2a80c_60000000 + : public omniCallDescriptor +{ +public: + inline _0RL_cd_00d6793dc2c2a80c_60000000(LocalCallFn lcfn,const char* op_,size_t oplen,_CORBA_Boolean upcall=0): + omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 0, upcall) + { + + } + + void marshalArguments(cdrStream&); + void unmarshalArguments(cdrStream&); + + + + static const char* const _user_exns[]; + + plpbus_orb::OrbClient_var arg_0_; + plpbus_orb::OrbClient_ptr arg_0; + ::CORBA::String_var arg_1_; + const char* arg_1; +}; + +void _0RL_cd_00d6793dc2c2a80c_60000000::marshalArguments(cdrStream& _n) +{ + plpbus_orb::OrbClient::_marshalObjRef(arg_0,_n); + _n.marshalString(arg_1,0); + +} + +void _0RL_cd_00d6793dc2c2a80c_60000000::unmarshalArguments(cdrStream& _n) +{ + arg_0_ = plpbus_orb::OrbClient::_unmarshalObjRef(_n); + arg_0 = arg_0_.in(); + arg_1_ = _n.unmarshalString(0); + arg_1 = arg_1_.in(); + +} + +const char* const _0RL_cd_00d6793dc2c2a80c_60000000::_user_exns[] = { + 0 +}; + +// Local call call-back function. +static void +_0RL_lcfn_00d6793dc2c2a80c_70000000(omniCallDescriptor* cd, omniServant* svnt) +{ + _0RL_cd_00d6793dc2c2a80c_60000000* tcd = (_0RL_cd_00d6793dc2c2a80c_60000000*)cd; + plpbus_orb::_impl_OrbServer* impl = (plpbus_orb::_impl_OrbServer*) svnt->_ptrToInterface(plpbus_orb::OrbServer::_PD_repoId); + impl->send_message_and_request_response(tcd->arg_0, tcd->arg_1); + + +} + +void plpbus_orb::_objref_OrbServer::send_message_and_request_response(::plpbus_orb::OrbClient_ptr response_listener_param, const char* msg_param) +{ + _0RL_cd_00d6793dc2c2a80c_60000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_70000000, "send_message_and_request_response", 34); + _call_desc.arg_0 = response_listener_param; + _call_desc.arg_1 = msg_param; + + _invoke(_call_desc); + + + +} +// Proxy call descriptor class. Mangled signature: +// void_i_cplpbus__orb_mOrbClient_i_cplpbus__orb_mDataItemSequence +class _0RL_cd_00d6793dc2c2a80c_80000000 + : public omniCallDescriptor +{ +public: + inline _0RL_cd_00d6793dc2c2a80c_80000000(LocalCallFn lcfn,const char* op_,size_t oplen,_CORBA_Boolean upcall=0): + omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 0, upcall) + { + + } + + void marshalArguments(cdrStream&); + void unmarshalArguments(cdrStream&); + + + + static const char* const _user_exns[]; + + plpbus_orb::OrbClient_var arg_0_; + plpbus_orb::OrbClient_ptr arg_0; + plpbus_orb::DataItemSequence_var arg_1_; + const plpbus_orb::DataItemSequence* arg_1; +}; + +void _0RL_cd_00d6793dc2c2a80c_80000000::marshalArguments(cdrStream& _n) +{ + plpbus_orb::OrbClient::_marshalObjRef(arg_0,_n); + (const plpbus_orb::DataItemSequence&) *arg_1 >>= _n; + +} + +void _0RL_cd_00d6793dc2c2a80c_80000000::unmarshalArguments(cdrStream& _n) +{ + arg_0_ = plpbus_orb::OrbClient::_unmarshalObjRef(_n); + arg_0 = arg_0_.in(); + arg_1_ = new plpbus_orb::DataItemSequence; + (plpbus_orb::DataItemSequence&)arg_1_ <<= _n; + arg_1 = &arg_1_.in(); + +} + +const char* const _0RL_cd_00d6793dc2c2a80c_80000000::_user_exns[] = { + 0 +}; + +// Local call call-back function. +static void +_0RL_lcfn_00d6793dc2c2a80c_90000000(omniCallDescriptor* cd, omniServant* svnt) +{ + _0RL_cd_00d6793dc2c2a80c_80000000* tcd = (_0RL_cd_00d6793dc2c2a80c_80000000*)cd; + plpbus_orb::_impl_OrbServer* impl = (plpbus_orb::_impl_OrbServer*) svnt->_ptrToInterface(plpbus_orb::OrbServer::_PD_repoId); + impl->send_dataitem_message_and_request_response(tcd->arg_0, *tcd->arg_1); + + +} + +void plpbus_orb::_objref_OrbServer::send_dataitem_message_and_request_response(::plpbus_orb::OrbClient_ptr response_listener_param, const ::plpbus_orb::DataItemSequence& req_seq_param) +{ + _0RL_cd_00d6793dc2c2a80c_80000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_90000000, "send_dataitem_message_and_request_response", 43); + _call_desc.arg_0 = response_listener_param; + _call_desc.arg_1 = &(::plpbus_orb::DataItemSequence&) req_seq_param; + + _invoke(_call_desc); + + + +} +// Proxy call descriptor class. Mangled signature: +// _cstring_i_cstring_o_clong +class _0RL_cd_00d6793dc2c2a80c_a0000000 + : public omniCallDescriptor +{ +public: + inline _0RL_cd_00d6793dc2c2a80c_a0000000(LocalCallFn lcfn,const char* op_,size_t oplen,_CORBA_Boolean upcall=0): + omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 0, upcall) + { + + } + + void marshalArguments(cdrStream&); + void unmarshalArguments(cdrStream&); + + void unmarshalReturnedValues(cdrStream&); + void marshalReturnedValues(cdrStream&); + + + static const char* const _user_exns[]; + + ::CORBA::String_var arg_0_; + const char* arg_0; + ::CORBA::Long arg_1; + ::CORBA::String_var result; +}; + +void _0RL_cd_00d6793dc2c2a80c_a0000000::marshalArguments(cdrStream& _n) +{ + _n.marshalString(arg_0,0); + +} + +void _0RL_cd_00d6793dc2c2a80c_a0000000::unmarshalArguments(cdrStream& _n) +{ + arg_0_ = _n.unmarshalString(0); + arg_0 = arg_0_.in(); + +} + +void _0RL_cd_00d6793dc2c2a80c_a0000000::marshalReturnedValues(cdrStream& _n) +{ + _n.marshalString(result,0); + arg_1 >>= _n; + +} + +void _0RL_cd_00d6793dc2c2a80c_a0000000::unmarshalReturnedValues(cdrStream& _n) +{ + result = _n.unmarshalString(0); + (::CORBA::Long&)arg_1 <<= _n; + +} + +const char* const _0RL_cd_00d6793dc2c2a80c_a0000000::_user_exns[] = { + 0 +}; + +// Local call call-back function. +static void +_0RL_lcfn_00d6793dc2c2a80c_b0000000(omniCallDescriptor* cd, omniServant* svnt) +{ + _0RL_cd_00d6793dc2c2a80c_a0000000* tcd = (_0RL_cd_00d6793dc2c2a80c_a0000000*)cd; + plpbus_orb::_impl_OrbServer* impl = (plpbus_orb::_impl_OrbServer*) svnt->_ptrToInterface(plpbus_orb::OrbServer::_PD_repoId); + tcd->result = impl->send_message_and_wait_response(tcd->arg_0, tcd->arg_1); + + +} + +char* plpbus_orb::_objref_OrbServer::send_message_and_wait_response(const char* msg_req_param, ::CORBA::Long& err_flg) +{ + _0RL_cd_00d6793dc2c2a80c_a0000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_b0000000, "send_message_and_wait_response", 31); + _call_desc.arg_0 = msg_req_param; + + _invoke(_call_desc); + err_flg = _call_desc.arg_1; + return _call_desc.result._retn(); + + +} +// Proxy call descriptor class. Mangled signature: +// _clong_i_cplpbus__orb_mDataItemSequence_o_cplpbus__orb_mDataItemSequence +class _0RL_cd_00d6793dc2c2a80c_c0000000 + : public omniCallDescriptor +{ +public: + inline _0RL_cd_00d6793dc2c2a80c_c0000000(LocalCallFn lcfn,const char* op_,size_t oplen,_CORBA_Boolean upcall=0): + omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 0, upcall) + { + + } + + void marshalArguments(cdrStream&); + void unmarshalArguments(cdrStream&); + + void unmarshalReturnedValues(cdrStream&); + void marshalReturnedValues(cdrStream&); + + + static const char* const _user_exns[]; + + plpbus_orb::DataItemSequence_var arg_0_; + const plpbus_orb::DataItemSequence* arg_0; + plpbus_orb::DataItemSequence_var arg_1; + ::CORBA::Long result; +}; + +void _0RL_cd_00d6793dc2c2a80c_c0000000::marshalArguments(cdrStream& _n) +{ + (const plpbus_orb::DataItemSequence&) *arg_0 >>= _n; + +} + +void _0RL_cd_00d6793dc2c2a80c_c0000000::unmarshalArguments(cdrStream& _n) +{ + arg_0_ = new plpbus_orb::DataItemSequence; + (plpbus_orb::DataItemSequence&)arg_0_ <<= _n; + arg_0 = &arg_0_.in(); + +} + +void _0RL_cd_00d6793dc2c2a80c_c0000000::marshalReturnedValues(cdrStream& _n) +{ + result >>= _n; + (const plpbus_orb::DataItemSequence&) arg_1 >>= _n; + +} + +void _0RL_cd_00d6793dc2c2a80c_c0000000::unmarshalReturnedValues(cdrStream& _n) +{ + (::CORBA::Long&)result <<= _n; + arg_1 = new plpbus_orb::DataItemSequence; + (plpbus_orb::DataItemSequence&)arg_1 <<= _n; + +} + +const char* const _0RL_cd_00d6793dc2c2a80c_c0000000::_user_exns[] = { + 0 +}; + +// Local call call-back function. +static void +_0RL_lcfn_00d6793dc2c2a80c_d0000000(omniCallDescriptor* cd, omniServant* svnt) +{ + _0RL_cd_00d6793dc2c2a80c_c0000000* tcd = (_0RL_cd_00d6793dc2c2a80c_c0000000*)cd; + plpbus_orb::_impl_OrbServer* impl = (plpbus_orb::_impl_OrbServer*) svnt->_ptrToInterface(plpbus_orb::OrbServer::_PD_repoId); + tcd->result = impl->send_dataitem_message_and_wait_response(*tcd->arg_0, tcd->arg_1.out()); + + +} + +::CORBA::Long plpbus_orb::_objref_OrbServer::send_dataitem_message_and_wait_response(const ::plpbus_orb::DataItemSequence& req_seq_param, ::plpbus_orb::DataItemSequence_out rsp_seq_param) +{ + _0RL_cd_00d6793dc2c2a80c_c0000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_d0000000, "send_dataitem_message_and_wait_response", 40); + _call_desc.arg_0 = &(::plpbus_orb::DataItemSequence&) req_seq_param; + + _invoke(_call_desc); + rsp_seq_param = _call_desc.arg_1._retn(); + return _call_desc.result; + + +} +// Proxy call descriptor class. Mangled signature: +// void_i_cplpbus__orb_mOrbClient_i_cstring_i_cunsigned_pshort +class _0RL_cd_00d6793dc2c2a80c_e0000000 + : public omniCallDescriptor +{ +public: + inline _0RL_cd_00d6793dc2c2a80c_e0000000(LocalCallFn lcfn,const char* op_,size_t oplen,_CORBA_Boolean upcall=0): + omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 0, upcall) + { + + } + + void marshalArguments(cdrStream&); + void unmarshalArguments(cdrStream&); + + + + static const char* const _user_exns[]; + + plpbus_orb::OrbClient_var arg_0_; + plpbus_orb::OrbClient_ptr arg_0; + ::CORBA::String_var arg_1_; + const char* arg_1; + ::CORBA::UShort arg_2; +}; + +void _0RL_cd_00d6793dc2c2a80c_e0000000::marshalArguments(cdrStream& _n) +{ + plpbus_orb::OrbClient::_marshalObjRef(arg_0,_n); + _n.marshalString(arg_1,0); + arg_2 >>= _n; + +} + +void _0RL_cd_00d6793dc2c2a80c_e0000000::unmarshalArguments(cdrStream& _n) +{ + arg_0_ = plpbus_orb::OrbClient::_unmarshalObjRef(_n); + arg_0 = arg_0_.in(); + arg_1_ = _n.unmarshalString(0); + arg_1 = arg_1_.in(); + (::CORBA::UShort&)arg_2 <<= _n; + +} + +const char* const _0RL_cd_00d6793dc2c2a80c_e0000000::_user_exns[] = { + 0 +}; + +// Local call call-back function. +static void +_0RL_lcfn_00d6793dc2c2a80c_f0000000(omniCallDescriptor* cd, omniServant* svnt) +{ + _0RL_cd_00d6793dc2c2a80c_e0000000* tcd = (_0RL_cd_00d6793dc2c2a80c_e0000000*)cd; + plpbus_orb::_impl_OrbServer* impl = (plpbus_orb::_impl_OrbServer*) svnt->_ptrToInterface(plpbus_orb::OrbServer::_PD_repoId); + impl->add_event_listener(tcd->arg_0, tcd->arg_1, tcd->arg_2); + + +} + +void plpbus_orb::_objref_OrbServer::add_event_listener(::plpbus_orb::OrbClient_ptr callback_client_param, const char* msg_param, ::CORBA::UShort period_secs) +{ + _0RL_cd_00d6793dc2c2a80c_e0000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_f0000000, "add_event_listener", 19); + _call_desc.arg_0 = callback_client_param; + _call_desc.arg_1 = msg_param; + _call_desc.arg_2 = period_secs; + + _invoke(_call_desc); + + + +} +// Proxy call descriptor class. Mangled signature: +// void +class _0RL_cd_00d6793dc2c2a80c_01000000 + : public omniCallDescriptor +{ +public: + inline _0RL_cd_00d6793dc2c2a80c_01000000(LocalCallFn lcfn,const char* op_,size_t oplen,_CORBA_Boolean upcall=0): + omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 0, upcall) + { + + } + + + + + static const char* const _user_exns[]; + + +}; + +const char* const _0RL_cd_00d6793dc2c2a80c_01000000::_user_exns[] = { + 0 +}; + +// Local call call-back function. +static void +_0RL_lcfn_00d6793dc2c2a80c_11000000(omniCallDescriptor*, omniServant* svnt) +{ + + plpbus_orb::_impl_OrbServer* impl = (plpbus_orb::_impl_OrbServer*) svnt->_ptrToInterface(plpbus_orb::OrbServer::_PD_repoId); + impl->shutdown(); + + +} + +void plpbus_orb::_objref_OrbServer::shutdown() +{ + _0RL_cd_00d6793dc2c2a80c_01000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_11000000, "shutdown", 9); + + + _invoke(_call_desc); + + + +} +plpbus_orb::_pof_OrbServer::~_pof_OrbServer() {} + + +omniObjRef* +plpbus_orb::_pof_OrbServer::newObjRef(omniIOR* ior, omniIdentity* id) +{ + return new ::plpbus_orb::_objref_OrbServer(ior, id); +} + + +::CORBA::Boolean +plpbus_orb::_pof_OrbServer::is_a(const char* id) const +{ + if( omni::ptrStrMatch(id, ::plpbus_orb::OrbServer::_PD_repoId) ) + return 1; + + return 0; +} + +const plpbus_orb::_pof_OrbServer _the_pof_plpbus__orb_mOrbServer; + +plpbus_orb::_impl_OrbServer::~_impl_OrbServer() {} + + +::CORBA::Boolean +plpbus_orb::_impl_OrbServer::_dispatch(omniCallHandle& _handle) +{ + const char* op = _handle.operation_name(); + + if( omni::strMatch(op, "send_message_and_request_response") ) { + + _0RL_cd_00d6793dc2c2a80c_60000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_70000000, "send_message_and_request_response", 34, 1); + + _handle.upcall(this,_call_desc); + return 1; + } + + if( omni::strMatch(op, "send_dataitem_message_and_request_response") ) { + + _0RL_cd_00d6793dc2c2a80c_80000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_90000000, "send_dataitem_message_and_request_response", 43, 1); + + _handle.upcall(this,_call_desc); + return 1; + } + + if( omni::strMatch(op, "send_message_and_wait_response") ) { + + _0RL_cd_00d6793dc2c2a80c_a0000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_b0000000, "send_message_and_wait_response", 31, 1); + + _handle.upcall(this,_call_desc); + return 1; + } + + if( omni::strMatch(op, "send_dataitem_message_and_wait_response") ) { + + _0RL_cd_00d6793dc2c2a80c_c0000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_d0000000, "send_dataitem_message_and_wait_response", 40, 1); + + _handle.upcall(this,_call_desc); + return 1; + } + + if( omni::strMatch(op, "add_event_listener") ) { + + _0RL_cd_00d6793dc2c2a80c_e0000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_f0000000, "add_event_listener", 19, 1); + + _handle.upcall(this,_call_desc); + return 1; + } + + if( omni::strMatch(op, "shutdown") ) { + + _0RL_cd_00d6793dc2c2a80c_01000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_11000000, "shutdown", 9, 1); + + _handle.upcall(this,_call_desc); + return 1; + } + + + return 0; +} + +void* +plpbus_orb::_impl_OrbServer::_ptrToInterface(const char* id) +{ + if( id == ::plpbus_orb::OrbServer::_PD_repoId ) + return (::plpbus_orb::_impl_OrbServer*) this; + + if( id == ::CORBA::Object::_PD_repoId ) + return (void*) 1; + + if( omni::strMatch(id, ::plpbus_orb::OrbServer::_PD_repoId) ) + return (::plpbus_orb::_impl_OrbServer*) this; + + if( omni::strMatch(id, ::CORBA::Object::_PD_repoId) ) + return (void*) 1; + return 0; +} + +const char* +plpbus_orb::_impl_OrbServer::_mostDerivedRepoId() +{ + return ::plpbus_orb::OrbServer::_PD_repoId; +} + +POA_plpbus_orb::OrbClient::~OrbClient() {} + +POA_plpbus_orb::OrbServer::~OrbServer() {} + diff --git a/src/plpbus/ServerEventThread.cc b/src/plpbus/ServerEventThread.cc new file mode 100644 index 0000000..f0cb4dc --- /dev/null +++ b/src/plpbus/ServerEventThread.cc @@ -0,0 +1,42 @@ +/* + * server_thread.cc + * + * Created on: Jun 2, 2010 + * Author: lamikr + */ + +////////////////////////////////////////////////////////////////////// + +// A thread object used to server clients registered +// using the plpbus_orb::OrbServer::register() method. +#include "BusServer.hh" +#include "ServerEventThread.hh" +using namespace std; +using namespace plpbus; + +ServerEventThread::ServerEventThread(plpbus_orb::OrbClient_ptr client, + const char *msg, + int period, + OrbServerImpl *server_obj) +{ + this->_orb_client = plpbus_orb::OrbClient::_duplicate(client); + this->_orb_msg = msg; + this->_interval = period; + this->_server_obj = server_obj; + _orb_client->receive_event_message("event_listener_started"); +} + +void ServerEventThread::run(void* arg) +{ + try { + while(_server_obj->is_shutdown_pending() == 0) { + omni_thread::sleep(_interval); + _orb_client->receive_event_message(_orb_msg); + } + } + catch(...) { + cout << "server_thread failed, could not connect to client!" << endl; + } + cout << "server_thread, closing" << endl; + _server_obj->server_thread_closed(); +} diff --git a/src/plpbus/ServerEventThread.hh b/src/plpbus/ServerEventThread.hh new file mode 100644 index 0000000..da0561b --- /dev/null +++ b/src/plpbus/ServerEventThread.hh @@ -0,0 +1,34 @@ +/* + * server_thread.hh + * + * Created on: Jun 2, 2010 + * Author: lamikr + */ + +#ifndef SERVEREVENTTHREAD_HH_ +#define SERVEREVENTTHREAD_HH_ + +#include +#include + +#include "RequestResponseBus.hh" +#include "OrbServerImpl.hh" + +namespace plpbus { + class ServerEventThread : public omni_thread { + public: + ServerEventThread(plpbus_orb::OrbClient_ptr client, + const char *msg, + int period, + plpbus::OrbServerImpl *server_obj); + virtual void run(void* arg); + + private: + plpbus_orb::OrbClient_var _orb_client; + CORBA::String_var _orb_msg; + int _interval; + plpbus::OrbServerImpl *_server_obj; + }; +} + +#endif /* SERVEREVENTTHREAD_HH_ */ diff --git a/src_test/Makefile.am b/src_test/Makefile.am new file mode 100644 index 0000000..35cf430 --- /dev/null +++ b/src_test/Makefile.am @@ -0,0 +1,16 @@ +bin_PROGRAMS = test_admin \ + test_client \ + test_server + +test_admin_SOURCES = test_admin.cc +test_admin_LDADD = $(SRC_LIBS) ../src/.libs/libplpbus.a + +test_client_SOURCES = test_client.cc +test_client_LDADD = $(SRC_LIBS) ../src/.libs/libplpbus.a + +test_server_SOURCES = test_server.cc +test_server_LDADD = $(SRC_LIBS) ../src/.libs/libplpbus.a + +AM_CPPFLAGS = $(SRC_CFLAGS) -I../src + +DISTCLEANFILES = Makefile.in diff --git a/src_test/test_admin.cc b/src_test/test_admin.cc new file mode 100644 index 0000000..5f2ba79 --- /dev/null +++ b/src_test/test_admin.cc @@ -0,0 +1,21 @@ +/* + * test_admin.cc + * + * Created on: Jun 7, 2010 + * Author: lamikr + */ +#include "plpbus/BusClient.hh" + +using namespace std; +using namespace plpbus; + +int main(int argc, char** argv) +{ + BusClient *client; + + cout << "hello world" << endl; + client = new plpbus::BusClient(); + client->init(argv[1]); + client->request_shutdown(); + return 0; +} diff --git a/src_test/test_client.cc b/src_test/test_client.cc new file mode 100644 index 0000000..aeca510 --- /dev/null +++ b/src_test/test_client.cc @@ -0,0 +1,90 @@ +/* + * test_client.cc + * + * Created on: Jun 9, 2010 + * Author: lamikr + */ + +#include "plpbus/BusServer.hh" +#include "plpbus/BusClient.hh" +#include "plpbus/BusMessage.hh" + +using namespace std; +using namespace plpbus; + +class ClientListenerImpl : public IClientListener +{ + public: + inline ClientListenerImpl() {} + virtual ~ClientListenerImpl() {} + virtual int response_received(const char *msg_rsp_param); + virtual int response_received(const BusMessage *msg_rsp_param); + virtual int event_received(const char *event_param); + virtual int event_received(const BusMessage *event_param); +}; + +int ClientListenerImpl::response_received(const char *msg_rsp_param) { + cout << "response_received(char *: " << msg_rsp_param << ") " << endl; + return 0; +} + +int ClientListenerImpl::response_received(const BusMessage *msg_rsp_param) { + cout << "response_received(BusMessage *) " << endl; + return 0; +} + +int ClientListenerImpl::event_received(const char *event_param) { + cout << "event_received(char *" << event_param << ") " << endl; + return 0; +} + +int ClientListenerImpl::event_received(const BusMessage *event_param) { + cout << "event_received(BusMessage *)" << endl; + return 0; +} + +int main(int argc, char** argv) +{ + BusClient *client; + ClientListenerImpl *lstnr; + int err_flg; + BusMessage *busmsg; + + if (argc >= 3) { + client = new BusClient(); + lstnr = new ClientListenerImpl(); + err_flg = client->init(argv[1]); + if (err_flg == 0) { + cout << "init success" << endl; + err_flg = client->add_client_listener(lstnr); + if (err_flg == 0) { + int err_flg; + char *rsp; + + busmsg = new BusMessage(); + busmsg->add_string_parameter("a", "hello"); + busmsg->add_string_parameter("b", "world"); + client->send_message_and_request_response(busmsg); + + rsp = NULL; + err_flg = client->send_message_and_wait_response(argv[2], &rsp); + cout << "rsp: " << rsp << endl; + err_flg = client->send_message_and_request_response(argv[2]); + if (err_flg == 0) { + cout << "request message send successfully" << endl; + } + sleep(10); + } + else { + cout << "client failed to add response listener" << endl; + } + } + else { + cout << "client failed to init" << endl; + } + } + else { + cout << "usage: " << endl; + } + return 0; +} diff --git a/src_test/test_server.cc b/src_test/test_server.cc new file mode 100644 index 0000000..801ca08 --- /dev/null +++ b/src_test/test_server.cc @@ -0,0 +1,46 @@ +#include "plpbus/BusServer.hh" + +using namespace std; +using namespace plpbus; + +class ServerListenerImpl : public IServerListener +{ + public: + inline ServerListenerImpl() {} + virtual ~ServerListenerImpl() {} + virtual int request_received(const char *msg_req, char **msg_rsp); + virtual int request_received(const BusMessage *msg_req, BusMessage **msg_rsp); +}; + +int ServerListenerImpl::request_received(const char *msg_req_param, char **msg_rsp_param) { + cout << "request_received(char *" << msg_req_param << ") " << endl; + *msg_rsp_param = strdup("jee"); + return 0; +} + +int ServerListenerImpl::request_received(const BusMessage *msg_req_param, BusMessage **msg_rsp_param) { + cout << "request_received(BusMessage *) " << endl; + *msg_rsp_param = new BusMessage(); + double dbl = (double)1.0; + (*msg_rsp_param)->add_double_parameter("rsp_param_double", dbl); + return 0; +} + +int main(int argc, char** argv) +{ + BusServer *server; + ServerListenerImpl *listener; + + if (argc >= 2) { + cout << "starting server" << endl; + server = new BusServer(); + server->init(); + listener = new ServerListenerImpl(); + server->add_server_listener(listener); + server->launch(argv[1]); + } + else { + cout << "usage: give server name as a parameter" << endl; + } + return 0; +} -- 2.41.1