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

bool RLogMill::findRepository(boost::filesystem::path& dir, std::string& log_format) {

    dir = absolute(dir);

    //fprintf(stderr, "find repository from initial path: %s\n", dir.string().c_str());

    while(is_directory(dir)) {

             if(is_directory(dir / ".git")) log_format = "git";
        else if(is_directory(dir / ".hg"))  log_format = "hg";
        else if(is_directory(dir / ".bzr")) log_format = "bzr";
        else if(is_directory(dir / ".svn")) log_format = "svn";

        if(!log_format.empty()) {
            //fprintf(stderr, "found '%s' repository at: %s\n", log_format.c_str(), dir.string().c_str());
            return true;
        }

        if(!dir.has_parent_path()) return false;

        dir = dir.parent_path();
    }

    return false;
}

boost::optional<fs::path> HeaderTagger::toUserLibHeader(const fs::path& path) const {
	static const boost::optional<fs::path> fail;

	if(userIncludeDirs.empty()) { return fail; }

	if(contains(userIncludeDirs, fs::canonical(path))) { return fs::path(); }

	if(!path.has_parent_path()) { return fail; }

	// if it is within the user-added-include directory, build relative path
	auto res = toUserLibHeader(path.parent_path());
	return (res) ? (*res / path.filename()) : fail;
}

/**
 * A utility function cutting down std-lib header files.
 */
boost::optional<fs::path> HeaderTagger::toStdLibHeader(const fs::path& path) const {
	static const boost::optional<fs::path> fail;

	if(stdLibDirs.empty()) { return fail; }

	if(contains(stdLibDirs, fs::canonical(path))) { // very expensive, keep low use
		return fs::path();
	}

	if(!path.has_parent_path()) { return fail; }

	// if it is within the std-lib directory, build relative path
	auto res = toStdLibHeader(path.parent_path());
	return (res) ? (*res / path.filename()) : fail;
}

void path_init( const std::string &repo )
{
   path_repo = repo;

   while ( true )
   {
      if ( boost::filesystem::exists( path_repo / path_bak ) )
         break;

      if ( path_repo.has_parent_path( ) )
         path_repo = path_repo.parent_path( );
      else
         break;
   }
}

bool IsInside(const fs::path& path, const fs::path& directory) {
    const fs::path target = fs::canonical(directory);

    if (!path.has_parent_path()) {
        return false;
    }

    fs::path cur = path.parent_path();
    while (cur.has_parent_path()) {
        if (cur == target) {
            return true;
        } else {
            cur = cur.parent_path();
        }
    }
    return false;
}

static bool Path::mkdir(const boost::filesystem::path& path, bool recurse)
try {
	if (recurse) {
		if (path.has_parent_path()) {
			boost::filesystem::path parent = path.parent_path();
			if (!boost::filesystem::exists(parent)) {
				mkdir(parent, recurse);
			}
		}
		if (boost::filesystem::is_directory(path)) {
			return true;
		}
	}
	return boost::filesystem::create_directory(path);
} catch (boost::filesystem::basic_filesystem_error<boost::filesystem::path>& e) {
	return false;
}

    /** Find local sub directories of \p path. */
    std::vector<std::string> FindLocalRelativeDirs(const fs::path& path) {
        std::vector<std::string> dirs;
        if (path.has_parent_path() && path.parent_path() != path) {
                dirs.push_back("..");
        }

        fs::directory_iterator end_it;
        for (fs::directory_iterator it(path); it != end_it; ++it) {
            if (fs::is_directory(it->path())) {
                fs::path last_bit_of_path = it->path().filename();
                std::string utf8_dir_name = PathToString(last_bit_of_path);
                DebugLogger() << "SaveFileDialog::FindLocalRelativeDirs name: " << utf8_dir_name
                              << " valid UTF-8: " << IsValidUTF8(utf8_dir_name);
                dirs.push_back(utf8_dir_name);
            }
        }

        return dirs;
    }

  static boost::filesystem::path system_absolute(
      const boost::filesystem::path path)
  {
    if (path.empty())
      return path;

    if (path.is_absolute())
      return path;

    if (path.has_parent_path())
      return bfs::system_complete(path);

    if (!bfs::exists(path) || bfs::is_directory(path))
    {
      std::string envPath = qi::os::getenv("PATH");
      size_t begin = 0;
#ifndef _WIN32
      static const char SEPARATOR = ':';
#else
      static const char SEPARATOR = ';';
#endif
      for (size_t end = envPath.find(SEPARATOR, begin);
          end != std::string::npos;
          begin = end + 1, end = envPath.find(SEPARATOR, begin))
      {
        std::string realPath = envPath.substr(begin, end - begin);
        bfs::path p(realPath);

        p /= path;
        p = boost::filesystem::system_complete(p);

        if (boost::filesystem::exists(p) &&
            !boost::filesystem::is_directory(p))
          return p.string(qi::unicodeFacet());
      }
    }

    // fallback to something
    return bfs::system_complete(path);
  }

auto	detect_file_or_url( const fs::path & file, const fs::path & saveTo, double k ) {
	auto isExists = fs::exists( file );
	auto isUrl = is_url( file );
	if ( !isExists && !isUrl ) {
		std::cout << "File or directory " << file << " not is exists" << std::endl;
		return -1;
	}

	auto outDir = saveTo.empty() ? ( file.has_parent_path() ? file.parent_path() : "./" ) : saveTo;
	if ( !isUrl ) {
		outDir /= file.stem();
	}

	if ( !fs::exists( outDir ) && !fs::create_directories( outDir ) ) {
		std::cout << "Unable to create directory " << outDir << std::endl;
		return -1;
	}

	std::cout << "Begin. k = " << k << "." << std::endl;
	std::cout << "Input " << ( isUrl ? "url" : "file" ) << " is " << file << std::endl;
	std::cout << "Files save to " << outDir << std::endl;
	
	return detect( file.string(), outDir.string(), k );
}

      // Read parameter from spec file.
      // Return true if read succeeded.
      bool XMLSpecReaderImpl::read(const std::string& filePath)
      {
        // Read XML file.
        boost::property_tree::ptree root;
        boost::property_tree::read_xml(filePath, root);

        // Set current directory.
        const boost::filesystem::path oldPath = boost::filesystem::current_path();
        const boost::filesystem::path currentPath = boost::filesystem::path(filePath);
        if(currentPath.has_parent_path())
          boost::filesystem::current_path(currentPath.parent_path());

        // Read fields.
        // name
        if( boost::optional<std::string> value = root.get_optional<std::string>("animation.<xmlattr>.name") )
        {
          _name = value.get();
        }

        // loops
        if( boost::optional<unsigned int> value = root.get_optional<unsigned int>("animation.<xmlattr>.loops") )
        {
          _loops = value.get();
        }

        // skip_first
        if( boost::optional<bool> value = root.get_optional<bool>("animation.<xmlattr>.skip_first") )
        {
          _skipFirst = value.get();
        }

        // delay
        Delay defaultDelay = { DEFAULT_FRAME_NUMERATOR, DEFAULT_FRAME_DENOMINATOR };
        if( boost::optional<std::string> value = root.get_optional<std::string>("animation.<xmlattr>.default_delay") )
        {
          if( !str2delay(value.get(), &defaultDelay) )
          {
            defaultDelay.num = DEFAULT_FRAME_NUMERATOR;
            defaultDelay.den = DEFAULT_FRAME_DENOMINATOR;
          }
        }

        // frames
        if( boost::optional<boost::property_tree::ptree&> child = root.get_child_optional("animation") )
        {
          BOOST_FOREACH(const boost::property_tree::ptree::value_type& current, child.get())
          {
            std::string file;
            Delay delay;
            const boost::property_tree::ptree& frame = current.second;

            // filepath
            if( boost::optional<std::string> value = frame.get_optional<std::string>("<xmlattr>.src") )
            {
              file = value.get();
            }
            if(file.empty())
              continue;

            // delay
            if( boost::optional<std::string> value = frame.get_optional<std::string>("<xmlattr>.delay") )
            {
              if( !str2delay(value.get(), &delay) )
                delay = defaultDelay;
            }
            else
            {
              delay = defaultDelay;
            }

            // Add frame informations.
            const FrameInfo frameInfo = { boost::filesystem::absolute(file).string(), delay };
            _frameInfos.push_back(frameInfo);
          }
        }