bool CServerApp::loadConfig(const CString& pathname) { try { // load configuration LOG((CLOG_DEBUG "opening configuration \"%s\"", pathname.c_str())); std::ifstream configStream(pathname.c_str()); if (!configStream.is_open()) { // report failure to open configuration as a debug message // since we try several paths and we expect some to be // missing. LOG((CLOG_DEBUG "cannot open configuration \"%s\"", pathname.c_str())); return false; } configStream >> *args().m_config; LOG((CLOG_DEBUG "configuration read successfully")); return true; } catch (XConfigRead& e) { // report error in configuration file LOG((CLOG_ERR "cannot read configuration \"%s\": %s", pathname.c_str(), e.what())); } return false; }
void Config::readConfigFile() { std::string line; std::fstream configStream("config.ini", std::fstream::in); if(!configStream.is_open()) throw "config.ini could not be opened."; while(!configStream.eof()) { getline(configStream, line); Config::variables.insert(std::make_pair( line.substr(0, line.find('=')), std::atoi(line.substr(line.find('=') + 1, line.length()).c_str()) )); } configStream.close(); }
bool Config::save() { int size; int i; size = ::strlen(config.vcPath); for(i = 0; i < size; ++i) if(config.vcPath[i] == ' ') config.vcPath[i] = CONFIG_TRANSFORM_SYMBOL; char path[strlen(CONFIG_SAVE_FILE) + strlen(appRoot) + 2]; sprintf(path, "%s\\%s", appRoot, CONFIG_SAVE_FILE); std::ofstream configStream(path, std::ios::binary); configStream << config.vcPath << " "; configStream.close(); }
void CliConfigBase::loadOptions(const boost::program_options::options_description &options, const std::string &configFile) { namespace po = boost::program_options; std::ifstream configStream(configFile.c_str()); po::parsed_options configFileOptions = po::parse_config_file(configStream, options, true); po::store(configFileOptions, configVars); unregConfigFileOptions = po::collect_unrecognized(configFileOptions.options, po::include_positional); // FIXME: Proper handling of required options is not available in Boost 1.41 /*if (!(configVars.count(CmdLine_Help) || configVars.count(CmdLine_Version))) po::notify(configVars);*/ std::ostringstream ostr; ostr << options; configUsage = ostr.str(); }
bool Config::load() { char path[strlen(CONFIG_SAVE_FILE) + strlen(appRoot) + 2]; sprintf(path, "%s\\%s", appRoot, CONFIG_SAVE_FILE); struct stat info; bool fileExists = !stat(path, &info); if(fileExists) { // Load from file int size; int i; std::ifstream configStream(path, std::ios::binary); configStream >> config.vcPath; configStream.close(); size = ::strlen(config.vcPath); for(i = 0; i < size; ++i) if(config.vcPath[i] == CONFIG_TRANSFORM_SYMBOL) config.vcPath[i] = ' '; } else { // Default values
int main() { #if MFluidSolver_LOG_LEVEL <= MFluidSolver_LOG_INFO // Print version info std::cout << "INFO: Version " << MFluidSolver_VERSION_MAJOR << "." << MFluidSolver_VERSION_MINOR << std::endl; #endif // Initialize GLFW if (!glfwInit()) { #if MFluidSolver_LOG_LEVEL <= MFluidSolver_LOG_ERROR std::cerr << "FATAL: Failed to initiaize GLFW" << std::endl; #endif getchar(); // Wait for key before quit return -1; } // Seed randomness std::time_t seed = std::time(NULL); std::srand(seed); #if MFluidSolver_LOG_LEVEL <= MFluidSolver_LOG_INFO // Only affects particle visualization selection std::cout << "INFO: std::rand seed: " << seed << std::endl; #endif // Initialize non-OpenGL #if MFluidSolver_USE_OPENVDB openvdb::initialize(); #endif #if MFluidSolver_USE_TBB tbb::task_scheduler_init init(tbb::task_scheduler_init::automatic); #endif // Set JSON file location std::string configJSON = MFluidSolver_DEFAULT_CONFIG_FILE; #if MFluidSolver_LOG_LEVEL <= MFluidSolver_LOG_INFO std::cout << "INFO: Loading config file: " << configJSON << std::endl; #endif // Open JSON file Json::Reader reader; Json::Value root; std::ifstream configStream(configJSON, std::ifstream::binary); bool success = reader.parse(configStream, root, false); if (!success) { #if MFluidSolver_LOG_LEVEL <= MFluidSolver_LOG_ERROR std::cerr << "ERROR: Failed to parse config file " << configJSON.c_str() << std::endl; #endif } // Parse JSON std::string sceneJSON = root.get( "sceneJSON", MFluidSolver_DEFAULT_SCENE_FILE).asString(); std::string wireVShader = root.get( "wireVShader", MFluidSolver_DEFAULT_WIRE_VERT_FILE).asString(); std::string wireFShader = root.get( "wireFShader", MFluidSolver_DEFAULT_WIRE_FRAG_FILE).asString(); std::string particleVShader = root.get( "particleVShader", MFluidSolver_DEFAULT_PARTICLE_VERT_FILE).asString(); std::string particleFShader = root.get( "particleFShader", MFluidSolver_DEFAULT_PARTICLE_FRAG_FILE).asString(); std::string particleTexture = root.get( "particleTexture", MFluidSolver_DEFAULT_PARTICLE_TEX_FILE).asString(); bool autoRender = root.get( "autoRender", MFluidSolver_DEFAULT_AUTORENDER).asBool(); unsigned int renderSkip = root.get( "renderSkip", MFluidSolver_DEFAULT_RENDERSKIP).asInt(); // Initialize project objects Viewer viewer; Input::viewer = &viewer; try { viewer.init(); } catch (std::exception &e) { #if MFluidSolver_LOG_LEVEL <= MFluidSolver_LOG_FATAL std::cerr << "FATAL: " << e.what() << std::endl; #endif return -1; } // Print OpenGL info #if MFluidSolver_LOG_LEVEL <= MFluidSolver_LOG_INFO std::cout << "INFO: OpenGL Version " << glGetString(GL_VERSION) << std::endl; #endif // Set a few settings/modes in OpenGL rendering glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LESS); glEnable(GL_LINE_SMOOTH); glEnable(GL_POLYGON_SMOOTH); glHint(GL_LINE_SMOOTH_HINT, GL_NICEST); glHint(GL_POLYGON_SMOOTH_HINT, GL_NICEST); // Set the size with which points should be rendered glPointSize(MFluidSolver_DEFAULT_POINT_SIZE); // Set background color glClearColor(MFluidSolver_DEFAULT_BG_COLOR_R, MFluidSolver_DEFAULT_BG_COLOR_G, MFluidSolver_DEFAULT_BG_COLOR_B, 0.0f); // Bind vertex array object GLuint vaoID; glGenVertexArrays(1, &vaoID); glBindVertexArray(vaoID); // After vertex array object init viewer.wireShader = new ShaderProgram(wireVShader, wireFShader); viewer.particleShader = new ParticleShaderProgram(&(viewer.scene.solver), particleVShader, particleFShader, particleTexture); viewer.scene.solver.loadConfig(configJSON); viewer.configureScreenshot(autoRender, renderSkip); // Run! Catch and print exceptions as necessary int returnCode = 0; #if MFluidSolver_MAIN_CATCH_EXCEPTIONS try { #endif viewer.scene.loadJSON(sceneJSON); viewer.particleShader->init(); viewer.run(); #if MFluidSolver_MAIN_CATCH_EXCEPTIONS } catch (std::exception &e) { #if MFluidSolver_LOG_LEVEL <= MFluidSolver_LOG_FATAL std::cerr << "FATAL: " << e.what() << std::endl; #endif returnCode = -1; } #endif // Performance #if MFluidSolver_RECORD_PERFORMANCE viewer.scene.solver.endSimulation(); viewer.scene.solver.printPerformanceStats(); #endif // Cleanup glDeleteVertexArrays(1, &vaoID); return returnCode; }
/** * Module initialization function. The initialization arguments string should * provide the path of a module configuration file that defines what files * are interesting. If the empty string is passed to this function, the module * assumes a default config file is present in the output directory. * * @param args Path of the configuration file that defines what files are * interesting, may be set to the empty string. * @return TskModule::OK on success, TskModule::FAIL otherwise. */ TSK_MODULE_EXPORT TskModule::Status initialize(const char* arguments) { TskModule::Status status = TskModule::OK; const std::string MSG_PREFIX = "InterestingFilesModule::initialize : "; try { // Make sure the file sets are cleared in case initialize() is called more than once. fileSets.clear(); configFilePath.assign(arguments); if (configFilePath.empty()) { // Use the default config file path. Poco::Path configurationFilePath(Poco::Path::forDirectory(GetSystemProperty(TskSystemProperties::MODULE_CONFIG_DIR))); configurationFilePath.pushDirectory(MODULE_NAME); configurationFilePath.setFileName(DEFAULT_CONFIG_FILE_NAME); configFilePath = configurationFilePath.toString(); } // Compile the contents of the config file into interesting file set definitions. Poco::File configFile = Poco::File(configFilePath); if (configFile.exists()) { std::ifstream configStream(configFile.path().c_str()); if (configStream) { Poco::XML::InputSource inputSource(configStream); Poco::AutoPtr<Poco::XML::Document> configDoc = Poco::XML::DOMParser().parse(&inputSource); Poco::XML::Element * rootElement = configDoc->documentElement(); if (rootElement == NULL) { std::ostringstream msg; msg << MSG_PREFIX << "Root element of config file is NULL."; throw TskException(msg.str()); } const std::string& ignoreKnownValue = Poco::XML::fromXMLString(rootElement->getAttribute(IGNORE_KNOWN_TAG)); if (!ignoreKnownValue.empty()) { knownType = parseKnownType(ignoreKnownValue); ignoreKnown = true; } Poco::AutoPtr<Poco::XML::NodeList> fileSetDefinitions = configDoc->getElementsByTagName(INTERESTING_FILE_SET_ELEMENT_TAG); for (unsigned long i = 0; i < fileSetDefinitions->length(); ++i) { compileInterestingFilesSet(fileSetDefinitions->item(i)); } } else { std::ostringstream msg; msg << MSG_PREFIX << "failed to open config file '" << configFilePath << "'"; throw TskException(msg.str()); } } else { std::ostringstream msg; msg << MSG_PREFIX << "config file'" << configFilePath << "' does not exist"; LOGERROR(msg.str()); } // Log the configuration. std::ostringstream msg; msg << MSG_PREFIX << "configured with " << fileSets.size() << " interesting file set definitions from '" << configFilePath << "'"; LOGINFO(msg.str()); } catch (TskException &ex) { status = TskModule::FAIL; configFilePath.clear(); std::ostringstream msg; msg << MSG_PREFIX << "TskException: " << ex.message(); LOGERROR(msg.str()); } catch (Poco::Exception &ex) { status = TskModule::FAIL; configFilePath.clear(); std::ostringstream msg; msg << MSG_PREFIX << "Poco::Exception: " << ex.displayText(); LOGERROR(msg.str()); } catch (std::exception &ex) { status = TskModule::FAIL; configFilePath.clear(); std::ostringstream msg; msg << MSG_PREFIX << "std::exception: " << ex.what(); LOGERROR(msg.str()); } catch (...) { status = TskModule::FAIL; configFilePath.clear(); LOGERROR(MSG_PREFIX + "unrecognized exception"); } return status; }