static void bb_select_once()
{
int i;
fd_set fdreads;
int fdmax = 0;
int n;
FD_ZERO(&fdreads);
for(i=0; i<RECEIVERS_MAX && BellBoy->receivers[i] != NULL; ++i){
Receiver *rev = BellBoy->receivers[i];
log_debug("bb_select_once:select %d:%d", i, rev->fd);
if(rev->select_for_read == false)
continue;
FD_SET(rev->fd, &fdreads);
if(fdmax < rev->fd)
fdmax = rev->fd;
}
n = select(fdmax+1, &fdreads, NULL, NULL, &BellBoy->select_timeout);
if(n > 0){
for(i=0; i<RECEIVERS_MAX && BellBoy->receivers[i] != NULL; ++i){
Receiver *rev = BellBoy->receivers[i];
if(FD_ISSET(rev->fd, &fdreads)){
log_debug("bb_select_once:call %d:%d", i, rev->fd);
rev->select_for_read = rev->call(rev->fd, rev->data);
}
}
}
}
/*! Upon completion, the flux of the archive will be normalized with
respect to the flux of the calibrator, such that a FluxCalibrator
simply scales the archive by the calibrator flux. */
void Pulsar::PolnCalibrator::calibrate (Archive* arch) try
{
if (verbose > 2)
cerr << "Pulsar::PolnCalibrator::calibrate" << endl;
calibration_setup (arch);
if (arch->get_npol() == 4)
{
BackendCorrection correct_backend;
correct_backend (arch);
if (verbose > 2)
cerr << "Pulsar::PolnCalibrator::calibrate Archive::transform" <<endl;
arch->transform (response);
arch->set_poln_calibrated (true);
if (receiver)
{
Receiver* rcvr = arch->get<Receiver>();
if (!rcvr)
throw Error (InvalidState, "Pulsar::PolnCalibrator::calibrate",
"Archive has no Receiver Extension");
rcvr->set_basis_corrected (true);
}
}
else if (arch->get_npol() == 1)
{
if (Archive::verbose)
cerr << "Pulsar::PolnCalibrator::calibrate WARNING"
" calibrating only absolute gain" << endl;
unsigned nsub = arch->get_nsubint ();
unsigned nchan = arch->get_nchan ();
for (unsigned isub=0; isub < nsub; isub++)
{
Integration* subint = arch->get_Integration (isub);
for (unsigned ichan=0; ichan < nchan; ichan++)
{
double gain = abs(det( response[ichan] ));
Profile* profile = subint->get_Profile (0, ichan);
profile -> scale (gain);
profile -> set_weight ( profile->get_weight() / gain );
}
}
}
else
throw Error (InvalidParam, "Pulsar::PolnCalibrator::calibrate",
"Archive::npol == %d not yet implemented", arch->get_npol());
arch->set_scale (Signal::ReferenceFluxDensity);
}
catch (Error& error)
{
throw error += "Pulsar::PolnCalibrator::calibrate";
}
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
Receiver receiver;
receiver.show();
return app.exec();
}
qpid::types::Variant::Map agocontrol::AgoConnection::sendMessageReply(const char *subject, qpid::types::Variant::Map content) {
Message message;
qpid::types::Variant::Map responseMap;
Receiver responseReceiver;
try {
encode(content, message);
message.setSubject(subject);
Address responseQueue("#response-queue; {create:always, delete:always}");
responseReceiver = session.createReceiver(responseQueue);
message.setReplyTo(responseQueue);
sender.send(message);
Message response = responseReceiver.fetch(Duration::SECOND * 3);
session.acknowledge();
if (response.getContentSize() > 3) {
decode(response,responseMap);
} else {
responseMap["response"] = response.getContent();
}
} catch (qpid::messaging::NoMessageAvailable) {
printf("WARNING, no reply message to fetch\n");
} catch(const std::exception& error) {
std::cerr << error.what() << std::endl;
}
try {
responseReceiver.close();
} catch(const std::exception& error) {
std::cerr << error.what() << std::endl;
}
return responseMap;
}
static int qpidhello(char *br) {
std::string broker = br ? br : "localhost:5672";
std::string address = "amq.topic";
std::string connectionOptions = "";
Connection connection(broker, connectionOptions);
try {
connection.open();
Session session = connection.createSession();
Receiver receiver = session.createReceiver(address);
Sender sender = session.createSender(address);
sender.send(Message("Hello world!"));
Message message = receiver.fetch(Duration::SECOND * 1);
std::cout << message.getContent() << std::endl;
session.acknowledge();
connection.close();
return 0;
} catch(const std::exception& error) {
std::cerr << error.what() << std::endl;
connection.close();
return 1;
}
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
if (parse_args (argc, argv) == -1)
return -1;
Sender sender;
Receiver receiver;
// If passive side
if (host == 0)
{
if (receiver.open_addr (ACE_INET_Addr (port)) == -1)
return -1;
}
// If active side
else if (sender.open (host, port) == -1)
return -1;
for (int success = 1;
success > 0 && !done;
)
// Dispatch events via Proactor singleton.
success = ACE_Proactor::instance ()->handle_events ();
return 0;
}
void ClientHandler::operator()(Socket& socket_)
{
Display *disp = new Display();
BlockingQueue<string> q_;
while (true)
{
Receiver *rs = new Receiver();
std::string command = socket_.recvString();
q_.enQ(command);
if (command.size() == 0)
break;
size_t size= q_.size();
string ackmsg;
for (size_t i = 0; i < size; i++)
{
command = q_.deQ();
ackmsg = rs->start(command, socket_);
}
Sender *s = new Sender();
if (ackmsg != "")
{
s->sendAck(socket_, ackmsg);
}
}
disp->show("ClientHandler socket connection closing");
socket_.shutDown();
socket_.close();
disp->show("ClientHandler thread terminating");
}
void Soundcard::ReceiverRemoved(ReceiverManager3Receiver& aReceiver)
{
Receiver* receiver = (Receiver*)(aReceiver.UserData());
ASSERT(receiver);
(*iReceiverCallback)(iReceiverPtr, eRemoved, (THandle)receiver);
receiver->RemoveRef();
}
int main(int argc, char** argv) {
const char* url = argc>1 ? argv[1] : "amqp:tcp:127.0.0.1:5672";
try {
Connection connection = Connection::open(url);
Session session = connection.newSession();
Receiver receiver = session.createReceiver("service_queue; {create: always}");
while (true) {
Message request = receiver.fetch();
const Address& address = request.getReplyTo();
if (address) {
Sender sender = session.createSender(address);
std::string s = request.getContent();
std::transform(s.begin(), s.end(), s.begin(), toupper);
Message response(s);
sender.send(response);
std::cout << "Processed request: "
<< request.getContent()
<< " -> "
<< response.getContent() << std::endl;
session.acknowledge();
} else {
std::cerr << "Error: no reply address specified for request: " << request.getContent() << std::endl;
session.reject(request);
}
}
connection.close();
return 0;
} catch(const std::exception& error) {
std::cout << error.what() << std::endl;
}
return 1;
}
int main(int argc, char** argv) {
std::string broker = argc > 1 ? argv[1] : "localhost:5672";
std::string address = argc > 2 ? argv[2] : "amq.topic";
Connection connection(broker);
try {
connection.open();
Session session = connection.createSession();
Receiver receiver = session.createReceiver(address);
Sender sender = session.createSender(address);
sender.send(Message("Hello world!"));
Message message = receiver.fetch(Duration::SECOND * 1);
std::cout << message.getContent() << std::endl;
session.acknowledge();
connection.close();
return 0;
} catch(const std::exception& error) {
std::cerr << error.what() << std::endl;
connection.close();
return 1;
}
}
void Pulsar::WAPPArchive::load_extensions()
{
// Telescope extension
Telescope *t = getadd<Telescope>();
Telescopes::Arecibo(t);
// Backend extension
Backend *b = getadd<Backend>();
b->set_name("WAPP");
// ObsExtension
ObsExtension *o = getadd<ObsExtension>();
o->observer = hdr->observers;
o->project_ID = hdr->project_id;
// Receiver
Receiver *r = getadd<Receiver>();
// Use codes to init recvr
string rcode = hdr->frontend;
if (rcode=="lbw") Arecibo::L_wide(r);
else if (rcode=="sbw") Arecibo::S_wide(r);
else if (rcode=="430") Arecibo::Greg_430(r);
else if (rcode=="327") Arecibo::Greg_327(r);
else if (rcode=="cb") Arecibo::C_band(r);
else r->set_name(rcode);
// TODO : figure out hybrid field in hdr
// FITSUBHdr
FITSSUBHdrExtension *fs = getadd<FITSSUBHdrExtension>();
fs->set_tsamp(hdr->samp_time*1e-6);
}
PRIVATE inline
Receiver::Rcv_state
Receiver::vcpu_async_ipc(Sender const *sender) const
{
if (EXPECT_FALSE(state() & Thread_ipc_mask))
return Rs_not_receiving;
Vcpu_state *vcpu = vcpu_state().access();
if (EXPECT_FALSE(!vcpu_irqs_enabled(vcpu)))
return Rs_not_receiving;
Receiver *self = const_cast<Receiver*>(this);
if (this == current())
self->spill_user_state();
if (self->vcpu_enter_kernel_mode(vcpu))
vcpu = vcpu_state().access();
LOG_TRACE("VCPU events", "vcpu", this, Vcpu_log,
l->type = 1;
l->state = vcpu->_saved_state;
l->ip = Mword(sender);
l->sp = regs()->sp();
l->space = ~0; //vcpu_user_space() ? static_cast<Task*>(vcpu_user_space())->dbg_id() : ~0;
);
qpid::types::Variant::Map agocontrol::AgoConnection::getInventory() {
Variant::Map content;
Variant::Map responseMap;
content["command"] = "inventory";
Message message;
encode(content, message);
Address responseQueue("#response-queue; {create:always, delete:always}");
Receiver responseReceiver = session.createReceiver(responseQueue);
message.setReplyTo(responseQueue);
sender.send(message);
try {
Message response = responseReceiver.fetch(Duration::SECOND * 3);
session.acknowledge();
if (response.getContentSize() > 3) {
decode(response,responseMap);
}
} catch (qpid::messaging::NoMessageAvailable) {
printf("WARNING, no reply message to fetch\n");
}
try {
responseReceiver.close();
} catch(const std::exception& error) {
std::cerr << error.what() << std::endl;
}
return responseMap;
}
int main(int argc, char** argv)
{
Options options;
if (options.parse(argc, argv) && options.checkAddress()) {
Connection connection;
try {
connection = Connection(options.url, options.connectionOptions);
connection.open();
Session session = connection.createSession();
Receiver receiver = session.createReceiver(options.address);
Duration timeout = options.getTimeout();
int count = options.getCount();
Message message;
int i = 0;
while (receiver.fetch(message, timeout)) {
std::cout << message << std::endl;
session.acknowledge();
if (count && (++i == count))
break;
}
receiver.close();
session.close();
connection.close();
return 0;
} catch(const std::exception& error) {
std::cout << "Error: " << error.what() << std::endl;
connection.close();
}
}
return 1;
}
size_t CurlSource::WriteFunc(void* buffer, size_t size, size_t nmemb, void* data)
{
Receiver* rv = static_cast<Receiver*>(data);
if (rv->Cancelled())
return 0;
rv->Receive(buffer, size, nmemb);
return size * nmemb;
}
int main(int argc, char** argv) {
const char* url = argc>1 ? argv[1] : "amqp:tcp:127.0.0.1:5672";
std::string connectionOptions = argc > 2 ? argv[2] : "";
Connection connection(url, connectionOptions);
try {
connection.open();
Session session = connection.createSession();
Receiver receiver = session.createReceiver("service_queue; {create: always}");
while (true) {
Message request = receiver.fetch();
const Address& address = request.getReplyTo();
if (address) {
Sender sender = session.createSender(address);
Message response;
qpid::types::Variant requestObj = request.getContentObject();
if (requestObj.getType() == qpid::types::VAR_STRING) {
// Received a string.
// Server returns request string in upper case with same encoding.
std::string s = requestObj;
std::transform(s.begin(), s.end(), s.begin(), toupper);
qpid::types::Variant responseObj(s);
responseObj.setEncoding( requestObj.getEncoding() );
response.setContentObject( responseObj );
} else {
// Received something other than a string.
// Server echos received object as a utf8 string.
qpid::types::Variant responseObj( requestObj.asString() );
responseObj.setEncoding( "utf8" );
response.setContentObject( requestObj );
}
sender.send(response);
std::cout << "Processed request: "
<< request.getContentObject()
<< " -> "
<< response.getContentObject() << std::endl;
session.acknowledge();
sender.close();
} else {
std::cerr << "Error: no reply address specified for request: " << request.getContent() << std::endl;
session.reject(request);
}
}
connection.close();
return 0;
} catch(const std::exception& error) {
std::cout << error.what() << std::endl;
connection.close();
}
return 1;
}
void
ReceiverTest::onCollision()
{
receiver->onCollision();
wns::events::scheduler::Interface* es = wns::simulator::getEventScheduler();
es->processOneEvent();
WNS_ASSERT_MAX_REL_ERROR( simTimeType(0.01), es->getTime(), 1E-10);
CPPUNIT_ASSERT_EQUAL( 1, carrierSensing->cOnCollision );
receiver->onCollision();
es->processOneEvent();
WNS_ASSERT_MAX_REL_ERROR( simTimeType(0.02), es->getTime(), 1E-10);
CPPUNIT_ASSERT_EQUAL( 2, carrierSensing->cOnCollision );
}
void
Acceptor::on_delete_receiver (Receiver &rcvr)
{
ACE_Guard<ACE_Recursive_Thread_Mutex> locker (this->mutex_);
this->sessions_--;
this->total_snd_ += rcvr.get_total_snd ();
this->total_rcv_ += rcvr.get_total_rcv ();
this->total_w_ += rcvr.get_total_w ();
this->total_r_ += rcvr.get_total_r ();
if (rcvr.index_ < MAX_RECEIVERS
&& this->list_receivers_[rcvr.index_] == &rcvr)
this->list_receivers_[rcvr.index_] = 0;
ACE_TCHAR bufs [256];
ACE_TCHAR bufr [256];
ACE_OS::sprintf ( bufs , ACE_TEXT ("%ld(%ld)"),
rcvr.get_total_snd (),
rcvr.get_total_w () );
ACE_OS::sprintf ( bufr , ACE_TEXT ("%ld(%ld)"),
rcvr.get_total_rcv (),
rcvr.get_total_r ());
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Receiver::~DTOR index=%d snd=%s rcv=%s sessions_=%d\n"),
rcvr.index_,
bufs,
bufr,
this->sessions_));
}
int main()
{
int ret = 0;
try
{
string srcAddr = "127.0.0.1", srcPort ="8484" , targetAddr = "127.0.0.1", targetPort ="8181" , targetCommunicator = "file_processor";
Message msg, msgEcho; Header hdr, hdrEcho;
hdr.setCmd("send_file");
hdr.setAddr(targetAddr, targetPort);//IP address
hdr.setAttrib("filename","D:/proj3/SocketDemo2/Test/sender/foobar.txt");//name value pairs
hdr.setAttrib("msg", "File transfer");
hdr.setSrcAddr(srcAddr, srcPort);
hdr.setContentLength(1024);
hdr.setTargetCommunicator("FileHandlerCommunicator");
msg.setHdr(hdr);
hdrEcho.setCmd("echo_msg");
hdrEcho.setAttrib("msg", "Hi there!");
hdrEcho.setAddr(targetAddr, targetPort);//IP address
hdrEcho.setSrcAddr(srcAddr, srcPort);
hdrEcho.setTargetCommunicator("EchoCommunicator");
msgEcho.setHdr(hdrEcho);
Sender sndr1;
int clientPort = 8484;
Receiver rcvr;
rcvr.connect(clientPort);
EchoCommunicator echo;
echo.setName(CLientEchoCommunicator);
rcvr.registerComm(&echo);
echo.start();
sndr1.start();
sndr1.postMessage(msgEcho);
sndr1.e(msg);
echo.wait();
rcvr.wait();
sndr1.wait();
sout << "That's all folks!";
}
catch(std::exception& ex)
{
sout << "\n\n " << ex.what();
ret = 1;
}
catch(...)
{
sout << "\n\n something bad happend to a sender";
ret = 1;
}
std::cout << "\n\n That's all Folks!\n\n";
return ret;
}
int main(int argc, char *argv[])
{
QGuiApplication app(argc, argv);
QQmlApplicationEngine engine;
Receiver receiver;
QQmlContext* ctx = engine.rootContext();
ctx->setContextProperty("receiver", &receiver);
engine.load(QUrl(QStringLiteral("qrc:///main.qml")));
receiver.sendToQml(43);
return app.exec();
}
/**
@brief pure virtual destructor
The Emitter destructor cleans up message dispatch relationships
*/
Emitter::~Emitter()
{
for(ReceiverList::Container::iterator i = receiverList->c.begin(); i != receiverList->c.end(); ++i)
{
ReceiverList::ReceiverSet & targets = (*i).second;
for(ReceiverList::ReceiverSet::iterator j = targets.begin(); j != targets.end(); ++j)
{
Receiver * r = (*j);
r->emitterDestroyed(*this);
}
}
delete receiverList;
receiverList = 0;
}
int ReceptionManager::receive(Receiver& rec, abort_cb_f abort_cb, void* user) {
Receiver::Type type;
uint16_t tag;
size_t len;
char val[65536];
do {
type = rec.receive(&tag, &len, val);
if (type < 0) {
hlog_debug("receive: type=%d tag=%d len=%zu msg=%s", type, tag, len,
val);
} else {
hlog_debug_buffer(len, val, "receive: type=%d tag=%d len=%zu val:",
type, tag, len);
}
switch (type) {
case Receiver::CHECK:
if ((abort_cb != NULL) && abort_cb(user)) {
return -ECANCELED;
}
case Receiver::START:
case Receiver::END:
break;
case Receiver::DATA: {
int sub_rc = submit(tag, len, val);
if (sub_rc < 0) {
return sub_rc;
}
} break;
default:
return -EBADE;
}
} while (type > Receiver::END);
return 0;
}
virtual void Execute()
{
if (0 != m_receiver)
{
m_receiver->Action();
}
}
int
run_main (int, ACE_TCHAR *[])
{
ACE_START_TEST (ACE_TEXT ("RMCast_UDP_Best_Effort_Test"));
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("This is ACE Version %u.%u.%u\n\n"),
ACE::major_version(),
ACE::minor_version(),
ACE::beta_version()));
ACE_INET_Addr mcast_group;
mcast_group.set (12345, ACE_TEXT ("224.9.9.1"));
Receiver receiver (mcast_group);
if (receiver.open () != 0)
ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("Error in Receiver::open\n")), 1);
Sender sender (mcast_group);
if (sender.activate () != 0)
ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("Error in Sender::activate\n")), 1);
ACE_Time_Value tv (120, 0);
for (;;)
{
int r = receiver.handle_events (&tv);
if (r < 0)
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("Error in handle_events()\n")),
1);
}
if (tv == ACE_Time_Value::zero)
break;
}
if (ACE_Thread_Manager::instance ()->wait () != 0)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("Error in Thread_Manager::wait\n")),
1);
receiver.dump ();
ACE_END_TEST;
return 0;
}
void EventManager::tick()
{
#ifdef USE_SDL
DWORD now = SDL_GetTicks();
#else
DWORD now = timeGetTime();
#endif
while (m_EventHeap.size() && now >= m_EventHeap.front()->m_eventTime)// < 0x80000000)
{
pop_heap(m_EventHeap.begin(), m_EventHeap.end(), Event::Compare());
Event* pEvent = m_EventHeap.back();
assert(pEvent != NULL);
assert(pEvent->m_loopTime != TIME_EVENT_INFINITE || pEvent->m_loopDelay > 0);
Receiver* pReceiver = getReceiver(pEvent->m_Receiver);
if (pReceiver == NULL) // receiver not found
{
m_EventHeap.pop_back();
delete pEvent; // delete it
continue;
}
if (pEvent->m_loopTime == TIME_EVENT_INFINITE || --pEvent->m_loopTime > 0)
{
// if the event is a loop event, and still need to be sent.
// push back it again
pEvent->m_eventTime += pEvent->m_loopDelay;
// refBuffer(pEvent->m_bufferid); // add ref
push_heap(m_EventHeap.begin(), m_EventHeap.end(), Event::Compare());
pReceiver->addEvent(TodoEvent(pEvent, 0)); // 0: can not release after event processed
}
else
{
// otherwise, pop it out
m_EventHeap.pop_back();
// only handle to the event is saved in receiver. the receiver should delete it when it processed
pReceiver->addEvent(TodoEvent(pEvent, 1)); // 1: must release after event processed
}
}
}
string MsgLogger::_formatCopyTo( const Msg_p& _pMsg ) const
{
std::string out;
if( _pMsg->hasCopyTo() )
{
char temp[64];
Receiver * pCopyTo = _pMsg->getCopyTo().rawPtr();
const char * pType = pCopyTo->className();
sprintf( temp, " copyTo=%p (%s)", pCopyTo, pType );
out = temp;
}
return out;
}
/**
@brief emit a message
All targeted Receivers will receive the Message that is emitted by
this Emitter object. The Message is forwarded to the MessageManager
to be dispatched to objects that are interested in receiving ALL
messages of a specific type, regardless of who emits it. Those
Receiver objects will only receive the Message via the MessageManager
if they did NOT receive the message from this Emitter object as a
targetted message.
@param message A const reference to a MessageBase object that will
be delivered to registered Receivers.
@see addReceiver
@see MessageManager::addReceiver
@author Justin Randall
*/
void Emitter::emitMessage(const MessageBase & message) const
{
NOT_NULL(receiverList);
ReceiverList::Container::iterator i = receiverList->c.find(message.getType());
if(i != receiverList->c.end())
{
//-- make copy
const ReceiverList::ReceiverSet targets = (*i).second;
for(ReceiverList::ReceiverSet::const_iterator j = targets.begin(); j != targets.end(); ++j)
{
Receiver * r = (*j);
NOT_NULL(r);
r->receiveMessage(*this, message);
}
}
MessageManager::getInstance().emitMessage(*this, message);
}
int test2(int K, string m){
Commiter c;
Receiver r;
commit(&c, &r, 16, BitUtils::string_to_bits(m));
string m1 = BitUtils::bits_to_string(open_commitment(&c, &r));
if (m1 != m){
cerr << "ERR open failed" << endl;
return 1;
}
string m2 = BitUtils::bits_to_string(r.force_open());
if (m2 != m){
cerr << "ERR force open failed" << endl;
return 1;
}
return 0;
}
int main(int argc, char** argv)
{
Options options;
if (options.parse(argc, argv) && options.checkAddress()) {
Connection connection(options.url, options.connectionOptions);
try {
connection.open();
Session session = connection.createSession();
Receiver receiver = session.createReceiver(options.address);
Duration timeout = options.getTimeout();
int count = options.getCount();
Message message;
int i = 0;
while (receiver.fetch(message, timeout)) {
std::cout << "Message(properties=" << message.getProperties();
if (!message.getSubject().empty()) {
std::cout << ", subject='" << message.getSubject() << "'";
}
std::cout << ", content='";
if (message.getContentType() == "amqp/map") {
std::cout << message.getContentObject().asMap();
} else {
std::cout << message.getContentObject();
}
std::cout << "')" << std::endl;
session.acknowledge();
if (count && (++i == count))
break;
}
receiver.close();
session.close();
connection.close();
return 0;
} catch(const std::exception& error) {
std::cout << error.what() << std::endl;
connection.close();
}
}
return 1;
}
int main()
{
int ret = 0;
try
{
Receiver rcvr;
rcvr.connect(8181);
EchoCommunicator echo; // Concrete implementation of abstract communicator
echo.setName("EchoCommunicator");
rcvr.registerComm(&echo);
echo.start();
FileProcessingCommunicator fileComm;//concrete implementation
fileComm.setName("FileHandlerCommunicator");
rcvr.registerComm(&fileComm);
fileComm.start();
string targetAddr = "127.0.0.1", targetPort = "8080";
Sender sender;
sender.setName("SenderCommunicator");
////sender.connect(targetAddr, targetPort);
rcvr.registerComm(&sender);
sender.start();
echo.wait();
fileComm.wait();
}
catch (std::exception& ex)
{
std::cout << "\n\n " << ex.what();
ret = 1;
}
catch (...)
{
sout << "\n something bad happened";
ret = 1;
}
sout << "\n\n";
return ret;
}
