FrameworkGraph.h

Go to the documentation of this file.

/*
 * Copyright (C) 2012 by
 *   MetraLabs GmbH (MLAB), GERMANY
 * and
 *   Neuroinformatics and Cognitive Robotics Labs (NICR) at TU Ilmenau, GERMANY
 * All rights reserved.
 *
 * Contact: info@mira-project.org
 *
 * Commercial Usage:
 *   Licensees holding valid commercial licenses may use this file in
 *   accordance with the commercial license agreement provided with the
 *   software or, alternatively, in accordance with the terms contained in
 *   a written agreement between you and MLAB or NICR.
 *
 * GNU General Public License Usage:
 *   Alternatively, this file may be used under the terms of the GNU
 *   General Public License version 3.0 as published by the Free Software
 *   Foundation and appearing in the file LICENSE.GPL3 included in the
 *   packaging of this file. Please review the following information to
 *   ensure the GNU General Public License version 3.0 requirements will be
 *   met: http://www.gnu.org/copyleft/gpl.html.
 *   Alternatively you may (at your option) use any later version of the GNU
 *   General Public License if such license has been publicly approved by
 *   MLAB and NICR (or its successors, if any).
 *
 * IN NO EVENT SHALL "MLAB" OR "NICR" BE LIABLE TO ANY PARTY FOR DIRECT,
 * INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF
 * THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF "MLAB" OR
 * "NICR" HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * "MLAB" AND "NICR" SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING,
 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
 * ON AN "AS IS" BASIS, AND "MLAB" AND "NICR" HAVE NO OBLIGATION TO
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS OR MODIFICATIONS.
 */

#ifndef _MIRA_FRAMEWORKGRAPH_H_
#define _MIRA_FRAMEWORKGRAPH_H_

#include <string>

#include <serialization/adapters/std/list>
#include <serialization/adapters/boost/shared_ptr.hpp>
#include <geometry/Point.h>

#include <fw/AuthorityDescription.h>

#include <fw/Framework.h>
#include <fw/RemoteModule.h>

namespace mira {


template <int C, typename T>
class FrameworkGraphMixin : public T {};

template <int C> // note, the C helps us to generate different classes to avoid compiler warning concerning inaccessible base classes
class FrameworkGraphMixin<C,void> {};

template <typename NodeMixin = void,
          typename AuthorityNodeMixin=void,
          typename ChannelNodeMixin=void,
          typename NamespaceNodeMixin=void,
          typename FrameworkNodeMixin=void>
class FrameworkGraph : boost::noncopyable
{
    class EmptyMixin {};

public:

    class Node;
    typedef boost::shared_ptr<Node> NodePtr;

    class ChannelNode;
    typedef boost::shared_ptr<ChannelNode> ChannelNodePtr;

    class AuthorityNode;
    typedef boost::shared_ptr<AuthorityNode> AuthorityNodePtr;

    class NamespaceNode;
    typedef boost::shared_ptr<NamespaceNode> NamespaceNodePtr;

    class FrameworkNode;
    typedef boost::shared_ptr<FrameworkNode> FrameworkNodePtr;

    class Node : public FrameworkGraphMixin<0,NodeMixin>
    {
    public:
        virtual ~Node() {}

        virtual std::set<NodePtr> getAdjacentNodes() = 0;
    };

    class ChannelNode : public Node, public FrameworkGraphMixin<1,ChannelNodeMixin>
    {
    public:
        ChannelNode(const std::string& iID) : id(iID) {}
        bool operator==(const std::string& id) {
            return id==this->id;
        }

        virtual std::set<NodePtr> getAdjacentNodes()
        {
            std::set<NodePtr> nodes;
            foreach(auto p, mSubscribedAuthorities)
                nodes.insert(p);
            foreach(auto p, mPublishingAuthorities)
                nodes.insert(p);
            return nodes;
        }

        std::set<AuthorityNodePtr> getSubscribedAuthorities() {
            return mSubscribedAuthorities;
        }

        std::set<AuthorityNodePtr> getPublishingAuthorities() {
            return mPublishingAuthorities;
        }

        NamespaceNodePtr getNamespace() {
            return mNamespace;
        }

    public:

        std::string id;

    protected:
        friend class FrameworkGraph;
        std::set<AuthorityNodePtr> mSubscribedAuthorities;
        std::set<AuthorityNodePtr> mPublishingAuthorities;
        NamespaceNodePtr mNamespace;
    };

    class AuthorityNode : public Node, public FrameworkGraphMixin<2,AuthorityNodeMixin> {
    public:
        AuthorityNode(const AuthorityDescription& iDesc) : desc(iDesc) {}
        bool operator==(const std::string& id) {
            return id == (desc.ns / desc.id);
        }

    public:

        virtual std::set<NodePtr> getAdjacentNodes()
        {
            std::set<NodePtr> nodes;
            foreach(auto p, mSubscribedChannels)
                nodes.insert(p);
            foreach(auto p, mPublishedChannels)
                nodes.insert(p);
            return nodes;
        }

        std::set<ChannelNodePtr> getPublishedChannels() {
            return mPublishedChannels;
        }

        std::set<ChannelNodePtr> getSubscribedChannels() {
            return mSubscribedChannels;
        }

        NamespaceNodePtr getNamespace() {
            return mNamespace;
        }

        FrameworkNodePtr getFramework() {
            return mFramework;
        }

        std::map<AuthorityNodePtr, std::set<ChannelNodePtr>> getDependees() {
            std::map<AuthorityNodePtr, std::set<ChannelNodePtr>> nodes;
            foreach(auto c, mSubscribedChannels)
                foreach(auto a, c->getPublishingAuthorities())
                    nodes[a].insert(c);
            return nodes;
        }

        std::map<AuthorityNodePtr, std::set<ChannelNodePtr>> getDependers() {
            std::map<AuthorityNodePtr, std::set<ChannelNodePtr>> nodes;
            foreach(auto c, mPublishedChannels)
                foreach(auto a, c->getSubscribedAuthorities())
                    nodes[a].insert(c);
            return nodes;
        }


    public:

        AuthorityDescription desc;

    protected:
        friend class FrameworkGraph;
        std::set<ChannelNodePtr> mSubscribedChannels;
        std::set<ChannelNodePtr> mPublishedChannels;
        NamespaceNodePtr mNamespace;
        FrameworkNodePtr mFramework;
    };

    class NamespaceNode : public Node, public FrameworkGraphMixin<3,NamespaceNodeMixin> {
    public:
        NamespaceNode(const ResourceName& iNs) : ns(iNs) {}
        bool operator==(const ResourceName& iNs) {
            return iNs==ns;
        }

        static void setParent(NamespaceNodePtr child, NamespaceNodePtr parent) {
            assert(parent && child);
            parent->children.insert(child);
            child->parent = parent;
        }

    public:

        virtual std::set<NodePtr> getAdjacentNodes()
        {
            static std::set<NodePtr> empty;
            return empty;
        }

    public:

        ResourceName ns;

        NamespaceNodePtr parent;

        std::set<NamespaceNodePtr> children;

        std::set<NodePtr> nodes;
    };

    class FrameworkNode : public Node, public FrameworkGraphMixin<4,FrameworkNodeMixin> {
    public:
        FrameworkNode(const std::string& iName) : name(iName) {}
        bool operator==(const std::string& iName) {
            return iName==name;
        }

    public:

        virtual std::set<NodePtr> getAdjacentNodes()
        {
            static std::set<NodePtr> empty;
            return empty;
        }

    public:

        std::string name;

        std::set<NodePtr> nodes;
    };

public:

    FrameworkGraph() {
        // create a root namespace node
        mRootNamespace = getNamespaceNode(ResourceName("/"));
    }

    bool discover(boost::function<void()> changeCb = boost::function<void()>())
    {
        mGraphHasChanged = false; // <this variable is reseted several times
        bool graphHasChanged = false; // <this one holds whether the graph has any changes

        // Channels
        foreach(const std::string& id, MIRA_FW.getChannelManager().getChannels())
        {
            ChannelNodePtr node = getChannelNode(id);
        }

        graphHasChanged |= mGraphHasChanged;
        if(mGraphHasChanged && changeCb)
            changeCb();

        // Authorities
        // discovery of authorities may be a little time consuming, if
        // a lot of remote authorities and hence RPC calls are involved
        auto authorities = MIRA_FW.getAuthorityManager().getAuthorities();
        foreach(auto id, authorities)
        {
            mGraphHasChanged = false; // reset marker

            AuthorityNodePtr node = findPtr(mAuthorities, id);
            if(!node) {
                AuthorityDescription d = MIRA_FW.getAuthorityManager().getDescription(id);

                boost::mutex::scoped_lock lock(mMutex);
                node.reset(new AuthorityNode(d));
                mAuthorities.push_back(node);

                // Namespace
                NamespaceNodePtr ns = getNamespaceNode(d.ns);
                node->mNamespace = ns;
                ns->nodes.insert(node);

                // Framework
                std::string fwid = "local";
                foreach(const auto& connection, *(MIRA_FW.getRemoteModule()->getConnections()))
                {
                    if (connection.second->hasAuthority(id)) {
                        fwid = connection.second->getAddress().address;
                        break;
                    }
                }
                FrameworkNodePtr fw = getFrameworkNode(fwid);
                node->mFramework = fw;
                fw->nodes.insert(node);

                mGraphHasChanged = true;
            }

            // connections: Authorities -> Channels:
            auto publishedChannels = MIRA_FW.getAuthorityManager().getPublishedChannels(id);
            foreach(const std::string& channel, publishedChannels)
            {
                boost::mutex::scoped_lock lock(mMutex);
                ChannelNodePtr channelNode = getChannelNode(channel);
                mGraphHasChanged |= node->mPublishedChannels.insert(channelNode).second;
                mGraphHasChanged |= channelNode->mPublishingAuthorities.insert(node).second;
            }

            auto subscribedChannels = MIRA_FW.getAuthorityManager().getSubscribedChannels(id);
            foreach(const std::string& channel, subscribedChannels)
            {
                boost::mutex::scoped_lock lock(mMutex);
                ChannelNodePtr channelNode = getChannelNode(channel);
                mGraphHasChanged |= node->mSubscribedChannels.insert(channelNode).second;
                mGraphHasChanged |= channelNode->mSubscribedAuthorities.insert(node).second;
            }

            graphHasChanged |= mGraphHasChanged;
            if(mGraphHasChanged && changeCb)
                changeCb();
        }
        return graphHasChanged;
    }

private:

    ChannelNodePtr getChannelNode(const std::string& id)
    {
        ChannelNodePtr node = findPtr(mChannels, id);
        if(!node) {
            node.reset(new ChannelNode(id));
            mChannels.push_back(node);
            NamespaceNodePtr ns = getNamespaceNode(ResourceName(id).parent());
            node->mNamespace = ns;
            ns->nodes.insert(node);
            mGraphHasChanged = true;
        }
        return node;
    }

    NamespaceNodePtr getNamespaceNode(const ResourceName& ns)
    {
        NamespaceNodePtr node = findPtr(mNamespaces, ns);
        if(!node) {
            node.reset(new NamespaceNode(ns));
            mNamespaces.push_back(node);
            if(!node->ns.isRoot())
                integrateNamespaceNode(node);
            mGraphHasChanged = true;
        }
        return node;
    }

    FrameworkNodePtr getFrameworkNode(const std::string& name)
    {
        FrameworkNodePtr node = findPtr(mFrameworks, name);
        if(!node) {
            node.reset(new FrameworkNode(name));
            mFrameworks.push_back(node);
            mGraphHasChanged = true;
        }
        return node;
    }

public:

    std::list<NodePtr> getNodes() {
        std::list<NodePtr> nodes;
        std::copy(getChannels().begin(),getChannels().end(),std::back_inserter(nodes));
        std::copy(getAuthorities().begin(),getAuthorities().end(),std::back_inserter(nodes));
        return nodes;
    }

    std::list<ChannelNodePtr>& getChannels() {
        return mChannels; }

    template <typename Visitor>
    void visitAuthorities(Visitor&& visit){
        boost::mutex::scoped_lock lock(mMutex);
        for(auto&& auth: mAuthorities)
        {
            visit(auth);
        }
    }
    
    std::list<AuthorityNodePtr>& getAuthorities() {
        return mAuthorities; }

    std::list<NamespaceNodePtr>& getNamespaces() {
        return mNamespaces; }

    std::list<FrameworkNodePtr>& getFrameworks() {
        return mFrameworks; }

    NamespaceNodePtr getRootNamespace() {
        return mRootNamespace; }

    void integrateNamespaceNode(NamespaceNodePtr node)
    {
        assert(mRootNamespace);

        // find direct ancestor node
        NamespaceNodePtr ancestor = mRootNamespace;
        bool abort;
        do {
            abort = true;
            foreach(NamespaceNodePtr child, ancestor->children)
            {
                if(child->ns.isAncestorOf(node->ns)) {
                    ancestor = child;
                    abort = false;
                    break;
                }
            }
        } while(!abort);


        // now add all children from ancestor that are actually our children
        // and remove them from ancestor
        auto childrenSet = ancestor->children;
        foreach(NamespaceNodePtr child, childrenSet)
        {
            if(child->ns.isChildOf(node->ns)) {
                node->children.insert(child);
                ancestor->children.erase(child);
                child->parent = node;
            }
        }

        // add us as new child to the ancestor
        ancestor->children.insert(node);
        // which is our parent
        node->parent = ancestor;

        // check if 'ancestor' is direct namespace parent of 'node'
        // if not, add all missing namespaces between 'ancestor' and 'node' recursively,
        // beginning with the direct parent of 'node'
        auto parent_ns = node->ns.parent();
        if (parent_ns != ancestor->ns)
        {
            NamespaceNodePtr n(new NamespaceNode(parent_ns));
            mNamespaces.push_back(n);
            integrateNamespaceNode(n);
        }
    }

    /*
    2nd version of the above method, work in progress
    void integrateNamespaceNode2(NamespaceNodePtr node)
    {
        assert(mRootNamespace);

        NamespaceNodePtr parent = getNamespaceNode(node->ns.parent());
        parent->children.insert(node);
        node->parent = parent;
    }
    */

protected:

    boost::mutex mMutex;
    std::list<AuthorityNodePtr> mAuthorities;
    std::list<ChannelNodePtr> mChannels;
    std::list<NamespaceNodePtr> mNamespaces;
    std::list<FrameworkNodePtr> mFrameworks;
    NamespaceNodePtr mRootNamespace;

    bool mGraphHasChanged;



    template <typename Container, typename Key>
    typename Container::value_type findPtr(Container& c, const Key& key)
    {
        foreach(typename Container::value_type ptr, c)
            if(*ptr == key)
                return ptr;
        return typename Container::value_type();
    }
};


} // namespace

#endif