implementators.
Signed-off-by: Mika Laitio <lamikr@pilppa.org>
12 files changed:
plpbus/BusServer.hh \
plpbus/BusClient.hh \
plpbus/BusMessage.hh \
plpbus/BusServer.hh \
plpbus/BusClient.hh \
plpbus/BusMessage.hh \
- plpbus/IServerListener.hh
+ plpbus/IClientListener.hh \
+ plpbus/IServerListener.hh \
+ idl/RequestResponseBus.hh
#include <plp/log.h>
#include "BusClient.hh"
#include <plp/log.h>
#include "BusClient.hh"
+#include "ClientServerCommon.hh"
#include "BusMessageInternal.hh"
#include "BusMessageInternal.hh"
+#include "RequestResponseBus.hh"
using namespace std;
using namespace plpbus;
using namespace std;
using namespace plpbus;
+using namespace plpbus_orb;
-class OrbClientImpl : public virtual POA_plpbus_orb::OrbClient
-{
+class OrbClientImpl : public virtual POA_plpbus_orb::OrbClient {
private:
IClientListener *listener;
public:
private:
IClientListener *listener;
public:
}
int BusClient::send_message_and_request_response(BusMessage *msg_req_param) {
}
int BusClient::send_message_and_request_response(BusMessage *msg_req_param) {
- _server->send_dataitem_message_and_request_response(_client, msg_req_param->_dataItemSeq);
+ DataItemSequence *seq;
+
+ seq = (DataItemSequence *)msg_req_param->_dataItemSeq;
+ _server->send_dataitem_message_and_request_response(_client, *seq);
return 0;
}
int BusClient::send_message_and_wait_response(BusMessage *msg_req_param, BusMessage **msg_rsp_param) {
return 0;
}
int BusClient::send_message_and_wait_response(BusMessage *msg_req_param, BusMessage **msg_rsp_param) {
- plpbus_orb::DataItemSequence *seq_rsp;
+ DataItemSequence *seq_rsp;
+ DataItemSequence *seq;
- _server->send_dataitem_message_and_wait_response(msg_req_param->_dataItemSeq, seq_rsp);
+ seq = (DataItemSequence *)msg_req_param->_dataItemSeq;
+ _server->send_dataitem_message_and_wait_response(*seq, seq_rsp);
#include "RequestResponseBus.hh"
#include "IClientListener.hh"
#include "RequestResponseBus.hh"
#include "IClientListener.hh"
-#include "ClientServerCommon.hh"
#include "BusMessage.hh"
namespace plpbus {
#include "BusMessage.hh"
namespace plpbus {
#include <plp/log.h>
#include "BusMessage.hh"
#include <plp/log.h>
#include "BusMessage.hh"
+#include "RequestResponseBus.hh"
using namespace std;
using namespace plpbus_orb;
using namespace plpbus;
using namespace CORBA;
using namespace std;
using namespace plpbus_orb;
using namespace plpbus;
using namespace CORBA;
-BusMessage::BusMessage()
-{
- _dataItemSeq.length(0);
-
+BusMessage::BusMessage() {
+ _dataItemSeq = new DataItemSequence();
+ log_debug("new BusMessage()\n");
-BusMessage::BusMessage(const char *name_param, const char *value_param)
-{
- DataItem *item;
+BusMessage::BusMessage(const char *name_param, const char *value_param) {
+ DataItem *item;
+ DataItemSequence *seq;
if (name_param != NULL) {
item = new DataItem();
item->name = strdup(name_param);
item->value <<= strdup(value_param);
if (name_param != NULL) {
item = new DataItem();
item->name = strdup(name_param);
item->value <<= strdup(value_param);
- _dataItemSeq.length(1);
- _dataItemSeq[0] = *item;
+ seq = new DataItemSequence(0);
+ seq->length(1);
+ (*seq)[0] = *item;
+ _dataItemSeq = seq;
- _dataItemSeq.length(0);
+ _dataItemSeq = new DataItemSequence(0);
-BusMessage::~BusMessage()
-{
- // TODO Auto-generated destructor stub
+BusMessage::~BusMessage() {
}
int BusMessage::add_string_parameter(const char *name_param, const char *value_param)
{
}
int BusMessage::add_string_parameter(const char *name_param, const char *value_param)
{
- long length;
- int ret_val;
- DataItem *item;
+ long length;
+ int ret_val;
+ DataItem *item;
+ DataItemSequence *seq;
+ seq = (DataItemSequence *)_dataItemSeq;
if (name_param != NULL) {
if (name_param != NULL) {
- length = _dataItemSeq.length();
+ length = seq->length();
- item->name = strdup(name_param);
+ item->name = strdup(name_param);
if (value_param != NULL) {
item->value <<= strdup(value_param);
if (value_param != NULL) {
item->value <<= strdup(value_param);
- _dataItemSeq.length(length + 1);
- _dataItemSeq[length] = *item;
+ seq->length(length + 1);
+ (*seq)[length] = *item;
- _dataItemSeq.length(0);
ret_val = -1;
}
return ret_val;
ret_val = -1;
}
return ret_val;
int BusMessage::add_long_parameter(const char *name_param, long value_param)
{
int BusMessage::add_long_parameter(const char *name_param, long value_param)
{
- long length;
- int ret_val;
- DataItem *item;
+ long length;
+ int ret_val;
+ DataItem *item;
+ DataItemSequence *seq;
+ seq = (DataItemSequence *)_dataItemSeq;
if (name_param != NULL) {
if (name_param != NULL) {
- length = _dataItemSeq.length();
+ length = seq->length();
item = new DataItem();
item->name = strdup(name_param);
item->value <<= value_param;
item = new DataItem();
item->name = strdup(name_param);
item->value <<= value_param;
- _dataItemSeq.length(length + 1);
- _dataItemSeq[length] = *item;
+ seq->length(length + 1);
+ (*seq)[length] = *item;
- _dataItemSeq.length(0);
ret_val = -1;
}
return ret_val;
ret_val = -1;
}
return ret_val;
int BusMessage::add_int_parameter(const char *name_param, int value_param)
{
int BusMessage::add_int_parameter(const char *name_param, int value_param)
{
- long length;
- int ret_val;
- DataItem *item;
+ long length;
+ int ret_val;
+ DataItem *item;
+ DataItemSequence *seq;
+ seq = (DataItemSequence *)_dataItemSeq;
if (name_param != NULL) {
if (name_param != NULL) {
- length = _dataItemSeq.length();
+ length = seq->length();
item = new DataItem();
item->name = strdup(name_param);
item->value <<= (long)value_param;
item = new DataItem();
item->name = strdup(name_param);
item->value <<= (long)value_param;
- _dataItemSeq.length(length + 1);
- _dataItemSeq[length] = *item;
+ seq->length(length + 1);
+ (*seq)[length] = *item;
- _dataItemSeq.length(0);
ret_val = -1;
}
return ret_val;
ret_val = -1;
}
return ret_val;
int BusMessage::add_double_parameter(const char *name_param, double value_param)
{
int BusMessage::add_double_parameter(const char *name_param, double value_param)
{
- long length;
- int ret_val;
- DataItem *item;
+ long length;
+ int ret_val;
+ DataItem *item;
+ DataItemSequence *seq;
+ log_debug("add_double_parameter() started\n");
+ seq = (DataItemSequence *)_dataItemSeq;
if (name_param != NULL) {
if (name_param != NULL) {
- length = _dataItemSeq.length();
+ length = seq->length();
item = new DataItem();
item->name = strdup(name_param);
item->value <<= (long)value_param;
item = new DataItem();
item->name = strdup(name_param);
item->value <<= (long)value_param;
- _dataItemSeq.length(length + 1);
- _dataItemSeq[length] = *item;
+ seq->length(length + 1);
+ (*seq)[length] = *item;
- _dataItemSeq.length(0);
+ log_debug("add_double_parameter() done\n");
return ret_val;
}
int BusMessage::add_float_parameter(const char *name_param, float value_param)
{
return ret_val;
}
int BusMessage::add_float_parameter(const char *name_param, float value_param)
{
- long length;
- int ret_val;
- DataItem *item;
+ long length;
+ int ret_val;
+ DataItem *item;
+ DataItemSequence *seq;
+ seq = (DataItemSequence *)_dataItemSeq;
if (name_param != NULL) {
if (name_param != NULL) {
- length = _dataItemSeq.length();
+ length = seq->length();
item = new DataItem();
item->name = strdup(name_param);
item->value <<= (long)value_param;
item = new DataItem();
item->name = strdup(name_param);
item->value <<= (long)value_param;
- _dataItemSeq.length(length + 1);
- _dataItemSeq[length] = *item;
+ seq->length(length + 1);
+ (*seq)[length] = *item;
- _dataItemSeq.length(0);
ret_val = -1;
}
return ret_val;
}
ret_val = -1;
}
return ret_val;
}
-void BusMessage::printout_dataitem(long index, plpbus_orb::DataItem *item) {
+void BusMessage::printout_dataitem(long index, void *item) {
+ dataitem = (DataItem *)item;
- if (item->name != NULL) {
- kind = item->value.type()->kind();
+ if (dataitem->name != NULL) {
+ kind = dataitem->value.type()->kind();
switch(kind) {
case tk_string:
{
const char *val;
switch(kind) {
case tk_string:
{
const char *val;
- item->value >>= val;
- log_debug(" [%ld], value: %s\n", index, val);
+ dataitem->value >>= val;
+ log_debug("\t[%ld], value: %s\n", index, val);
}
break;
case tk_long:
{
long val;
}
break;
case tk_long:
{
long val;
- item->value >>= val;
- log_debug(" [%ld], value: %ld\n", index, val);
+ dataitem->value >>= val;
+ log_debug("\t[%ld], value: %ld\n", index, val);
//val_str = strdup("long");
}
break;
case tk_double:
{
double val;
//val_str = strdup("long");
}
break;
case tk_double:
{
double val;
- item->value >>= val;
- log_debug(" [%ld], value: %f\n", index, val);
+ dataitem->value >>= val;
+ log_debug("\t[%ld], value: %f\n", index, val);
//val_str = strdup("double");
}
break;
case tk_float:
{
float val;
//val_str = strdup("double");
}
break;
case tk_float:
{
float val;
- item->value >>= val;
- log_debug(" [l%ld] value: %f\n", index, val);
+ dataitem->value >>= val;
+ log_debug("\t[l%ld] value: %f\n", index, val);
//val_str = strdup("float");
}
break;
default:
//val_str = strdup("float");
}
break;
default:
- log_error(" [%ld], value unknown\n", index);
+ log_error("\t[%ld], value unknown\n", index);
- log_error(" [%ld] Invalid data item name name or value\n", index);
+ log_error("\t[%ld] Invalid data item name name or value\n", index);
- log_error(" [%ld] dataItem NULL.", index);
+ log_error("\t[%ld] dataItem NULL.", index);
}
}
void BusMessage::printout() {
}
}
void BusMessage::printout() {
- long int count;
- DataItem item;
+ long int count;
+ DataItem item;
+ DataItemSequence *seq;
- count = _dataItemSeq.length();
+ seq = (DataItemSequence *)_dataItemSeq;
+ count = seq->length();
log_debug("BusMessage.printout(): parameter count: %ld\n", count);
for (long ii = 0; ii < count; ii++) {
log_debug("BusMessage.printout(): parameter count: %ld\n", count);
for (long ii = 0; ii < count; ii++) {
- item = _dataItemSeq[ii];
printout_dataitem(ii, &item);
}
log_debug("BusMessage.printout() done\n");;
printout_dataitem(ii, &item);
}
log_debug("BusMessage.printout() done\n");;
#ifndef BUSMESSAGE_H_
#define BUSMESSAGE_H_
#ifndef BUSMESSAGE_H_
#define BUSMESSAGE_H_
-#include "RequestResponseBus.hh"
-
namespace plpbus {
class BusMessage
{
public:
namespace plpbus {
class BusMessage
{
public:
- plpbus_orb::DataItemSequence _dataItemSeq;
BusMessage();
BusMessage(const char *name_param, const char *string_value_param);
BusMessage();
BusMessage(const char *name_param, const char *string_value_param);
int add_float_parameter(const char *name_param, float value_param);
void printout();
private:
int add_float_parameter(const char *name_param, float value_param);
void printout();
private:
- void printout_dataitem(long index, plpbus_orb::DataItem *item);
+ void printout_dataitem(long index, void *item);
#include "BusMessageInternal.hh"
#include "BusMessageInternal.hh"
+using namespace plpbus_orb;
+
- BusMessageInternal::BusMessageInternal(plpbus_orb::DataItemSequence seq_param) {
- _dataItemSeq = seq_param;
+ BusMessageInternal::BusMessageInternal(DataItemSequence seq_param) {
+ _dataItemSeq = new DataItemSequence(seq_param);
- BusMessageInternal::~BusMessageInternal()
- {
- // TODO Auto-generated destructor stub
+ BusMessageInternal::~BusMessageInternal() {
#define BUSMESSAGEINTERNAL_HH_
#include "BusMessage.hh"
#define BUSMESSAGEINTERNAL_HH_
#include "BusMessage.hh"
+#include "RequestResponseBus.hh"
namespace plpbus {
class BusMessageInternal: public plpbus::BusMessage
namespace plpbus {
class BusMessageInternal: public plpbus::BusMessage
#define BUSSERVER_HH_
#include "IServerListener.hh"
#define BUSSERVER_HH_
#include "IServerListener.hh"
-//#include "OrbServerImpl.hh"
namespace plpbus {
class BusServer {
namespace plpbus {
class BusServer {
if (_listener != NULL) {
log_debug("send_message_and_request_response(): %s, server callback != NULL\n", msg_req);
_listener->request_received(msg_req, &msg_rsp);
if (_listener != NULL) {
log_debug("send_message_and_request_response(): %s, server callback != NULL\n", msg_req);
_listener->request_received(msg_req, &msg_rsp);
+ log_debug("send_message_and_request_response(), request_received\n");
response_listener_param->receive_response_message(msg_rsp);
}
else {
response_listener_param->receive_response_message(msg_rsp);
}
else {
void OrbServerImpl::send_dataitem_message_and_request_response(OrbClient_ptr response_listener_param,
const ::DataItemSequence& msg_req_param) {
void OrbServerImpl::send_dataitem_message_and_request_response(OrbClient_ptr response_listener_param,
const ::DataItemSequence& msg_req_param) {
- BusMessage *msg_req;
- BusMessage *msg_rsp;
+ BusMessage *msg_req;
+ BusMessage *msg_rsp;
+ DataItemSequence *seq;
if (CORBA::is_nil(response_listener_param) == false) {
if (_listener != NULL) {
if (CORBA::is_nil(response_listener_param) == false) {
if (_listener != NULL) {
msg_req->printout();
msg_rsp = NULL;
_listener->request_received(msg_req, &msg_rsp);
msg_req->printout();
msg_rsp = NULL;
_listener->request_received(msg_req, &msg_rsp);
- log_debug("msg_rsp length: %ld\n", msg_rsp->_dataItemSeq.length());
+ seq = (DataItemSequence *)msg_rsp->_dataItemSeq;
+ log_debug("msg_rsp length: %ld\n", seq->length());
- response_listener_param->receive_response_dataitem_sequence(msg_rsp->_dataItemSeq);
+ response_listener_param->receive_response_dataitem_sequence(*seq);
}
else {
log_error("send_dataitem_message_and_request_response() error, server_callback == NULL\n");
}
else {
log_error("send_dataitem_message_and_request_response() error, server_callback == NULL\n");
}
CORBA::Long OrbServerImpl::send_dataitem_message_and_wait_response(const DataItemSequence& req_seq_param,
}
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;
+ DataItemSequence_out rsp_seq_param) {
+ BusMessage *msg_req;
+ BusMessage *msg_rsp;
+ DataItemSequence *seq;
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);
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);
+ seq = (DataItemSequence *)msg_rsp->_dataItemSeq;
+ rsp_seq_param._data = seq;
//this->_remove_ref();
naming_context = get_service_naming_context(CONST_CONTEXT_NAME__PLPBUS, CONST_CONTEXT_KIND__PLPBUS);
if (naming_context != NULL) {
//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);
+ 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();
if (ok_flg == true) {
cout << "Registered to naming service: " << server_name << endl;
_orb->run();
public:
OrbServerImpl();
virtual ~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 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);
-//////////////////////////////////////////////////////////////////////
-
// A thread object used to server clients registered
// using the plpbus_orb::OrbServer::register() method.
// A thread object used to server clients registered
// using the plpbus_orb::OrbServer::register() method.
#include "BusServer.hh"
#include "ServerEventThread.hh"
#include "BusServer.hh"
#include "ServerEventThread.hh"
using namespace std;
using namespace plpbus;
using namespace std;
using namespace plpbus;
- cout << "server_thread failed, could not connect to client!" << endl;
+ log_error("server_thread failed, could not connect to client!\n");
- cout << "server_thread, closing" << endl;
+ log_debug("server_thread, closing\n");
_server_obj->server_thread_closed();
}
_server_obj->server_thread_closed();
}
+#include <string.h>
+#include <plp/log.h>
#include "plpbus/BusServer.hh"
#include "plpbus/BusServer.hh"
};
int ServerListenerImpl::request_received(const char *msg_req_param, char **msg_rsp_param) {
};
int ServerListenerImpl::request_received(const char *msg_req_param, char **msg_rsp_param) {
- cout << "request_received(char *" << msg_req_param << ") " << endl;
+ log_debug("request_received(), request_param: %s\n", msg_req_param);
*msg_rsp_param = strdup("jee");
*msg_rsp_param = strdup("jee");
+ log_debug("request_received(), response param set: %s\n", *msg_rsp_param);
return 0;
}
int ServerListenerImpl::request_received(const BusMessage *msg_req_param, BusMessage **msg_rsp_param) {
return 0;
}
int ServerListenerImpl::request_received(const BusMessage *msg_req_param, BusMessage **msg_rsp_param) {
- cout << "request_received(BusMessage *) " << endl;
+ log_debug("request_received(BusMessage *) started\n");
*msg_rsp_param = new BusMessage();
double dbl = (double)1.0;
(*msg_rsp_param)->add_double_parameter("rsp_param_double", dbl);
*msg_rsp_param = new BusMessage();
double dbl = (double)1.0;
(*msg_rsp_param)->add_double_parameter("rsp_param_double", dbl);
+ log_debug("request_received(BusMessage *) done\n");
ServerListenerImpl *listener;
if (argc >= 2) {
ServerListenerImpl *listener;
if (argc >= 2) {
- cout << "starting server" << endl;
+ log_info("starting server\n");
server = new BusServer();
server->init();
listener = new ServerListenerImpl();
server = new BusServer();
server->init();
listener = new ServerListenerImpl();
server->launch(argv[1]);
}
else {
server->launch(argv[1]);
}
else {
- cout << "usage: give server name as a parameter" << endl;
+ log_info("usage: give server name as a parameter\n");