bool CrashHandlerImpl::addAttachedFile(const fs::path & file) {
if(file.is_relative()) {
fs::path absolute = fs::current_path() / file;
if(absolute.is_relative()) {
return false;
}
return addAttachedFile(absolute);
}
Autolock autoLock(&m_Lock);
if(m_pCrashInfo->nbFilesAttached == CrashInfo::MaxNbFiles) {
LogError << "Too much files already attached to the crash report (" << m_pCrashInfo->nbFilesAttached << ").";
return false;
}
if(file.string().size() >= CrashInfo::MaxFilenameLen) {
LogError << "File name is too long.";
return false;
}
for(u32 i = 0; i < m_pCrashInfo->nbFilesAttached; i++) {
if(strcmp(m_pCrashInfo->attachedFiles[i], file.string().c_str()) == 0) {
LogWarning << "File \"" << file << "\" is already attached.";
return false;
}
}
util::storeStringTerminated(m_pCrashInfo->attachedFiles[m_pCrashInfo->nbFilesAttached], file.string());
m_pCrashInfo->nbFilesAttached++;
return true;
}
bool CrashHandlerImpl::addAttachedFile(const fs::path& file) {
Autolock autoLock(&m_Lock);
if(m_pCrashInfo->nbFilesAttached == CrashInfo::MaxNbFiles) {
LogError << "Too much files already attached to the crash report (" << m_pCrashInfo->nbFilesAttached << ").";
return false;
}
if(file.string().size() >= CrashInfo::MaxFilenameLen) {
LogError << "File name is too long.";
return false;
}
for(int i = 0; i < m_pCrashInfo->nbFilesAttached; i++) {
if(strcmp(m_pCrashInfo->attachedFiles[i], file.string().c_str()) == 0) {
LogWarning << "File \"" << file << "\" is already attached.";
return false;
}
}
strcpy(m_pCrashInfo->attachedFiles[m_pCrashInfo->nbFilesAttached], file.string().c_str());
m_pCrashInfo->nbFilesAttached++;
return true;
}
Cursor::Cursor(fs::path imgPath, float hotSpotX, float hotSpotY) {
sf::Image gif;
if(!gif.loadFromFile(imgPath.string())) {
std::string error = "Error loading cursor from " + imgPath.string();
throw error;
}
// Calculate the AND and XOR masks
HBITMAP cursorAnd = CreateCompatibleBitmap(GetDC(NULL), gif.getSize().x, gif.getSize().y);
HBITMAP cursorXor = CreateCompatibleBitmap(GetDC(NULL), gif.getSize().x, gif.getSize().y);
GetMaskBitmaps(gif, cursorAnd, cursorXor);
ICONINFO iconinfo = {0};
iconinfo.fIcon = FALSE;
iconinfo.xHotspot = hotSpotX;
iconinfo.yHotspot = hotSpotY;
iconinfo.hbmMask = cursorAnd;
iconinfo.hbmColor = cursorXor;
HCURSOR hCursor = CreateIconIndirect(&iconinfo);
if(hCursor == NULL) {
std::string error = "Error creating cursor from " + imgPath.string();
error += " (error code " + std::to_string(GetLastError()) + ")";
throw error;
}
ptr = hCursor;
DeleteObject(cursorAnd);
DeleteObject(cursorXor);
}
void
FileSystemTestSetup::setup_clustercache_device(const fs::path& device,
uint64_t size) const
{
int fd = ::open(device.string().c_str(),
O_RDWR| O_CREAT | O_EXCL,
S_IWUSR | S_IRUSR);
if(fd < 0)
{
LOG_ERROR("Couldn't open file " << device << ", " << strerror(errno));
throw fungi::IOException("Couldn't open file", device.string().c_str());
}
BOOST_SCOPE_EXIT((fd))
{
::close(fd);
}
BOOST_SCOPE_EXIT_END;
int ret = ::posix_fallocate(fd, 0, size);
if (ret != 0)
{
LOG_ERROR("Could not allocate file " << device << " with size " << size << ", " << strerror(ret));
throw fungi::IOException("Could not allocate file",
device.string().c_str(),
ret);
}
::fchmod(fd, 00600);
}
bool CMissionManager::DoCopyFile(const fs::path& source, const fs::path& dest, bool overwrite)
{
if (overwrite)
{
try
{
// According to docs, remove() doesn't throw if file doesn't exist
fs::remove(dest);
DM_LOG(LC_MAINMENU, LT_INFO)LOGSTRING("Destination file %s already exists, has been removed before copying.\r", dest.string().c_str());
}
catch (fs::filesystem_error& e)
{
// Don't care about removal error
DM_LOG(LC_MAINMENU, LT_DEBUG)LOGSTRING("Caught exception while removing destination file %s: %s\r", dest.string().c_str(), e.what());
}
}
// Copy the source file to the destination
try
{
fs::copy_file(source, dest);
DM_LOG(LC_MAINMENU, LT_INFO)LOGSTRING("File successfully copied to %s.\r", dest.string().c_str());
return true;
}
catch (fs::filesystem_error& e)
{
DM_LOG(LC_MAINMENU, LT_ERROR)LOGSTRING("Exception while coyping file from %s to %s: %s\r",
source.string().c_str(), dest.string().c_str(), e.what());
return false;
}
}
/*******************************************************************
* Function Name: Save
* Return Type : int
* Created On : Nov 10, 2013
* Created By : hrushi
* Comments : Save SVM
* Arguments : const fs::path fs
*******************************************************************/
int SVMLearning::Save( const fs::path fs) const
{
cout << "Writing to: " << fs.string() << endl;
m_SVM.save(fs.string().c_str());
return EXIT_SUCCESS;
}
void GstVideoServer::load( const fs::path& path )
{
CI_LOG_I("Load file: " << path.string() );
GstPlayer::load(path.string());
mCurrentFileName = path.filename().string();
///> Now that we have loaded we can grab the pipeline..
mGstPipeline = GstPlayer::getPipeline();
setupNetworkClock();
}
int remove_hjtremove(fs::path path, void* data)
{
if (strstr(path.string().c_str(),".hjtremove") ||
strstr(path.string().c_str(),".tmp")){
boost::system::error_code ec;
fs::remove(path, ec);
return ec.value();
}
return 0;
}
bool RenameOver(fs::path src, fs::path dest)
{
#ifdef WIN32
return MoveFileExA(src.string().c_str(), dest.string().c_str(),
MOVEFILE_REPLACE_EXISTING) != 0;
#else
int rc = std::rename(src.string().c_str(), dest.string().c_str());
return (rc == 0);
#endif /* WIN32 */
}
bool MDeepFileIteratorImp::Next(
fs::path& outFile)
{
bool result = false;
while (not result and not mStack.empty())
{
struct dirent* e = nil;
MInfo& top = mStack.top();
if (top.mDIR != nil)
THROW_IF_POSIX_ERROR(::readdir_r(top.mDIR, &top.mEntry, &e));
if (e == nil)
{
if (top.mDIR != nil)
closedir(top.mDIR);
mStack.pop();
}
else
{
outFile = top.mParent / e->d_name;
struct stat st;
if (stat(outFile.string().c_str(), &st) < 0 or S_ISLNK(st.st_mode))
continue;
if (S_ISDIR(st.st_mode))
{
if (strcmp(e->d_name, ".") and strcmp(e->d_name, ".."))
{
MInfo info;
info.mParent = outFile;
info.mDIR = opendir(outFile.string().c_str());
memset(&info.mEntry, 0, sizeof(info.mEntry));
mStack.push(info);
}
continue;
}
if (mOnlyTEXT and not IsTEXT(outFile))
continue;
if (mFilter.length() and not FileNameMatches(mFilter.c_str(), outFile))
continue;
result = true;
}
}
return result;
}
TEST_F(FileUtilsTest, copy)
{
std::string content("content");
const fs::path a = FileUtils::create_temp_file_in_temp_dir();
{
std::ofstream ofs(a.string().c_str());
ofs << content;
ofs.close();
}
const size_t size = fs::file_size(a);
const fs::path b = FileUtils::create_temp_file_in_temp_dir("b");
ASSERT_NO_THROW(fs::remove(b));
ASSERT_FALSE(fs::exists(b));
EXPECT_NO_THROW(FileUtils::safe_copy(a, b));
EXPECT_TRUE(fs::exists(b));
EXPECT_EQ(size, fs::file_size(b));
std::string read;
{
std::ifstream ifs(b.string().c_str());
ifs >> read;
ifs.close();
}
EXPECT_EQ(content, read);
// copy to a larger, existing file
read = "";
{
std::ofstream ofs(a.string().c_str());
ofs << content << content << content;
ofs.close();
}
EXPECT_LT(size, fs::file_size(a));
EXPECT_NO_THROW(FileUtils::safe_copy(b, a));
EXPECT_EQ(size, fs::file_size(a));
{
std::ifstream ifs(a.string().c_str());
ifs >> read;
ifs.close();
}
EXPECT_EQ(content, read);
}
bool CrashHandlerImpl::setReportLocation(const fs::path& location) {
Autolock autoLock(&m_Lock);
if(location.string().size() >= CrashInfo::MaxFilenameLen) {
LogError << "Report location path is too long.";
return false;
}
strcpy(m_pCrashInfo->crashReportFolder, location.string().c_str());
return true;
}
static void test_parent(const fs::path & in, const std::string & out) {
fs::path p = in.parent();
arx_assert_msg(p.string() == out, "\"%s\".parent() -> \"%s\" != \"%s\"",
in.string().c_str(), p.string().c_str(), out.c_str());
fs::path temp = in;
temp.up();
arx_assert_msg(temp.string() == out, "\"%s\".up() ->\"%s\" != \"%s\"",
in.string().c_str(), temp.string().c_str(), out.c_str());
}
bool FileService::deleteFile(const fs::path& file)
{
try
{
os_chmod(file.string().c_str(), S_IRUSR|S_IWUSR);
return fs::remove(file);
}
catch (const std::exception ex)
{
std::cout << "ERROR: delete file " << file.string() << "; exception: " << ex.what() << std::endl;
return false;
}
}
void ControleaseApp::loadCanvasFromFile(fs::path file)
{
console() << "loading patch from: " << file.string() << endl;
if (!exists(file)) {
console() << "error: cannot find '"<<file.string()<<"'"<<endl;
return;
}
// get size of file
XmlTree xml(loadFile(file));
canvas->initFromXml(xml.getChild("Canvas"));
}
static void test_resolve(const fs::path & left, const fs::path & right, const std::string & out) {
fs::path result = left / right;
arx_assert_msg(result.string() == out, "\"%s\" / \"%s\" -> \"%s\" != \"%s\"",
left.string().c_str(), right.string().c_str(), result.string().c_str(),
out.c_str());
fs::path temp = left;
temp /= right;
arx_assert_msg(temp.string() == out, "\"%s\" /= \"%s\" -> \"%s\" != \"%s\"",
left.string().c_str(), right.string().c_str(), temp.string().c_str(),
out.c_str());
}
bool copyFile(const fs::path& from, const fs::path& to) {
std::ifstream in(from.string().c_str(), std::ios::binary);
if (!in)
return false;
std::ofstream out(to.string().c_str(), std::ios::binary);
if (!out)
return false;
out << in.rdbuf();
if (out.bad())
return false;
in.close();
out.close();
return true;
}
bool FileService::copyFile(const fs::path& source, const fs::path& destination)
{
try
{
if (fs::exists(destination))
os_chmod(destination.string().c_str(), S_IRUSR|S_IWUSR);
fs::copy_file(source, destination, fs::copy_option::overwrite_if_exists);
return true;
}
catch (const std::exception ex)
{
std::cout << "ERROR: copy file " << source.string() << " to " << destination.string() << "; exception: " << ex.what() << std::endl;
return false;
}
}
// calls must be locked by write-lock
void StylesheetManager::onNewStylesheet(const fs::path& stylesheet_path)
{
// lock the weak_ptr to manager
shared_ptr<RequestManager> manager = this->manager.lock();
assert(manager);
shared_ptr<Stylesheet> stylesheet;
int timeout = config->get<int>(opt::server::parse_timeout);
try {
std::string new_filename = stylesheet_path.filename().string() + ".mapcss";
fs::path filename(new_filename);
stylesheet = Stylesheet::Load(stylesheetFolder / filename, manager->getGeodata(), timeout);
} catch(excp::ParseException& e)
{
shared_ptr<ParserLogger> logger = *boost::get_error_info<excp::InfoParserLogger>(e);
// Something went wrong!
logger->errorStream() << "Parsing of file \"" << excp::ErrorOut<excp::InfoFileName>(e, stylesheet_path.string()) << "\" failed:";
logger->errorStream() << excp::ErrorOut<excp::InfoWhat>(e, "unknown reason!");
logger->errorStream() << "In line " << excp::ErrorOut<excp::InfoFailureLine>(e) << " column " << excp::ErrorOut<excp::InfoFailureColumn>(e) << ":";
const string* errLine = boost::get_error_info<excp::InfoFailureLineContent>(e);
const int* errColumn = boost::get_error_info<excp::InfoFailureColumn>(e);
if(errLine)
logger->errorStream() << "'" << *errLine << "'";
if(errColumn)
logger->errorStream() << string(*errColumn, ' ') << "^-here";
return;
} catch(excp::TimeoutException&)
{
shared_ptr<ParserLogger> logger = boost::make_shared<ParserLogger>(stylesheet_path.string());
logger->errorStream() << "Parsing of stylesheet " << stylesheet_path << " took more then " << timeout << " ms!";
logger->errorStream() << "Parsing canceled!";
logger->errorStream() << "You can configure the timeout via '--parse-timeout'.";
return;
}
parsedStylesheets[stylesheet_path] = stylesheet;
// prerenders the upmost tile as well as all higher zoomlevels that are specified in the configuration
manager->enqueue(boost::make_shared<MetaIdentifier>(TileIdentifier(0, 0, 0, stylesheet_path.string(), TileIdentifier::PNG)));
}
bool ChooseDirectory(
fs::path& outDirectory)
{
GtkWidget* dialog = nil;
bool result = false;
try
{
dialog =
gtk_file_chooser_dialog_new(_("Select Folder"), nil,
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
THROW_IF_NIL(dialog);
string currentFolder = gApp->GetCurrentFolder();
if (currentFolder.length() > 0)
{
gtk_file_chooser_set_current_folder_uri(
GTK_FILE_CHOOSER(dialog), currentFolder.c_str());
}
if (fs::exists(outDirectory) and outDirectory != fs::path())
{
gtk_file_chooser_select_filename(GTK_FILE_CHOOSER(dialog),
outDirectory.string().c_str());
}
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
{
char* uri = gtk_file_chooser_get_uri(GTK_FILE_CHOOSER(dialog));
if (uri != nil)
{
MFile url(uri, true);
outDirectory = url.GetPath();
g_free(uri);
result = true;
}
//
// gApp->SetCurrentFolder(
// gtk_file_chooser_get_current_folder_uri(GTK_FILE_CHOOSER(dialog)));
}
}
catch (exception& e)
{
if (dialog)
gtk_widget_destroy(dialog);
throw;
}
gtk_widget_destroy(dialog);
return result;
}
bool LockDirectory(const fs::path& directory, const std::string lockfile_name, bool probe_only)
{
std::lock_guard<std::mutex> ulock(cs_dir_locks);
fs::path pathLockFile = directory / lockfile_name;
// If a lock for this directory already exists in the map, don't try to re-lock it
if (dir_locks.count(pathLockFile.string())) {
return true;
}
// Create empty lock file if it doesn't exist.
FILE* file = fsbridge::fopen(pathLockFile, "a");
if (file) fclose(file);
try {
auto lock = MakeUnique<boost::interprocess::file_lock>(pathLockFile.string().c_str());
if (!lock->try_lock()) {
return false;
}
if (!probe_only) {
// Lock successful and we're not just probing, put it into the map
dir_locks.emplace(pathLockFile.string(), std::move(lock));
}
} catch (const boost::interprocess::interprocess_exception& e) {
return error("Error while attempting to lock directory %s: %s", directory.string(), e.what());
}
return true;
}
std::vector<fs::path> ListWalletDir()
{
const fs::path wallet_dir = GetWalletDir();
const size_t offset = wallet_dir.string().size() + 1;
std::vector<fs::path> paths;
for (auto it = fs::recursive_directory_iterator(wallet_dir); it != fs::recursive_directory_iterator(); ++it) {
// Get wallet path relative to walletdir by removing walletdir from the wallet path.
// This can be replaced by boost::filesystem::lexically_relative once boost is bumped to 1.60.
const fs::path path = it->path().string().substr(offset);
if (it->status().type() == fs::directory_file && IsBerkeleyBtree(it->path() / "wallet.dat")) {
// Found a directory which contains wallet.dat btree file, add it as a wallet.
paths.emplace_back(path);
} else if (it.level() == 0 && it->symlink_status().type() == fs::regular_file && IsBerkeleyBtree(it->path())) {
if (it->path().filename() == "wallet.dat") {
// Found top-level wallet.dat btree file, add top level directory ""
// as a wallet.
paths.emplace_back();
} else {
// Found top-level btree file not called wallet.dat. Current bitcoin
// software will never create these files but will allow them to be
// opened in a shared database environment for backwards compatibility.
// Add it to the list of available wallets.
paths.emplace_back(path);
}
}
}
return paths;
}
void QuickTimeSampleApp::loadMovieFile( const fs::path& moviePath )
{
try {
// load up the movie, set it to loop, and begin playing
mMovie = qtime::MovieGl( moviePath );
mMovie.setLoop();
mMovie.play();
// create a texture for showing some info about the movie
TextLayout infoText;
infoText.clear( ColorA( 0.2f, 0.2f, 0.2f, 0.5f ) );
infoText.setColor( Color::white() );
infoText.addCenteredLine( getPathFileName( moviePath.string() ) );
infoText.addLine( toString( mMovie.getWidth() ) + " x " + toString( mMovie.getHeight() ) + " pixels" );
infoText.addLine( toString( mMovie.getDuration() ) + " seconds" );
infoText.addLine( toString( mMovie.getNumFrames() ) + " frames" );
infoText.addLine( toString( mMovie.getFramerate() ) + " fps" );
infoText.setBorder( 4, 2 );
mInfoTexture = gl::Texture( infoText.render( true ) );
}
catch( ... ) {
console() << "Unable to load the movie." << std::endl;
mMovie.reset();
mInfoTexture.reset();
}
mFrameTexture.reset();
}
imageHasher::db::table::ImageRecord Database::get_imagerecord(fs::path filepath) {
ImageRecord ir;
try {
transaction t(orm_db->begin());
std::string *p;
LOG4CPLUS_DEBUG(logger, "Getting imagerecord for path " << filepath);
odb::prepared_query<ImageRecord> pq = this->prep_query->get_imagerecord_path_query(p);
*p = filepath.string();
result<ImageRecord> r(pq.execute());
for (result<ImageRecord>::iterator itr(r.begin()); itr != r.end(); ++itr) {
ir = *itr;
break;
}
t.commit();
} catch (odb::exception *e) {
LOG4CPLUS_ERROR(logger, "Failed to get ImageRecord for path " << filepath << " : " << e);
}
return ir;
}
std::list<fs::path> Database::getFilesWithPath(fs::path directoryPath) {
std::list<fs::path> filePaths;
std::string path_query(directoryPath.string());
path_query += "%";
LOG4CPLUS_INFO(logger, "Looking for files with path " << directoryPath);
transaction t (orm_db->begin());
std::string *param;
odb::prepared_query<ImageRecord> pq = prep_query->get_files_with_path_query(param);
*param = path_query;
odb::result<ImageRecord> r(pq.execute());
for(result<ImageRecord>::iterator itr (r.begin()); itr != r.end(); ++itr) {
filePaths.push_back(fs::path(itr->getPath()));
}
t.commit();
LOG4CPLUS_INFO(logger, "Found " << filePaths.size() << " records for path " << directoryPath);
return filePaths;
}
/*
csv file format
L1:x1, L1:laserOnoff, L2:x1, L2:laserOnoff, ..., R5:x1, R1:laserOnoff
each line number = frame number (25fps)
*/
void cApp::loadCsv( fs::path path, vector<vector<float>> & array, bool print ){
ifstream file ( path.string() );
if( !file.is_open() ){
cout << "cant open file" << endl;
}else{
std::string line;
while ( std::getline( file, line ) ){
std::istringstream iss{ line };
std::vector<float> tokens;
std::string cell;
while( std::getline(iss, cell, ',') ){
cell.erase( std::remove(cell.begin(), cell.end(), '\r'), cell.end() ); // erase \r
float cell_f = fromString<float>(cell);
tokens.push_back( cell_f );
}
array.push_back( tokens );
}
}
if( print ){
for (auto & line : array){
for (auto & val : line){
printf( "%f ", val);
}
printf("\n");
}
}
}
fs::path AppImplMsw::getFolderPath( const fs::path &initialPath )
{
wstring initialPathWide( toUtf16( initialPath.string() ) );
string result;
::BROWSEINFO bi = { 0 };
bi.lParam = reinterpret_cast<LPARAM>( initialPathWide.c_str() );
bi.lpfn = getFolderPathBrowseCallbackProc;
bi.lpszTitle = L"Pick a Directory";
::LPITEMIDLIST pidl = ::SHBrowseForFolder( &bi );
if( pidl ) {
// get the name of the folder
TCHAR path[MAX_PATH];
if( ::SHGetPathFromIDList ( pidl, path ) ) {
result = toUtf8( path );
}
// free memory used
::IMalloc * imalloc = 0;
if( SUCCEEDED( ::SHGetMalloc( &imalloc ) ) ) {
imalloc->Free( pidl );
imalloc->Release();
}
}
return result;
}
TableRopeScene::TableRopeScene(fs::path ropeFile, bool telekinesis) : GrabbingScene(telekinesis) {
// vector<double> firstJoints = doubleVecFromFile((KNOT_DATA / "init_joints_train.txt").string());
// ValuesInds vi = getValuesInds(firstJoints);
// setupDefaultROSRave();
// pr2m->pr2->setDOFValues(vi.second, vi.first);
vector<int> indices(1,pr2m->pr2->robot->GetJointIndex("torso_lift_joint"));
vector<double> values(1, .31);
pr2m->pr2->setDOFValues(indices, values);
vector<btVector3> tableCornersWorld = toBulletVectors(floatMatFromFile((KNOT_DATA / "table_corners.txt").string())) * METERS;
vector<btVector3> controlPointsWorld = toBulletVectors(floatMatFromFile(ropeFile.string())) * METERS;
PlotPoints::Ptr corners(new PlotPoints(20));
corners->setPoints(tableCornersWorld);
env->add(corners);
m_table = makeTable(tableCornersWorld, .1*GeneralConfig::scale);
float seglen = controlPointsWorld[0].distance(controlPointsWorld[1]);
// m_rope.reset(new CapsuleRope(controlPointsWorld, fmin(seglen/4.1,.0075*METERS)));
m_rope.reset(new CapsuleRope(controlPointsWorld, .0075*METERS));
env->add(m_rope);
env->add(m_table);
setGrabBodies(m_rope->children);
}
void AudioVisualizerApp::playAudio( const fs::path& file )
{
FMOD_RESULT err;
// ignore if this is not a file
if( file.empty() || !fs::is_regular_file( file ) )
return;
// if audio is already playing, stop it first
stopAudio();
// stream the audio
err = mFMODSystem->createStream( file.string().c_str(), FMOD_SOFTWARE, NULL, &mFMODSound );
err = mFMODSystem->playSound( FMOD_CHANNEL_FREE, mFMODSound, false, &mFMODChannel );
// we want to be notified of channel events
err = mFMODChannel->setCallback( channelCallback );
// keep track of the audio file
mAudioPath = file;
mIsAudioPlaying = true;
//
console() << "Now playing:" << mAudioPath.filename() << std::endl;
}
void dir_spec::iterate_dir(const fs::path & dir) {
LDBG_ << "Parsing dir " << fs::system_complete(dir).string();
if ( !fs::exists( dir) ) {
LERR_ << "Dir " << dir.string() << " does not exist anymore!";
return ;
}
for ( fs::directory_iterator b(dir), e; b != e; ++b) {
if ( fs::is_directory(*b))
iterate_dir(*b);
else {
// file
bool matches_ext = false;
for ( extensions::array::const_iterator b_ext = m_ext.vals.begin(), e_ext = m_ext.vals.end(); b_ext != e_ext; ++b_ext)
if ( fs::extension(*b) == "." + *b_ext) {
matches_ext = true;
break;
}
if ( matches_ext) {
m_stats += parse_file(*b);
++m_file_count;
}
else
LDBG_ << "Ignoring file " << b->string();
}
}
}
