Boost C++ Libraries: Ticket #1976: Inverse function for complete

me22.ca+boost@… — Thu, 21 Aug 2008 23:52:35 GMT

An additional use case for this came up on the users list: http://lists.boost.org/boost-users/2008/08/39597.php

The use case here is creating complete output paths for "copy-pasting a sub-tree from input_base_path to output_base_path" (ofcourse with some transformations along the way).

For now, I am using

  fs::wpath output_path=output_base_path;
  int k=0; for(fs::wpath::iterator
i=input_path.begin();i!=input_path.end();i++,k++) if(k>=7)
output_path/=(*i);

Again, 7 is the number of elements in input_base_path. advance() would make it atleast slightly cleaner (remove k, and the if on k), uncomplete would be ideal.

anonymous — Fri, 22 Aug 2008 00:56:14 GMT

Here's a naive implementation (that doesn't handle symlinks and isn't well tested):

#include <boost/filesystem.hpp>
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;
        }
    }
}

anonymous — Sat, 07 Feb 2009 02:58:40 GMT

I would like this functionality to be added as well. My use case is similar to the first one mentioned (wanting to persist relative paths).

anonymous — Sat, 21 Feb 2009 11:54:28 GMT

Getting paths relative to an arbitrary directory is a very useful feature. My use case is the same at the first one (it is an IDE which needs to store paths relative to project file).

tom@… — Mon, 06 Jul 2009 12:29:50 GMT

I would like this for a media application which should save lines in an M3U playlist as filepaths relative to the playlist path.

anonymous — Tue, 13 Jul 2010 19:24:40 GMT

This would be useful for me as well.

anonymous — Fri, 11 Mar 2011 10:07:46 GMT

This feature would be very useful for us, too. In a use case similar to the first one.

sorokin@… — Sun, 24 Apr 2011 20:08:57 GMT

Is there any plans to include this function is boost? Maybe under name relativize?

cc set

Thu, 08 Dec 2011 15:17:51 GMT

cc taylor@… added

anonymous — Thu, 08 Nov 2012 08:07:11 GMT

I'm interested in this feature too.

cc changed

Sun, 10 Feb 2013 02:46:50 GMT

cc boost@… added

anonymous — Mon, 27 Jan 2014 22:12:53 GMT

There a quite a few links on the internet linking here. This would be a great feature. I'd wonder how to make this portable though with drive letters on windows, reparse points, symlinks on *nix...

anonymous — Wed, 05 Mar 2014 16:47:33 GMT

There's an example at https://svn.boost.org/trac/boost/ticket/6249 , it relies only on lexicographic compare so doesn't handle links etc, but on the other hand I think the expected behavior of such a function is that it's entirely lexicographic on the path.

Sat, 15 Nov 2014 15:56:56 GMT

+1 for this as well

anonymous — Wed, 29 Jul 2015 00:29:20 GMT

I also need this!

status, milestone changed; resolution set

Beman Dawes — Sat, 05 Sep 2015 18:22:25 GMT

status new → closed
resolution → fixed
milestone Boost 1.36.0 → Boost 1.60.0

Boost 1.60.0 will add functions lexically_normal, lexically_relative, relative, and weakly_canonical. These are designed to provide the functionality requested by this ticket.

See http://boostorg.github.io/filesystem/relative_proposal.html for more information. It proposes additional lexical and operational proximate functions, but I have chosen not to include those now. They will be reconsidered once users get some field experience with the core functionality for computing relative paths.

These function are available now on the https://github.com/boostorg/filesystem develop branch, and will be merged to master as soon as sufficient regression tests have cycled. They will also be proposed for inclusion in the next version of the C++ committee's TS 18822, File System Technical Specification.

Many thanks to Jamie Allsop for his help and perseverance, and to everyone else who made suggestions and comments. Jamie's paper is available at https://github.com/ja11sop/std-filesystem-relative

Thanks,

--Beman