NodeRepository.h

Go to the documentation of this file.

/*******************************************************************************
 *
 * Copyright (c) 2008-2010 Michael Schulze <mschulze@ivs.cs.uni-magdeburg.de>
 *               2009-2010 Michael Kriese <kriese@cs.uni-magdeburg.de>
 * All rights reserved.
 *
 *    Redistribution and use in source and binary forms, with or without
 *    modification, are permitted provided that the following conditions
 *    are met:
 *
 *    * Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *
 *    * Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in
 *      the documentation and/or other materials provided with the
 *      distribution.
 *
 *    * Neither the name of the copyright holders nor the names of
 *      contributors may be used to endorse or promote products derived
 *      from this software without specific prior written permission.
 *
 *
 *    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 (INCLUDING, BUT NOT
 *    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 *    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 *    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 * $Id$
 *
 ******************************************************************************/
#ifndef __NodeRepository_hpp__
#define __NodeRepository_hpp__

#include <map>
#include <list>
#include <ctime>
#include "boost/noncopyable.hpp"
#include "boost/shared_ptr.hpp"
#include "boost/shared_container_iterator.hpp"
#include <boost/mpl/for_each.hpp>
#include "mw/common/Subject.h"
#include "mw/nl/awds/MAC.h"
#include "mw/nl/awds/Node.h"
#include "mw/nl/awds/Attributes.h"
#include "mw/nl/awds/ComparableAttributeSet.h"

namespace famouso {
    namespace mw {
        namespace nl {
            namespace awds {

                typedef ComparableAttributeSet<AWDSAttributeSet::type> Attributes;

                typedef detail::Node<AWDSAttributeSet::type> Node;

                class NodeRepository: boost::noncopyable {

                    public:

                        typedef NodeRepository type;

                        typedef boost::shared_container_iterator<std::list<Node::type> > NodeIterator;

                        typedef famouso::mw::Subject SNN;

                    private:

                        class Subscriber: boost::noncopyable {

                                clock_t _time; 
                                Subscriber() :
                                    _time(std::clock()) {
                                }

                            public:

                                typedef boost::shared_ptr<Subscriber> type;

                                static type Create(Attributes::type a, FlowId fId = 0) {
                                    type res = type(new Subscriber());
                                    res->attribs = a;
                                    res->flowId = fId;
                                    return res;
                                }

                                int elapsed() const {
                                    return static_cast<int> (std::clock() - _time);
                                }

                                Attributes::type attribs; 
                                FlowId flowId; 
                        };

                        template< class AttrSet >
                        class attr_finder {
                                typedef typename AttrSet::sequence Seq;

                                AttrSet &_res; 
                                Attributes::type &_pub, 
                                &_sub; 
                                attr_finder(AttrSet &res, Attributes::type &pub, Attributes::type &sub) :
                                    _res(res), _pub(pub), _sub(sub) {
                                }

                            public:

                                static void apply(AttrSet &res, Attributes::type &pub, Attributes::type &sub) {
                                    boost::mpl::for_each<Seq>(attr_finder(res, pub, sub));
                                }

                                template< class Attrib >
                                void operator()(Attrib a) {
                                    typedef typename Attrib::comparator cmp;

                                    if (!Attrib::highDensity)
                                        return; // Only high density attributes are searched.

                                    // The resulting attribute
                                    Attrib *r = _res.template find_rt<Attrib> ();
                                    // the publisher attribute
                                    Attrib *p = _pub->template find<Attrib> ();
                                    // the subscriber attribute
                                    Attrib *s = _sub->template find<Attrib> ();

                                    if (p) {
                                        // publisher attibute is defined
                                        if (s && cmp::apply_runtime(p->getValue(), s->getValue()))
                                            // subscriber attribute is also defined and stricter, so use this
                                            r->setValue(s->getValue());
                                        else
                                            // subscriber attribute not defined or not stricter, so use publisher attribute
                                            r->setValue(p->getValue());
                                    } else if (s) {
                                        // only subscriber attibute is defined
                                        r->setValue(s->getValue());
                                    } else
                                        log::emit<AWDS>() << "Missing attribute with id " << (int) Attrib::id << log::endl;
                                }
                        };

                        typedef std::list<Node::type> NodeList;

                        typedef std::map<Node::type, Subscriber::type, Node::comp> NodeSubscriberMap;

                        typedef std::map<SNN, boost::shared_ptr<NodeSubscriberMap> > SubscriberMap;

                        typedef std::map<SNN, Attributes::type> PublisherMap;

                        //typedef std::list<Node::type, Node::comp> NodeList;

                        NodeRepository();

                        Subscriber::type findSub(Node::type &node, SNN subject);

                    public:

                        static type& getInstance();

                        Node::type find(MAC &mac);

                        std::pair<NodeIterator, NodeIterator> find(SNN subject);

                        FlowId flowid(Node::type &node, SNN subject);

                        int elapsed(Node::type &node, SNN subject);

                        template< class AttrSet >
                        void find(Node::type &node, SNN subject, AttrSet &cas) {
                            Attributes::type subAttr, pubAttr = _snnAttribs[subject];

                            // find the subsciber
                            Subscriber::type s = findSub(node, subject);
                            if (s) // we found the subscriber
                                subAttr = s->attribs; // get the subscriber attributes

                            if (pubAttr && subAttr)
                                attr_finder<AttrSet>::apply(cas, pubAttr, subAttr);
                            else
                                log::emit<AWDS>() << "Missing attributes of subscriber or publisher." << log::endl;
                        }

                        void remove(Node::type &node);

                        void remove(SNN &subject);

                        void reg(Node::type &node, SNN &subject, Attributes::type &attribs);

                        void reg(SNN subject, Attributes::type &attribs);

                        void unreg(Node::type &node);

                        void unreg(Node::type &node, SNN subject);

                        void update(Node::type &node, SNN subject, FlowId fId);

                    private:
                        SubscriberMap _snnmap; 
                        NodeList _nodes; 
                        PublisherMap _snnAttribs; 
                };

            } /* namespace awds */
        } /* namespace nl */
    } /* namespace mw */
} /* namespace famouso */
#endif /* __ClientRepository_hpp__ */