ComparableAttributeSet.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 _ComparableAttributeSet_h_
#define _ComparableAttributeSet_h_

#include <boost/shared_ptr.hpp>
#include <boost/shared_array.hpp>
#include <boost/noncopyable.hpp>
#include <boost/mpl/list.hpp>
#include <boost/asio/buffer.hpp>
#include "mw/attributes/AttributeSet.h"
#include "mw/attributes/filter/greater_than_or_equal_to.h"
#include "mw/attributes/filter/less_than_or_equal_to.h"
#include "mw/nl/awds/AWDS_Packet.h"
#include "mw/nl/awds/logging.h"

#include "mw/attributes/access/Attribute_RT.h"
#include "mw/attributes/access/AttributeSet_RT.h"

namespace famouso {
    namespace mw {
        namespace nl {
            namespace awds {
                namespace detail {
                    template< typename Comparator >
                    struct op_printer {
                            static const char* op() {
                                return (" ? ");
                            }
                    };
                    template< >
                    struct op_printer<famouso::mw::attributes::filter::less_than_or_equal_to> {
                            static const char* op() {
                                return (" <= ");
                            }
                    };
                    template< >
                    struct op_printer<famouso::mw::attributes::filter::greater_than_or_equal_to> {
                            static const char* op() {
                                return (" >= ");
                            }
                    };
                } /* namespace detail */

                /* \brief A class for holding attributes of publisher, subscriber or network.
                 *
                 * \tparam AttrSet An AttributesSet containing a list of attributes.
                 */
                template< class AttrSet = famouso::mw::attributes::AttributeSet<> >
                class ComparableAttributeSet: boost::noncopyable {

                    public:
                        typedef typename AttrSet::sequence AttrSeq;

                    private:
                        typedef boost::shared_array<uint8_t> pData;

                        pData data; 
                        template< class Seq, class Itr = typename boost::mpl::begin<Seq>::type >
                        class AttributeIterator {

                                typedef typename boost::mpl::deref<Itr>::type attrib;

                                typedef typename attrib::comparator cmp;

                                typedef typename boost::mpl::end<Seq>::type end;

                                static void echo(::logging::loggingReturnType &out, attrib *a) {
                                    if (a)
                                        out << (intmax_t) a->getValue();
                                    else
                                        out << "nd";
                                }

                                static bool match(const attrib *a, const attrib *b) {
                                    // if attrib b is empty check is always true
                                    if (!b)
                                        return true;

                                    // if attrib b is not empty, attrib a has to be not empty too, so check if it matches
                                    if (a && cmp::apply_runtime(a->getValue(), b->getValue()))
                                        return true;

                                    // attributes doesn't match
                                    return false;
                                }

                            public:

                                static bool match(AttrSet &a, AttrSet &b) {
                                    // find attributes
                                    attrib *l = a.template find_rt<attrib> ();
                                    attrib *r = b.template find_rt<attrib> ();

                                    ::logging::loggingReturnType &out = log::emit<ATTR>();

                                    out << "matching " << (int) attrib::id << ": ";
                                    echo(out, l);
                                    out << detail::op_printer<cmp>::op();
                                    echo(out, r);
                                    out << log::endl;

                                    // match attribute
                                    if (!match(l, r)) {
                                        log::emit<ATTR>() << "unsuccessfull" << log::endl;
                                        return false; // if attribs not match
                                    }

                                    // Check the next attribute in list
                                    return AttributeIterator<Seq, typename boost::mpl::next<Itr>::type>::match(a, b);
                                }

                                static void print(::logging::loggingReturnType &out, AttrSet &a) {
                                    // find the attribute
                                    attrib *attr = a.template find_rt<attrib> ();
                                    if (attr) {
                                        // found, so print name and value
                                        out << " [" << (int) attrib::id << "]={" << (intmax_t) attr->getValue() << "}";
                                    }

                                    // print next attribute in list
                                    AttributeIterator<Seq, typename boost::mpl::next<Itr>::type>::print(out, a);
                                }
                        };

                        template< class Seq >
                        class AttributeIterator<Seq, typename boost::mpl::end<Seq>::type> {
                            public:

                                static bool match(const AttrSet &a, const AttrSet &b) {
                                    log::emit<ATTR>() << "successfull" << log::endl;
                                    return true;
                                }

                                static void print(::logging::loggingReturnType &out, const AttrSet &a) {
                                }
                        };

                        /* \brief Copy the data to this instance.
                         *
                         * \param d the data pointer
                         * \param s the size of the data
                         */
                        void set(uint8_t *d, uint16_t s) {
                            static uint8_t p[1] = { 0 };

                            if (s <= 0) {
                                s = 1;
                                d = p;
                            }
                            data = pData(new uint8_t[s]);
                            std::memcpy(data.get(), d, s);

                        }

                        static uint16_t size(uint8_t* data) {

                            if (!data) // just to be a little secure.
                                return 0;

                            typedef famouso::mw::attributes::access::AttributeSet_RT *AS;

                            const AS set_rt = reinterpret_cast<const AS> (&data[0]);

                            return set_rt->length();
                        }

                        ComparableAttributeSet() {
                            set(NULL, 0);
                        }

                        AttrSet &getSet() {
                            return *reinterpret_cast<AttrSet*> (data.get());
                        }

                    public:
                        typedef boost::shared_ptr<ComparableAttributeSet> type;

                        void set(awds::AWDS_Packet &p) {
                            // if this is not an attributes packet
                            if (p.header.type != AWDS_Packet::constants::packet_type::attributes)
                                return;

                            set(p.data, size(p.data));
                        }

                        static bool match(const type & a, const type & b) {
                            return AttributeIterator<AttrSeq>::match(a->getSet(), b->getSet());
                        }

                        void print(::logging::loggingReturnType &out) {
                            out << ::logging::log::dec;
                            AttributeIterator<AttrSeq>::print(out, getSet());
                        }

                        type clone() {
                            type res = create(getSet());
                            return res;
                        }

                        template< class Attrib >
                        Attrib *find() {
                            return getSet().template find_rt<Attrib> ();
                        }

                        operator boost::asio::const_buffer() {
                            uint8_t *d = data.get();
                            return boost::asio::buffer(d, size(d));
                        }


                        uint16_t size(){
                            return size(data.get());
                        }

                        static type create() {
                            type res = type(new ComparableAttributeSet());
                            return res;
                        }

                        static type create(AWDS_Packet &p) {
                            type res = create();
                            res->set(p);
                            return res;
                        }

                        template< class AttrSeq2 >
                        static type create(famouso::mw::attributes::AttributeSet<AttrSeq2> &p) {
                            type res = create();
                            uint8_t *d = reinterpret_cast<uint8_t*> (&p);
                            res->set(d, size(d));
                            return res;
                        }

                        static type create(uint8_t *d) {
                            type res = create();
                            if (d)
                                res->set(d, size(d));
                            return res;
                        }
                };

            } /* namespace awds */
        } /* namespace nl */
    } /* namespace mw */
} /* namespace famouso */

namespace logging {
    using famouso::mw::nl::awds::ComparableAttributeSet;

    template< class AttrSeq >
    inline ::logging::loggingReturnType &operator<<(loggingReturnType &out, const boost::shared_ptr<ComparableAttributeSet<AttrSeq> > &att) {
        att->print(out);
        return out;
    }

} /* namespace logging */
#endif /* _ComparableAttributeSet_ */