C++ path::relative_path方法代码示例

boost::filesystem::path naive_uncomplete(boost::filesystem::path const path, 
    boost::filesystem::path const base) {
    if (path.has_root_path()){
        if (path.root_path() != base.root_path()) {
            return path;
        } else {
            return naive_uncomplete(path.relative_path(), base.relative_path());
        }
    } else {
        if (base.has_root_path()) {
            throw "cannot uncomplete a path relative path from a rooted base";
        } else {
            typedef boost::filesystem::path::const_iterator path_iterator;
            path_iterator path_it = path.begin();
            path_iterator base_it = base.begin();
            while ( path_it != path.end() && base_it != base.end() ) {
                if (*path_it != *base_it) break;
                ++path_it; ++base_it;
            }
            boost::filesystem::path result;
            for (; base_it != base.end(); ++base_it) {
                result /= "..";
            }
            for (; path_it != path.end(); ++path_it) {
                result /= *path_it;
            }
            return result;
        }
    }
}

/**
 * Iterate over a directory.
 *
 * @param dir Directory to iterate over.
 */
void Dir_Parse::iterate(fs::path dir) {
	fs::directory_iterator end_iter;
	vector<fs::path> dirs;

	#ifdef DEBUG
	cout << endl << "==== " << string(dir.relative_path().c_str()).substr(cut_path) << " ===="  << endl;
	#endif

	for (fs::directory_iterator dir_itr(dir); dir_itr != end_iter; ++dir_itr) {
		try {
			// Ignore hidden directories.
			if (dir_itr->path().filename().c_str()[0] != '.') {
				if (fs::is_directory(dir_itr->status())) {
					// Directory
					#ifdef DEBUG
					cout << dir_itr->path().filename() << " - Directory" << endl;
					#endif

					dirs.push_back(dir_itr->path());
				} else if (fs::is_regular_file(dir_itr->status())) {
					// File
					vector<string> datasheet;
					vector<string> tags = get_tags(dir_itr->path());

					datasheet.push_back(string(dir_itr->path().c_str()));
					datasheet.push_back(boost::algorithm::join(tags, ","));

					datasheets.push_back(datasheet);

					#ifdef DEBUG
					cout << trim_path(dir_itr->path()) << endl;
					cout << dir_itr->path().filename() << " - File" << endl;

					for (size_t i = 0; i < tags.size(); ++i) {
						cout << tags[i];

						if (i < tags.size() - 1) {
							cout << ", ";
						} else {
							cout << endl << endl;
						}
					}
					#endif
				}
				#ifdef DEBUG
				else {
					// Other
					cout << dir_itr->path().filename() << ": WTF is this?!" << endl;
				}
				#endif
			}
		} catch (const exception &e) {
			cout << dir_itr->path().filename() << ": " << e.what() << endl;
		}
	}

	for (size_t i = 0; i < dirs.size(); ++i) {
		iterate(dirs[i]);
	}
}

CryDevice::BlobWithParent CryDevice::LoadBlobWithParent(const bf::path &path) {
  optional<unique_ref<DirBlobRef>> parentBlob = none;
  optional<unique_ref<FsBlobRef>> currentBlobOpt = _fsBlobStore->load(_rootKey);
  if (currentBlobOpt == none) {
    LOG(ERROR) << "Could not load root blob. Is the base directory accessible?";
    throw FuseErrnoException(EIO);
  }
  unique_ref<FsBlobRef> currentBlob = std::move(*currentBlobOpt);

  for (const bf::path &component : path.relative_path()) {
    auto currentDir = dynamic_pointer_move<DirBlobRef>(currentBlob);
    if (currentDir == none) {
      throw FuseErrnoException(ENOTDIR); // Path component is not a dir
    }

    auto childOpt = (*currentDir)->GetChild(component.c_str());
    if (childOpt == boost::none) {
      throw FuseErrnoException(ENOENT); // Child entry in directory not found
    }
    Key childKey = childOpt->key();
    auto nextBlob = _fsBlobStore->load(childKey);
    if (nextBlob == none) {
      throw FuseErrnoException(ENOENT); // Blob for directory entry not found
    }
    parentBlob = std::move(*currentDir);
    currentBlob = std::move(*nextBlob);
  }

  return BlobWithParent{std::move(currentBlob), std::move(parentBlob)};

  //TODO (I think this is resolved, but I should test it)
  //     Running the python script, waiting for "Create files in sequential order...", then going into dir ~/tmp/cryfs-mount-.../Bonnie.../ and calling "ls"
  //     crashes cryfs with a sigsegv.
  //     Possible reason: Many parallel changes to a directory blob are a race condition. Need something like ParallelAccessStore!
}

 void
 TeaSafe::removeDeletedParentFromCache(boost::filesystem::path const &path)
 {
     auto it(m_folderCache.find(path.relative_path().string()));
     if (it != m_folderCache.end()) {
         m_folderCache.erase(it);
     }
 }

 boost::filesystem::path MultiresImagePlugin::MakePathRelative(boost::filesystem::path path, boost::filesystem::path base)
 {
   // Borrowed from: https://svn.boost.org/trac/boost/ticket/1976#comment:2
   if (path.has_root_path())
   {
     if (path.root_path() != base.root_path())
     {
       return path;
     }
     else
     {
       return MakePathRelative(path.relative_path(), base.relative_path());
     }
   }
   else
   {
     if (base.has_root_path())
     {
       ROS_WARN("Cannot uncomplete a path relative path from a rooted base.");
       return path;
     }
     else
     {
       typedef boost::filesystem::path::const_iterator path_iterator;
       path_iterator path_it = path.begin();
       path_iterator base_it = base.begin();
       while (path_it != path.end() && base_it != base.end())
       {
         if (*path_it != *base_it)
           break;
         ++path_it;
         ++base_it;
       }
       boost::filesystem::path result;
       for (; base_it != base.end(); ++base_it)
       {
         result /= "..";
       }
       for (; path_it != path.end(); ++path_it)
       {
         result /= *path_it;
       }
       return result;
     }
   }
 }

/**
 * Function to return list of images in a directory (searched recursively).
 * The output paths are w.r.t. the path imgsDir
 */
void genImgsList(const fs::path& imgsDir, vector<fs::path>& list) {
  if(!fs::exists(imgsDir) || !fs::is_directory(imgsDir)) return;
  vector<string> imgsExts = {".jpg", ".png", ".jpeg", ".JPEG", ".PNG", ".JPG"};

  fs::recursive_directory_iterator it(imgsDir);
  fs::recursive_directory_iterator endit;
  while(it != endit) {
    if(fs::is_regular_file(*it) && 
        find(imgsExts.begin(), imgsExts.end(), 
          it->path().extension()) != imgsExts.end())
      // write out paths but clip out the initial relative path from current dir 
      list.push_back(fs::path(it->path().relative_path().string().
            substr(imgsDir.relative_path().string().length())));
    ++it;
  }
  LOG(INFO) << "Found " << list.size() << " image file(s) in " << imgsDir;
}

SUBSHADERTYPE AssetManager::GetSubShaderTypeFromFile(boost::filesystem::path path)
{
  std::string subshaderfile = path.relative_path().stem().string();
  subshaderfile = subshaderfile.substr(subshaderfile.find("_") + 1);

  std::transform(subshaderfile.begin(), subshaderfile.end(), subshaderfile.begin(), ::tolower);

  SUBSHADERTYPE sstype;
  if (subshaderfile == VSfilstr)
    sstype = VERTEX_SHADER;
  else if (subshaderfile == PSfilstr)
    sstype = PIXEL_SHADER;
  else if (subshaderfile == CSfilstr)
	sstype = COMPUTE_SHADER;
  else if (subshaderfile == GSfilstr)
	sstype = GEOMETRY_SHADER;

  return sstype;
}

    void
    CoreFS::removeFolderFromCache(::boost::filesystem::path const &path)
    {

        auto strPath = path.relative_path().string();
        // need to reset root path if root, otherwise
        // we'll continue to use 'cached' version
        if(strPath == "/") {
            removeAllChildFoldersToo(path, m_rootFolder);
            m_rootFolder = std::make_shared<CompoundFolder>(m_io, m_io->rootBlock, "root");
            return;
        }

        // else belongs to cache
        auto it(m_folderCache.find(strPath));
        if (it != m_folderCache.end()) {
            removeAllChildFoldersToo(path, it->second);
            m_folderCache.erase(it);
        }
    }