Path.h

Go to the documentation of this file.

//   ____   __                  __  __
// /\__  _\/\ \                /\ \/\ \
// \/_/\ \/\ \ \___      __    \ \ \_\ \    ___   __  __    ____     __
//    \ \ \ \ \  _ `\  /'__`\   \ \  _  \  / __`\/\ \/\ \  /',__\  /'__`\
//     \ \ \ \ \ \ \ \/\  __/    \ \ \ \ \/\ \L\ \ \ \_\ \/\__, `\/\  __/
//      \ \_\ \ \_\ \_\ \____\    \ \_\ \_\ \____/\ \____/\/\____/\ \____\
//       \/_/  \/_/\/_/\/____/     \/_/\/_/\/___/  \/___/  \/___/  \/____/
 
 
#pragma once
#include <string>
 
#include "Framework/Engine.h"
#include "Framework/GameObject.h"
 
#include "System/SceneManager.h"
 
#include "Utility/Path/PathException.h"
#include "Utility/Path/private/PathBase.h"
#include "Utility/Path/private/PathDir.h"
#include "Utility/Path/private/PathFilter.h"
#include "Utility/Path/private/PathName.h"
#include "Utility/Path/private/PathNode.h"
#include "Utility/Path/private/PathRoot.h"
#include "Utility/Path/private/PathUp.h"
 
 
namespace gobj
{

template <typename Gobj = GameObject>
class Path
{
public:
    static auto bindLuaTypes(sol::state& lua) -> void
    {
    }
    
    using value_type = Gobj;
 
    
    
    explicit Path(std::string pathString)
        : path(std::make_unique<PathRoot>())
    {
        switch (pathString[0])
        {
        case '~':
        {
            path       = std::make_shared<PathBase>(*Engine::getSystem<sys::SceneManager>()->getCurrentScene());
            pathString = pathString.substr(1);
            break;
        }
        case '^':
        {
            pathString = pathString.substr(1);
            break;
        }
        case '/':
        {
            path = std::make_shared<PathRoot>();
            break;
        }
        case '.':
        {
            // do nothing
            assert(false && "Cannot create a path that starts with . without passing a gameObject as base");
            break;
        }
        default:
        {
            break;
        }
        }
 
        // parse path, getting rid of the first 2 characters
        parsePath(pathString);
 
 
    }
 

    Path(std::string pathString, GameObject& rootObject)
    {
        assert(pathString[0] == '.');
        path = std::make_shared<PathBase>(rootObject);
        // remove the first character, so we don't have an extra directory marker 
        // (the other dir marker will be removed at the end of this function)
        pathString = pathString.substr(1);
 
        parsePath(pathString);
    }
 

    operator Gobj&()
    {
        return *begin();
    }

    operator Gobj*()
    {
        return get();
    }

    operator const Gobj&()
    {
        return *begin();
    }
 
private:
    // path objects
 
    // possibly cache begin and end to optimize
    // begin_
    // end_

    std::shared_ptr<PathNode> path;
 
public:
    class iterator
    {

        explicit iterator(PathNode::path_iterator itr)
            : itr(std::move(itr))
        {
        }
 
    public:
        friend Path;
 
        // Part of making iterators stl compliant is declaring public types
        using difference_type = std::ptrdiff_t;
        using value_type      = Gobj;

        iterator() = default;

        auto get() const -> Gobj*
        {
            auto result = dynamic_cast<Gobj*>(itr.get());
            if (!result)
            {
                throw PathException("Path iterator called get() on GameObject that isn't same type as iterator");
            }
            return result;
        }

        auto operator++() -> iterator&
        {
            ++itr;
            return *this;
        }

        auto operator++(int) -> iterator
        {
            auto copy = *this;
            ++*this;
            return copy;
        }

        auto operator==(iterator other) const -> bool
        {
            return itr == other.itr;
        }

        auto operator*() const -> std::add_lvalue_reference_t<Gobj>
        {
            auto result = dynamic_cast<Gobj*>(itr.get());
            if (result == nullptr)
            {
                throw PathException("Path iterator dereferenced GameObject that isn't same type as iterator");
            }
            return *result;
        }

        auto operator->() const -> Gobj*
        {
            return get();
        }
 
    private:
        PathNode::path_iterator itr;
 
    };
 
    // Check to make sure Path::iterator is stl compliant
    static_assert(std::input_iterator<iterator>);
    static_assert(std::sentinel_for<iterator, iterator>);
 

    auto begin() const -> iterator
    {
        return static_cast<iterator>(path->begin());
    }
 

    auto end() const -> iterator
    {
        return static_cast<iterator>(path->end());
    }

    auto get() const -> Gobj*
    {
        return begin().get();
    }

    auto operator->() const -> Gobj*
    {
        return get();
    }
 
    // helper functions
private:
    static auto splitString(const std::string& fullString, const std::string& delimiter) -> std::vector<std::string>
    {
        size_t start         = 0;
        auto end             = delimiter.length();
        auto delimiterLength = delimiter.length();
        std::string token;
        std::vector<std::string> result;
 
        while ((end = fullString.find(delimiter, start)) != std::string::npos)
        {
            token = fullString.substr(start, end - start);
            start = end + delimiterLength;
            result.push_back(token);
        }
 
        result.push_back(fullString.substr(start));
        return result;
    }
 
    void addFilterBasedOnType()
    {
        // if we are Component path
        if (std::is_same_v<Gobj, Component>)
        {
            path->appendPathNode(std::make_shared<PathFilter>(
                    [](const GameObject& g)
                    {
                        return g.isType(Type::Component);
                    }
                    ));
        }
        // if we are an entity path
        else if (std::is_same_v<Gobj, Entity>)
        {
            path->appendPathNode(std::make_shared<PathFilter>(
                    [](const GameObject& g)
                    {
                        return g.isType(Type::Entity);
                    }
                    ));
        }
        // if we are a System path
        else if (std::is_same_v<Gobj, System>)
        {
            path->appendPathNode(std::make_shared<PathFilter>(
                    [](const GameObject& g)
                    {
                        return g.isType(Type::System);
                    }
                    ));
        }
        // if we are a path to a something other than a general GameObject, or general System 
        // (so any specific Component, or any specific System) 
        // (also some other things, but you can't make Paths to them)
        else if (!std::is_same_v<Gobj, GameObject> && !std::is_same_v<Gobj, System>)
        {
            path->appendPathNode(std::make_shared<PathFilter>(
                    [](const GameObject& g)
                    {
                        // return true if `g` is of type Gobj
                        return !!(dynamic_cast<const Gobj*>(&g));
                    }
                    ));
        }
    }

    auto parsePath(const std::string& pathString) -> void
    {
        // get rid of first token
        std::string dir = "/";
 
        auto nodes = splitString(pathString, dir);
 
        for (auto itr = nodes.begin(); itr != nodes.end(); ++itr)
        {
            // don't do this the first time, or if we are going to add an Up
            if (itr != nodes.begin() && *itr != "..")
            {
                path->appendPathNode(std::make_shared<PathDir>());
 
            }
            if (*itr == "..")
            {
                path->appendPathNode(std::make_shared<PathUp>());
            }
            else if (*itr == "")
            {
            }
            else
            {
                path->appendPathNode(std::make_shared<PathName>(*itr));
            }
        }
 
        // add a filter to the end to only look at the objects we care about
        // if we have a range, ie a `/` at the end
        if (nodes.back().empty())
        {
            addFilterBasedOnType();
        }
    }
 
};

template<std::derived_from<GameObject> Gobj, typename ... Args>
constexpr auto FormatPath(const std::format_string<Args...>&& fmt_path, Args&&... args) -> Path<Gobj>
{
    return Path<Gobj>(std::format(fmt_path, std::forward<Args>(args)...));
}
 

template<std::derived_from<GameObject> Gobj, typename ... Args>
constexpr auto FormatPath(GameObject& rootObject, const std::format_string<Args...>&& fmt_path, Args&&... args) -> Path<Gobj>
{   
    return Path<Gobj>(std::format(fmt_path, std::forward<Args>(args)...), rootObject);
}
 

 
}