bool RobotBrainServiceService::start(int argc, char* argv[])
{
  char adapterStr[255];

  LINFO("Creating Topic!");
  //Create the topics
//  SimEventsUtils::createTopic(communicator(), "RetinaMessageTopic");

  //Create the adapter
  int port = RobotBrainObjects::RobotBrainPort;
  bool connected = false;
  LDEBUG("Opening Connection");

  while(!connected)
  {
    try
    {
      LINFO("Trying Port:%d", port);
      sprintf(adapterStr, "default -p %i", port);
      itsAdapter = communicator()->createObjectAdapterWithEndpoints("Retina",
          adapterStr);
      connected = true;
    }
    catch(Ice::SocketException)
    {
      port++;
    }
  }

  //Create the manager and its objects
        itsMgr = new ModelManager("RetinaService");

  LINFO("Starting Retina");
  nub::ref<RetinaI> ret(new RetinaI(0, *itsMgr, "Retina1", "Retina2"));
  LINFO("Retina Created");
  itsMgr->addSubComponent(ret);
  LINFO("Retina Added As Sub Component");
  ret->init(communicator(), itsAdapter);
  LINFO("Retina Inited");

  itsMgr->parseCommandLine((const int)argc, (const char**)argv, "", 0, 0);

  itsAdapter->activate();

  itsMgr->start();

  return true;
}

communicator communicator::split(int color, int key) const
{
  MPI_Comm newcomm;
  BOOST_MPI_CHECK_RESULT(MPI_Comm_split,
                         (MPI_Comm(*this), color, key, &newcomm));
  return communicator(newcomm, comm_take_ownership);
}

int HelloServer::run(int argc, char* argv[])
{
	if (argc > 1)
	{
		std::cerr << appName() << ": too many arguments" << std::endl;
		return EXIT_FAILURE;
	}

	Ice::ObjectAdapterPtr adapter = communicator()->createObjectAdapter("Hello");
	Demo::HelloPtr hello = new HelloI;
	adapter->add(hello, communicator()->stringToIdentity("hello"));
	adapter->activate();

	communicator()->waitForShutdown();
	return EXIT_SUCCESS;
}

int main(int argc, char *argv[])
{
	int const port = 8888;

	QApplication app(argc, argv);

	QString configPath = "./";
	if (app.arguments().contains("-c")) {
		int const index = app.arguments().indexOf("-c");
		if (app.arguments().count() <= index + 1) {
			qDebug() << "Usage: ./trikServer [-c <config file path>]";
			return 1;
		}

		configPath = app.arguments()[index + 1];
		if (configPath.right(1) != "/") {
			configPath += "/";
		}
	}

	qDebug() << "Running TrikServer on port" << port;

	trikCommunicator::TrikCommunicator communicator(configPath);
	communicator.listen(port);

	return app.exec();
}

void MPIPortsCommunication:: requestConnection
(
  const std::string& nameAcceptor,
  const std::string& nameRequester,
  int                requesterProcessRank,
  int                requesterCommunicatorSize )
{
  preciceTrace2 ( "requestConnection()", nameAcceptor, nameRequester );
  assertion ( not _isConnection );

  int argc = 1;
  char* arg = new char[8];
  strcpy(arg, "precice");
  char** argv = &arg;
  utils::Parallel::initialize ( &argc, &argv, nameRequester );
  delete[] arg;

  std::string portFilename(_publishingDirectory + "." + nameRequester + "-portname");
  std::ifstream inFile;
  do {
    inFile.open ( portFilename.c_str(), std::ios::in );
    usleep(100000);
  } while ( not inFile );
  inFile.getline ( _portname, MPI_MAX_PORT_NAME );
  inFile.close();
  preciceDebug ( "Read connection info \"" + std::string(_portname) +
                 "\" from file " + portFilename );
  preciceDebug("Calling MPI_Comm_connect() with portname = " << _portname);
  MPI_Comm localComm = utils::Parallel::getLocalCommunicator();
  MPI_Comm_connect ( _portname, MPI_INFO_NULL, 0, localComm, &communicator() );
  _isConnection = true;
}

int main(int argc, char *argv[])
{
	const int port = 8888;

	QApplication app(argc, argv);
	app.setApplicationName("TrikServer");
	trikKernel::ApplicationInitHelper initHelper(app);

	if (!initHelper.parseCommandLine()) {
		return 0;
	}

	initHelper.init();

	QLOG_INFO() << "TrikServer started on port" << port;
	qDebug() << "Running TrikServer on port" << port;

	QScopedPointer<trikControl::BrickInterface> brick(trikControl::BrickFactory::create(
			initHelper.configPath(), trikKernel::Paths::mediaPath()));

	trikKernel::Configurer configurer(
			initHelper.configPath() + "/system-config.xml"
			, initHelper.configPath() + "/model-config.xml"
			);

	QScopedPointer<trikNetwork::MailboxInterface> mailbox(trikNetwork::MailboxFactory::create(configurer));

	trikCommunicator::TrikCommunicator communicator(*brick, mailbox.data());
	communicator.startServer(port);

	return app.exec();
}

	bool Application::configGetBool (const std::string name, bool &value, const int default_value)
	{
		string tmp;
		tmp = communicator()->getProperties()->getProperty( name );
		if ( tmp.length() == 0 )
		{
			if (default_value != -1)
			{
				std::cout << name << " property does not exist. Using default value." << std::endl;
				value = default_value;
				return false;
			}
			else
			{
				printf("Can't read configuration parameter %s. Got %s.", name.c_str(), tmp.c_str());
				qFatal("Error\n");
			}
		}
		if(tmp == "true" or tmp == "True" or tmp == "yes" or tmp == "Yes" or tmp == "1")
		{
			value = true;
		} 
		else if (tmp == "false" or tmp == "False" or tmp == "no" or tmp == "No" or tmp == "0")
		{
			value = false;
		}
		else
		{
			qFatal("Reading config file: '%s' is not a valid boolean", name.c_str());
		}
		std::cout << name << " " << value << std::endl;
		return true;
	}

void QUHttpCollector::processNetworkOperationDone(bool error) {
	int count = localFiles().size();
	closeLocalFiles();

	if(error) {
		setState(Idle);
		communicator()->send(http()->errorString());
		communicator()->send(QUCommunicatorInterface::Failed);
		return;
	}

	if(state() == SearchRequest) {
		ignoredUrls = 0;
		processSearchResults();
	} else if(state() == ImageRequest)
		processImageResults(count);
}

int MPIPortsCommunication:: getRemoteCommunicatorSize()
{
  preciceTrace ( "getRemoteCommunicatorSize()" );
  assertion ( _isConnection );
  int remoteSize = 0;
  MPI_Comm_remote_size ( communicator(), &remoteSize );
  return remoteSize;
}

   /*
   * Read and execute commands from a specified command file.
   */
   void McSimulation::readCommands(std::istream &in)
   {
      if (!isInitialized_) {
         UTIL_THROW("McSimulation is not initialized");
      }

      std::string    command;
      std::string    filename;
      std::ifstream  inputFile;
      std::ofstream  outputFile;

      #ifndef UTIL_MPI
      std::istream&     inBuffer = in;
      #else
      std::stringstream inBuffer;
      std::string       line;
      #endif

      bool readNext = true;
      while (readNext) {

         // iffdef UTIL_MPI, read a line and copy to stringstream inBuffer
         // ifndef UTIL_MPI, inBuffer is simply a reference to istream in.

         #ifdef UTIL_MPI
         // Read a command line, and broadcast if necessary.
         if (!hasIoCommunicator() || isIoProcessor()) {
            getNextLine(in, line);
         }
         if (hasIoCommunicator()) {
            bcast<std::string>(communicator(), line, 0);
         }

         // Copy the command line to inBuffer.
         inBuffer.clear();
         for (unsigned i=0; i < line.size(); ++i) {
            inBuffer.put(line[i]);
         }
         #endif

         inBuffer >> command;
         Log::file() << command;

         if (isRestarting_) {

            if (command == "RESTART") {
               int endStep;
               inBuffer >> endStep;
               Log::file() << "  " << iStep_ << " to " 
                           << endStep << std::endl;
               simulate(endStep, isRestarting_);
               isRestarting_ = false;
            } else {
               UTIL_THROW("Missing RESTART command");
            }

         } else {

	virtual int run(int argc, char* argv[])
	{
		ClientOrServer::run(argc, argv);
		
		// Register a new object adapter
		Ice::ObjectAdapterPtr adapter = communicator()->createObjectAdapter("SonarEventListener.Subscriber");
		
		// Subscribe to the event
		IceStorm::QoS qos;
		Ice::ObjectPrx subscriber = adapter->addWithUUID(new SonarEventPrinter);
		sonarTopic->subscribe(qos, subscriber);
		
		// Start the adapter and keep going until the program is killed
		adapter->activate();
		shutdownOnInterrupt();
		communicator()->waitForShutdown();
		sonarTopic->unsubscribe(subscriber);
		return EXIT_SUCCESS;
	}

void
diy::mpi::communicator::
duplicate(const communicator& other)
{
#ifndef DIY_NO_MPI
    MPI_Comm newcomm;
    MPI_Comm_dup(other.comm_, &newcomm);
    (*this) = std::move(communicator(newcomm,true));
#endif
}

int Server::run(int argc, char* argv[])
{
    int ret;
    if ((ret = SPI_init())) return ret;

    shutdownOnInterrupt();

    Ice::ObjectAdapterPtr adapter = communicator()->
        createObjectAdapterWithEndpoints("Guitar", "default -p 10000");

    guitarlib::ApplicationI *app = new guitarlib::ApplicationI(adapter);
    adapter->add(app, communicator()->stringToIdentity("Application"));
    adapter->activate();

    communicator()->waitForShutdown();

    ret = SPI_exit();
    return ret;
}

int ClientApp::initializeDetector(cvac::DetectorPrx detector)
{
	cvac::DetectorData detectorData;
	cvac::localAndClientMsg(VLogger::DEBUG, NULL, "Client using Detector-name: %s\n", detector->ice_getIdentity().name.c_str());
	detectorData.type = ::cvac::FILE;
	
	// If a detector dat file was passed then use that instead of getting it from the config file
	if (m_detectorData.length() > 0)
	{
		detectorData.file.directory.relativePath = cvac::getFilePath(m_detectorData);
		detectorData.file.filename = cvac::getFileName(m_detectorData);
	}
	else
	{ // Determine which data files to pass as detector data based on .DetectorFilename in 'config.client'
		std::string filenameStr = m_detectorName + ".DetectorFilename";
		Ice::PropertiesPtr props = communicator()->getProperties();
		std::string filename = props->getProperty(filenameStr);
		
		if (filename.length() == 0)
		{
			cvac::localAndClientMsg(VLogger::WARN, NULL, "No .DetectorFilename pair found for %s.\n", m_detectorName.c_str());
			return EXIT_FAILURE;
		}
		
		if ((filename.length() > 1 && filename[1] == ':' )||
			filename[0] == '/' ||
			filename[0] == '\\')
		{  // absolute path
			int idx = filename.find_last_of('/');
			detectorData.file.directory.relativePath = filename.substr(0, idx);
			detectorData.file.filename = filename.substr(idx+1, filename.length() - idx);
		}
		else
		{ //Add the current directory
			detectorData.file.directory.relativePath = "DefaultDetectors";
			detectorData.file.filename = filename;
		}
	}
	try
	{
		cvac::localAndClientMsg(VLogger::INFO, NULL, "Initializing detector with relativePath: %s\n", detectorData.file.directory.relativePath.c_str());
		cvac::localAndClientMsg(VLogger::INFO, NULL, "Initializing detector with filename: %s\n", detectorData.file.filename.c_str());
		detector->initialize(5, detectorData);
		cvac::localAndClientMsg(VLogger::DEBUG, NULL, "IceBox test client: initialized the detector\n");
	}
	catch (const Ice::Exception& ex)
	{
		cvac::localAndClientMsg(VLogger::WARN, NULL, "Ice- name():  %s\n", ex.ice_name().c_str());
		cvac::localAndClientMsg(VLogger::WARN, NULL, "Ice- stackTrace(): \n%s\n", ex.ice_stackTrace().c_str());
		cvac::localAndClientMsg(VLogger::WARN, NULL, "%s\n", ex.what());
		return EXIT_FAILURE;
	}

  return EXIT_SUCCESS;
}

QFile* QUHttpCollector::openLocalFile(const QString &filePath) {
	QFile *file = new QFile(filePath, this);

	if(!file->open(QIODevice::WriteOnly | QIODevice::Truncate)) {
		communicator()->send(tr("Could not open local file: \"%1\"").arg(filePath));
		return 0;
	}

	_localFiles.append(file);
	return file;
}

int main(int argc, char** argv) {

    // Random seed
#ifdef _WIN32
    srand(123456);
#else
    srandom(123456);
#endif
    
    // Client or server mode?
    char* modeString = getOption(argc, argv, "-m");
    CommunicatorMode mode = COMMUNICATOR_MODE_NONE;
    if (!strcmp(modeString, "client"))
        mode = COMMUNICATOR_MODE_CLIENT;
    else if (!strcmp(modeString, "server"))
        mode = COMMUNICATOR_MODE_SERVER;
    else
        printUsageAndExit(argv[0]);
    
    // Declare our timeline. It will be initialized by the Communicator.
    Timeline timeline;
    
    // Declare our communicator
    Communicator communicator(timeline, mode);
    
    // If we're a client, who are we connecting to?
    if (mode == COMMUNICATOR_MODE_CLIENT)
        communicator.SetServer(getOption(argc, argv, "-s"));
    
    // Otherwise, how many clients are we waiting for?
    else {
        int numClients = atoi(getOption(argc, argv, "-n"));
        if (numClients < 0)
            printUsageAndExit(argv[0]);
        communicator.SetNumClientsExpected((unsigned) numClients);
    }
    
    // Start background music
    sf::Music Music;
    if (!Music.OpenFromFile("scenefiles/bgm.ogg"))
    {
        std::cout << "Error loading music file\n";
    }
    Music.SetLoop(true);
    Music.Play();

    Game growblesGame(timeline, communicator);
    growblesGame.Setup();

    return 0;
}

 void PetscPreconditioner<T>::set_petsc_subpreconditioner_type(const PCType type, PC& pc)
#endif
{
  // For catching PETSc error return codes
  int ierr = 0;

  // get the communicator from the PETSc object
  Parallel::communicator comm;
  PetscObjectGetComm((PetscObject)pc, &comm);
  Parallel::Communicator communicator(comm);

  // All docs say must call KSPSetUp or PCSetUp before calling PCBJacobiGetSubKSP.
  // You must call PCSetUp after the preconditioner operators have been set, otherwise you get the:
  //
  // "Object is in wrong state!"
  // "Matrix must be set first."
  //
  // error messages...
  ierr = PCSetUp(pc);
  CHKERRABORT(comm,ierr);

  // To store array of local KSP contexts on this processor
  KSP* subksps;

  // the number of blocks on this processor
  PetscInt n_local;

  // The global number of the first block on this processor.
  // This is not used, so we just pass PETSC_NULL instead.
  // int first_local;

  // Fill array of local KSP contexts
  ierr = PCBJacobiGetSubKSP(pc, &n_local, PETSC_NULL, &subksps);
  CHKERRABORT(comm,ierr);

  // Loop over sub-ksp objects, set ILU preconditioner
  for (PetscInt i=0; i<n_local; ++i)
    {
      // Get pointer to sub KSP object's PC
      PC subpc;
      ierr = KSPGetPC(subksps[i], &subpc);
      CHKERRABORT(comm,ierr);

      // Set requested type on the sub PC
      ierr = PCSetType(subpc, type);
      CHKERRABORT(comm,ierr);
    }

}

	bool Application::configGetFloat( const std::string name, float &value, const float default_value, QList< int > *list )
	{
		QString tmp;
	
		tmp = QString::fromStdString(communicator()->getProperties()->getProperty( name ));
		if ( tmp.length() == 0)
		{
			std::cout << name << " property does not exist. Using default value." << std::endl;
			value = default_value;
			return false;
		}
		value = tmp.toFloat();
		if(list != NULL)
		{
			if (list->contains(value) == false)
			{
				qFatal("Reading config file: '%s' is not a valid float", name.c_str());
			}
		}
		std::cout << name << " " << value << std::endl;
		return true;
	}

 template<typename T, typename Op> inline void all_reduce(const Op& op, const std::vector<T>& in_values, const std::vector<int>& in_map, std::vector<T>& out_values, const std::vector<int>& out_map, const int stride=1)
 {
          mpi::all_reduce(communicator(), op, in_values, in_map, out_values, out_map, stride);
 }

void QUHttpCollector::processNetworkStateChange(int state) {
	if(state == QHttp::Sending)
		communicator()->send(tr("Sending..."));
	else if(state == QHttp::Reading)
		communicator()->send(tr("Reading..."));
}