qevt.h

Go to the documentation of this file.

// Product: QP/C++
// Last Updated for Version: 4.5.04
// Date of the Last Update:  Jan 16, 2013
//
//                    Q u a n t u m     L e a P s
//                    ---------------------------
//                    innovating embedded systems
//
// Copyright (C) 2002-2013 Quantum Leaps, LLC. All rights reserved.
//
// This program is open source 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, either version 2 of the License, or
// (at your option) any later version.
//
// Alternatively, this program may be distributed and modified under the
// terms of Quantum Leaps commercial licenses, which expressly supersede
// the GNU General Public License and are specifically designed for
// licensees interested in retaining the proprietary status of their code.
//
// 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, see <http://www.gnu.org/licenses/>.
//
// Contact information:
// Quantum Leaps Web sites: http://www.quantum-leaps.com
//                          http://www.state-machine.com
// e-mail:                  info@quantum-leaps.com
#ifndef qevt_h
#define qevt_h


#define QP_VERSION      0x4503U

#ifndef Q_ROM












    #define Q_ROM
#endif
#ifndef Q_ROM_VAR            // if NOT defined, provide the default definition













    #define Q_ROM_VAR
#endif
#ifndef Q_ROM_BYTE













    #define Q_ROM_BYTE(rom_var_)   (rom_var_)
#endif

#ifndef Q_SIGNAL_SIZE






    #define Q_SIGNAL_SIZE 2
#endif

#ifndef Q_NNAMESPACE

    #define QP_BEGIN_  namespace QP {

    #define QP_END_    }

    #define QP_        QP::

#else

    #define QP_BEGIN_
    #define QP_END_
    #define QP_

#endif

QP_BEGIN_

#if (Q_SIGNAL_SIZE == 1)
    typedef uint8_t QSignal;
#elif (Q_SIGNAL_SIZE == 2)









    typedef uint16_t QSignal;
#elif (Q_SIGNAL_SIZE == 4)
    typedef uint32_t QSignal;
#else
    #error "Q_SIGNAL_SIZE defined incorrectly, expected 1, 2, or 4"
#endif

#ifdef Q_EVT_CTOR               // Provide the constructor for the QEvt class?

    class QEvt {
    public:
        QSignal sig;                         

        QEvt(QSignal const s)           // poolId_ intentionally uninitialized
          : sig(s) {}

#ifdef Q_EVT_VIRTUAL
        virtual ~QEvt() {}                               // virtual destructor
#endif

    private:
        uint8_t poolId_;                     
        uint8_t refCtr_;                                

        friend class QF;
        friend class QTimeEvt;
        friend uint8_t QF_EVT_POOL_ID_ (QEvt const * const e);
        friend uint8_t QF_EVT_REF_CTR_ (QEvt const * const e);
        friend void QF_EVT_REF_CTR_INC_(QEvt const * const e);
        friend void QF_EVT_REF_CTR_DEC_(QEvt const * const e);
    };

#else                                    // QEvt is a POD (Plain Old Datatype)

    struct QEvt {
        QSignal sig;                         
        uint8_t poolId_;                     
        uint8_t refCtr_;                                
    };

#endif                                                           // Q_EVT_CTOR

QP_END_

#define Q_DIM(array_) (sizeof(array_) / sizeof(array_[0]))

// typedefs for basic numerical types; MISRA-C++ 2008 rule 3-9-2(req).

typedef char char_t;

typedef float float32_t;

typedef double float64_t;

typedef int enum_t;

#define Q_UINT2PTR_CAST(type_, uint_)  (reinterpret_cast<type_ *>(uint_))

#define QEVT_INITIALIZER(sig_) { static_cast<QP_ QSignal>(sig_), \
    static_cast<uint8_t>(0), static_cast<uint8_t>(0) }

// facilities for backwards compatibility
//
#ifndef Q_NQEVENT
//    typedef struct QEvt QEvent;
    #define QEvent QEvt
#endif

#endif                                                               // qevt_h