Server.cpp

Go to the documentation of this file.

 
#include "rogue/Directives.h"
 
#include "rogue/protocols/rssi/Server.h"
 
#include <memory>
 
#include "rogue/GeneralError.h"
#include "rogue/GilRelease.h"
#include "rogue/protocols/rssi/Application.h"
#include "rogue/protocols/rssi/Controller.h"
#include "rogue/protocols/rssi/Transport.h"
 
namespace rpr = rogue::protocols::rssi;
namespace ris = rogue::interfaces::stream;
 
#ifndef NO_PYTHON
    #include <boost/python.hpp>
namespace bp = boost::python;
#endif
 
rpr::ServerPtr rpr::Server::create(uint32_t segSize) {
    rpr::ServerPtr r = std::make_shared<rpr::Server>(segSize);
    return (r);
}
 
void rpr::Server::setup_python() {
#ifndef NO_PYTHON
 
    bp::class_<rpr::Server, rpr::ServerPtr, boost::noncopyable>("Server", bp::init<uint32_t>())
        .def("transport", &rpr::Server::transport)
        .def("application", &rpr::Server::application)
        .def("getOpen", &rpr::Server::getOpen)
        .def("getDownCount", &rpr::Server::getDownCount)
        .def("getDropCount", &rpr::Server::getDropCount)
        .def("getRetranCount", &rpr::Server::getRetranCount)
        .def("getLocBusy", &rpr::Server::getLocBusy)
        .def("getLocBusyCnt", &rpr::Server::getLocBusyCnt)
        .def("getRemBusy", &rpr::Server::getRemBusy)
        .def("getRemBusyCnt", &rpr::Server::getRemBusyCnt)
        .def("setLocTryPeriod", &rpr::Server::setLocTryPeriod)
        .def("getLocTryPeriod", &rpr::Server::getLocTryPeriod)
        .def("setLocMaxBuffers", &rpr::Server::setLocMaxBuffers)
        .def("getLocMaxBuffers", &rpr::Server::getLocMaxBuffers)
        .def("setLocMaxSegment", &rpr::Server::setLocMaxSegment)
        .def("getLocMaxSegment", &rpr::Server::getLocMaxSegment)
        .def("setLocCumAckTout", &rpr::Server::setLocCumAckTout)
        .def("getLocCumAckTout", &rpr::Server::getLocCumAckTout)
        .def("setLocRetranTout", &rpr::Server::setLocRetranTout)
        .def("getLocRetranTout", &rpr::Server::getLocRetranTout)
        .def("setLocNullTout", &rpr::Server::setLocNullTout)
        .def("getLocNullTout", &rpr::Server::getLocNullTout)
        .def("setLocMaxRetran", &rpr::Server::setLocMaxRetran)
        .def("getLocMaxRetran", &rpr::Server::getLocMaxRetran)
        .def("setLocMaxCumAck", &rpr::Server::setLocMaxCumAck)
        .def("getLocMaxCumAck", &rpr::Server::getLocMaxCumAck)
        .def("curMaxBuffers", &rpr::Server::curMaxBuffers)
        .def("curMaxSegment", &rpr::Server::curMaxSegment)
        .def("curCumAckTout", &rpr::Server::curCumAckTout)
        .def("curRetranTout", &rpr::Server::curRetranTout)
        .def("curNullTout", &rpr::Server::curNullTout)
        .def("curMaxRetran", &rpr::Server::curMaxRetran)
        .def("curMaxCumAck", &rpr::Server::curMaxCumAck)
        .def("resetCounters", &rpr::Server::resetCounters)
        .def("setTimeout", &rpr::Server::setTimeout)
        .def("_stop", &rpr::Server::stop)
        .def("_start", &rpr::Server::start);
#endif
}
 
rpr::Server::Server(uint32_t segSize) {
    app_  = rpr::Application::create();
    tran_ = rpr::Transport::create();
    cntl_ = rpr::Controller::create(segSize, tran_, app_, true);
 
    app_->setController(cntl_);
    tran_->setController(cntl_);
}
 
rpr::Server::~Server() {
    cntl_->stop();
}
 
rpr::TransportPtr rpr::Server::transport() {
    return (tran_);
}
 
rpr::ApplicationPtr rpr::Server::application() {
    return (app_);
}
 
bool rpr::Server::getOpen() {
    return (cntl_->getOpen());
}
 
uint32_t rpr::Server::getDownCount() {
    return (cntl_->getDownCount());
}
 
uint32_t rpr::Server::getDropCount() {
    return (cntl_->getDropCount());
}
 
uint32_t rpr::Server::getRetranCount() {
    return (cntl_->getRetranCount());
}
 
bool rpr::Server::getLocBusy() {
    return (cntl_->getLocBusy());
}
 
uint32_t rpr::Server::getLocBusyCnt() {
    return (cntl_->getLocBusyCnt());
}
 
bool rpr::Server::getRemBusy() {
    return (cntl_->getRemBusy());
}
 
uint32_t rpr::Server::getRemBusyCnt() {
    return (cntl_->getRemBusyCnt());
}
 
void rpr::Server::setLocTryPeriod(uint32_t val) {
    cntl_->setLocTryPeriod(val);
}
 
uint32_t rpr::Server::getLocTryPeriod() {
    return cntl_->getLocTryPeriod();
}
 
void rpr::Server::setLocMaxBuffers(uint8_t val) {
    cntl_->setLocMaxBuffers(val);
}
 
uint8_t rpr::Server::getLocMaxBuffers() {
    return cntl_->getLocMaxBuffers();
}
 
void rpr::Server::setLocMaxSegment(uint16_t val) {
    cntl_->setLocMaxSegment(val);
}
 
uint16_t rpr::Server::getLocMaxSegment() {
    return cntl_->getLocMaxSegment();
}
 
void rpr::Server::setLocCumAckTout(uint16_t val) {
    cntl_->setLocCumAckTout(val);
}
 
uint16_t rpr::Server::getLocCumAckTout() {
    return cntl_->getLocCumAckTout();
}
 
void rpr::Server::setLocRetranTout(uint16_t val) {
    cntl_->setLocRetranTout(val);
}
 
uint16_t rpr::Server::getLocRetranTout() {
    return cntl_->getLocRetranTout();
}
 
void rpr::Server::setLocNullTout(uint16_t val) {
    cntl_->setLocNullTout(val);
}
 
uint16_t rpr::Server::getLocNullTout() {
    return cntl_->getLocNullTout();
}
 
void rpr::Server::setLocMaxRetran(uint8_t val) {
    cntl_->setLocMaxRetran(val);
}
 
uint8_t rpr::Server::getLocMaxRetran() {
    return cntl_->getLocMaxRetran();
}
 
void rpr::Server::setLocMaxCumAck(uint8_t val) {
    cntl_->setLocMaxCumAck(val);
}
 
uint8_t rpr::Server::getLocMaxCumAck() {
    return cntl_->getLocMaxCumAck();
}
 
uint8_t rpr::Server::curMaxBuffers() {
    return cntl_->curMaxBuffers();
}
 
uint16_t rpr::Server::curMaxSegment() {
    return cntl_->curMaxSegment();
}
 
uint16_t rpr::Server::curCumAckTout() {
    return cntl_->curCumAckTout();
}
 
uint16_t rpr::Server::curRetranTout() {
    return cntl_->curRetranTout();
}
 
uint16_t rpr::Server::curNullTout() {
    return cntl_->curNullTout();
}
 
uint8_t rpr::Server::curMaxRetran() {
    return cntl_->curMaxRetran();
}
 
uint8_t rpr::Server::curMaxCumAck() {
    return cntl_->curMaxCumAck();
}
 
void rpr::Server::resetCounters() {
    cntl_->resetCounters();
}
 
void rpr::Server::setTimeout(uint32_t timeout) {
    cntl_->setTimeout(timeout);
}
 
void rpr::Server::stop() {
    return (cntl_->stop());
}
 
void rpr::Server::start() {
    return (cntl_->start());
}