예제 #1
0
int main(int argc, char **argv) {
  if (argc != 3) {
    printf("Usage: %s mmap_directory revision_input_file\n",
           argv[0]);
    exit(1);
  }
  struct revision_stats stats;
  get_file_stats(argv[2], &stats);
  printf("%d max user, %d max page, %"PRId64" max revision, %"PRId64" total revisions\n",
	 stats.max_user_id, stats.max_page_id, stats.max_revision_id, stats.total_revisions);
  char *user_index_mmap_name = full_path(argv[1], USER_INDEX_MMAP_NAME);
  char *page_index_mmap_name = full_path(argv[1], PAGE_INDEX_MMAP_NAME);
  char *revisions_mmap_name = full_path(argv[1], REVISIONS_MMAP_NAME);
  char *user_index_mmap = create_mmap(user_index_mmap_name, user_index_mmap_size(&stats));
  char *page_index_mmap = create_mmap(page_index_mmap_name, page_index_mmap_size(&stats));
  char *revisions_mmap = create_mmap(revisions_mmap_name, revision_mmap_size(&stats));
  ((struct user_header*)user_index_mmap)->count_users = stats.max_user_id + 1;
  ((struct page_header*)page_index_mmap)->count_pages = stats.max_page_id + 1;
  ((struct revision_header*)revisions_mmap)->count_revisions = stats.max_revision_id + 1;
  fill_mmaps(argv[2], &stats, user_index_mmap, page_index_mmap, revisions_mmap);
  free(user_index_mmap_name);
  free(page_index_mmap_name);
  free(revisions_mmap_name);
  return 0;
}
예제 #2
0
파일: mod_cse.c 프로젝트: triclops200/CSE
int old(char* filename)
{

	char * ffpath = full_path(filename,".md5");
	char * tspath = full_path(COMPDIR,ffpath);
	free(ffpath);
	int ol = 1;
	if (file_exists(tspath) && file_exists(filename))
	{
		FILE * f = fopen(tspath,"r");
		char * inner = read_entire_file(f);
		fclose(f);
		inner[strlen(inner)-1]=0;
		struct stat file_stat;
		stat(filename,&file_stat);
		if(DEBUG){
			fprintf(stderr,"%s:%d %s:%d\n",tspath,atoi(inner),filename,file_stat.st_mtime);
			fflush(stderr);
		}
		if(file_stat.st_mtime<=atoi(inner))
		{
			ol = 0;
		}
		else
		{
			ol = 1;
		}
		free(inner);
	}
	free(tspath);
	return ol;
}
예제 #3
0
void cOverworld_Manager :: Load_Dir( const std::string &dir, bool user_dir /* = 0 */ ) 
{
	// set world directory
// fixme : boost should use a codecvt_facet but for now we convert to UCS-2
#ifdef _WIN32
	fs::path full_path( utf8_to_ucs2( dir ) );
#else
	fs::path full_path( dir );
#endif
	fs::directory_iterator end_iter;

	for( fs::directory_iterator dir_itr( full_path ); dir_itr != end_iter; ++dir_itr )
	{
		try
		{
			std::string current_dir = dir_itr->path().filename().string();

			// only directories with an existing description
			if( fs::is_directory( *dir_itr ) && File_Exists( dir + "/" + current_dir + "/description.xml" ) )
			{
				cOverworld *overworld = Get_from_Path( current_dir );

				// already available
				if( overworld )
				{
					overworld->m_description->m_user = 2;
					continue;
				}

				overworld = new cOverworld();

				// set path
				overworld->m_description->m_path = current_dir;
				// default name is the path
				overworld->m_description->m_name = current_dir;
				// set user
				overworld->m_description->m_user = user_dir;

				objects.push_back( overworld );

				overworld->Load();
			}
		}
		catch( const std::exception &ex )
		{
			printf( "%s %s\n", dir_itr->path().filename().string().c_str(), ex.what() );
		}
	}
}
예제 #4
0
void FileSystemMap::CreateMap(string const& MountPoint) {

	fs::path full_path(fs::initial_path<fs::path>());

	full_path = fs::system_complete(fs::path(MountPoint));

	if (!fs::exists(full_path)) {
		BOOST_THROW_EXCEPTION(
				invalid_argument(string(MountPoint).append(" Not found")));
	}

	if (fs::is_directory(full_path)) {
		BuildMap(full_path);
	} else {
		BOOST_THROW_EXCEPTION(
				invalid_argument(
						string("Expecting directory, found :").append(
								full_path.c_str())));
	}
#ifdef __DEBUG__FSM
	std::cout << "\n" << FileCount << " files\n" << DirCount << " directories\n"
			<< OtherCount << " others\n" << ErrCount << " errors\n";
#endif
	return;

}
예제 #5
0
	void cFontLoader::
		ExportDFFToFile(tDistanceFontHandle font, const Twine& in_path /*= ""*/)
	{
		auto& dff = DistanceFont(font);
		size_t face_size = cSerialization::SerializedSize(dff.Face());
		cDFFFile pair(dff, face_size);
		AlignedBuffer<16> buffer;
		cSerialization::SerializeLZMA(pair,buffer);
		cStringRef file_data(buffer.ptr<char>(), buffer.size());

		try{
			if (sys::path::has_filename(in_path))
			{
				WriteFileToDisk(file_data, in_path);
			}
			else
			{
				cSmallVector<char, 256> path_buf;
				cStringRef temp_path = in_path.toNullTerminatedStringRef(path_buf);
				sys::path::append(path_buf, in_path, dff.FontName() + ".dff");
				cStringRef full_path(path_buf.data(), path_buf.size());
				WriteFileToDisk(file_data, full_path);
			}
		}
		catch (const Exception& e)
		{
			Log::Warn("Swallowed exception while trying to write dff file: %s",
								e.what());
		}
	}
예제 #6
0
void TexManager::loadTexture(string filename, bool alpha) {
  unsigned int flags = SOIL_FLAG_MIPMAPS;
  if (alpha)
    flags = flags | SOIL_FLAG_MULTIPLY_ALPHA;
    
  #ifdef DEVICE
    char app_dir[256];
    PDL_GetCallingPath(app_dir, 256);
    string full_path(app_dir);
    full_path.append(filename);
  #else
    string full_path = filename;
  #endif
  
  inst->texture[inst->texture_ref] = SOIL_load_OGL_texture
    (   
      full_path.c_str(),
      SOIL_LOAD_AUTO,
      SOIL_CREATE_NEW_ID,
      flags
    );
    
  if (inst->texture[inst->texture_ref] == 0) {
    printf( "SOIL loading error: '%s'\n", SOIL_last_result() );
  } else {
    printf("loaded\n");
  }
    
  inst->texture_ref++;
}
예제 #7
0
    std::string appendFilename(const std::string parent_path, const std::string filename)
    {
        boost::filesystem::path full_path(parent_path);
        full_path /= filename; // appends filename to full_path with the preferred separator

        return full_path.make_preferred().string();
    }
예제 #8
0
파일: rpath.c 프로젝트: sabrown256/pactnew
static int expand_path(const char *name, int fullp, int nt, int dt, int rv)
   {int i, nc, ok;
    char *fname;
    char pname[PATH_MAX], rname[PATH_MAX+1];

    nc = PATH_MAX - 1;

    ok = 1;
    if (fullp == TRUE)
       {ok = full_path(pname, nc, 1, NULL, name);
	if (ok != 0)
	   rv |= 1;};
    if (ok != 0)
       nstrncpy(pname, PATH_MAX, name, -1);

    fname = NULL;
    for (i = 0; i < nt; i++)
        {fname = realpath(pname, rname);
	 if (fname == NULL)
	    sleep(dt);
	 else
	    break;};
    if (fname == NULL)
       {if (nt > 0)
	   rv |= 2;
	fprintf(stdout, "%s\n", pname);}
    else
       fprintf(stdout, "%s\n", rname);

    return(rv);}
예제 #9
0
int metafile::unlink(int dfd, const char * name, bool recursive)
{
	scopelock scope(mf_map_lock);
	istr path = full_path(dfd, name);
	if(!path)
		return -1;
	MF_S_DEBUG("%s", path.str());
	mf_map_t::iterator itr = mf_map.find(path);
	if(itr != mf_map.end())
	{
		if(itr->second->usage)
		{
			fprintf(stderr, "Warning: tried to unlink open metafile %s\n", path.str());
			return -EBUSY;
		}
		/* flush it, in case something later fails */
		itr->second->flush();
		delete itr->second;
	}
	uint8_t type = recursive ? MF_TX_RM_R : MF_TX_UNLINK;
	uint16_t path_len = path.length();
	journal::ovec ov[3] = {{&type, sizeof(type)},
	                       {&path_len, sizeof(path_len)},
	                       {&path[0], path_len}};
	assert(current_journal);
	return current_journal->appendv(ov, 3);
}
예제 #10
0
파일: StockReply.C 프로젝트: ReWeb3D/wt
::int64_t StockReply::contentLength()
{
  std::string full_path(configuration().errRoot()
			+ stock_replies::toName(status()));
  std::string original_url;
  std::string content = "";
  std::string line;
  size_t clen = content_.length();
  std::ifstream ifstr(full_path.c_str(), std::ios::in | std::ios::binary);

  while (ifstr.good() && !ifstr.eof()) {
    std::getline(ifstr, line);
    size_t index = 0;

    while ((index = line.find("<-- SPECIAL CONTENT -->", index)) != line.npos) {
      line.replace(index,sizeof("<-- SPECIAL CONTENT -->")-1, content_);
      index += clen;
    }

    index = line.find("<-- ORIGINAL URL -->");

    if (index != line.npos) {
      stock_replies::buildOriginalURL(request_, original_url);
      clen = original_url.length();

      do {
	line.replace(index,sizeof("<-- ORIGINAL URL -->")-1, original_url);
	index += clen;
      } while((index = line.find("<-- ORIGINAL URL -->", index) != line.npos));

    }

    index = line.find("<-- ORIGINAL URL ESCAPED -->");

    if (index != line.npos) {
      if (original_url.empty())
	stock_replies::buildOriginalURL(request_, original_url);

      std::string escapedUrl = Wt::Utils::urlEncode(original_url);
      clen = escapedUrl.length();

      do {
	line.replace(index,sizeof("<-- ORIGINAL URL ESCAPED -->") - 1,
		     escapedUrl);
	index += clen;
      } while((index = line.find("<-- ORIGINAL URL ESCAPED -->", index)
	       != line.npos));
    }
    content += line + "\r\n";
  }
  ifstr.close();

  if (content.empty())
    content_ = stock_replies::toText(status()) + content_;
  else
    content_ = content;

  return content_.length();
}
예제 #11
0
void filesystem_enumerate_callback(void *data, const char *directory, const char *filename)
{
    std::list<std::string> *list = (std::list<std::string> *)data;
    std::string full_path(directory);
    full_path.append("/");
    full_path.append(filename);
    list->push_back(full_path);
}
예제 #12
0
void AssetBrowser::openInExternalEditor(const char* path)
{
	if (m_editor.getEngine().getPatchFileDevice())
	{
		Lumix::StaticString<Lumix::MAX_PATH_LENGTH> full_path(m_editor.getEngine().getPatchFileDevice()->getBasePath());
		full_path << path;
		if (PlatformInterface::fileExists(full_path))
		{
			PlatformInterface::shellExecuteOpen(full_path);
			return;
		}
	}

	Lumix::StaticString<Lumix::MAX_PATH_LENGTH> full_path(m_editor.getEngine().getDiskFileDevice()->getBasePath());
	full_path << path;
	PlatformInterface::shellExecuteOpen(full_path);
}
예제 #13
0
string Unix_Utility::get_cwd()
{
   fs::path full_path(fs::initial_path<fs::path>() );
   full_path = fs::system_complete( "." );
   string tmp_str =  full_path.file_string();
   tmp_str.erase( tmp_str.size() - 1 );
   return tmp_str;
}
예제 #14
0
// OgreScriptBuilder
int OgreScriptBuilder::LoadScriptSection(const char* full_path_cstr)
{
    // Get filename - required to retrieve file from OGRe's resource system.
    //  This function received filename in older AngelScript versions, but now receives full path
    //      (reconstructed wrong by CScriptBuilder because it doesn't know about OGRE's ZIP files).
    //  TODO: Refactor the entire script building logic 
    //      - create fully RoR-custom builder instead of hacked stock CScriptBuilder + our overload. ~ only_a_ptr, 08/2017

    std::string full_path(full_path_cstr);
    std::string filename;
    size_t slash_pos = full_path.rfind('/'); // AngelScript always uses forward slashes in paths.
    if (slash_pos != std::string::npos)
    {
        filename = full_path.substr(slash_pos+1);
    }
    else
    {
        filename = full_path;
    }

    Ogre::DataStreamPtr ds;
    try
    {
        ds = Ogre::ResourceGroupManager::getSingleton().openResource(filename, Ogre::ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME);
                 //TODO: do not use `AUTODETECT_RESOURCE_GROUP_NAME`, use specific group, lookups are slow!
                 //see also https://github.com/OGRECave/ogre/blob/master/Docs/1.10-Notes.md#resourcemanager-strict-mode ~ only_a_ptr, 08/2017
    }
    catch (Ogre::Exception e)
    {
        LOG("[RoR|Scripting] exception upon loading script file '"+filename+"', message: " + e.getFullDescription());
        return -1;
    }
    // In some cases (i.e. when fed a full path with '/'-s on Windows), `openResource()` will silently return NULL for datastream. ~ only_a_ptr, 08/2017
    if (ds.isNull())
    {
        LOG("[RoR|Scripting] Failed to load file '"+filename+"', reason unknown.");
        return -1;
    }

    // Read the entire file
    std::string code;
    code.resize(ds->size());
    ds->read(&code[0], ds->size());

    // hash it
    {
        char hash_result[250];
        memset(hash_result, 0, 249);
        RoR::CSHA1 sha1;
        sha1.UpdateHash((uint8_t *)code.c_str(), (uint32_t)code.size());
        sha1.Final();
        sha1.ReportHash(hash_result, RoR::CSHA1::REPORT_HEX_SHORT);
        hash = Ogre::String(hash_result);
    }

    return ProcessScriptSection(code.c_str(), code.length(), filename.c_str(), 0);
}
예제 #15
0
BlockInputStreams StorageStripeLog::read(
    const Names & column_names,
    const SelectQueryInfo & /*query_info*/,
    const Context & context,
    QueryProcessingStage::Enum & processed_stage,
    const size_t /*max_block_size*/,
    unsigned num_streams)
{
    std::shared_lock<std::shared_mutex> lock(rwlock);

    check(column_names);
    processed_stage = QueryProcessingStage::FetchColumns;

    NameSet column_names_set(column_names.begin(), column_names.end());

    if (!Poco::File(full_path() + "index.mrk").exists())
        return { std::make_shared<NullBlockInputStream>() };

    CompressedReadBufferFromFile index_in(full_path() + "index.mrk", 0, 0, INDEX_BUFFER_SIZE);
    std::shared_ptr<const IndexForNativeFormat> index{std::make_shared<IndexForNativeFormat>(index_in, column_names_set)};

    BlockInputStreams res;

    size_t size = index->blocks.size();
    if (num_streams > size)
        num_streams = size;

    for (size_t stream = 0; stream < num_streams; ++stream)
    {
        IndexForNativeFormat::Blocks::const_iterator begin = index->blocks.begin();
        IndexForNativeFormat::Blocks::const_iterator end = index->blocks.begin();

        std::advance(begin, stream * size / num_streams);
        std::advance(end, (stream + 1) * size / num_streams);

        res.emplace_back(std::make_shared<StripeLogBlockInputStream>(
            *this, context.getSettingsRef().max_read_buffer_size, index, begin, end));
    }

    /// We do not keep read lock directly at the time of reading, because we read ranges of data that do not change.

    return res;
}
예제 #16
0
QString XmlLookupTable::lookup(const QString &path, bool *ok) const
{
    QHash<QString, Entry>::ConstIterator it = m_data.find(full_path(path));
    bool found = (it != m_data.end());
    if (ok)
        *ok = found;
    if (found)
        return it->data;
    else
        return QString(); // default
}
예제 #17
0
Directory::Ptr Directory::get_subdir(const char* name)
{
  ACE_TString t_name = ACE_TEXT_CHAR_TO_TCHAR(name);
  Map::iterator it = dirs_.find(t_name);

  if (it == dirs_.end()) {
    return make_new_subdir(t_name);

  } else {
    return new Directory(full_path(it->second), it->first, this);
  }
}
예제 #18
0
void AssetBrowser::openInExternalEditor(const char* path)
{
	StringBuilder<Lumix::MAX_PATH_LENGTH> full_path(m_editor.getEngine().getDiskFileDevice()->getBasePath(0));
	full_path << path;
	if (!PlatformInterface::fileExists(path))
	{
		full_path.data[0] = 0;
		full_path << m_editor.getEngine().getDiskFileDevice()->getBasePath(0);
		full_path << path;
	}
	PlatformInterface::shellExecuteOpen(full_path);
}
예제 #19
0
static std::string MakeProjectTitle(bool with_path_breakdown = false)
{
    ADatabase& db = AData();
    if( !db.IsProjectSet() )
        return "untitled.bmd";

    fs::path full_path(db.GetProjectFName());
    std::string res_str = fs::name_str(full_path);
    if( with_path_breakdown )
        res_str += " (" + full_path.branch_path().string() + ")";
    return res_str;
}
예제 #20
0
metafile * metafile::open(int dfd, const char * name, bool create)
{
	int fd;
	metafile * fp = NULL;
	mf_map_t::iterator itr;
	scopelock scope(mf_map_lock);
	istr path = full_path(dfd, name);
	if(!path)
		return NULL;
	MF_S_DEBUG("%s", path.str());
	itr = mf_map.find(path);
	if(itr != mf_map.end())
	{
		MF_S_DEBUG("cached");
		itr->second->usage++;
		return itr->second;
	}
	/* open read-write just to make sure we can */
	fd = openat(dfd, name, O_RDWR);
	if(fd < 0)
	{
		/* side effect: may non-transactionally create an empty file */
		fd = openat(dfd, name, O_RDWR | O_CREAT, 0644);
		if(fd < 0)
			return NULL;
		fp = new metafile(path);
		if(!fp)
			goto fail_close;
	}
	else
	{
		struct stat st;
		if(fstat(fd, &st) < 0)
			goto fail_close;
		fp = new metafile(path);
		if(!fp)
			goto fail_close;
		if(fp->data.set_size(st.st_size, false) < 0)
			goto fail_delete;
		if(st.st_size && pread(fd, &fp->data[0], st.st_size, 0) != st.st_size)
			goto fail_delete;
	}
	
	::close(fd);
	return fp;
	
fail_delete:
	delete fp;
fail_close:
	::close(fd);
	return NULL;
}
예제 #21
0
void Dictionary::loadDictionary()
{
    // Make sure data dictionary is loaded
    if (!dcmDataDict.isDictionaryLoaded())
    {
        ::boost::filesystem::path full_path(::boost::filesystem::initial_path< ::boost::filesystem::path >());
        std::string dicoPath = full_path.string() + "/share/" + PRJ_NAME + "_" + FWDICOMIOEXT_VER + "/dicom.dic";
        bool loaded = dcmDataDict.wrlock().loadDictionary(dicoPath.c_str());
        dcmDataDict.unlock();
        SLM_ASSERT("Unable to load DICOM dictionary !", loaded);
        SLM_TRACE("DICOM dictionary loaded !");
    }
}
예제 #22
0
bool file_utils::create_directories(const dynamic_string &path, bool remove_filename)
{
    dynamic_string path_to_create(path);

    full_path(path_to_create);

    if (remove_filename)
    {
        dynamic_string pn, fn;
        split_path(path_to_create.get_ptr(), pn, fn);
        path_to_create = pn;
    }

    return create_directories_from_full_path(path_to_create);
}
예제 #23
0
/*static*/ void CompilerTools::retrive_obj_path(const std::vector<std::string> &tokens, std::string &obj_path, std::string &obj_file)
{
    std::string path;
    std::vector<std::string>::const_iterator fo_itor = std::find_if(tokens.begin(), tokens.end(), string_finder_pred("/Fo"));
    if(fo_itor != tokens.end())
        path = ((*fo_itor).substr(3));

    StringTools::str_replace(path, "\\\\", "\\");
    StringTools::str_replace(path, "//", "//");
    StringTools::str_replace(path, "\"", "");

    boost::filesystem::path full_path(path);
    obj_path = full_path.branch_path().string();
    obj_file = full_path.filename().string();
}
예제 #24
0
File::Ptr Directory::get_file(const char* name)
{
  if (std::strlen(name) >= FSS_MAX_FILE_NAME) {
    throw std::runtime_error("file name too long");
  }

  ACE_TString t_name(ACE_TEXT_CHAR_TO_TCHAR(name));
  Map::iterator it = files_.find(t_name);

  if (it == files_.end()) {
    return make_new_file(t_name);

  } else {
    return new File(full_path(it->second), it->first, this);
  }
}
예제 #25
0
inline std::wstring GetFullPathNameWrapper(std::wstring const& path)
{
  std::vector<wchar_t> full_path(HADESMEM_DETAIL_MAX_PATH_UNICODE);
  DWORD len = GetFullPathNameW(path.c_str(),
                               static_cast<DWORD>(full_path.size()),
                               full_path.data(),
                               nullptr);
  if (!len || full_path.size() < len)
  {
    DWORD const last_error = ::GetLastError();
    HADESMEM_DETAIL_THROW_EXCEPTION(
      Error{} << ErrorString{"GetFullPathNameW failed."}
              << ErrorCodeWinLast{last_error} << ErrorCodeWinOther{len});
  }

  return full_path.data();
}
예제 #26
0
value
guestfs_int_mllib_full_path (value dirv, value namev)
{
  CAMLparam2 (dirv, namev);
  CAMLlocal1 (rv);
  const char *name = NULL;
  char *ret;

  if (namev != Val_int (0))
    name = String_val (Field (namev, 0));

  ret = full_path (String_val (dirv), name);
  rv = caml_copy_string (ret);
  free (ret);

  CAMLreturn (rv);
}
예제 #27
0
파일: mylibc.c 프로젝트: digcon9/sandbox
/* Is the given file replaced. Returns the replace name or NULL */
char* is_replaced(const char* filename){
	int i, count = (sizeof replaced_files) / (sizeof (struct replaced_file)); 
	char *full_name = full_path(filename);
	char *name = basename(full_name);
	strcpy(max_path, filename);
	char *dname = dirname(max_path);
	for(i = 0; i < count; i++){
		if(!strcmp(name, replaced_files[i].original)){
			if(!strcmp(dname, ".")){
				sprintf(max_path, "%s", replaced_files[i].replace);
			}
			else
				sprintf(max_path, "%s/%s", dname, replaced_files[i].replace);
			return max_path;
		}
	}
	return NULL;
}
예제 #28
0
int main( int argc, char* argv[] )
{ 
  fs::path full_path( fs::initial_path<fs::path>());

  if ( argc > 1 )
  {
    full_path = fs::system_complete( fs::path( argv[1]));
  }

  else
  {
    std::cout << "\nUsage: directoryScan [path]" << std::endl;
    return 0;
  }

  if (!fs::exists(full_path))
  {
    std::cout << "\nNot found: " << full_path.string() << std::endl;
    return 0;
  }

  if (fs::is_directory(full_path))
  { 
    //std::vector<fs::path> ret;
    unsigned long file_count = 0;
    std::cout<<"Is a valid directory"<<std::endl;
    const std::string ext = ".pcd";
    fs::recursive_directory_iterator it(full_path);
    fs::recursive_directory_iterator endit;

    while(it != endit)
    {  
      if(fs::is_regular_file(*it) && it->path().extension() == ext) 
      { 
       std::cout<<it->path().filename()<<std::endl;
       ++file_count;
        //ret.push_back(it->path().filename());
      }
      ++it;
    }
  }

  return 1;
}
예제 #29
0
                // test helpers
                std::string fixture_load(const std::string & fname)
                {
                    // glue paths together
                    boost::filesystem::path full_path(FIXTURES_DIR);
                    full_path /= fname.c_str();

                    // get a suitable string
                    std::string abs_fname =
                        boost::filesystem::canonical(full_path).string();

                    uintmax_t size = boost::filesystem::file_size(full_path);

                    // read the file into the vector
                    std::vector<char>(size).swap(m_data);
                    std::ifstream input(abs_fname.c_str());
                    input.read(&m_data[0], size);

                    return abs_fname;
                }
예제 #30
0
/**
 * Get the cached file as well as metadata associated with it.
 *
 * @return if the file exists on disk, a shared_ptr to the 
 * CachedFile object associated with the file; NULL shared_ptr
 * otherwise.  If the file is not in cache, it will be automatically
 * loaded.  If the cached object is out of date, it will be refreshed.
 */
bool FileCache::get_cached_object(const std::string& file_path, 
                                  CachedFilePtr& cached_file) {
    //Check if the file is already being cached.
    CachedFilesMap::const_iterator it = cached_files_.find(file_path);
    
    if (it == cached_files_.end()) {
        //Start caching the file.
        std::string full_path(file_root_ + file_path);
        cached_file = CachedFilePtr(new CachedFile(full_path, expiration_period_));
        cached_files_[file_path] = cached_file;
    
    } else {
        cached_file = it->second;
    }
    
    //Get the file contents.
    const bool found_file = cached_file->refresh_if_expired();
    
    return found_file;
}