source: trash/old-modules/transport/protlib/messages.h@ 7834

/// ----------------------------------------*- mode: C++; -*--
/// @file messages.h
/// internal messages sent between modules and other components
/// ----------------------------------------------------------
/// $Id: messages.h 3013 2008-05-15 16:12:27Z roehricht $
/// $HeadURL: https://svn.ipv6.tm.uka.de/nsis/protlib/trunk/include/messages.h $
// ===========================================================
//                      
// Copyright (C) 2005-2007, all rights reserved by
// - Institute of Telematics, Universitaet Karlsruhe (TH)
//
// More information and contact:
// https://projekte.tm.uka.de/trac/NSIS
//                      
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; version 2 of the License
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
//
// ===========================================================

/** @ingroup messages
 * @file
 * These messages are sent between modules and other DRM components.
 */

#ifndef _PROTLIB__MESSAGE_H_
#define _PROTLIB__MESSAGE_H_

#include <pthread.h>
#include <ext/hash_set>

#include "protlib_types.h"
#include "fqueue.h"

namespace protlib {

/** @addtogroup messages Internal Messages
 * @{
 */

// class FastQueue is declared in fqueue.h
class FastQueue;

// class Context is declared in context.h
class Context;

/// internal messages
/** Base class of all internal drm messages passed between modules. */
class message {
public:
        /// message type
        /** Each subclass of class message has its own unique type. */
        enum type_t {
                type_transport,
                type_timer,
                type_signaling,
                type_context,
                type_info,
                type_routing,
                type_API
        }; // end type_t

        /// source ID
        /** Identifies the module which sent the message.
         *  If you add an id here, please add also the corresponding string in qaddr_string
         */
        enum qaddr_t {
                qaddr_unknown, // used as return value in NSLPtable.get_address() if there is no address found
                qaddr_transport,
                qaddr_timer,
                qaddr_coordination,
                qaddr_coordination_internal,
                qaddr_signaling,
                qaddr_policy,
                qaddr_resource,
                qaddr_routing,
                qaddr_accounting,
                qaddr_router_config,
                qaddr_tp_over_sctp,
                qaddr_tp_over_tcp,
                qaddr_tp_over_tls_tcp,
                qaddr_tp_over_udp,
                qaddr_tp_queryencap,
                qaddr_qos_nslp_timerprocessing,
                qaddr_qos_nslp_coordination,
                qaddr_qos_nslp_signaling,
                qaddr_appl_qos_signaling,
                qaddr_qos_appl_signaling,
                qaddr_gui,
                qaddr_api_0,
                qaddr_api_1,
                qaddr_api_2,
                qaddr_api_3,
                qaddr_api_4,
                qaddr_api_5,
                qaddr_api_6,
                qaddr_api_7,
                qaddr_api_wrapper_input,
                qaddr_tp_over_uds,
                qaddr_uds_appl_qos      // receives messages from an external client via UDS
        }; // end qaddr_t

        /// message ID
        /** Each message has an ID.
         * Message IDs are not unique, you can use the same ID e.g. for request
         * and response. You cannot use an unused message ID, you can just reuse
         * an already used ID. ID 0 sets an unused ID.
         * Since id_t is 64-bit long, you can send 10^10 messages per seconds
         * for over 30 years without reusing an ID.
         */
        typedef gp_id_t id_t;
        /// constructor
        message(type_t t, qaddr_t s = qaddr_unknown, id_t id = 0);
        /// destructor
        virtual ~message();
        /// get ID
        id_t get_id() const;
        /// set ID or generate a new one
        id_t set_id(id_t id);
        /// get new ID
        id_t new_id();
        /// get message type
        type_t get_type() const;
        /// get source module queue
        FastQueue *get_source_queue() const;
        /// get source ID
        qaddr_t get_source() const;
        /// set source ID
        qaddr_t set_source(qaddr_t s);
        /// get name of message source
        const char* get_qaddr_name() const;
        /// get source name
        static const char* get_qaddr_name(qaddr_t s);
        /// get name of message type
        const char* get_type_name() const { return type_string[type]; }
        /// get type name
        static const char* get_type_name(type_t t) { return type_string[t]; }
        /// send the message to a queue
        bool send(qaddr_t src, FastQueue* destqueue, bool exp = false);
        /// send the message
        bool send(qaddr_t src, qaddr_t dest, bool exp = false);
        // @{
        /// send the message to dest
        bool send_to(qaddr_t dest, bool exp = false);
        bool send_to(FastQueue* destqueue, bool exp = false);
        // @}
        /// send the message back
        bool send_back(qaddr_t from, bool exp = false);
        //@{
        /// send or delete the message
        void send_or_delete(qaddr_t src, qaddr_t dest, bool exp = false) {      if (!send(src,dest,exp)) delete this; }
        void send_to_or_delete(qaddr_t dest, bool exp = false) { if (!send_to(dest,exp)) delete this; }
        void send_back_or_delete(qaddr_t src, bool exp = false) { if (!send_back(src,exp)) delete this; }
        //@}
        /// clear all pointers
        virtual void clear_pointers();
private:
        const type_t type;
        qaddr_t source;
        id_t msg_id;
        /// printable message source names
        static const char* const qaddr_string[];
        /// printable message typee names
        static const char* const type_string[];
}; // end class message



//@}

} // end namespace protlib

namespace __gnu_cxx {

/// message pointer hasher
/** Hash value is the address of the object pointed to. */
template <> struct hash<protlib::message*> {
        inline size_t operator()(protlib::message* m) const { return (size_t)m; }
}; // end msgp_hash

} // end namespace __gnu_cxx

#endif // _PROTLIB__MESSAGE_H_