/*******************************************************************
void runSimulationA(Simulation sim, int iTimeLimit)
Purpose:
Runs a simulation on the event list. Prints a table displaying
the arrival and departures of travelers
Parameters:
I Simulation simulation
I int iTimeLimit
Returns:
1. Does not return anything functionally
Notes:
1. Uses removeLL function
*******************************************************************/
void runSimulationA(Simulation sim, int iTimeLimit)
{
Event event; // Creates a local event variable to store current
// nodes event information into (uses in simulation evaluation)
Server server1 = newServer("Server 1"); // Creates a new server -
// - contains Server Name, whether it is busy or not, and a widget
Server server2 = newServer("Server 2"); // creates the second server for our program (refer to server1 comments)
Queue queue1 = newQueue("Queue 1"); // Creates a new queue
Queue queue2 = newQueue("Queue 2"); // Creates a new queue
if (sim->bVerbose == TRUE)
printf("%-4s %-6s %-10s\n", "TIME", "WIDGET", "EVENT"); //table header
while (removeLL(sim->eventList, &event))
{
// buffer to stop arrivals after the time limit
if (event.iEventType == EVT_ARRIVAL && event.iTime > iTimeLimit)
continue;
sim->iClock = event.iTime; // advance clock to current event time
// the switch evaluates the eventType
switch(event.iEventType)
{
case EVT_ARRIVAL:
arrival(sim, &event.widget);
queueUp(sim, queue1, &event.widget);
seize(sim, queue1, server1);
break;
case EVT_SERVER1_COMPLETE:
release(sim, queue1, server1, &event.widget);
queueUp(sim, queue2, &event.widget);
seize(sim, queue2, server2);
break;
case EVT_SERVER2_COMPLETE:
release(sim, queue2, server2, &event.widget);
leaveSystem(sim, event.widget);
break;
default:
ErrExit(ERR_ALGORITHM, "Unknown event type: %d\n", event.iEventType);
}
}
// prints the averages produced by the simulation
printStatistics(sim, queue1, queue2);
// frees servers and queues used in simulation A
free(server1);
free(server2);
free(queue1);
free(queue2);
}
PackageManagerSettings::PackageManagerSettings( QWidget* parent, const char* name, WFlags fl )
: PackageManagerSettingsBase( parent, name, fl )
{
connect( newserver, SIGNAL(clicked()), this, SLOT(newServer()) );
connect( removeserver, SIGNAL(clicked()), this, SLOT(removeServer()) );
connect( servers, SIGNAL(highlighted(int)), this, SLOT(editServer(int)) );
connect( newdestination, SIGNAL(clicked()), this, SLOT(newDestination()) );
connect( removedestination, SIGNAL(clicked()), this, SLOT(removeDestination()) );
connect( destinations, SIGNAL(highlighted(int)), this, SLOT(editDestination(int)) );
// connect( CheckBoxLink, SIGNAL(toggled(bool)),
// activeLinkDestination, SLOT(setEnabled(bool)) );
// connect( settingName, SIGNAL(activated(int)), this, SLOT(installationSettingChange(int)) );
// connect( settingName, SIGNAL(textChanged(const QString&)), this, SLOT(installationSettingSetName(const QString&)) );
// connect( newsetting, SIGNAL(clicked()), this, SLOT(newInstallationSetting()) );
// connect( renamesetting, SIGNAL(clicked()), this, SLOT(renameInstallationSetting()) );
// connect( removesetting, SIGNAL(clicked()), this, SLOT(removeInstallationSetting()) );
servername->setEnabled(FALSE);
serverurl->setEnabled(FALSE);
serverurlDic.setAutoDelete(TRUE);
destinationname->setEnabled(FALSE);
destinationurl->setEnabled(FALSE);
destinationurlDic.setAutoDelete(TRUE);
readSettings();
activeLinkDestination->hide();
serverChanged = false;
// get rid of setups
// Settings->hide();
// settingName->hide();
// newsetting->hide();
// renamesetting->hide();
// removesetting->hide();
}
Server::Server(const QString &name, QObject *parent)
: QObject(parent)
, m_server(newServer(name, this))
, m_socketCount(0)
{
qRegisterMetaType<Arguments>("Arguments");
connect( qApp, SIGNAL(aboutToQuit()), SLOT(close()) );
}
void setupFDs(const std::vector<std::string>& uris)
{
for (uint i = 0; i < uris.size(); ++i)
{
int fd = newServer(uris[i]);
if (dup2(fd, SD_LISTEN_FDS_START + i) < 0)
perror("sdlaunch");
}
setenv("LISTEN_FDS", itoa(uris.size()), 1);
}
void identd::enable(bool aEnable)
{
if (iEnabled == aEnable)
return;
iEnabled = aEnable;
if (iEnabled)
{
server_pointer newServer(new neolib::tcp_string_packet_stream_server(iModel.owner_thread(), 113));
iServer = newServer;
iServer->add_observer(*this);
}
else
{
iServer.reset();
}
}
void RemoteProcess::start(const QString &newServerName, const QStringList &arguments)
{
Q_ASSERT(m_server == NULL);
Q_ASSERT(m_socket == NULL);
Q_ASSERT(!isConnected());
if ( isConnected() )
return;
m_server = newServer(newServerName, &m_process);
m_process.start( QCoreApplication::applicationFilePath(), arguments );
if ( m_process.waitForStarted(2000) && m_server->waitForNewConnection(2000) ) {
m_socket = m_server->nextPendingConnection();
connect( m_socket, SIGNAL(readyRead()),
this, SLOT(readyRead()) );
}
}
bool ReefServer::receiveMsg(RMessage& msg){
bool retBool = false;
int msgMode = getReceiveMsgMode();
std::string aka;
switch (msgMode){
case 0: //add new Server to the Reef
newServer();
break;
case 1: //add new Satellite to the Reef
newSatellite();
break;
case 2: //publish Messages for a dependent Satellite
aka = s_recv(rep);
resetWatchlist(aka);
retBool = pubRequest(msg);
s_send(rep, ""); //request socket of the satellite needs a reply to unblock
break;
case 3: //publish Messages for a dependent Satellite, reply with stored Messages for Satellite
aka = s_recv(rep);
resetWatchlist(aka);
retBool = pubRequest(msg);
//std::cout << "vor recRequest case 3" << std::endl;
recRequest(aka);
//std::cout << "nach recRequest" << std::endl;
break;
case 4: //reply with stored Messages for Satellite
aka = s_recv(rep);
resetWatchlist(aka);
//std::cout << "vor recRequest case 4" << std::endl;
recRequest(aka);
//std::cout << "nach recRequest" << std::endl;
break;
default: //TODO Throw Error?
break;
}
return retBool;
}
QubanWizard::QubanWizard(QWidget* parent)
: QDialog(parent)
{
setupUi(this);
config = Configuration::getConfig();
prefGeneral = new PrefGeneral(generalFrame);
generalLayout->addWidget(prefGeneral);
prefUnpack = new PrefUnpack(unpackFrame);
unpackLayout2->addWidget(prefUnpack);
fromCheck->setChecked(config->showFrom);
detailsCheck->setChecked(config->showDetails);
dateCheck->setChecked(config->showDate);
sortCheck->setChecked(config->rememberSort);
sizeCheck->setChecked(config->rememberWidth);
compressedCheck->setChecked(config->downloadCompressed);
groupingSizeSpinBox->setValue(config->groupCheckCount);
deleteBtn->setChecked(config->deleteFailed);
keepBtn->setChecked(!config->deleteFailed);
overwriteBtn->setChecked(config->overwriteExisting);
renameBtn->setChecked(!config->overwriteExisting);
if (config->singleViewTab)
{
oneTabBtn->setChecked(true);
askBtn->setEnabled(false);
}
else
multiTabBtn->setChecked(true);
if (config->dViewed == Configuration::Ask)
{
if (!config->singleViewTab)
askBtn_2->setChecked(true);
else
keepBtn_2->setChecked(true);
}
else if (config->dViewed == Configuration::No)
keepBtn_2->setChecked(true);
else
deleteBtn_2->setChecked(true);
textFileSuffixes->setText(config->textSuffixes);
activateBtn->setChecked(config->activateTab);
statusBtn->setChecked(config->showStatusBar);
if (config->markOpt == Configuration::Ask)
askBtn->setChecked(true);
else if (config->markOpt == Configuration::No)
nullBtn->setChecked(true);
else markBtn->setChecked(true);
if (config->checkDaysValue)
{
checkDaysValue->setValue(config->checkDaysValue);
checkHeadersCheck->setChecked(config->checkDaysValue);
}
bulkLoadValue->setValue(config->bulkLoadThreshold);
bulkDeleteValue->setValue(config->bulkDeleteThreshold);
connect(okButton, SIGNAL(clicked()), this, SLOT(slotOkClicked()));
connect(cancelButton, SIGNAL(clicked()), this, SLOT(slotCancelClicked()));
connect(addServerButton, SIGNAL(clicked()), this, SIGNAL(newServer()));
connect(getGroupListButton, SIGNAL(clicked()), this, SIGNAL(sigGetGroups()));
connect(checkHeadersCheck, SIGNAL(toggled(bool)), this, SLOT(slotToggleDay(bool)));
}
/**************************** runSimulation ************************************
void runSimulation(Simulation sim, int iTimeLimit)
Purpose:
Goes through a list of events in a Simulation and run them as they are
encountered.
Parameters:
I Simulation sim The simulation variable containing the list of
events.
I int iTimeLimit A time limit upon which the simulation will terminate
if it is reached before all of the events are ran.
Returns:
Notes:
*******************************************************************************/
void runSimulation(Simulation sim, int iTimeLimit)
{
//Variables
Event event;
Server server1, server2;
Queue queue1, queue2;
//create servers and queues
server1 = newServer("Server 1");
queue1 = newQueue("Queue 1");
if (sim->cRunType == 'A')
{
server2 = newServer("Server 2");
queue2 = newQueue("Queue 2");
}
//begin simulation
printHeader(sim);
while (removeLL(sim->eventList, &event))
{
if (event.iTime > iTimeLimit)
{
printFooter(sim, queue1, queue2);
freeServersAndQueues(sim, server1, server2, queue1, queue2);
ErrExit(ERR_BAD_INPUT, "Event time (%d) is out of simulation bounds (%d)\n",
event.iTime, iTimeLimit);
}
sim->iClock = event.iTime;
switch (event.iEventType)
{
case EVT_ARRIVAL:
arrival(sim, &event.widget);
queueUp(sim, &event.widget, queue1);
seize(sim, queue1, server1);
break;
case EVT_SERVER1_COMPLETE:
release(sim, queue1, server1);
if (sim->cRunType == 'A') //Alternative A follows up with server 2
{
queueUp(sim, &event.widget, queue2);
seize(sim, queue2, server2);
}
else //Alternative B and Current leave after server 1
{
leaveSystem(sim, &event.widget);
}
break;
case EVT_SERVER2_COMPLETE:
release(sim, queue2, server2);
leaveSystem(sim, &event.widget);
break;
default:
ErrExit(ERR_ALGORITHM, "Unknown event type: %d\n", event.iEventType);
}
}
printFooter(sim, queue1, queue2);
freeServersAndQueues(sim, server1, server2, queue1, queue2);
}
