コード例 #1
0
	void AsyncCopy::Run(void* data)
	{
		START_KROLL_THREAD;

		Logger* logger = Logger::Get("Filesystem.AsyncCopy");

		AsyncCopy* ac = static_cast<AsyncCopy*>(data);
		std::vector<std::string>::iterator iter = ac->files.begin();
		Poco::Path to(ac->destination);
		Poco::File tof(to.toString());

		logger->Debug("Job started: dest=%s, count=%i", ac->destination.c_str(), ac->files.size());
		if (!tof.exists())
		{
			tof.createDirectory();
		}
		int c = 0;
		while (!ac->stopped && iter!=ac->files.end())
		{
			bool err_copy = false;
			std::string file = (*iter++);
			c++;

			logger->Debug("File: path=%s, count=%i\n", file.c_str(), c);
			try
			{
				Poco::Path from(file);
				Poco::File f(file);
				if (f.isDirectory())
				{
					ac->Copy(from,to);
				}
				else
				{
					Poco::Path dest(to,from.getFileName());
					ac->Copy(from,dest);
				}
				logger->Debug("File copied");

				KValueRef value = Value::NewString(file);
				ValueList args;
				args.push_back(value);
				args.push_back(Value::NewInt(c));
				args.push_back(Value::NewInt(ac->files.size()));
				args.push_back(Value::NewBool(true));
				RunOnMainThread(ac->callback, args, false);

				logger->Debug("Callback executed");
			}
			catch (ValueException &ex)
			{
				err_copy = true;
				SharedString ss = ex.DisplayString();
				logger->Error(std::string("Error: ") + *ss + " for file: " + file);
			}
			catch (Poco::Exception &ex)
			{
				err_copy = true;
				logger->Error(std::string("Error: ") + ex.displayText() + " for file: " + file);
			}
			catch (std::exception &ex)
			{
				err_copy = true;
				logger->Error(std::string("Error: ") + ex.what() + " for file: " + file);
			}
			catch (...)
			{
				err_copy = true;
				logger->Error(std::string("Unknown error during copy: ") + file);
			}
			try
			{
				if(err_copy)
				{
					KValueRef value = Value::NewString(file);
					ValueList args;
					args.push_back(value);
					args.push_back(Value::NewInt(c));
					args.push_back(Value::NewInt(ac->files.size()));
					args.push_back(Value::NewBool(false));
					RunOnMainThread(ac->callback, args, false);
				}
			}
			catch(...)
			{
				err_copy = true;
				logger->Error(std::string("Unknown error during copy: ") + file);
			}

		}
		ac->Set("running",Value::NewBool(false));
		ac->stopped = true;

		logger->Debug(std::string("Job finished"));

		END_KROLL_THREAD;
	}
コード例 #2
0
void set_log_level(int level){
	logger.setLevel(level);
}
コード例 #3
0
int get_log_level(const char * levelname){
	return logger.getLevel(levelname);
}
コード例 #4
0
ファイル: f2cc.cpp プロジェクト: forsyde/f2cc
int main(int argc, const char* argv[]) {
    const string error_abort_str("\nProgram aborted.\n\n");
    const string parse_error_str("PARSE ERROR:\n");
    const string processnetwork_error_str("INVALID MODEL ERROR:\n");
    const string io_error_str("I/O ERROR:\n");
    const string critical_error_str("CRITICAL PROGRAM ERROR:\n");

    string header = string()
        + "f2cc - A CUDA C synthesizer for ForSyDe models\n\n";
    cout << header;

    // Get configuration
    Config config;
    try {
        config.setFromCommandLine(argc, argv);
    }
    catch (InvalidFormatException& ex) {
        cout << ex.getMessage() << endl;
        return 0;
    }
    catch (Exception& ex) {
        cout << ex.toString() << endl;
        cout << error_abort_str << endl;
        return 0;
    }

    if (config.doPrintHelpMenu()) {
        cout << config.getHelpMenu() << endl;
        return 0;
    }

    if (config.doPrintVersion()) {
        cout << "Version: " << config.getVersion() << endl
             << "SVN revision: " << config.getSvnRevision() << endl;
        return 0;
    }

    // Prepare logger
    Logger logger;
    logger.setLogLevel(config.getLogLevel());
    try {
        logger.open(config.getLogFile());
    }
    catch (Exception& ex) {
        cout << ex.toString() << endl;
        cout << error_abort_str << endl;
    }
    logger.logDebugMessage("Logger open");

    // Execute
    try {
        try {
        	Frontend* parser;
            switch (config.getInputFormat()) {
                case Config::XML: {
                	logger.logInfoMessage(string("New XML format assumed.")
                			+ " The execution will follow the path from v0.2...");
                	parser = new (std::nothrow) XmlParser(logger);
                    break;
                }

                case Config::CUDA: {
                	logger.logInfoMessage(string("Old GraphML format assumed.")
                	        + " The execution will follow the path from v0.1...");
                	parser = new (std::nothrow) GraphmlParser(logger);
                    break;
                }
            }
            if (!parser) THROW_EXCEPTION(OutOfMemoryException);
            logger.logInfoMessage(string("MODEL INPUT FILE: ")
                                  + config.getInputFile());
            logger.logInfoMessage("Parsing input file...");
            ProcessNetwork* processnetwork = parser->parse(config.getInputFile());
            delete parser;

            string processnetwork_info_message("MODEL INFO:\n");
            processnetwork_info_message += getProcessNetworkInfo(processnetwork);
            logger.logInfoMessage(processnetwork_info_message);

            string target_platform_message("TARGET PLATFORM: ");
            switch (config.getTargetPlatform()) {
                case Config::C: {
                    target_platform_message += "C";
                    break;
                }

                case Config::CUDA: {
                    target_platform_message += "CUDA";
                    break;
                }
            }
            logger.logInfoMessage(target_platform_message);

            // Make processnetwork modifications, if necessary
            ModelModifier modifier(processnetwork, logger);
            logger.logInfoMessage("Removing redundant leafs...");
            modifier.removeRedundantLeafs();
            logger.logInfoMessage("Converting Comb leafs "
                              "with one in port to Comb leafs...");
            modifier.convertZipWith1ToMap();
            if (config.getTargetPlatform() == Config::CUDA) {
                string leaf_coalescing_message("DATA PARALLEL PROCESS "
                                                  "COALESCING: ");
                if (config.doDataParallelLeafCoalesing()) {
                    leaf_coalescing_message += "YES";
                }
                else {
                    leaf_coalescing_message += "NO";
                }
                logger.logInfoMessage(leaf_coalescing_message);
                if (config.doDataParallelLeafCoalesing()) {
                    logger.logInfoMessage(""
                                      "Performing data parallel Comb leaf "
                                      "coalescing...");
                    modifier.coalesceDataParallelLeafs();
                }

                logger.logInfoMessage(
                                  "Splitting data parallel segments...");
                modifier.splitDataParallelSegments();

                logger.logMessage(Logger::INFO,
                                  "Fusing chains of Unzipx-map-Zipx "
                                  "leafs...");
                modifier.fuseUnzipMapZipLeafs();

                if (config.doDataParallelLeafCoalesing()) {
                    logger.logInfoMessage(""
                                      "Performing ParallelMap leaf "
                                      "coalescing...");
                    modifier.coalesceParallelMapSyLeafs();
                }
            }
            processnetwork_info_message = "NEW MODEL INFO:\n";
            processnetwork_info_message += getProcessNetworkInfo(processnetwork);
            logger.logInfoMessage(processnetwork_info_message);

            // Generate code and write to file
            Synthesizer synthesizer(processnetwork, logger, config);
            Synthesizer::CodeSet code;
            switch (config.getTargetPlatform()) {
                case Config::C: {
                    code = synthesizer.generateCCode();
                    break;
                }

                case Config::CUDA: {
                    code = synthesizer.generateCudaCCode();
                    break;
                }
            }

            logger.logInfoMessage("Writing code to output files...");
            tools::writeFile(config.getHeaderOutputFile(), code.header);
            tools::writeFile(config.getImplementationOutputFile(),
                             code.implementation);

            logger.logInfoMessage("MODEL SYNTHESIS COMPLETE");

            // Clean up
            delete processnetwork;
            logger.logDebugMessage("Closing logger...");
            logger.close();
        } catch (FileNotFoundException& ex) {
            logger.logErrorMessage(ex.getMessage());
        } catch (ParseException& ex) {
            logger.logErrorMessage(parse_error_str + ex.getMessage());
        } catch (InvalidModelException& ex) {
            logger.logErrorMessage(processnetwork_error_str + ex.getMessage());
        } catch (IOException& ex) {
            logger.logErrorMessage(io_error_str + ex.getMessage());
        } catch (Exception& ex) {
            logger.logCriticalMessage(critical_error_str + ex.toString()
                                      + error_abort_str);
        }
    } catch (Exception&) {
        // Ignore
    }

    return 0;
}
コード例 #5
0
int main (int argc, char *argv[]) {

    BasicConfigurator config;
    config.configure();

    int loglevel = 0;

	namespace po = boost::program_options;

	po::options_description desc("Allowed options");
	desc.add_options()
	    ("help,h",    "show help message")
	    ("version,V", "show version (and exit)")
	    ("daemon,d",  "daemon mode, run in background")
	    ("list,l",    "list available CEC adapters and devices")
	    ("verbose,v", accumulator<int>(&loglevel)->implicit_value(1), "verbose output (use -vv for more)")
	    ("quiet,q",   "quiet output (print almost nothing)")
	    ("donotactivate,a", "do not activate device on startup")
	    ("onstandby", value<string>()->value_name("<path>"),  "command to run on standby")
	    ("onactivate", value<string>()->value_name("<path>"),  "command to run on activation")
	    ("ondeactivate", value<string>()->value_name("<path>"),  "command to run on deactivation")
	    ("port,p", value<HDMI::address>()->value_name("<a[.b.c.d]>"),  "HDMI port A or address A.B.C.D (overrides autodetected value)")
	    ("usb", value<string>()->value_name("<path>"), "USB adapter path (as shown by --list)")
	;

	po::positional_options_description p;
	p.add("usb", 1);

    po::variables_map vm;
    try
    {
        po::store(po::command_line_parser(argc, argv).options(desc).positional(p).run(), vm);
    }
    catch( po::error &e )
    {
        cerr << argv[0] << ": " << e.what() << endl;
        cerr << "Type \"" << argv[0] << " --help\" for more information." << endl;
        return 1;
    }
    po::notify(vm);

	if (vm.count("help")) {
		cout << "Usage: " << argv[0] << " [options] [usb]" << endl << endl;
	    cout << desc << endl;
	    return 0;
	}

	if (vm.count("version")) {
		cout << PACKAGE_STRING << endl;
		return 0;
	}

	if(vm.count("quiet")) {
		loglevel = -1;
	} else {
		loglevel = min(loglevel, 2);
	}

	Logger root = Logger::getRoot();
	switch (loglevel) {
		case 2:  root.setLogLevel(TRACE_LOG_LEVEL); break;
		case 1:  root.setLogLevel(DEBUG_LOG_LEVEL); break;
		default: root.setLogLevel(INFO_LOG_LEVEL); break;
		case -1: root.setLogLevel(FATAL_LOG_LEVEL); break;
	}

	try {
		// Create the main
		Main & main = Main::instance();
        string device = "";

		if (vm.count("list")) {
			main.listDevices();
			return 0;
		}

		if (vm.count("donotactivate")) {
			main.setMakeActive(false);
		}

		if (vm.count("usb")) {
			device = vm["usb"].as< string >();
		}

		if (vm.count("onstandby")) {
			main.setOnStandbyCommand(vm["onstandby"].as< string >());
		}

		if (vm.count("onactivate")) {
			main.setOnActivateCommand(vm["onactivate"].as< string >());
		}

		if (vm.count("ondeactivate")) {
			main.setOnDeactivateCommand(vm["ondeactivate"].as< string >());
		}

		if (vm.count("port")) {
            main.setTargetAddress(vm["port"].as< HDMI::address >());
        }

        if (vm.count("daemon")) {
            if( daemon(0, 0) )
                return -1;
        }

		main.loop(device);

	} catch (std::exception & e) {
		cerr << e.what() << endl;
		return -1;
	}

	return 0;
}
コード例 #6
0
bool UploadDump(const char* file, const char* user, int build, int branch, DelegateI<Prog_s>* progress)
{
	Logger log;
	log.write("---------------------------------------\r\n");

	time_t ltime; /* calendar time */
	ltime=time(NULL); /* get current cal time */

	
#ifdef WIN32
	char buff[255] = {0};

	struct tm t;
	localtime_s(&t, &ltime);
	asctime_s(buff, 255, &t);
#else
	struct tm *t = localtime(&ltime);
	char* buff = asctime(t);
#endif

	log.write("%s\r\n", buff);
	log.write("---------------------------------------\r\n");

	log.write("Uploaded crash dump: [%s]\r\n", file);


	gcString dump(file);

	if (PrepDumpForUpload(dump) == false)
	{
		log.write("Failed to prepare crash dump.\r\n");
		return false;
	}
	else
	{
		log.write("Prepared crash dump to: [%s]\r\n", dump.c_str());
	}

	std::string os = UTIL::OS::getOSString();

	HttpHandle hh(DUMP_UPLOAD_URL);

	if (progress)
		hh->getProgressEvent() += progress;

	hh->setUserAgent(DUMP_UPLOAD_AGENT);

	hh->cleanUp();
	hh->addPostText("os", os.c_str());
	hh->addPostText("build", build);
	hh->addPostText("appid", branch);

	if (user)
		hh->addPostText("user", user);

	hh->addPostFile("crashfile", dump.c_str());

	try
	{
		hh->postWeb();
	}
	catch (gcException &except)
	{
		log.write("Failed to upload crash: %s [%d.%d].\r\n", except.getErrMsg(), except.getErrId(), except.getSecErrId());
		return false;
	}

	TiXmlDocument doc;
	doc.LoadBuffer(const_cast<char*>(hh->getData()), hh->getDataSize());
	
	try
	{
		XML::processStatus(doc, "crashupload");
		log.write("Uploaded dump\r\n");
		UTIL::FS::delFile(UTIL::FS::Path(dump, "", true));		
	}
	catch (gcException &)
	{
		log.write("Bad status returned from upload crash dump.\r\n");

		gcString res;
		res.assign(hh->getData(), hh->getDataSize());

		log.write("Result: \r\n\r\n%s\r\n\r\n", res.c_str());
		
		return false;	
	}

	return true;
}
コード例 #7
0
ファイル: Components.cpp プロジェクト: scottp/xcsoar
void XCSoarInterface::Shutdown(void) {
  CreateProgressDialog(gettext(TEXT("Shutdown, please wait...")));
  StartHourglassCursor();

  StartupStore(TEXT("Entering shutdown...\n"));
  StartupLogFreeRamAndStorage();

  // turn off all displays
  globalRunningEvent.reset();

  StartupStore(TEXT("dlgAirspaceWarningDeInit\n"));
  dlgAirspaceWarningDeInit();

  CreateProgressDialog(gettext(TEXT("Shutdown, saving logs...")));
  // stop logger
  logger.guiStopLogger(Basic(),true);

  CreateProgressDialog(gettext(TEXT("Shutdown, saving profile...")));
  // Save settings
  Profile::StoreRegistry();

  // Stop sound

  StartupStore(TEXT("SaveSoundSettings\n"));
  Profile::SaveSoundSettings();

#ifndef DISABLEAUDIOVARIO
  //  VarioSound_EnableSound(false);
  //  VarioSound_Close();
#endif

  // Stop drawing
  CreateProgressDialog(gettext(TEXT("Shutdown, please wait...")));

  StartupStore(TEXT("CloseDrawingThread\n"));
  closeTriggerEvent.trigger();

  calculation_thread->join();
  StartupStore(TEXT("- calculation thread returned\n"));

  instrument_thread->join();
  StartupStore(TEXT("- instrument thread returned\n"));

  draw_thread->join();
  StartupStore(TEXT("- draw thread returned\n"));

  delete draw_thread;

  // Clear data

  CreateProgressDialog(gettext(TEXT("Shutdown, saving task...")));
  StartupStore(TEXT("Resume abort task\n"));
  task.ResumeAbortTask(SettingsComputer(), -1); // turn off abort if it was on.
  StartupStore(TEXT("Save default task\n"));
  task.SaveDefaultTask();
  StartupStore(TEXT("Clear task data\n"));
  task.ClearTask();
  StartupStore(TEXT("Close airspace\n"));
  CloseAirspace();

  StartupStore(TEXT("Close waypoints\n"));
  way_points.clear();

  CreateProgressDialog(gettext(TEXT("Shutdown, please wait...")));

  StartupStore(TEXT("CloseTerrainTopology\n"));

  RASP.Close();
  terrain.CloseTerrain();

  delete topology;
  delete marks;

  devShutdown();

  SaveCalculationsPersist(Basic(),Calculated());
#if (EXPERIMENTAL > 0)
  //  CalibrationSave();
#endif

  #if defined(GNAV) && !defined(PCGNAV)
    StartupStore(TEXT("Altair shutdown\n"));
    Sleep(2500);
    StopHourglassCursor();
    InputEvents::eventDLLExecute(TEXT("altairplatform.dll SetShutdown 1"));
    while(1) {
      Sleep(100); // free time up for processor to perform shutdown
    }
  #endif

  CloseFLARMDetails();

  // Kill windows

  StartupStore(TEXT("Destroy Info Boxes\n"));
  InfoBoxManager::Destroy();

  StartupStore(TEXT("Destroy Button Labels\n"));
  ButtonLabel::Destroy();

  StartupStore(TEXT("Delete Objects\n"));

  // Kill graphics objects

  DeleteFonts();

  DeleteAirspace();

  StartupStore(TEXT("Close Progress Dialog\n"));

  CloseProgressDialog();

  CloseGeoid();

  StartupStore(TEXT("Close Windows - main \n"));
  main_window.reset();
  StartupStore(TEXT("Close Graphics\n"));
  MapGfx.Destroy();

#ifdef DEBUG_TRANSLATIONS
  StartupStore(TEXT("Writing missing translations\n"));
  WriteMissingTranslations();
#endif

  StartupLogFreeRamAndStorage();
  StartupStore(TEXT("Finished shutdown\n"));
  StopHourglassCursor();

}
コード例 #8
0
ファイル: log.cpp プロジェクト: txsniper/Note
 int log_level() {
     Logger* logger = get_or_create_global_logger();
     return logger->get_level();
 }
コード例 #9
0
ファイル: log.cpp プロジェクト: txsniper/Note
 void set_log_level(int level) {
     Logger* logger = get_or_create_global_logger();
     logger->set_level(level);
 }
コード例 #10
0
ファイル: log.cpp プロジェクト: txsniper/Note
 int log_open(FILE *fp, int level) {
     Logger* logger = get_or_create_global_logger();
     return logger->open(fp, level);
 }
コード例 #11
0
ファイル: log.cpp プロジェクト: txsniper/Note
 int log_open(const char *filename, int level,
         uint64_t rotate_size) {
     Logger* logger = get_or_create_global_logger();
     return logger->open(filename, level, rotate_size);
 }
コード例 #12
0
ファイル: ctpp2_functions.cpp プロジェクト: Azq2/php-ctpp2
	INT_32 FN_CoNaN::Usage(Logger &logger) {
		logger.Emerg("Usage: CoNaN(N, LIST(\"язык\", \"языка\", \"языков\"), [concat_num = true]) or CoNaN(N, \"язык\", \"языка\", \"языков\", [concat_num = true])");
		return -1;
	}
コード例 #13
0
ファイル: main.cpp プロジェクト: smeyel/M2
/** Implementation of M2 scenario
*/
int main(int argc, char *argv[])
{
	if (argc>=2)
	{
		// INI file is given as command line parameter
		configfilename = argv[1];
	}
	// Setup config management
	configManager.init(configfilename);

	// Setup statistics output file
	Logger *logger = new FileLogger(configManager.logFileName.c_str());
	logger->SetLogLevel(Logger::LOGLEVEL_INFO);
	Logger::getInstance()->Log(Logger::LOGLEVEL_VERBOSE,"M2Host","M2Host started\n");

	cout << "Log is written to: " << configManager.logFileName << endl;

	// Write current time and date to log
    time_t t = time(0);   // get time now
    struct tm * now = localtime( & t );
	Logger::getInstance()->Log(Logger::LOGLEVEL_VERBOSE,"M2Host","Current time: %d-%d-%d, %d:%d:%d\n",
		(now->tm_year + 1900),(now->tm_mon + 1),now->tm_mday,now->tm_hour,now->tm_min,now->tm_sec );

	Logger::getInstance()->Log(Logger::LOGLEVEL_VERBOSE,"M2Host","Configuration: %s\n",configfilename);
	Logger::getInstance()->Log(Logger::LOGLEVEL_VERBOSE,"M2Host","Local measurement log: %s\nRemote measurement log: %s\n",
		configManager.localMLogFilename.c_str(), configManager.remoteMLogFilename.c_str());

	// Setup time management
	// Waiting a little to allow other processes to init...
	// Useful if started together with CamClient which needs to start its server.
	cout << "Waiting 3s..." << endl;
#ifdef WIN32
	Sleep(3000);
#else
#error TODO: Sleep not implemented for non-Win32.
#endif

	const bool useLocalCamera=true;

	CameraProxy *camProxy = NULL;
	CameraRemoteProxy *camRemoteProxy = NULL;
	CameraLocalProxy *camLocalProxy = NULL;
	if (useLocalCamera)
	{
		camProxy = camLocalProxy = new CameraLocalProxy(VIDEOINPUTTYPE_PS3EYE,0);
	}
	else
	{
		camProxy = camRemoteProxy = new CameraRemoteProxy();
	}

	// Prepare camera and detector objects
	//ChessboardDetector detector(Size(9,6),36.1);	// Chessboard cell size is 36x36mm, using CameraProxy default
	camProxy->camera->cameraID=0;
	camProxy->camera->isStationary=false;
	camProxy->camera->loadCalibrationData(configManager.camIntrinsicParamsFileName.data());

	if (camRemoteProxy)
	{
		cout << "Connecting..." << endl;
		camRemoteProxy->Connect(configManager.phoneIpAddress.c_str(),configManager.phonePort);
	}

	// --------------------------- Execute main task
	cout << "Main task started" << endl;

	// ---Currently, multiple possible measurements are supported.
	// - Original "capture 100 frames and report capture times" measurement
	//camRemoteProxy->PerformCaptureSpeedMeasurement_A(100,configManager.MLogFilename.c_str());
	// - Reading TimeSyncBeacon measurement
	M2_TimeSyncTest(camProxy,10);

	cout << "Main task finished" << endl;
	// --------------------------- Closing...
	if (camRemoteProxy)
	{
		cout << "Disconnecting..." << endl;
		camRemoteProxy->Disconnect();
	}

	delete camProxy;
	cout << "Done." << endl;
}
コード例 #14
0
ファイル: Atlas.cpp プロジェクト: irov/AfterEffectsPlugins
	bool Atlas::clearTexture( Logger & _logger, const MAGIC_CHANGE_ATLAS & c )
	{
		uint32_t index = s_imageIndex( c );

		TMapImages::iterator it_found = m_images.find( index );

		if( it_found == m_images.end() )
		{
			_logger.message("Atlas::clearTexture not found!"
				);

			return false;
		}

		ImageDesc & desc = it_found->second;

		desc.texture->Release();
		
		m_images.erase( it_found );

		IDirect3DSurface9 * back = NULL;
		DXCALL m_pDevice->GetRenderTarget( 0, &back );

		if( back == NULL )
		{
			return false;
		}

		IDirect3DSurface9 * dest = NULL;
		m_pTexture->GetSurfaceLevel( 0, &dest );

		if( dest == NULL )
		{
			return false;
		}

		DXCALL m_pDevice->SetRenderTarget( 0, dest );

		D3DSURFACE_DESC texDesc;
		DXCALL m_pTexture->GetLevelDesc( 0, &texDesc );

		float cw = (float)c.width;
		float ch = (float)c.height;

		float tw = (float)texDesc.Width;
		float th = (float)texDesc.Height;

		float scale_x = tw / cw;
		float scale_y = th / ch;

		D3DRECT rect[1];
		rect[0].x1 = (LONG)( (c.x * scale_x) + 0.5f );
		rect[0].y1 = (LONG)((c.y * scale_y) + 0.5f);
		rect[0].x2 = (LONG)((c.x + c.width) * scale_x + 0.5f);
		rect[0].y2 = (LONG)((c.y + c.height) * scale_y + 0.5f);

		m_pDevice->Clear( 1, rect, D3DCLEAR_TARGET, 0x0, 0.f, 0 );
		
		dest->Release();

		m_pDevice->SetRenderTarget( 0, back );
		back->Release();

		return true;
	}
コード例 #15
0
ファイル: main.cpp プロジェクト: allenday/eXpress
/**
 * Parses argument options and sets variables appropriately.
 * @param ac number of arguments.
 * @param pointer to array of arguments as character arrays.
 * @return True iff there was an error.
 */
bool parse_options(int ac, char ** av) {

  size_t additional_online = 0;
  size_t additional_batch = 0;
  
  po::options_description standard("Standard Options");
  standard.add_options()
  ("help,h", "produce help message")
  ("output-dir,o", po::value<string>(&output_dir)->default_value(output_dir),
   "write all output files to this directory")
#ifdef PROTO
  ("preprocess,D", "run preprocess script for eXpressD")
#endif
  ("frag-len-mean,m", po::value<size_t>(&def_fl_mean)->default_value(def_fl_mean),
   "prior estimate for average fragment length")
  ("frag-len-stddev,s",
   po::value<size_t>(&def_fl_stddev)->default_value(def_fl_stddev),
   "prior estimate for fragment length std deviation")
  ("haplotype-file,H",
   po::value<string>(&haplotype_file_name)->default_value(haplotype_file_name),
   "path to a file containing haplotype pairs")
  ("additional-batch,B",
   po::value<size_t>(&additional_batch)->default_value(additional_batch),
   "number of additional batch EM rounds after initial online round")
  ("additional-online,O",
   po::value<size_t>(&additional_online)->default_value(additional_online),
   "number of additional online EM rounds after initial online round")
  ("max-read-len,L",
   po::value<size_t>(&max_read_len)->default_value(max_read_len),
   "maximum allowed length of a read")
  ("output-align-prob",
   "output alignments (sam/bam) with probabilistic assignments")
  ("output-align-samp",
   "output alignments (sam/bam) with sampled assignments")
  ("fr-stranded",
   "accept only forward->reverse alignments (second-stranded protocols)")
  ("rf-stranded",
   "accept only reverse->forward alignments (first-stranded protocols)")
  ("f-stranded",
   "accept only forward single-end alignments (second-stranded protocols)")
  ("r-stranded",
   "accept only reverse single-end alignments (first-stranded protocols)")
  ("no-update-check", "disables automatic check for update via web")
  ("logtostderr", "prints all logging messages to stderr")
  ;
  
  po::options_description advanced("Advanced Options");
  advanced.add_options()
  ("forget-param,f", po::value<double>(&ff_param)->default_value(ff_param),
   "sets the 'forgetting factor' parameter (0.5 < c <= 1)")
  ("library-size", po::value<size_t>(&library_size),
   "specifies library size for FPKM instead of calculating from alignments")
  ("max-indel-size",
   po::value<size_t>(&max_indel_size)->default_value(max_indel_size),
   "sets the maximum allowed indel size, affecting geometric indel prior")
  ("calc-covar", "calculate and output covariance matrix")
  ("expr-alpha", po::value<double>(&expr_alpha)->default_value(expr_alpha),
   "sets the strength of the prior, per bp")
  ("stop-at", po::value<size_t>(&stop_at)->default_value(stop_at),
   "sets the number of fragments to process, disabled with 0")
  ("burn-out", po::value<size_t>(&burn_out)->default_value(burn_out),
   "sets number of fragments after which to stop updating auxiliary parameters")
  ("no-bias-correct", "disables bias correction")
  ("no-error-model", "disables error modelling")
  ("aux-param-file",
   po::value<string>(&param_file_name)->default_value(param_file_name),
   "path to file containing auxiliary parameters to use instead of learning")
  ;

  string prior_file = "";

  po::options_description hidden("Experimental/Debug Options");
  hidden.add_options()
  ("num-threads,p", po::value<size_t>(&num_threads)->default_value(num_threads),
   "number of threads (>= 2)")
  ("edit-detect","")
  ("single-round", "")
  ("output-running-rounds", "")
  ("output-running-reads", "")
  ("batch-mode","")
  ("both","")
  ("prior-params", po::value<string>(&prior_file)->default_value(""), "")
  ("sam-file", po::value<string>(&in_map_file_names)->default_value(""), "")
  ("fasta-file", po::value<string>(&fasta_file_name)->default_value(""), "")
  ("num-neighbors", po::value<size_t>(&num_neighbors)->default_value(0), "")
  ("bias-model-order",
   po::value<size_t>(&bias_model_order)->default_value(bias_model_order),
   "sets the order of the Markov chain used to model sequence bias")
  ;

  po::positional_options_description positional;
  positional.add("fasta-file",1).add("sam-file",1);

  po::options_description cmdline_options;
  cmdline_options.add(standard).add(advanced).add(hidden);

  bool error = false;
  po::variables_map vm;
  try {
    po::store(po::command_line_parser(ac, av).options(cmdline_options)
              .positional(positional).run(), vm);
  } catch (po::error& e) {
    logger.info("Command-Line Argument Error: %s.", e.what());
    error = true;
  }
  po::notify(vm);

  if (ff_param > 1.0 || ff_param < 0.5) {
    logger.info("Command-Line Argument Error: forget-param/f option must be "
                "between 0.5 and 1.0.");
    error= true;
  }

  if (fasta_file_name == "") {
    logger.info("Command-Line Argument Error: target sequence fasta file "
                "required.");
    error = true;
  }

  if (error || vm.count("help")) {
    cerr << "express v" << PACKAGE_VERSION << endl
         << "-----------------------------\n"
         << "File Usage:  express [options] <target_seqs.fa> <hits.(sam/bam)>\n"
         << "Piped Usage: bowtie [options] -S <index> <reads.fq> | express "
         << "[options] <target_seqs.fa>\n\n"
         << "Required arguments:\n"
         << " <target_seqs.fa>     target sequence file in fasta format\n"
         << " <hits.(sam/bam)>     read alignment file in SAM or BAM format\n\n"
         << standard
         << advanced;
    return 1;
  }

  if (param_file_name.size()) {
    burn_in = 0;
    burn_out = 0;
    burned_out = true;
  }
  
  size_t stranded_count = 0;
  if (vm.count("fr-stranded")) {
    direction = FR;
    stranded_count++;
  }
  if (vm.count("rf-stranded")) {
    direction = RF;
    stranded_count++;
  }
  if (vm.count("f-stranded")) {
    direction = F;
    stranded_count++;
  }
  if (vm.count("r-stranded")) {
    direction = R;
    stranded_count++;
  }
  if (stranded_count > 1) {
    logger.severe("Multiple strandedness flags cannot be specified in the same "
                  "run.");
  }
  if (vm.count("logtostderr")) {
    logger.info_out(&cerr);
  }
  
  edit_detect = vm.count("edit-detect");
  calc_covar = vm.count("calc-covar");
  bias_correct = !(vm.count("no-bias-correct"));
  error_model = !(vm.count("no-error-model"));
  output_align_prob = vm.count("output-align-prob");
  output_align_samp = vm.count("output-align-samp");
  output_running_rounds = vm.count("output-running-rounds");
  output_running_reads = vm.count("output-running-reads");
  batch_mode = vm.count("batch-mode");
  both = vm.count("both");
  remaining_rounds = max(additional_online, additional_batch);
  spark_pre = vm.count("preprocess");

  if (batch_mode) {
    ff_param = 1;
  }
  
  if (additional_online > 0 && additional_batch > 0) {
    logger.severe("Cannot add both online and batch rounds.");
  } else if (additional_online > 0) {
    online_additional = true;
  }
  
  if (output_align_prob && output_align_samp) {
    logger.severe("Cannot output both alignment probabilties and sampled "
                  "alignments.");
  }
  if ((output_align_prob || output_align_samp) && remaining_rounds == 0) {
    logger.warn("It is recommended that at least one additional round "
                "be used when outputting alignment probabilities or sampled "
                "alignments. Use the '-B' or '-O' option to enable.");
  }
  
  // We have 1 processing thread and 1 parsing thread always, so we should not
  // count these as additional threads.
  if (num_threads < 2) {
    num_threads = 0;
  }
  num_threads -= 2;
  if (num_threads > 0) {
    num_threads -= edit_detect;
  }
  if (remaining_rounds && in_map_file_names == "") {
    logger.severe("Cannot process multiple rounds from streaming input.");
  }
  if (remaining_rounds) {
    last_round = false;
  }
  if (prior_file != "") {
    expr_alpha_map = parse_priors(prior_file);
  }

#ifndef WIN32
  if (!vm.count("no-update-check")) {
    check_version(PACKAGE_VERSION);
  }
#endif

  return 0;
}
コード例 #16
0
	void Sink::run(void)
	{
		int32 ret = 0, is_msg = 0, handler_ret = 0;
		int32 data_ready = 0;

		Logger* sl = getBlockManager()->getLogger();
		cmessage cm;

		while (!_quit) {
			//if (_started) {
			//	// get a message from control pin non blocking
			//	ret = getControlPin()->tryRecvMessage(&cm);
			//	if (ret == SUCCESS) is_msg = 1;
			//} else {
			// get a message from control pin blocking
			ret = getControlPin()->recvMessage(&cm);
			if (ret == SUCCESS)
				is_msg = 1;
			//}

			if (is_msg) {
				// detect terminate event
				if (cm.code == Block::EVENT_TERMINATE) {
					_started = false; _quit = true;
					sl->log(Logger::LEVEL_NOTICE,
							"%s: terminate request received", getName());

					// set status
					setStatus(STATUS_TERMINATING);

					// jump to while()
					//continue;
				} else {
					// check message codes and set status
					switch (cm.code) {
					case EVENT_PAUSE:
						setStatus(STATUS_PAUSED);
						_started = false;
						sl->log(Logger::LEVEL_NOTICE,
								"%s: pause request received", getName());
						break;
					case EVENT_RESET:
						setStatus(STATUS_RESETTING);
						_started = false;
						sl->log(Logger::LEVEL_NOTICE,
								"%s: reset request received", getName());
						break;
					case EVENT_START:
						setStatus(STATUS_STARTED);
						_started = true;
						sl->log(Logger::LEVEL_NOTICE,
								"%s: start request received", getName());
						break;
					case EVENT_STOP:
						setStatus(STATUS_STOPPED);
						_started = false;
						sl->log(Logger::LEVEL_NOTICE,
								"%s: stop request received", getName());
						break;
					case EVENT_BUFFERIZE:
						setStatus(STATUS_BUFFERIZING);
						_started = true;
						sl->log(Logger::LEVEL_NOTICE,
								"%s: bufferize request received", getName());
						break;
					case EVENT_SEEK:
						setStatus(STATUS_SEEKING);
						setSeekInfo(&cm.seek);
						sl->log(Logger::LEVEL_NOTICE,
								"%s: seek request received (strange)",
								getName());
						break;
					case EVENT_TELL:
						setStatus(STATUS_TELLING);
						sl->log(Logger::LEVEL_NOTICE,
								"%s: tell request received (strange)",
								getName());
						break;
					case EVENT_SKIP:
						setStatus(STATUS_SKIPPING);
						_started = true;	setSeekInfo(&cm.seek);
						sl->log(Logger::LEVEL_NOTICE,
								"%s: skip request received", getName());
						break;
					case EVENT_QUIT:
						setStatus(STATUS_QUITTING);
						_started = false; _quit = true;
						sl->log(Logger::LEVEL_NOTICE,
								"%s: quit request received", getName());
						break;
					case EVENT_TIMEOUT:
						sl->log(Logger::LEVEL_NOTICE,
								"%s: timeout request received", getName());
						break;
					case EVENT_DATA_READY:
						setStatus(STATUS_STARTED);
						_started = true; data_ready = 1;
						sl->log(Logger::LEVEL_NOTICE,
								"%s: data_ready request received", getName());
						break;
					case EVENT_COMMAND:
						sl->log(Logger::LEVEL_NOTICE,
								"%s: command request received", getName());
						break;
					default:
						if (cm.code >= EVENT_MAX_ID)
							sl->log(Logger::LEVEL_CRIT,
									"%s: invalid message code (%d)",
									getName(), cm.code);
						else
							sl->log(Logger::LEVEL_CRIT,
									"%s: user message %d received", getName(),
									cm.code);
					}

					// execute event handler for this message code
					handler_ret = executeEventHandler(cm.code);
					if (handler_ret == Block::HANDLER_UNDEFINED) {
						sl->log(Logger::LEVEL_NOTICE,
								"%s: undefined handler %d", getName(), cm.code);
					} else if (handler_ret == BlockHandler::HFAILURE) {
						_started = false; setStatus(STATUS_READY);
						sl->log(Logger::LEVEL_ERROR, "%s: handler %d failed",
								getName(), cm.code);
					}

					/*
					 * This block checks for StatusListeners availability. If
					 * any status listener has been registered, this block sends
					 * status messages to it.
					 */
					if (cm.status_listener) {
						// DEBUG
						//UOSUTIL_DOUT((stderr, "Untested code: status listener\n"));

						smessage sm;
						memset(&sm, 0, sizeof(smessage));

						sm.code = cm.code;
						sm.serial = cm.serial;
						sm.status = getStatus();
						sm.eh_return = handler_ret;
						snprintf(sm.error, SM_MESSAGE_SZ, "%s",
							getErrorString());

						ret = cm.status_listener->notifyStatusMessage(&sm);
						if (ret == FAILURE) {
							sl->log(Logger::LEVEL_WARN,
									"%s: cannot notify status to registered listener",
									getName());
						}

						// DEBUG
						//UOSUTIL_DOUT((stderr, "Untested code: status listener end\n"));
					}

					// set status to ready if compatible
					if (cm.code != EVENT_START &&
						cm.code != EVENT_STOP &&
						cm.code != EVENT_PAUSE &&
						cm.code != EVENT_DATA_READY &&
						cm.code != EVENT_COMMAND)
						setStatus(STATUS_READY);

					// wait for next message
					is_msg = 0;
				}
			}

			if (_started && data_ready) {
				// do sink main action: consume data if ready
				handler_ret = executeActionHandler(ACTION_DATA_CONSUME);
				if (handler_ret == Block::HANDLER_UNDEFINED) {
					_started = false; setStatus(STATUS_READY);
					sl->log(Logger::LEVEL_CRIT,
							"%s: undefined action handler", getName());
				} else if (handler_ret == BlockHandler::HSUCCESS) {
					// DO NOTHING HERE (useless log)
				} else if (handler_ret == BlockHandler::HFAILURE) {
					   	_started = false; setStatus(STATUS_READY);
					sl->log(Logger::LEVEL_ERROR,
					   		"%s: action handler returned FAILURE", getName());
				} else if (handler_ret == BlockHandler::HCRITICAL) {
					   	_started = false; setStatus(STATUS_READY);
					sl->log(Logger::LEVEL_EMERG,
					   		"%s: action handler returned CRITICAL FAILURE",
					   		getName());
				} else {
					sl->log(Logger::LEVEL_CRIT,
					   		"%s: action handler returned undefined value",
					   		getName());
				}

				// reset data_ready flag
				data_ready = 0;
			}
		}


		// release the quit semaphore
		sl-> log(Logger::LEVEL_CRIT,
				"%s: Releasing QUIT SEMAPHORE (so quitting)", getName());

		_quitSem. post();

		// log termination before block destruction
		sl-> log(Logger::LEVEL_CRIT,
				"%s: Asking BlockManager for termination", getName());

		/*
		 * Notify the block manager that this block is quitting.
		 * Messages must be sent with normal priority since the
		 * block manager have to complete all pending activities.
		 */
		cmessage bmm;

		memset(&bmm, 0, sizeof(bmm));
		bmm. code = BlockManager::BM_MESSAGE_BLOCKQUIT;
		bmm. from = this;

		getControlPin()-> sendMessage(&bmm);
	}
コード例 #17
0
//
// Get configuration from variant data type
//
ServiceConfig::State ServiceConfig::GetConfig(const VariantNC  & oData,
                                              ServiceConfig    & oServiceConfig,
                                              Logger           & oLogger)
{
	// Allow connection from specified IP's or subnets
	if (ParseNetworks(oData, "AllowConnect", oServiceConfig, oServiceConfig.ipv4_allowed_networks, oLogger) != OK)
	{
		return CONFIG_ERROR;
	}

	// Deny connection from specified IP's or subnets
	if (ParseNetworks(oData, "DenyConnect", oServiceConfig, oServiceConfig.ipv4_denied_networks, oLogger) != OK)
	{
		return CONFIG_ERROR;
	}

	// Order of networks check
	oServiceConfig.allow_deny_order = ALLOW_DENY;

	const STLW::vector<STLW::string> vDenyAllow = oData["AllowDenyOrder"];
	if (!vDenyAllow.empty() && vDenyAllow[0] != "")
	{
		if (vDenyAllow.size() != 2)
		{
		 	oLogger.Emerg("Invalid format of parameter `Service/%s/AllowDenyOrder`: need `allow deny` or `deny allow`", oServiceConfig.name.c_str());
		 	return CONFIG_ERROR;
		}

		if (Unicode::CompareIgnoreCase(vDenyAllow[0].data(), vDenyAllow[0].size(), "deny", sizeof("deny") - 1) == 0)
		{
			oServiceConfig.allow_deny_order = DENY_ALLOW;
		}
	}

	// Listen to inteface
	STLW::vector<STLW::string> vListen;
	ConfigHelper::GetList(oData["Listen"], vListen);
	STLW::vector<STLW::string>::const_iterator itvListen = vListen.begin();
	while(itvListen != vListen.end())
	{
		ListenInterface  oInterface;
		ConfigHelper::State oRC = ConfigHelper::ParseAddress(*itvListen, oInterface.af, oInterface.address, oInterface.port);
		if (oRC != ConfigHelper::OK)
		{
			oLogger.Emerg("Invalid address: `%s`", itvListen -> c_str());
			return CONFIG_ERROR;
		}
		oServiceConfig.listen.push_back(oInterface);
		++itvListen;
	}
	// Socket listen queue
	oServiceConfig.listen_queue = oData["MaxQueueLength"];
	if (oServiceConfig.listen_queue == 0)
	{
		oLogger.Emerg("Invalid format of parameter `Service/%s/MaxQueueLength` not set", oServiceConfig.name.c_str());
		return CONFIG_ERROR;
	}

	// Read buffer size
	oServiceConfig.recv_buffer_size = ConfigHelper::ParseSize(oData["RecvBufferSize"]);
	if (oServiceConfig.recv_buffer_size == 0 || oServiceConfig.recv_buffer_size == UINT_32(-1))
	{
		oLogger.Emerg("Invalid format of parameter `Service/%s/RecvBufferSize` not set", oServiceConfig.name.c_str());
		return CONFIG_ERROR;
	}

	//  Maximum number of connections for this service
	oServiceConfig.max_clients    = oData["MaxClients"];
	if (oServiceConfig.max_clients == 0) { oLogger.Warn("Parameter `Service/%s/MaxClients`: not set", oServiceConfig.name.c_str()); }

	// Number of active clients
	oServiceConfig.active_clients = 0;

	// Read/Write timeout
	oServiceConfig.io_timeout = ConfigHelper::ParseTimeout(oData["IOTimeout"]) / 1000.0;
	if (oServiceConfig.io_timeout == 0)
	{
		oLogger.Emerg("Parameter `Service/%s/IOTimeout`: need to set positive value", oServiceConfig.name.c_str());
		return CONFIG_ERROR;
	}

#ifdef IRIS_TLS_SUPPORT
	// TLS parameters
	oServiceConfig.enable_ssl_tls = ConfigHelper::ParseBool(oData["EnableTLSSSL"]);
	if (oServiceConfig.enable_ssl_tls)
	{
		// File with the RSA certificate in PEM format.
		oServiceConfig.tls_cert_file = oData["TLSCertFile"];
		// File with the RSA private key in PEM format
		oServiceConfig.tls_key_file  = oData["TLSKeyFile"];
		// File with the DH data
		oServiceConfig.dh_file.assign(oData["DHFile"]);
		// SSL Ciphers
		oServiceConfig.ciphers.assign(oData["SSLCiphers"]);

		if (oServiceConfig.tls_cert_file.size() != oServiceConfig.tls_key_file.size())
		{
			oLogger.Emerg("Number of files `Service/%s/TLSCertFile` and Service/%s/TLSKeyFile` must be equal", oServiceConfig.name.c_str());
			return CONFIG_ERROR;
		}

		// Use Transport Level Security at connection time
		oServiceConfig.use_tls               = ConfigHelper::ParseBool(oData["UseTLS"]);
		// Allow upgrade an existing insecure connection to a secure connection using SSL/TLS
		oServiceConfig.start_tls             = ConfigHelper::ParseBool(oData["StartTLS"]);
		// Prefer to user server ciphers
		oServiceConfig.prefer_server_ciphers = ConfigHelper::ParseBool(oData["PreferServerCiphers"], true);
	}
#endif // IRIS_TLS_SUPPORT

	// Handler name
	oServiceConfig.handler_name.assign(oData["Handler"]);
	// Handler object
	oServiceConfig.handler = NULL;

return OK;
}
コード例 #18
0
ファイル: log.cpp プロジェクト: qtx0213/MultiCraft
		AndroidSystemLogOutput()
		{
			g_logger.addOutput(this);
		}
コード例 #19
0
ファイル: Components.cpp プロジェクト: scottp/xcsoar
/**
 * "Boots" up XCSoar
 * @param hInstance Instance handle
 * @param lpCmdLine Command line string
 * @return True if bootup successful, False otherwise
 */
bool XCSoarInterface::Startup(HINSTANCE hInstance, LPTSTR lpCmdLine)
{
  // The title bar text
  TCHAR szTitle[MAX_LOADSTRING];

  // Store instance handle in our global variable
  hInst = hInstance;

  // IDS_APP_TITLE = XCSoar (see XCSoar.rc)
  LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);

  //If it is already running, then focus on the window
  if (MainWindow::find(szTitle))
    return false;

  // Send the SettingsMap to the DeviceBlackboard
  SendSettingsMap();

  // Register window classes
  PaintWindow::register_class(hInst);
  MainWindow::register_class(hInst);
  MapWindow::register_class(hInst);

  // Fill the fast(co)sine table
  InitSineTable();

  PreloadInitialisation(true);

  // Send the SettingsMap to the DeviceBlackboard
  SendSettingsMap();

  // Creates the main window
  StartupStore(TEXT("Create main window\n"));
  RECT WindowSize = SystemWindowSize();
  main_window.set(szTitle,
		  WindowSize.left, WindowSize.top,
		  WindowSize.right, WindowSize.bottom);

  if (!main_window.defined()) {
    return false;
  }
  main_window.install_timer();

  // Initialize DeviceBlackboard
  device_blackboard.Initialise();

  // Initialize Marks
  marks = new Marks("xcsoar-marks");
  topology = new TopologyStore(marks->GetTopology());

  // Show the main and map windows
  StartupStore(TEXT("Create map window\n"));
  main_window.show();
  main_window.map.show();

#ifdef HAVE_ACTIVATE_INFO
  SHSetAppKeyWndAssoc(VK_APP1, main_window);
  SHSetAppKeyWndAssoc(VK_APP2, main_window);
  SHSetAppKeyWndAssoc(VK_APP3, main_window);
  SHSetAppKeyWndAssoc(VK_APP4, main_window);
  // Typical Record Button
  //	Why you can't always get this to work
  //	http://forums.devbuzz.com/m_1185/mpage_1/key_/tm.htm
  //	To do with the fact it is a global hotkey, but you can with code above
  //	Also APPA is record key on some systems
  SHSetAppKeyWndAssoc(VK_APP5, main_window);
  SHSetAppKeyWndAssoc(VK_APP6, main_window);
#endif

  // Initialize main blackboard data
  task.ClearTask();
  glide_computer.Initialise();
  logger.LinkGRecordDLL(); // try to link DLL if it exists

  // Load the EGM96 geoid data
  OpenGeoid();

  PreloadInitialisation(false);

  Profile::LoadWindFromRegistry();

  // TODO TB: seems to be out of date?!
  CalculateNewPolarCoef();

  // Calculate polar-related data and saves it to the cache
  StartupStore(TEXT("GlidePolar::UpdatePolar\n"));
  GlidePolar::UpdatePolar(false, SettingsComputer());

  // Show startup info depending on device
  StartupInfo();

  // Read the topology file(s)
  topology->Open();

  // Read the terrain file
  terrain.OpenTerrain();

  // Read the waypoint files
  ReadWayPoints(way_points, terrain);

  // Read and parse the airfield info file
  ReadAirfieldFile();

  // Set the home waypoint
  SetHome(way_points, terrain, SetSettingsComputer(), false, true);

  // ReSynchronise the blackboards here since SetHome touches them
  ReadBlackboardBasic(device_blackboard.Basic());

  terrain.ServiceFullReload(Basic().Location);

  // Scan for weather forecast
  CreateProgressDialog(gettext(TEXT("Scanning weather forecast")));
  StartupStore(TEXT("RASP load\n"));
  RASP.ScanAll(Basic().Location);

  // Reads the airspace files
  ReadAirspace();
  // Sorts the airspaces by priority
  SortAirspace();

  // Read the FLARM details file
  OpenFLARMDetails();

#ifndef DISABLEAUDIOVARIO
  /*
  VarioSound_Init();
  VarioSound_EnableSound(EnableSoundVario);
  VarioSound_SetVdead(SoundDeadband);
  VarioSound_SetV(0);
  VarioSound_SetSoundVolume(SoundVolume);
  */
#endif

  // Start the device thread(s)
  CreateProgressDialog(gettext(TEXT("Starting devices")));
  devStartup(lpCmdLine);

  // Reset polar in case devices need the data
  StartupStore(TEXT("GlidePolar::UpdatePolar\n"));
  GlidePolar::UpdatePolar(true, SettingsComputer());

  CreateProgressDialog(gettext(TEXT("Initialising display")));

  // Finally ready to go.. all structures must be present before this.

  // Create the drawing thread
  StartupStore(TEXT("CreateDrawingThread\n"));
  draw_thread = new DrawThread(main_window.map, main_window.flarm);
  draw_thread->start();

  // Show the infoboxes
  StartupStore(TEXT("ShowInfoBoxes\n"));
  InfoBoxManager::Show();

  // Create the calculation thread
  StartupStore(TEXT("CreateCalculationThread\n"));
  CreateCalculationThread();

#ifdef NEWTASK  
  { // NEWTASK
    PeriodClock t;
    t.reset(); t.update();
    CreateProgressDialog(gettext(TEXT("Running test 0")));
    test_newtask(0);
    StartupStore(TEXT("test 0 %d\n"),t.elapsed());

    /*
    t.update();
    CreateProgressDialog(gettext(TEXT("Running test 1")));
    test_newtask(1);
    StartupStore(TEXT("test 1 %d\n"),t.elapsed());

    t.update();
    CreateProgressDialog(gettext(TEXT("Running test 2")));
    test_newtask(2);
    StartupStore(TEXT("test 2 %d\n"),t.elapsed());

    t.update();
    CreateProgressDialog(gettext(TEXT("Running test 3")));
    test_newtask(3);
    StartupStore(TEXT("test 3 %d\n"),t.elapsed());

    t.update();
    CreateProgressDialog(gettext(TEXT("Running test 4")));
    test_newtask(4);
    StartupStore(TEXT("test 4 %d\n"),t.elapsed());
    */
    CreateProgressDialog(gettext(TEXT("test complete")));
  }
#endif

  // Initialise the airspace warning dialog
  StartupStore(TEXT("dlgAirspaceWarningInit\n"));
  dlgAirspaceWarningInit();

  // Find unique ID of this PDA
  ReadAssetNumber();

  StartupStore(TEXT("ProgramStarted\n"));

  // Give focus to the map
  main_window.map.set_focus();

  // Start calculation thread
  calculation_thread->start();

  // Start instrument thread
  instrument_thread->start();

  globalRunningEvent.trigger();

  return true;
}
コード例 #20
0
ファイル: log.cpp プロジェクト: qtx0213/MultiCraft
		~AndroidSystemLogOutput()
		{
			g_logger.removeOutput(this);
		}
コード例 #21
0
ファイル: mainCoach.cpp プロジェクト: Guidotti/Expertinos
/*! This is the main function and creates and links all the different
    classes.  First it reads in all the parameters from the command
    prompt (<program name> -help)and uses these values to create the
    classes. After all the classes are linked, the mainLoop in the
    Player class is called. */
int main( int argc, char * argv[] )
{
#ifdef WIN32
  HANDLE         listen, sense;
#else
  pthread_t      listen, sense;
#endif
  ServerSettings ss;
  PlayerSettings cs;

  // define variables for command options and initialize with default values
  char     strTeamName[MAX_TEAM_NAME_LENGTH] = "UvA_Trilearn";
  int      iPort                             = 6002;
  int      iMinLogLevel                      = 0 ;
  int      iMaxLogLevel                      = 0;
  char     strHost[128]                      = "localhost";
  double   dVersion                          = 14;
  int      iMode                             = 0;
  char     strFormations[128]                = "formations.conf";
  int      iNr                               = 0;
  int      iReconnect                        = -1;
  bool     bInfo                             = false;
  bool     bSuppliedLogFile                  = false;
  ofstream os;

  // read in all the command options and change the associated variables
  // assume every two values supplied at prompt, form a duo
  char * str;
  for( int i = 1 ; i < argc ; i = i + 2  )
  {
    // help is only option that does not have to have an argument
    if( i + 1 >= argc && strncmp( argv[i], "-help", 3 ) != 0 )
    {
      cout << "Need argument for option: " << argv[i] << endl;
      exit( 0 );
    }
    // read a command option
    if( argv[i][0] == '-' && strlen( argv[i] ) > 1)
    {
      switch( argv[i][1] )
      {
        case 'h':                                   // host server or help
          if( strlen( argv [i]) > 2 && argv[i][2] == 'e' )
          {
            printOptions( );
            exit(0);
          }
          else
            strcpy( strHost, argv[i+1] );
          break;
        case 'f':                                   // formations file
          strcpy( strFormations, argv[i+1] );
          break;
        case 'c':                                   // clientconf file
          if( cs.readValues( argv[i+1], ":" ) == false )
            cerr << "Error in reading client file: " << argv[i+1] << endl;
          break;
        case 'i':                                   // info 1 0
          str   = &argv[i+1][0];
          bInfo = (Parse::parseFirstInt( &str ) == 1 ) ? true : false ;
          break;
        case 'l':                                   // loglevel int[..int]
          str = &argv[i+1][0];
          iMinLogLevel = Parse::parseFirstInt( &str );
          while( iMinLogLevel != 0 )
          {
            if( *str == '.' ) // '.' indicates range of levels
            {
              iMaxLogLevel = Parse::parseFirstInt( &str );
              if( iMaxLogLevel == 0 ) iMaxLogLevel = iMinLogLevel;
              Log.addLogRange( iMinLogLevel, iMaxLogLevel );
            }
            else
              Log.addLogLevel( iMinLogLevel );
            iMinLogLevel = Parse::parseFirstInt( &str );
          }
          break;
        case 'm':                                   // mode int
          str = &argv[i+1][0];
          iMode = Parse::parseFirstInt( &str );
          break;
        case 'o':                                   // output file log info
          os.open( argv[i+1] );
          bSuppliedLogFile = true;
          break;
        case 'p':                                   // port
          str = &argv[i+1][0];
          iPort = Parse::parseFirstInt( &str );
          break;
        case 's':                                   // serverconf file
          if( ss.readValues( argv[i+1], ":" ) == false )
            cerr << "Error in reading server file: " << argv[i+1] << endl;
          break;
        case 't':                                   // teamname name
          strcpy( strTeamName, argv[i+1] );
          break;
        case 'v':                                   // version version
          str = &argv[i+1][0];
          dVersion = Parse::parseFirstDouble( &str );
          break;
        default:
          cerr << "(main) Unknown command option: " << argv[i] << endl;
      }
    }
  }


  if( bInfo == true )
  cout << "team         : "  << strTeamName    << endl <<
          "port         : "  << iPort          << endl <<
          "host         : "  << strHost        << endl <<
          "version      : "  << dVersion       << endl <<
          "min loglevel : "  << iMinLogLevel   << endl <<
          "max loglevel : "  << iMaxLogLevel   << endl <<
          "mode         : "  << iMode          << endl <<
          "playernr     : "  << iNr            << endl <<
          "reconnect    : "  << iReconnect     << endl ;

  if( bSuppliedLogFile == true )
    Log.setOutputStream( os );                   // initialize logger
  else
    Log.setOutputStream( cout );
  Log.restartTimer( );
  Formations fs( strFormations, (FormationT)cs.getInitialFormation(), iNr );
                                               // read formations file
  WorldModel wm( &ss, &cs, &fs );              // create worldmodel
  Connection c( strHost, iPort, MAX_MSG );     // make connection with server
  ActHandler a( &c, &wm, &ss );                // link actHandler and WM
  SenseHandler s( &c, &wm, &ss, &cs );         // link senseHandler with wm
  bool isTrainer = (iPort == ss.getCoachPort()) ? true : false;
  BasicCoach bp( &a, &wm, &ss, strTeamName, dVersion, isTrainer );
                                               // link acthandler and WM

#ifdef WIN32
  DWORD id1;
  sense = CreateThread(NULL, 0, &sense_callback, &s, 0, &id1);
  if (sense == NULL)
  {
      cerr << "create thread error" << endl;
      return false;
  }
#else
  pthread_create( &sense, NULL, sense_callback  , &s); // start listening
#endif

  if( iMode > 0 && iMode < 9 )       // only listen to sdtdin when not playing
#ifdef WIN32
  {
    DWORD id2;
    listen = CreateThread(NULL, 0, &stdin_callback, &bp, 0, &id2);
    if ( listen == NULL)
    {
        cerr << "create thread error" << endl;
        return false;
    }
  }
#else
    pthread_create( &listen, NULL, stdin_callback, &bp);
#endif
  
  if( iMode == 0 )
    bp.mainLoopNormal();

  c.disconnect();
  
  os.close();
}
コード例 #22
0
ファイル: log.cpp プロジェクト: qtx0213/MultiCraft
void RawLogBuffer::flush(const std::string &buffer)
{
	g_logger.logRaw(LL_NONE, buffer);
}
コード例 #23
0
ファイル: jambox.cpp プロジェクト: bramp/jambox
int main() {

	// Set up logging
    BasicConfigurator config;
    config.configure();
    logger.setLogLevel(TRACE_LOG_LEVEL);

	int r;
	UsbContext usb;
	UsbDevice dev (jambox_open(usb));

	if (!dev) {
		//LOG4CPLUS_TRACE_STR(logger, "Main::Main()");
		LOG4CPLUS_ERROR(logger, "Failed to find a jambox");
		return NULL;
	}

	


	/*
	unsigned char data[] = {0x00, 0xFC, 0x23, 0xC2, 0x00, 0x00, 0x11, 0x00,
	        0x3B, 0x71,/ 0x03, 0x70, 0x00, 0x00, 0x08, 0x01,
	        0x09, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00,
	        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	        0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
	int len = sizeof(data) / sizeof(*data);
	*/

	jambox_req req;
	int actual = 0; //used to find out how many bytes were written

	create_name_request(&req);

	unsigned char * data = (unsigned char *)&req;
	int len = 0x26;

	print_bytes(data, len);

	cout<<"Writing Data"<<endl;
	r = libusb_control_transfer(dev, LIBUSB_REQUEST_TYPE_CLASS | LIBUSB_RECIPIENT_INTERFACE, 0, 0, 0, data, len, USB_TIMEOUT);
	if(r == len) {
		cout<<"Writing Successful!"<<endl;
	} else {
		cout<<"Write Error "<< r << " " << actual << "/" << len << endl;
	}

	//r = libusb_interrupt_transfer(dev, 0x81, in, sizeof(in), &actual, USB_TIMEOUT);
	r = libusb_interrupt_transfer(dev, 0x81, &req.data[1], sizeof(req) - 1, &actual, USB_TIMEOUT);
	printf("interrupt read returned %d, %d bytes: ", r, actual);
	print_bytes((unsigned char *)&req, actual + 1);
	//printf("\n");

	printf("device name: %s\n", &req.data[20]);

	create_pair_request(&req);
	len = 0x6a;
	print_bytes((unsigned char *)&req, req.header.len + 3);
	

	r = libusb_control_transfer(dev, LIBUSB_REQUEST_TYPE_CLASS | LIBUSB_RECIPIENT_INTERFACE, 0, 0, 0, data, len, USB_TIMEOUT);
	if(r == len) {
		cout<<"Writing Successful!"<<endl;
	} else {
		cout<<"Write Error "<< r << " " << actual << "/" << len << endl;
	}

	//r = libusb_interrupt_transfer(dev, 0x81, in, sizeof(in), &actual, USB_TIMEOUT);
	r = libusb_interrupt_transfer(dev, 0x81, &req.data[1], sizeof(req) - 1, &actual, USB_TIMEOUT);
	printf("interrupt read returned %d, %d bytes: ", r, actual);
	print_bytes((unsigned char *)&req, actual + 1);
	//printf("\n");

	printf("device name: %s\n", &req.data[20]);


	return 0;
}
コード例 #24
0
ファイル: main.cpp プロジェクト: AXLEproject/nvram-sim
void nvlog_flush() {
  nvlogger.Flush();
}
コード例 #25
0
int main(int argc, char *argv[])
{
	#ifdef WIN32
	_CrtSetDbgFlag ( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF ); // dump leaks at return
	//_CrtSetBreakAlloc(287);
	#endif
	
	string verboseLevelConsole;
	string verboseLevelImages;
	vector<path> inputPaths;
	path inputFilelist;
	path inputDirectory;
	vector<path> inputFilenames;
	path configFilename;
	shared_ptr<ImageSource> imageSource;
	path outputPicsDir;

	try {
		po::options_description desc("Allowed options");
		desc.add_options()
			("help,h",
				"produce help message")
			("verbose,v", po::value<string>(&verboseLevelConsole)->implicit_value("DEBUG")->default_value("INFO","show messages with INFO loglevel or below."),
				  "specify the verbosity of the console output: PANIC, ERROR, WARN, INFO, DEBUG or TRACE")
			("verbose-images,w", po::value<string>(&verboseLevelImages)->implicit_value("INTERMEDIATE")->default_value("FINAL","write images with FINAL loglevel or below."),
				  "specify the verbosity of the image output: FINAL, INTERMEDIATE, INFO, DEBUG or TRACE")
			("config,c", po::value<path>()->required(), 
				"path to a config (.cfg) file")
			("input,i", po::value<vector<path>>()->required(), 
				"input from one or more files, a directory, or a  .lst-file containing a list of images")
			("output-dir,o", po::value<path>()->default_value("."),
				"output directory for the result images")
		;

		po::positional_options_description p;
		p.add("input", -1);
		
		po::variables_map vm;
		po::store(po::command_line_parser(argc, argv).options(desc).positional(p).run(), vm);
		po::notify(vm);
	
		if (vm.count("help")) {
			cout << "Usage: mergePlaygroundApp [options]\n";
			cout << desc;
			return EXIT_SUCCESS;
		}
		if (vm.count("verbose")) {
			verboseLevelConsole = vm["verbose"].as<string>();
		}
		if (vm.count("verbose-images")) {
			verboseLevelImages = vm["verbose-images"].as<string>();
		}
		if (vm.count("input"))
		{
			inputPaths = vm["input"].as<vector<path>>();
		}
		if (vm.count("config"))
		{
			configFilename = vm["config"].as<path>();
		}
		if (vm.count("output-dir"))
		{
			outputPicsDir = vm["output-dir"].as<path>();
		}
	} catch(std::exception& e) {
		cout << e.what() << endl;
		return EXIT_FAILURE;
	}

	loglevel logLevel;
	if(boost::iequals(verboseLevelConsole, "PANIC")) logLevel = loglevel::PANIC;
	else if(boost::iequals(verboseLevelConsole, "ERROR")) logLevel = loglevel::ERROR;
	else if(boost::iequals(verboseLevelConsole, "WARN")) logLevel = loglevel::WARN;
	else if(boost::iequals(verboseLevelConsole, "INFO")) logLevel = loglevel::INFO;
	else if(boost::iequals(verboseLevelConsole, "DEBUG")) logLevel = loglevel::DEBUG;
	else if(boost::iequals(verboseLevelConsole, "TRACE")) logLevel = loglevel::TRACE;
	else {
		cout << "Error: Invalid loglevel." << endl;
		return EXIT_FAILURE;
	}
	imagelogging::loglevel imageLogLevel;
	if(boost::iequals(verboseLevelImages, "FINAL")) imageLogLevel = imagelogging::loglevel::FINAL;
	else if(boost::iequals(verboseLevelImages, "INTERMEDIATE")) imageLogLevel = imagelogging::loglevel::INTERMEDIATE;
	else if(boost::iequals(verboseLevelImages, "INFO")) imageLogLevel = imagelogging::loglevel::INFO;
	else if(boost::iequals(verboseLevelImages, "DEBUG")) imageLogLevel = imagelogging::loglevel::DEBUG;
	else if(boost::iequals(verboseLevelImages, "TRACE")) imageLogLevel = imagelogging::loglevel::TRACE;
	else {
		cout << "Error: Invalid image loglevel." << endl;
		return EXIT_FAILURE;
	}
	
	Loggers->getLogger("classification").addAppender(make_shared<logging::ConsoleAppender>(logLevel));
	Loggers->getLogger("imageio").addAppender(make_shared<logging::ConsoleAppender>(logLevel));
	Loggers->getLogger("imageprocessing").addAppender(make_shared<logging::ConsoleAppender>(logLevel));
	Loggers->getLogger("detection").addAppender(make_shared<logging::ConsoleAppender>(logLevel));
	Loggers->getLogger("ffpDetectApp").addAppender(make_shared<logging::ConsoleAppender>(logLevel));
	Logger appLogger = Loggers->getLogger("ffpDetectApp");

	appLogger.debug("Verbose level for console output: " + logging::loglevelToString(logLevel));
	appLogger.debug("Verbose level for image output: " + imagelogging::loglevelToString(imageLogLevel));
	appLogger.debug("Using config: " + configFilename.string());
	appLogger.debug("Using output directory: " + outputPicsDir.string());
	if(outputPicsDir.empty()) {
		appLogger.info("Output directory not set. Writing images into current directory.");
	}

	ImageLoggers->getLogger("detection").addAppender(make_shared<imagelogging::ImageFileWriter>(imageLogLevel, outputPicsDir));
	ImageLoggers->getLogger("mergePlaygroundApp").addAppender(make_shared<imagelogging::ImageFileWriter>(imageLogLevel, outputPicsDir));


	
	// TEMP: Read a txt patchset from Cog, do WHI, and write a new .txt.
	// =================================================================
	vector<cv::Mat> positives;
	std::ifstream file("E:/training/ffd_training_regrPaperX200/data/posPatches.txt");
	if (!file.is_open()) {
		std::cout << "Invalid patches file" << std::endl;
		return 0;
	}
	while (file.good()) {
		string line;
		if (!std::getline(file, line))
			break;

		int width = 31;
		int height = 31;
		int dimensions = width * height;
		Mat patch(width, height, CV_8U);
		std::istringstream lineStream(line);
		if (!lineStream.good() || lineStream.fail()) {
			std::cout << "Invalid patches file l2" << std::endl;
			return 0;
		}
		uchar* values = patch.ptr<uchar>(0);
		float val;
		for (int j = 0; j < dimensions; ++j) {
			lineStream >> val;
			values[j] = static_cast<uchar>(val*255.0f);
		}

		positives.push_back(patch);
	}
	file.close();

	vector<cv::Mat> negatives;
	file.open("E:/training/ffd_training_regrPaperX200/data/negPatches.txt");
	if (!file.is_open()) {
		std::cout << "Invalid patches file" << std::endl;
		return 0;
	}
	while (file.good()) {
		string line;
		if (!std::getline(file, line))
			break;

		int width = 31;
		int height = 31;
		int dimensions = width * height;
		Mat patch(width, height, CV_8U);
		std::istringstream lineStream(line);
		if (!lineStream.good() || lineStream.fail()) {
			std::cout << "Invalid patches file l4" << std::endl;
			return 0;
		}
		uchar* values = patch.ptr<uchar>(0);
		float val;
		for (int j = 0; j < dimensions; ++j) {
			lineStream >> val;
			values[j] = static_cast<uchar>(val*255.0f);
		}

		negatives.push_back(patch);
	}
	file.close();

	shared_ptr<WhiteningFilter> fw = make_shared<WhiteningFilter>();
	shared_ptr<HistogramEqualizationFilter> fh = make_shared<HistogramEqualizationFilter>();
	shared_ptr<ConversionFilter> fc = make_shared<ConversionFilter>(CV_32F, 1.0/127.5, -1.0);
	shared_ptr<UnitNormFilter> fi = make_shared<UnitNormFilter>(cv::NORM_L2);
	shared_ptr<ReshapingFilter> fr = make_shared<ReshapingFilter>(1);
	for (auto& p : positives) {
		//p.convertTo(p, CV_32F);
		fw->applyInPlace(p);
		// min/max, stretch to [0, 255] 8U
		fh->applyInPlace(p);
		// need to go back to [-1, 1] before UnitNormFilter:
		fc->applyInPlace(p);
		fi->applyInPlace(p);
		fr->applyInPlace(p);
	}
	for (auto& p : negatives) {
		fw->applyInPlace(p);
		fh->applyInPlace(p);
		fc->applyInPlace(p);
		fi->applyInPlace(p);
		fr->applyInPlace(p);
	}

	std::ofstream ofile("E:/training/ffd_training_regrPaperX200/data/posPatchesWhi.txt");
	if (!ofile.is_open()) {
		std::cout << "Invalid patches file" << std::endl;
		return 0;
	}
	for (auto& p : positives) {
		int width = 31;
		int height = 31;
		int dimensions = width * height;
		float* values = p.ptr<float>(0);
		float val;
		for (int j = 0; j < dimensions; ++j) {
			ofile << values[j] << " ";
		}
		ofile << "\n";
	}
	ofile.close();

	ofile.open("E:/training/ffd_training_regrPaperX200/data/negPatchesWhi.txt");
	if (!ofile.is_open()) {
		std::cout << "Invalid patches file" << std::endl;
		return 0;
	}
	for (auto& p : negatives) {
		int width = 31;
		int height = 31;
		int dimensions = width * height;
		float* values = p.ptr<float>(0);
		float val;
		for (int j = 0; j < dimensions; ++j) {
			ofile << values[j] << " ";
		}
		ofile << "\n";
	}
	ofile.close();
	
	// END TEMP


	std::chrono::time_point<std::chrono::system_clock> start, end;
	Mat img;
	while(imageSource->next()) {

		img = imageSource->getImage();
		start = std::chrono::system_clock::now();

		// do something

		end = std::chrono::system_clock::now();

		int elapsed_seconds = std::chrono::duration_cast<std::chrono::seconds>(end-start).count();
		int elapsed_mseconds = std::chrono::duration_cast<std::chrono::milliseconds>(end-start).count();
		std::time_t end_time = std::chrono::system_clock::to_time_t(end);

		stringstream ss;
		ss << std::ctime(&end_time);
		appLogger.info("finished computation at " + ss.str() + "elapsed time: " + lexical_cast<string>(elapsed_seconds) + "s or exactly " + lexical_cast<string>(elapsed_mseconds) + "ms.\n");
	}
	
	return 0;
}
コード例 #26
0
ファイル: bsonobj.cpp プロジェクト: FikiHafana/djondb
char* BSONObj::toChar() {
	// if the toChar was already calculated before use it
	if (_cBSON != NULL) {
		return strcpy(_cBSON);
	}

	Logger* log = getLogger(NULL);
	
	char* result = (char*)malloc(MAX_BSONOBJ_BUFFER);
	memset(result, 0, MAX_BSONOBJ_BUFFER);

	__int32 pos = 0;
	result[0] = '{';
	pos += 1;

	bool first = true;
	
	for (std::map<std::string, BSONContent* >::const_iterator i = _elements.begin(); i != _elements.end(); i++) {
		if (!first) {
			result[pos] = ',';
			pos++;
		}
		first = false;
		BSONContent* content = i->second;
		std::string key = i->first;
		sprintf(result + pos, " \"%s\" : ", key.c_str());
		pos += key.length() + 6;
		//ss << "\"" << key << "\" :";
		char* chr;
		const char* cstr;
		switch (content->type())  {
			case BSON_TYPE: {
									 BSONContentBSON* bbson = (BSONContentBSON*)content;
									 BSONObj* bson = (BSONObj*)*bbson;
									 char* chrbson = bson->toChar();
									 sprintf(result + pos, "%s", chrbson);
									 free(chrbson);
									 break;
								 }
			case BSONARRAY_TYPE: {
											BSONContentBSONArray* bbsonarray = (BSONContentBSONArray*)content;
											BSONArrayObj* bsonarray = (BSONArrayObj*)*bbsonarray;
											char* chrbsonarray = bsonarray->toChar();
											sprintf(result + pos, "%s", chrbsonarray);
											free(chrbsonarray);
											break;
										}
			case BOOL_TYPE:  {
									 BSONContentBoolean* bb = (BSONContentBoolean*)content;
									 sprintf(result + pos, "%s", ((bool)*bb?"true": "false"));
									 break;
								 }
			case INT_TYPE:  {
									 BSONContentInt* bint = (BSONContentInt*)content;
									 sprintf(result + pos, "%d", (__int32)*bint);
									 break;
								 }
			case LONG_TYPE: {
									 BSONContentLong* blong = (BSONContentLong*)content;
									 sprintf(result + pos, "%ld", (__int64)*blong);
									 break;
								 }
			case DOUBLE_TYPE: {
									 BSONContentDouble* bdouble = (BSONContentDouble*)content;
									 sprintf(result + pos, "%f", (double)*bdouble);
									 break;
								 }
			case STRING_TYPE:
			case PTRCHAR_TYPE: { 
										 BSONContentString* bstring = (BSONContentString*)content;

										 djondb::string s = *bstring;
										 sprintf(result + pos, "\"%.*s\"", s.length(), s.c_str());
										 break;
									 }
		}
		pos = strlen(result);
		assert(pos < MAX_BSONOBJ_BUFFER);
	}
	result[pos] = '}';
	result[pos+1] = 0;
	pos++;

	__int32 len = strlen(result);

	// Saves the value to cache the calculated value
	_cBSON = result;

	char* cresult = strcpy(result);

	if (log->isDebug()) log->debug("toChar result: %s", cresult);

	return cresult;
}
コード例 #27
0
void log_open(const char *filename){
	return logger.open(filename);
}
コード例 #28
0
//
// Handler
//
INT_32 FnMBTruncate::Handler(CDT            * aArguments,
                             const UINT_32    iArgNum,
                             CDT            & oCDTRetVal,
                             Logger         & oLogger)
{
	if (iArgNum == 2)
	{
		const UINT_32       iMaxLen = UINT_32(aArguments[0].GetInt());
		const STLW::string  sData   = aArguments[1].GetString();

		CCHAR_P  szStart  = sData.data();
		CCHAR_P  szEnd    = sData.data() + sData.size();
		INT_32   iPos     = 0;
		UINT_32  iCharPos = 0;
		for(;;)
		{
			INT_32 iCharLen = utf_charlen(szStart + iPos, szEnd);
			if (iCharLen == -3) { break; }

			// Check character length
			if (iCharLen < 0) { iCharLen = 1; }
			// Skip errors
			else              { ++iCharPos;   }
			iPos += iCharLen;

			if (iCharPos >= iMaxLen) { break; }
		}

		if (iCharPos == iMaxLen) { oCDTRetVal = STLW::string(sData, 0, iPos); }
		else                     { oCDTRetVal = sData;                       }

		return 0;
	}
	else if (iArgNum == 3)
	{
		const UINT_32  iMaxLen = UINT_32(aArguments[1].GetInt());
		STLW::string   sData   = aArguments[2].GetString();

		CCHAR_P  szStart  = sData.data();
		CCHAR_P  szEnd    = sData.data() + sData.size();
		INT_32   iPos     = 0;
		UINT_32  iCharPos = 0;
		for(;;)
		{
			INT_32 iCharLen = utf_charlen(szStart + iPos, szEnd);

			if (iCharLen == -3) { break; }

			// Check character length
			if (iCharLen < 0) { iCharLen = 1; }
			// Skip errors
			else              { ++iCharPos;   }
			iPos += iCharLen;

			if (iCharPos >= iMaxLen) { break; }
		}
		if (iCharPos >= iMaxLen)
		{
			sData = STLW::string(sData, 0, iPos);
			sData.append(aArguments[0].GetString());
		}

		oCDTRetVal = sData;
		return 0;
	}

	oLogger.Emerg("Usage: MB_TRUNCATE(data, offset) or MB_TRUNCATE(data, offset, add_on)");
return -1;
}
コード例 #29
0
ファイル: MainForm.cpp プロジェクト: draekko/hydrogen
///
/// Create the menubar
///
void MainForm::createMenuBar()
{
	// menubar
	QMenuBar *m_pMenubar = new QMenuBar( this );
	setMenuBar( m_pMenubar );

	// FILE menu
	QMenu *m_pFileMenu = m_pMenubar->addMenu( trUtf8( "&Project" ) );

	m_pFileMenu->addAction( trUtf8( "&New" ), this, SLOT( action_file_new() ), QKeySequence( "Ctrl+N" ) );
	m_pFileMenu->addAction( trUtf8( "Show &info" ), this, SLOT( action_file_songProperties() ), QKeySequence( "" ) );

	m_pFileMenu->addSeparator();				// -----

	m_pFileMenu->addAction( trUtf8( "&Open" ), this, SLOT( action_file_open() ), QKeySequence( "Ctrl+O" ) );
	m_pFileMenu->addAction( trUtf8( "Open &Demo" ), this, SLOT( action_file_openDemo() ), QKeySequence( "Ctrl+D" ) );

	m_pRecentFilesMenu = m_pFileMenu->addMenu( trUtf8( "Open &recent" ) );

	m_pFileMenu->addSeparator();				// -----

	m_pFileMenu->addAction( trUtf8( "&Save" ), this, SLOT( action_file_save() ), QKeySequence( "Ctrl+S" ) );
	m_pFileMenu->addAction( trUtf8( "Save &as..." ), this, SLOT( action_file_save_as() ), QKeySequence( "Ctrl+Shift+S" ) );

	m_pFileMenu->addSeparator();				// -----

	m_pFileMenu->addAction ( trUtf8 ( "Open &Pattern" ), this, SLOT ( action_file_openPattern() ), QKeySequence ( "" ) );
	m_pFileMenu->addAction( trUtf8( "Expor&t pattern as..." ), this, SLOT( action_file_export_pattern_as() ), QKeySequence( "Ctrl+P" ) );

	m_pFileMenu->addSeparator();				// -----

	m_pFileMenu->addAction( trUtf8( "Export &MIDI file" ), this, SLOT( action_file_export_midi() ), QKeySequence( "Ctrl+M" ) );
	m_pFileMenu->addAction( trUtf8( "&Export song" ), this, SLOT( action_file_export() ), QKeySequence( "Ctrl+E" ) );
	m_pFileMenu->addAction( trUtf8( "Export &LilyPond file" ), this, SLOT( action_file_export_lilypond() ), QKeySequence( "Ctrl+L" ) );


#ifndef Q_OS_MACX
	m_pFileMenu->addSeparator();				// -----

	m_pFileMenu->addAction( trUtf8("&Quit"), this, SLOT( action_file_exit() ), QKeySequence( "Ctrl+Q" ) );
#endif

	updateRecentUsedSongList();
	connect( m_pRecentFilesMenu, SIGNAL( triggered(QAction*) ), this, SLOT( action_file_open_recent(QAction*) ) );
	//~ FILE menu

	// Undo menu
	QMenu *m_pUndoMenu = m_pMenubar->addMenu( trUtf8( "&Undo" ) );
	m_pUndoMenu->addAction( trUtf8( "Undo" ), this, SLOT( action_undo() ), QKeySequence( "Ctrl+Z" ) );
	m_pUndoMenu->addAction( trUtf8( "Redo" ), this, SLOT( action_redo() ), QKeySequence( "Shift+Ctrl+Z" ) );
	m_pUndoMenu->addAction( trUtf8( "Undo history" ), this, SLOT( openUndoStack() ), QKeySequence( "" ) );

	// INSTRUMENTS MENU
	QMenu *m_pInstrumentsMenu = m_pMenubar->addMenu( trUtf8( "I&nstruments" ) );
	m_pInstrumentsMenu->addAction( trUtf8( "&Add instrument" ), this, SLOT( action_instruments_addInstrument() ), QKeySequence( "" ) );
	m_pInstrumentsMenu->addAction( trUtf8( "&Clear all" ), this, SLOT( action_instruments_clearAll() ), QKeySequence( "" ) );
	m_pInstrumentsMenu->addAction( trUtf8( "&Save library" ), this, SLOT( action_instruments_saveLibrary() ), QKeySequence( "" ) );
	m_pInstrumentsMenu->addAction( trUtf8( "&Export library" ), this, SLOT( action_instruments_exportLibrary() ), QKeySequence( "" ) );
	m_pInstrumentsMenu->addAction( trUtf8( "&Import library" ), this, SLOT( action_instruments_importLibrary() ), QKeySequence( "" ) );




	// Tools menu
	QMenu *m_pToolsMenu = m_pMenubar->addMenu( trUtf8( "&Tools" ));

	m_pToolsMenu->addAction( trUtf8("Playlist &editor"), this, SLOT( action_window_showPlaylistDialog() ), QKeySequence( "" ) );
	m_pToolsMenu->addAction( trUtf8("Director"), this, SLOT( action_window_show_DirectorWidget() ), QKeySequence( "Alt+D" ) );

	m_pToolsMenu->addAction( trUtf8("&Mixer"), this, SLOT( action_window_showMixer() ), QKeySequence( "Alt+M" ) );

	m_pToolsMenu->addAction( trUtf8("&Instrument Rack"), this, SLOT( action_window_showDrumkitManagerPanel() ), QKeySequence( "Alt+I" ) );


	m_pInputModeMenu = m_pToolsMenu->addMenu( trUtf8( "Input mode" ) );
	m_pInstrumentAction = m_pInputModeMenu->addAction( trUtf8( "Instrument" ), this, SLOT( action_toggle_input_mode()), QKeySequence( "Ctrl+Alt+I" ) );
	m_pInstrumentAction->setCheckable( true );

	m_pDrumkitAction = m_pInputModeMenu->addAction( trUtf8( "Drumkit" ), this, SLOT( action_toggle_input_mode()), QKeySequence( "Ctrl+Alt+D" ) );
	m_pDrumkitAction->setCheckable( true );

	if( Preferences::get_instance()->__playselectedinstrument )
	{
		m_pInstrumentAction->setChecked( true );
		m_pDrumkitAction->setChecked (false );
	} else {
		m_pInstrumentAction->setChecked( false );
		m_pDrumkitAction->setChecked (true );
	}


	m_pToolsMenu->addAction( trUtf8("&Preferences"), this, SLOT( showPreferencesDialog() ), QKeySequence( "Alt+P" ) );

	//~ Tools menu


	Logger *pLogger = Logger::get_instance();
	if ( pLogger->bit_mask() >= 1 ) {
		// DEBUG menu
		QMenu *m_pDebugMenu = m_pMenubar->addMenu( trUtf8("De&bug") );
		m_pDebugMenu->addAction( trUtf8( "Show &audio engine info" ), this, SLOT( action_debug_showAudioEngineInfo() ) );
		if(pLogger->bit_mask() == 8) // hydrogen -V8 list object map in console
			m_pDebugMenu->addAction( trUtf8( "Print Objects" ), this, SLOT( action_debug_printObjects() ) );
		//~ DEBUG menu
	}

	// INFO menu
	QMenu *m_pInfoMenu = m_pMenubar->addMenu( trUtf8( "&Info" ) );
	m_pInfoMenu->addAction( trUtf8("&User manual"), this, SLOT( showUserManual() ), QKeySequence( "Ctrl+?" ) );
	m_pInfoMenu->addSeparator();
	m_pInfoMenu->addAction( trUtf8("&About"), this, SLOT( action_help_about() ), QKeySequence( trUtf8("", "Info|About") ) );
	m_pInfoMenu->addAction( trUtf8("Report bug"), this, SLOT( action_report_bug() ));
	//m_pInfoMenu->addAction( trUtf8("Donate"), this, SLOT( action_donate() ));
	//~ INFO menu
}
コード例 #30
0
ファイル: main.cpp プロジェクト: swordlegend/Inline-Engine
int main(int argc, char* argv[]) {
	// Initialize logger
	logFile.open("engine_test.log");
	logFilePath = std::experimental::filesystem::current_path();
	logFilePath /= "engine_test.log";
	cout << "Log files can be found at:\n   ";
	cout << "   " << logFilePath << endl;

	if (logFile.is_open()) {
		logger.OpenStream(&logFile);
	}
	else {
		logger.OpenStream(&std::cout);
	}

	// Set exception terminate handler
	std::set_terminate(OnTerminate);


	// Create the window itself
	Window window;
	window.SetTitle("QC Simulator");
	window.SetSize({ 960, 640 });


	// Create GraphicsEngine
	systemLogStream.Event("Initializing Graphics Engine...");

	std::unique_ptr<IGxapiManager> gxapiMgr;
	std::unique_ptr<IGraphicsApi, ReportDeleter> gxapi;
	std::unique_ptr<GraphicsEngine> engine;
	std::unique_ptr<QCWorld> qcWorld;
	std::unique_ptr<InputHandler> inputHandler;
	std::unique_ptr<Input> joyInput;
	std::unique_ptr<Input> keyboardInput;

	try {
		// Create manager
		systemLogStream.Event("Creating GxApi Manager...");
		gxapiMgr.reset(new GxapiManager());
		auto adapters = gxapiMgr->EnumerateAdapters();
		std::string cardList;
		for (auto adapter : adapters) {
			cardList += "\n";
			cardList += adapter.name;
		}
		systemLogStream.Event("Available graphics cards:" + cardList);


		// Create graphics api
		int device = 0;
		if (argc == 3 && argv[1] == std::string("--device") && isdigit(argv[2][0])) {
			device = argv[2][0] - '0'; // works for single digits, good enough, lol
		}
		systemLogStream.Event("Creating GraphicsApi...");
		gxapi.reset(gxapiMgr->CreateGraphicsApi(adapters[device].adapterId));
		std::stringstream ss;
		ss << "Using graphics card: " << adapters[device].name;
		systemLogStream.Event(ss.str());


		// Create graphics engine
		systemLogStream.Event("Creating Graphics Engine...");

		GraphicsEngineDesc desc;
		desc.fullScreen = false;
		desc.graphicsApi = gxapi.get();
		desc.gxapiManager = gxapiMgr.get();
		desc.width = window.GetClientSize().x;
		desc.height = window.GetClientSize().y;
		desc.targetWindow = window.GetNativeHandle();
		desc.logger = &logger;

		engine.reset(new GraphicsEngine(desc));

		// Load graphics pipeline
		std::string pipelineFileName = SelectPipeline(gxapi.get());
		std::string exeDir = System::GetExecutableDir();
		std::ifstream pipelineFile(INL_PIPELINE_DIRECTORY "\\" + pipelineFileName);
		if (!pipelineFile.is_open()) {
			throw FileNotFoundException("Failed to open pipeline JSON.");
		}
		std::string pipelineDesc((std::istreambuf_iterator<char>(pipelineFile)), std::istreambuf_iterator<char>());
		engine->LoadPipeline(pipelineDesc);


		// Create mini world
		qcWorld.reset(new QCWorld(engine.get()));
		

		// Create input handling
		inputHandler = std::make_unique<InputHandler>(qcWorld.get());

		window.OnResize += Delegate<void(ResizeEvent)>{ &InputHandler::OnResize, inputHandler.get() };

		auto joysticks = Input::GetDeviceList(eInputSourceType::JOYSTICK);
		if (!joysticks.empty()) {
			joyInput = std::make_unique<Input>(joysticks.front().id);
			joyInput->SetQueueMode(eInputQueueMode::QUEUED);
			joyInput->OnJoystickMove += Delegate<void(JoystickMoveEvent)>{ &InputHandler::OnJoystickMove, inputHandler.get() };
		}
		auto keyboards = Input::GetDeviceList(eInputSourceType::KEYBOARD);
		if (!keyboards.empty()) {
			keyboardInput = std::make_unique<Input>(keyboards.front().id);
			keyboardInput->SetQueueMode(eInputQueueMode::QUEUED);
			keyboardInput->OnKeyboard += Delegate<void(KeyboardEvent)>{ &InputHandler::OnKey, inputHandler.get() };
		}

		window.OnResize += [&engine, &qcWorld](ResizeEvent evt) {
			engine->SetScreenSize(evt.clientSize.x, evt.clientSize.y);
			qcWorld->ScreenSizeChanged(evt.clientSize.x, evt.clientSize.y);
		};

		logger.Flush();
	}
	catch (Exception& ex) {
		errorMessage = std::string("Error creating GraphicsEngine: ") + ex.what() + "\n" + ex.StackTraceStr();
		systemLogStream.Event(errorMessage);
		logger.Flush();
	}
	catch (std::exception& ex) {
		errorMessage = std::string("Error creating GraphicsEngine: ") + ex.what();
		systemLogStream.Event(errorMessage);
		logger.Flush();
	}

	if (!qcWorld) {
		return 0;
	}


	// Main rendering loop
	Timer timer;
	timer.Start();
	double frameTime = 0.05, frameRateUpdate = 0;
	std::vector<double> frameTimeHistory;
	float avgFps = 0;

	auto CaptionHandler = [&window](Vec2i cursorPos) {
		Vec2i size = window.GetSize();
		RectI rc;
		rc.top = 5;
		rc.bottom = 50;
		rc.right = size.x - 5;
		rc.left = size.x - 50;
		if (rc.IsPointInside(cursorPos))
			return eWindowCaptionButton::CLOSE;
		rc.Move({ -50, 0 });
		if (rc.IsPointInside(cursorPos))
			return eWindowCaptionButton::MAXIMIZE;
		rc.Move({ -50, 0 });
		if (rc.IsPointInside(cursorPos))
			return eWindowCaptionButton::MINIMIZE;
		if (cursorPos.y < 55) {
			return eWindowCaptionButton::BAR;
		}
		return eWindowCaptionButton::NONE;
	};
	//window.SetBorderless(true);
	//window.SetCaptionButtonHandler(CaptionHandler);

	while (!window.IsClosed()) {
		inputHandler->SetFocused(window.IsFocused());
		window.CallEvents();
		if (joyInput) {
			joyInput->CallEvents();
		}
		if (keyboardInput) {
			keyboardInput->CallEvents();
		}

		try {
			// Update world
			qcWorld->UpdateWorld(frameTime);
			qcWorld->RenderWorld(frameTime);

			// Calculate elapsed time for frame.
			frameTime = timer.Elapsed();
			timer.Reset();

			// Calculate average framerate
			frameRateUpdate += frameTime;
			if (frameRateUpdate > 0.5) {
				frameRateUpdate = 0;

				double avgFrameTime = 0.0;
				for (auto v : frameTimeHistory) {
					avgFrameTime += v;
				}
				avgFrameTime /= frameTimeHistory.size();
				avgFps = 1 / avgFrameTime;

				frameTimeHistory.clear();
			}
			frameTimeHistory.push_back(frameTime);

			// Set info text as window title
			unsigned width, height;
			engine->GetScreenSize(width, height);
			std::string title = "Graphics Engine Test | " + std::to_string(width) + "x" + std::to_string(height) + " | FPS=" + std::to_string((int)avgFps);
			window.SetTitle(title);
		}
		catch (Exception& ex) {
			std::stringstream trace;
			trace << "Graphics engine error:" << ex.what() << "\n";
			ex.PrintStackTrace(trace);
			systemLogStream.Event(trace.str());
			PostQuitMessage(0);
		}
		catch (std::exception& ex) {
			systemLogStream.Event(std::string("Graphics engine error: ") + ex.what());
			logger.Flush();
			PostQuitMessage(0);
		}
	}

	cout << "Shutting down." << endl;
	return 0;
}