GatewayNode.h

Go to the documentation of this file.

/*
Copyright (c) 2013,
    Neuroinformatics and Cognitive Robotics Labs at TU Ilmenau, Germany

All rights reserved.

Copying, resale, or redistribution, with or without modification, is strictly
prohibited.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES,
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#pragma once

#include <set>

#include <topomap/TopoMapFwd.h>
#include <topomap/GraphElement.h>

#include <geometry/Line.h>

namespace viros { namespace topomap {
using namespace mira;


class Gateway
{
public:
    Gateway();

    static GatewayPtr create() {
        return boost::make_shared<Gateway>();
    }

    template<typename Reflector>
    void reflect(Reflector& r)
    {
        r.member("Line", line, "");
        r.member("Interrupt", interrupt, "");
    }

public:

    Line2i line;
    bool interrupt;
};

class GatewayNode : public AttributedGraphElement, public boost::enable_shared_from_this<GatewayNode>
{
public:
    friend class TopoMap;

    // to be created and destroyed by TopoMap only
    GatewayNode();
    ~GatewayNode();

    static GatewayNodePtr create() {
        return boost::make_shared<GatewayNode>();
    }

    GatewayNodePtr thisP() {
        return shared_from_this();
    }

public:

    template<typename Reflector>
    void reflect(Reflector& r)
    {
        r.member("Node", mNode, "");
        //r.member("Links", mLinks, ""); //TODO: maybe use this?
        r.member("Gateway", mGateway, "");
    }

public:

    const std::string getFullName() const;

    void addLink(LinkPtr link);
    void removeLink(LinkPtr link);

    NodePtr getNode() { return mNode; }
    const NodePtr getNode() const { return mNode; }

    void setGateway(GatewayPtr gw);
    GatewayPtr getGateway() { return mGateway; }
    const GatewayPtr getGateway() const { return mGateway; }

    GatewayNodePtr getParentGatewayNode();
    GatewayNodePtr getChildGatewayNode();

    const LinkSet& links() const { return mLinks; }


    class OutgoingLinkIterator : public std::iterator<std::forward_iterator_tag, LinkPtr>
    {
    public:
        typedef LinkPtr           value_type;
        typedef const value_type& reference;
        typedef const value_type* pointer;

        enum SpecialValue {
            BEGIN_ITERATOR,
            END_ITERATOR
        };
        OutgoingLinkIterator(GatewayNodePtr g, SpecialValue v = BEGIN_ITERATOR);

    public:

        bool operator==(const OutgoingLinkIterator& other) const;
        bool operator!=(const OutgoingLinkIterator& other) const;

        pointer operator->() { return mCurrent.operator->(); }
        reference operator*()  { return mCurrent.operator*(); }

        // prefix ++operator
        OutgoingLinkIterator& operator++() {
            advance();
            return *this;
        }

        LinkPtr link() { return *mCurrent; }

        GatewayNodePtr endpoint();

    private:

        void advance();
        void nextValid();

    private:
        LinkSet::iterator mCurrent;
        GatewayNodePtr mGatewayNode;
    };

    class OutgoingLinks
    {
    public:
        OutgoingLinks(GatewayNodePtr g) : mGatewayNode(g) {}

        typedef OutgoingLinkIterator iterator;
        typedef OutgoingLinkIterator const_iterator;

        iterator begin() const { return iterator(mGatewayNode, iterator::BEGIN_ITERATOR); }
        iterator end()   const { return iterator(mGatewayNode, iterator::END_ITERATOR); }
    private:
        GatewayNodePtr mGatewayNode;
    };

    OutgoingLinks outgoingLinks() { return OutgoingLinks(thisP()); }


public:

    virtual GraphElementPtr findElement(const std::string& predicate);

private:
    friend class Node;

    NodePtr mNode;
    LinkSet mLinks;

    GatewayPtr mGateway;
};

std::ostream& operator<<(std::ostream& os, const GatewayNode& gatewayNode);


} } // namespace