BOOL build_app_bundle(const char *unix_link, const char *dir, const char *link, const char *link_name, const char *path, const char *args, const char *workdir, char **icon) { BOOL ret = FALSE; char *path_to_bundle, *path_to_macos, *path_to_script, *path_to_info, *path_to_resources; CFDictionaryRef info = NULL; path_to_bundle = heap_printf("%s/%s.app", dir, link); if (!path_to_bundle) return FALSE; path_to_macos = heap_printf("%s/Contents/MacOS", path_to_bundle); path_to_script = heap_printf("%s/Contents/MacOS/winelauncher", path_to_bundle); path_to_info = heap_printf("%s/Contents/Info.plist", path_to_bundle); path_to_resources = heap_printf("%s/Contents/Resources", path_to_bundle); if (!path_to_macos || !path_to_script || !path_to_info || !path_to_resources) goto out; if (!create_directories(path_to_macos) || !create_directories(path_to_resources)) goto out; if (!generate_bundle_script(path_to_script, path, args, workdir)) goto out; info = create_info_plist_dictionary(link_name, *icon); if (!info) goto out; if (!write_property_list(path_to_info, info, kCFPropertyListXMLFormat_v1_0)) goto out; if (*icon) { char *tmp = heap_printf("%s/%s", path_to_resources, *icon); if (!tmp) goto out; HeapFree(GetProcessHeap(), 0, *icon); *icon = tmp; } if (unix_link) { DWORD r = register_menus_entry(path_to_bundle, unix_link); if (r != ERROR_SUCCESS) goto out; } ret = TRUE; out: if (ret == FALSE) remove_unix_link(path_to_bundle); HeapFree(GetProcessHeap(), 0, path_to_bundle); HeapFree(GetProcessHeap(), 0, path_to_macos); HeapFree(GetProcessHeap(), 0, path_to_script); HeapFree(GetProcessHeap(), 0, path_to_info); HeapFree(GetProcessHeap(), 0, path_to_resources); if (info) CFRelease(info); return ret; }
TEST_F(ClientMetadataTest, TestSearchSuccess) { start(4, 4); create_index("/foo/bar", "dog"); create_directories("/foo/bar/zoo"); create_directories("/foo/bar/dogs"); create_directories("/foo/bar/cat"); for (int i = 0; i < 100; i++) { ObjectId oid; client_->create("/foo/bar/zoo/zoo" + to_string(i), 0644, 100, 100, &oid); client_->create("/foo/bar/dogs/dog" + to_string(i), 0644, 100, 100, &oid); client_->create("/foo/bar/cat/cat" + to_string(i), 0644, 100, 100, &oid); } vector<VSFSRpcClient::IndexUpdateRequest> requests; for (int i = 0; i < 100; i++) { requests.emplace_back(VSFSRpcClient::IndexUpdateRequest::INSERT, "/foo/bar/dogs/dog" + to_string(i), "dog", to_string(i)); } EXPECT_TRUE(client_->update(requests).ok()); vector<string> expected_files; for (int i = 51; i < 100; i++) { expected_files.push_back("/foo/bar/dogs/dog" + to_string(i)); } ComplexQuery query; query.parse("/foo?dog>50"); vector<string> actual_files; EXPECT_TRUE(client_->search(query, &actual_files).ok()); sort(actual_files.begin(), actual_files.end()); EXPECT_THAT(actual_files, ContainerEq(expected_files)); }
static path findUserPath(const char * name, const path & force, const char * registry, const char * prefix, const char * suffix, const path & fallback, bool create) { // Prefer command-line options if(!force.empty()) { path dir = canonical(force); if(create && !create_directories(dir)) { LogCritical << "Could not create " << name << " directory " << dir << '.'; return path(); } else { LogDebug("using " << name << " dir from command-line: " << dir); return dir; } } // Check system settings (windows registry) std::string temp; if(registry && platform::getSystemConfiguration(registry, temp)) { path dir = canonical(temp); if(!create) { return dir; } else if(create_directories(dir)) { LogDebug("got " << name << " dir from registry: \"" << temp << "\" = " << dir); return dir; } else { LogError << "Could not create " << name << " directory " << dir << '.'; LogDebug("ignoring " << name << " dir from registry: \"" << temp << '"'); } } // Search standard locations path to_create; std::vector<path> prefixes = getSearchPaths(prefix); std::vector<path> suffixes = getSearchPaths(suffix); if(prefix || suffix) { bool create_exists = false; BOOST_FOREACH(const path & prefix, prefixes) { BOOST_FOREACH(const path & suffix, suffixes) { path dir = canonical(prefix / suffix); if(is_directory(dir)) { LogDebug("got " << name << " dir from search: " << prefix << " + " << suffix << " = " << dir); return dir; } else { LogDebug("ignoring " << name << " dir from search: " << prefix << " + " << suffix << " = " << dir); } if(to_create.empty() || (!create_exists && is_directory(prefix))) { to_create = dir; create_exists = is_directory(prefix); } }
bool JobDir::create(fs::path const& base_dir) try { return create_directories(base_dir / fs::path(tmp_tag, fs::native)) && create_directories(base_dir / fs::path(new_tag, fs::native)) && create_directories(base_dir / fs::path(old_tag, fs::native)); } catch (boost::filesystem::filesystem_error const& e) { throw JobDirError(e.what()); }
bool MainForm::load_settings() { options = new Options(); if (!options->read()) { options = DEFAULT_SETTINGS; } edit_username->setText(options->get_hoster()->get_username().c_str()); edit_password->setText(options->get_hoster()->get_password().c_str()); mpv_settings->setPlainText(options->mpv_settings.c_str()); //todo hoster edit_down_speed->setValue(options->download_speed / 1024.0 / 1024.0); edit_memory->setValue(options->memory / 1024.0 / 1024.0); archive_directory->setFile(options->archive_directory.c_str()); download_directory->setFile(options->download_directory.c_str()); QFileInfo file(options->archive_directory.c_str()); create_directories(file.absoluteDir().absolutePath()); create_directories(options->download_directory.c_str()); disclaimer = options->disclaimer; bool first_run = disclaimer; if (disclaimer) { QMessageBox box; box.setText( "I will not take any responsibility for any of your actions. This program is maybe against your state's law."); box.setWindowTitle("Disclaimer"); box.setIcon(QMessageBox::Information); QPushButton *ok_button = box.addButton("Yes, I understand.", QMessageBox::ActionRole); QPushButton *abortButton = box.addButton("Terminate this programm.", QMessageBox::ActionRole); box.exec(); if (box.clickedButton() == ok_button) { disclaimer = false; } else if (box.clickedButton() == abortButton) { disclaimer = true; } } options->disclaimer = disclaimer; options->write(); return first_run; }
/*********************************************************************** * create_fake_dll */ BOOL create_fake_dll( const WCHAR *name, const WCHAR *source ) { HANDLE h; HMODULE module; BOOL ret; /* check for empty name which means to only create the directory */ if (name[strlenW(name) - 1] == '\\') { create_directories( name ); return TRUE; } /* first check for an existing file */ h = CreateFileW( name, GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL ); if (h != INVALID_HANDLE_VALUE) { if (!is_fake_dll( h )) { TRACE( "%s is not a fake dll, not overwriting it\n", debugstr_w(name) ); CloseHandle( h ); return TRUE; } /* truncate the file */ SetFilePointer( h, 0, NULL, FILE_BEGIN ); SetEndOfFile( h ); } else { if (GetLastError() == ERROR_PATH_NOT_FOUND) create_directories( name ); h = CreateFileW( name, GENERIC_WRITE, 0, NULL, CREATE_NEW, 0, NULL ); if (h == INVALID_HANDLE_VALUE) { ERR( "failed to create %s (error=%u)\n", debugstr_w(name), GetLastError() ); return FALSE; } } module = LoadLibraryW( source ); ret = build_fake_dll( h, module ); CloseHandle( h ); if (module) FreeLibrary( module ); if (!ret) DeleteFileW( name ); return ret; }
std::string ConvertToDDS(const char *filePath, filepath &baseDirectory, filepath &rootInputDirectory, filepath &rootOutputDirectory) { filepath relativePath(filePath); filepath relativeDDSPath(relativePath); relativeDDSPath.replace_extension("dds"); // If the file already exists in the output directory, we don't need to do anything filepath outputFilePath(rootOutputDirectory.file_string() + "\\" + relativeDDSPath.file_string()); if (exists(outputFilePath)) { return relativeDDSPath; } // Guarantee the output directory exists filepath outputDirectory(outputFilePath.parent_path()); create_directories(outputDirectory); // If input is already dds, but doesn't exist in the output directory, just copy the file to the output filepath inputFilePath(rootInputDirectory.file_string() + "\\" + relativePath.file_string()); if (_stricmp(relativePath.extension().c_str(), "dds") == 0) { copy_file(inputFilePath, outputFilePath); return relativeDDSPath; } // Otherwise, convert the file to DDS std::string call = baseDirectory.file_string() + "\\texconv.exe -ft dds -o " + outputDirectory.file_string() + " " + inputFilePath.file_string() + " > NUL"; std::system(call.c_str()); return relativeDDSPath; }
static BOOL appbundle_init(void) { WCHAR shellDesktopPath[MAX_PATH]; HRESULT hr = SHGetFolderPathW(NULL, CSIDL_DESKTOP, NULL, SHGFP_TYPE_CURRENT, shellDesktopPath); if (SUCCEEDED(hr)) mac_desktop_dir = wine_get_unix_file_name(shellDesktopPath); if (mac_desktop_dir == NULL) { WINE_ERR("error looking up the desktop directory\n"); return FALSE; } if (getenv("WINE_APPLICATIONS_DIR")) wine_applications_dir = strdupA(getenv("WINE_APPLICATIONS_DIR")); else wine_applications_dir = heap_printf("%s/Applications/Wine", getenv("HOME")); if (!wine_applications_dir) return FALSE; create_directories(wine_applications_dir); WINE_TRACE("Applications in %s\n", wine_applications_dir); return TRUE; }
int main(int argc, char* argv[]) try { std::ios_base::sync_with_stdio(false); if (argc < 2 || 4 < argc) throw std::runtime_error{ "Usage: ulgp source [destination] [file pattern]" }; fs::path arg1{fs::canonical(argv[1])}; std::regex pattern{argc == 4 ? argv[3] : ".*"}; if (fs::is_regular_file(arg1)) { auto folder = argc < 3 ? arg1.parent_path() / arg1.stem() : argv[2]; create_directories(folder); current_path(folder); extract(arg1, pattern); } else if (fs::is_directory(arg1)) { auto lgp = argc < 3 ? arg1.string() + ".lgp" : fs::absolute(argv[2]); current_path(arg1); add(lgp, pattern); } else throw std::runtime_error{ "Lgp file / folder not found." }; } catch (std::exception const& e) { std::cerr << e.what() << '\n'; }
/* create the fake dll destination file */ static HANDLE create_dest_file( const WCHAR *name ) { /* first check for an existing file */ HANDLE h = CreateFileW( name, GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL ); if (h != INVALID_HANDLE_VALUE) { if (!is_fake_dll( h )) { TRACE( "%s is not a fake dll, not overwriting it\n", debugstr_w(name) ); CloseHandle( h ); return 0; } /* truncate the file */ SetFilePointer( h, 0, NULL, FILE_BEGIN ); SetEndOfFile( h ); } else { if (GetLastError() == ERROR_PATH_NOT_FOUND) create_directories( name ); h = CreateFileW( name, GENERIC_WRITE, 0, NULL, CREATE_NEW, 0, NULL ); if (h == INVALID_HANDLE_VALUE) ERR( "failed to create %s (error=%u)\n", debugstr_w(name), GetLastError() ); } return h; }
TEST_F(ClientMetadataTest, TestCreateIndices) { start(4, 1); create_directories("/foo/bar/test"); create_directories("/foo/bar/zoo"); EXPECT_TRUE(client_->create_index("/foo/bar", "blue", IndexInfo::BTREE, INT32, 0755, 100, 100).ok()); EXPECT_TRUE(client_->create_index("/foo/bar", "蓝色", IndexInfo::BTREE, INT32, 0755, 100, 100).ok()); EXPECT_TRUE(client_->create_index("/foo/bar/zoo", "blue", IndexInfo::BTREE, INT32, 0755, 100, 100).ok()); struct stat stbuf; EXPECT_TRUE(client_->getattr("/foo/bar/.vsfs/blue", &stbuf).ok()); EXPECT_TRUE(client_->getattr("/foo/bar/.vsfs/蓝色", &stbuf).ok()); EXPECT_TRUE(client_->getattr("/foo/bar/zoo/.vsfs/blue", &stbuf).ok()); }
CSessionStorage::CSessionStorage(CSession* session) : m_app(muroa::CApp::getInstPtr()), m_session(session) { m_storage_path = m_app->settings().getConfigVal("msessiond.sessions_storage_dir", ""); m_storage_path = CUtils::expandvars(m_storage_path); m_storage_path/=m_session->getName(); LOG4CPLUS_INFO(m_app->logger(), "session storage in " << m_storage_path << endl ); if(!exists(m_storage_path) || !is_directory(m_storage_path)) { create_directories(m_storage_path); } if(!exists(m_storage_path/mediaColSubdir)) { create_directory(m_storage_path/mediaColSubdir); } if(!exists(m_storage_path/playlistSubdir)) { create_directory(m_storage_path/playlistSubdir); } if(!exists(m_storage_path/nextlistSubdir)) { create_directory(m_storage_path/nextlistSubdir); } if(!exists(m_storage_path/sessionStateSubdir)) { create_directory(m_storage_path/sessionStateSubdir); } }
void Wallpaper::initialize() { if ( !m_directory.empty() ) { return; } po::variables_map& vm = IConfigurationFile::instance().variables_map(); if ( vm.count( wallpaper_path ) ) { m_directory = fs::system_complete( vm[wallpaper_path].as<std::wstring>() ); } if ( vm.count( wallpaper_recycle_path ) ) { m_recycle_directory = fs::system_complete( vm[wallpaper_recycle_path].as<std::wstring>() ); if ( ! m_recycle_directory.empty() && ! exists( m_recycle_directory ) ) { boost::system::error_code ec; if ( ! create_directories( m_recycle_directory, ec ) ) { m_recycle_directory.clear(); } } } if ( vm.count( wallpaper_check_picture ) ) { m_check_picture = ( L"true" == vm[wallpaper_check_picture].as<std::wstring>() ); } }
void try_run_file(const boost::filesystem::path & cur) { if(cur.extension().native().compare(".py")) { return; } script_file_parser script_file(cur.native()); if(script_file.is_valid()) { boost::filesystem::path work, out; create_directories(cur, work, out); auto parent = cur.parent_path(); auto start = parent.begin(); for(auto p = config::tests.begin(); p != config::tests.end() && *p == *start; ++p, ++start) ; for(; start != parent.end(); ++start) { script_file.add_keyword((*start).native()); } script_file.add_title(cur.stem().native()); if(config::query->evaluate(script_file)) { script_scheduler()->schedule_file(cur, work, out); } } }
void move_log_file(std::string const& logpath, std::string const& new_name, int instance) { mutex::scoped_lock l(file_mutex); if (open_filename == m_filename) { log_file.close(); open_filename.clear(); } char log_name[512]; snprintf(log_name, sizeof(log_name), "libtorrent_logs%d", instance); std::string dir(combine_path(combine_path(complete(logpath), log_name), new_name) + ".log"); error_code ec; create_directories(parent_path(dir), ec); if (ec) fprintf(stderr, "Failed to create logfile directory %s: %s\n" , parent_path(dir).c_str(), ec.message().c_str()); ec.clear(); rename(m_filename, dir, ec); if (ec) fprintf(stderr, "Failed to move logfile %s: %s\n" , parent_path(dir).c_str(), ec.message().c_str()); m_filename = dir; }
static void outputStateVtk(const UnstructuredGrid& grid, const Opm::BlackoilState& state, const int step, const std::string& output_dir) { // Write data in VTK format. std::ostringstream vtkfilename; vtkfilename << output_dir << "/vtk_files"; boost::filesystem::path fpath(vtkfilename.str()); try { create_directories(fpath); } catch (...) { OPM_THROW(std::runtime_error, "Creating directories failed: " << fpath); } vtkfilename << "/output-" << std::setw(3) << std::setfill('0') << step << ".vtu"; std::ofstream vtkfile(vtkfilename.str().c_str()); if (!vtkfile) { OPM_THROW(std::runtime_error, "Failed to open " << vtkfilename.str()); } Opm::DataMap dm; dm["saturation"] = &state.saturation(); dm["pressure"] = &state.pressure(); std::vector<double> cell_velocity; Opm::estimateCellVelocity(grid, state.faceflux(), cell_velocity); dm["velocity"] = &cell_velocity; Opm::writeVtkData(grid, dm, vtkfile); }
static void outputStateMatlab(const UnstructuredGrid& grid, const Opm::BlackoilState& state, const int step, const std::string& output_dir) { Opm::DataMap dm; dm["saturation"] = &state.saturation(); dm["pressure"] = &state.pressure(); dm["surfvolume"] = &state.surfacevol(); std::vector<double> cell_velocity; Opm::estimateCellVelocity(grid, state.faceflux(), cell_velocity); dm["velocity"] = &cell_velocity; // Write data (not grid) in Matlab format for (Opm::DataMap::const_iterator it = dm.begin(); it != dm.end(); ++it) { std::ostringstream fname; fname << output_dir << "/" << it->first; boost::filesystem::path fpath = fname.str(); try { create_directories(fpath); } catch (...) { OPM_THROW(std::runtime_error, "Creating directories failed: " << fpath); } fname << "/" << std::setw(3) << std::setfill('0') << step << ".txt"; std::ofstream file(fname.str().c_str()); if (!file) { OPM_THROW(std::runtime_error, "Failed to open " << fname.str()); } file.precision(15); const std::vector<double>& d = *(it->second); std::copy(d.begin(), d.end(), std::ostream_iterator<double>(file, "\n")); } }
bool FilePath::createDirectories(const UString &path) { try { return create_directories(path.c_str()); } catch (std::exception &se) { throw Exception(se); } }
TEST_F(ClientMetadataTest, TestSearchUTF8Indices) { start(2, 2); create_index("/foo/bar", "测试"); create_directories("/foo/bar/dog"); for (int i = 0; i < 100; i++) { ObjectId oid; client_->create("/foo/bar/dog/dog" + to_string(i), 0644, 100, 100, &oid); } vector<VSFSRpcClient::IndexUpdateRequest> requests; for (int i = 0; i < 100; i++) { requests.emplace_back(VSFSRpcClient::IndexUpdateRequest::INSERT, "/foo/bar/dog/dog" + to_string(i), "测试", to_string(i)); } LOG(INFO) << "Update request;"; EXPECT_TRUE(client_->update(requests).ok()); ComplexQuery query; EXPECT_TRUE(query.parse("/foo?测试>50").ok()); vector<string> actual_files; EXPECT_TRUE(client_->search(query, &actual_files).ok()); EXPECT_EQ(49u, actual_files.size()); }
void outputWellStateMatlab(const Opm::WellState& well_state, const int step, const std::string& output_dir) { Opm::DataMap dm; dm["bhp"] = &well_state.bhp(); dm["wellrates"] = &well_state.wellRates(); // Write data (not grid) in Matlab format for (Opm::DataMap::const_iterator it = dm.begin(); it != dm.end(); ++it) { std::ostringstream fname; fname << output_dir << "/" << it->first; boost::filesystem::path fpath = fname.str(); try { create_directories(fpath); } catch (...) { OPM_THROW(std::runtime_error,"Creating directories failed: " << fpath); } fname << "/" << std::setw(3) << std::setfill('0') << step << ".txt"; std::ofstream file(fname.str().c_str()); if (!file) { OPM_THROW(std::runtime_error,"Failed to open " << fname.str()); } file.precision(15); const std::vector<double>& d = *(it->second); std::copy(d.begin(), d.end(), std::ostream_iterator<double>(file, "\n")); } }
void outputStateMatlab(const UnstructuredGrid& grid, const Opm::SimulationDataContainer& state, const int step, const std::string& output_dir) { Opm::DataMap dm; dm["saturation"] = &state.saturation(); dm["pressure"] = &state.pressure(); for (const auto& pair : state.cellData()) { const std::string& name = pair.first; std::string key; if( name == "SURFACEVOL" ) { key = "surfvolume"; } else if( name == "RV" ) { key = "rv"; } else if( name == "GASOILRATIO" ) { key = "rs"; } else { // otherwise skip entry continue; } // set data to datmap dm[ key ] = &pair.second; } std::vector<double> cell_velocity; Opm::estimateCellVelocity(AutoDiffGrid::numCells(grid), AutoDiffGrid::numFaces(grid), AutoDiffGrid::beginFaceCentroids(grid), UgGridHelpers::faceCells(grid), AutoDiffGrid::beginCellCentroids(grid), AutoDiffGrid::beginCellVolumes(grid), AutoDiffGrid::dimensions(grid), state.faceflux(), cell_velocity); dm["velocity"] = &cell_velocity; // Write data (not grid) in Matlab format for (Opm::DataMap::const_iterator it = dm.begin(); it != dm.end(); ++it) { std::ostringstream fname; fname << output_dir << "/" << it->first; boost::filesystem::path fpath = fname.str(); try { create_directories(fpath); } catch (...) { OPM_THROW(std::runtime_error, "Creating directories failed: " << fpath); } fname << "/" << std::setw(3) << std::setfill('0') << step << ".txt"; std::ofstream file(fname.str().c_str()); if (!file) { OPM_THROW(std::runtime_error, "Failed to open " << fname.str()); } file.precision(15); const std::vector<double>& d = *(it->second); std::copy(d.begin(), d.end(), std::ostream_iterator<double>(file, "\n")); } }
void Start() override { if (!RpcUrl.get_Port()) RpcUrl = Uri("http://127.0.0.1:" + Convert::ToString(GetFreePort())); else { try { DBG_LOCAL_IGNORE_CONDITION(errc::connection_refused); Call("getinfo"); if (!PathDaemon.empty()) { try { vector<Process> ps = Process::GetProcessesByName(PathDaemon.stem().c_str()); //!!! incorrect process can be selected and then terminated if (!ps.empty()) m_process = ps.back(); } catch (RCExc) { } } return; } catch (system_error& DBG_PARAM(ex)) { TRC(1, ex.code() << " " << ex.what()); } } if (PathDaemon.empty()) { LOG("Currency daemon for " << Name << " is unavailable"); return; } if (m_process) { if (!m_process.HasExited) return; TRC(2, "Process " << m_process.get_ID() << " exited with code " << m_process.get_ExitCode()); } String exeFilePath = System.get_ExeFilePath(); ostringstream os; create_directories(DataDir); Listen ? (os << " -port=" << GetFreePort()) : (os << " -listen=0"); os << " -rpcport=" << RpcUrl.get_Port() << " -rpcallowip=127.0.0.1" << " -rpcuser="******" -rpcpassword="******" -daemon" << " -server" << (IsTestNet ? " -testnet" : "") << " -datadir=\"" << DataDir << "\""; if (EnableNotifications) { os << " -blocknotify=\"" << exeFilePath << " " << EpApi << " blocknotify " << Name << " %s\"" << " -alertnotify=\"" << exeFilePath << " " << EpApi << " alertnotify " << Name << " %s\""; if (WalletNotifications) os << " -walletnotify=\"" << exeFilePath << " " << EpApi << " walletnotify " << Name << " %s\""; } if (!Args.empty()) os << " " << Args; ProcessStartInfo psi; psi.Arguments = os.str(); psi.FileName = PathDaemon; psi.EnvironmentVariables["ComSpec"] = exeFilePath; // to avoid console window m_process = Process::Start(psi); }
void extract_file(ff7::lgp::Archive::value_type const& file) { fs::path path{file.first}; if (path.has_parent_path()) create_directories(path.parent_path()); std::ofstream stream(file.first, std::ios::binary); util::write(stream, file.second->data()); }
// compiles all files bool opDriver::NormalMode(const opParameters& p) { // verify the output directory... path dirpath = p.GeneratedDirectory.GetString(); if (!exists(dirpath)) create_directories(dirpath); opSet<path> files = GetFiles(); // if there are no files to compile, return false if (files.size() == 0) { if (!p.Silent) Log("Error: No files to compile!"); return false; } // compile all files bool bResult = true; typedef opSet<path>::const_iterator fileit; if (p.Verbose) // spacing in verbose mode Log(' '); for (fileit it = files.begin(); it != files.end(); ++it) { bResult = NormalModeFile(p, *it) ? bResult : false; } // If we had errors, print out the number of errors. if (NumErrors > 0) { Log(""); string errorstring = (NumErrors == 1) ? " error" : " errors"; Log("opC++ - " + opString(NumErrors) + errorstring); Log(""); } if (!p.Silent && files.size() > 1) { if (p.Verbose) { Log(' '); if (bResult) { Log("opC++ - 0 errors"); Log(""); Log("--------------------------------"); Log("All Files Compiled Successfully!"); Log("--------------------------------"); } else { Log("-------------------------------------"); Log("Some File(s) Compiled Unsuccessfully!"); Log("-------------------------------------"); } Log(' '); } } return bResult; }
bool zathura_init(zathura_t* zathura) { if (zathura == NULL) { return false; } /* create zathura (config/data) directory */ create_directories(zathura); /* load plugins */ zathura_plugin_manager_load(zathura->plugins.manager); /* configuration */ config_load_default(zathura); config_load_files(zathura); /* UI */ if (!init_ui(zathura)) { goto error_free; } /* database */ init_database(zathura); /* bookmarks */ zathura->bookmarks.bookmarks = girara_sorted_list_new2( (girara_compare_function_t)zathura_bookmarks_compare, (girara_free_function_t)zathura_bookmark_free); /* jumplist */ init_jumplist(zathura); /* CSS for index mode */ init_css(zathura); /* Shortcut helpers */ init_shortcut_helpers(zathura); /* Start D-Bus service */ bool dbus = true; girara_setting_get(zathura->ui.session, "dbus-service", &dbus); if (dbus == true) { zathura->dbus = zathura_dbus_new(zathura); } return true; error_free: if (zathura->ui.page_widget != NULL) { g_object_unref(zathura->ui.page_widget); } return false; }
void vca_illegal_parking::init() { LOG ( INFO ) << "vca_illegal_parking[" << name_ << "]: initializing..."; working_dir_ = operator/( global::config()->get ( "vca.data_dir", "data" ), name_ ); create_directories ( working_dir_ ); event_queue_.reset( new squeue< shared_ptr< ptree > >() ); loiter_->subscribe ( event_queue_ ); }
TEST_F(TransformQueryTest, OmeTransformsXML) { boost::filesystem::path xmlfile = PROJECT_BINARY_DIR "/ome-xml/src/test/cpp/data/ome-transforms.xml"; boost::filesystem::path xmldir = xmlfile.parent_path(); if (!exists(xmldir) && !is_directory(xmldir) && !create_directories(xmldir)) throw std::runtime_error("Data directory unavailable and could not be created"); std::ofstream xmlstream(xmlfile.string().c_str()); write_ome_transforms(resolver, xmlstream); write_ome_transforms(resolver, std::cout); }
bool FileSystem::CreateDirectory_(const string& path) { try { return create_directories(path); } catch (filesystem_error& e) { LOGF_ERROR("FileSystem::CreateDirectory: %s, %s", e.what(), path.c_str()); return true; } }
Status ObjectStorageManager::init() { // Creates subdirs if not existed. for (int i = 0; i < num_subdirs_; i++) { auto subdir = fs::path(base_path_) / to_string(i); boost::system::error_code ec; create_directories(subdir, ec); if (ec.value() > 0) { return Status(ec.value(), ec.message()); } } return Status::OK; }
TEST_F(TransformQueryTest, GraphViz) { boost::filesystem::path dotfile = PROJECT_BINARY_DIR "/ome-xml/src/test/cpp/data/ome-transforms.dot"; boost::filesystem::path dotdir = dotfile.parent_path(); if (!exists(dotdir) && !is_directory(dotdir) && !create_directories(dotdir)) throw std::runtime_error("Data directory unavailable and could not be created"); std::ofstream dotstream(dotfile.string().c_str()); resolver.write_graphviz(dotstream); resolver.write_graphviz(std::cout); }