PathParseAndRetrieve.h

Go to the documentation of this file.

// Copyright 2014 Sensics, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef INCLUDED_PathParseAndRetrieve_h_GUID_C451663C_0711_4B85_2011_61D26E5C237C
#define INCLUDED_PathParseAndRetrieve_h_GUID_C451663C_0711_4B85_2011_61D26E5C237C

// Internal Includes
#include <osvr/Common/RoutingConstants.h>
#include <osvr/Common/RoutingExceptions.h>
#include <osvr/Util/TreeNode.h>

// Library/third-party includes
#include <boost/assert.hpp>
#include <boost/algorithm/string/find_iterator.hpp>
#include <boost/algorithm/string/finder.hpp>
#include <boost/range/adaptor/sliced.hpp>

// Standard includes
#include <string>

namespace osvr {
namespace common {
    namespace detail {
        struct GetOrCreateFunctor {
            template <typename Node>
            Node *operator()(Node *node, std::string const &component) const {
                return &(node->getOrCreateChildByName(component));
            }
        };

        struct GetChildFunctor {
            template <typename Node>
            Node const *operator()(Node const *node,
                                   std::string const &component) const {
                return &(node->getChildByName(component));
            }
        };
        enum ParentPolicy { GETPARENT_PERMIT, GETPARENT_DENY };
        enum AbsolutePolicy { ABSOLUTEPATH_PERMIT, ABSOLUTEPATH_DENY };

        template <typename GetChildFunctor, typename Node>
        inline Node &treePathRetrieveImplementation(
            GetChildFunctor f, Node &node, std::string path,
            ParentPolicy permitParent = GETPARENT_DENY,
            AbsolutePolicy permitAbsolute = ABSOLUTEPATH_PERMIT) {

            if (path.empty()) {
                return node;
            }
            Node *ret = &node;

            // Check for leading slash, indicating absolute path
            if (path.at(0) == getPathSeparatorCharacter()) {
                if (ABSOLUTEPATH_PERMIT != permitAbsolute) {
                    throw exceptions::ForbiddenAbsolutePath();
                }
                // Got it, so move to the root of the tree.
                while (!ret->isRoot()) {
                    ret = ret->getParent();
                }
                if (path == getPathSeparator()) {
                    // Literally just asking for the root.
                    return *ret;
                }
                // Remove the leading slash for the iterator's benefit.
                path.erase(begin(path));
            }

            // Remove any trailing slash
            if (path.back() == getPathSeparatorCharacter()) {
                path.pop_back();
            }

            // new scope for the iterators and loop:
            {
                // Create a boost string algorithm "split iterator" to iterate
                // through components of the path.
                auto begin = boost::algorithm::make_split_iterator(
                    path,
                    boost::first_finder(getPathSeparator(), boost::is_equal()));
                // Create the corresponding end iterator: same type as begin,
                // but default constructed.
                auto end = decltype(begin)();

                // Temporary string that will be re-used each pass through the
                // loop
                std::string component;

                // Use the iterators as a range in a loop, to process each
                // component of the path
                for (auto rangeIt : boost::make_iterator_range(begin, end)) {
                    // Extract the component to a string for interpretation.
                    component = boost::copy_range<std::string>(rangeIt);

                    // Interpret the component: four cases
                    if (component.empty()) {
                        // Empty components are forbidden
                        throw exceptions::EmptyPathComponent(path);
                    } else if (component == ".") {
                        // current location - go to the next component without
                        // changing location
                        continue;
                    } else if (component == "..") {
                        // parent path - must check for permission first, then
                        // possibility (root has no parent)
                        if (GETPARENT_PERMIT != permitParent) {
                            throw exceptions::ForbiddenParentPath();
                        }
                        if (ret->isRoot()) {
                            throw exceptions::ImpossibleParentPath();
                        }
                        ret = ret->getParent();
                    } else {
                        // A non-special string: just get the child
                        ret = f(ret, component);
                    }
                    // if we make it to here we've updated ret.
                }
            }

            return *ret;
        }

    } // namespace detail
    template <typename ValueType>
    inline util::TreeNode<ValueType> &
    treePathRetrieve(util::TreeNode<ValueType> &node, std::string path,
                     bool permitParent = false) {
        return detail::treePathRetrieveImplementation(
            detail::GetOrCreateFunctor(), node, path,
            permitParent ? detail::GETPARENT_PERMIT : detail::GETPARENT_DENY);
    }

    template <typename ValueType>
    inline util::TreeNode<ValueType> const &
    treePathRetrieve(util::TreeNode<ValueType> const &node, std::string path,
                     bool permitParent = false) {
        return detail::treePathRetrieveImplementation(
            detail::GetChildFunctor(), node, path,
            permitParent ? detail::GETPARENT_PERMIT : detail::GETPARENT_DENY);
    }

    template <typename ValueType>
    inline util::TreeNode<ValueType> &
    pathParseAndRetrieve(util::TreeNode<ValueType> &root,
                         std::string const &path) {
        BOOST_ASSERT_MSG(root.isRoot(), "Must pass the root node!");
        if (path.empty()) {
            throw exceptions::EmptyPath();
        }
        if (path == getPathSeparator()) {
            return root;
        }
        if (path.at(0) != getPathSeparatorCharacter()) {
            throw exceptions::PathNotAbsolute(path);
        }

        return treePathRetrieve(root, path);
    }

    template <typename ValueType>
    inline util::TreeNode<ValueType> const &
    pathParseAndRetrieve(util::TreeNode<ValueType> const &root,
                         std::string const &path) {
        BOOST_ASSERT_MSG(root.isRoot(), "Must pass the root node!");
        if (path.empty()) {
            throw exceptions::EmptyPath();
        }
        if (path == getPathSeparator()) {
            return root;
        }
        if (path.at(0) != getPathSeparatorCharacter()) {
            throw exceptions::PathNotAbsolute(path);
        }

        return treePathRetrieve(root, path);
    }
} // namespace common
} // namespace osvr

#endif // INCLUDED_PathParseAndRetrieve_h_GUID_C451663C_0711_4B85_2011_61D26E5C237C