.. _program_listing_file_include_libcaercpp_events_special.hpp:

Program Listing for File special.hpp
====================================

|exhale_lsh| :ref:`Return to documentation for file <file_include_libcaercpp_events_special.hpp>` (``include/libcaercpp/events/special.hpp``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   #ifndef LIBCAER_EVENTS_SPECIAL_HPP_
   #define LIBCAER_EVENTS_SPECIAL_HPP_
   
   #include "../../libcaer/events/special.h"
   
   #include "common.hpp"
   
   namespace libcaer {
   namespace events {
   
   struct SpecialEvent : public caer_special_event {
       int32_t getTimestamp() const noexcept {
           return (caerSpecialEventGetTimestamp(this));
       }
   
       int64_t getTimestamp64(const EventPacket &packet) const noexcept {
           return (caerSpecialEventGetTimestamp64(
               this, reinterpret_cast<caerSpecialEventPacketConst>(packet.getHeaderPointer())));
       }
   
       void setTimestamp(int32_t ts) {
           if (ts < 0) {
               throw std::invalid_argument("Negative timestamp not allowed.");
           }
   
           caerSpecialEventSetTimestamp(this, ts);
       }
   
       bool isValid() const noexcept {
           return (caerSpecialEventIsValid(this));
       }
   
       void validate(EventPacket &packet) noexcept {
           caerSpecialEventValidate(this, reinterpret_cast<caerSpecialEventPacket>(packet.getHeaderPointer()));
       }
   
       void invalidate(EventPacket &packet) noexcept {
           caerSpecialEventInvalidate(this, reinterpret_cast<caerSpecialEventPacket>(packet.getHeaderPointer()));
       }
   
       uint8_t getType() const noexcept {
           return (caerSpecialEventGetType(this));
       }
   
       void setType(uint8_t t) noexcept {
           caerSpecialEventSetType(this, t);
       }
   
       uint32_t getData() const noexcept {
           return (caerSpecialEventGetData(this));
       }
   
       void setData(uint32_t d) noexcept {
           caerSpecialEventSetData(this, d);
       }
   };
   
   static_assert(std::is_standard_layout<SpecialEvent>::value, "SpecialEvent is not standard layout.");
   
   class SpecialEventPacket : public EventPacketCommon<SpecialEventPacket, SpecialEvent> {
   public:
       // Constructors.
       SpecialEventPacket(size_type eventCapacity, int16_t eventSource, int32_t tsOverflow) {
           constructorCheckCapacitySourceTSOverflow(eventCapacity, eventSource, tsOverflow);
   
           caerSpecialEventPacket packet = caerSpecialEventPacketAllocate(eventCapacity, eventSource, tsOverflow);
           constructorCheckNullptr(packet);
   
           header        = &packet->packetHeader;
           isMemoryOwner = true; // Always owner on new allocation!
       }
   
       SpecialEventPacket(caerSpecialEventPacket packet, bool takeMemoryOwnership = true) {
           constructorCheckNullptr(packet);
   
           constructorCheckEventType(&packet->packetHeader, SPECIAL_EVENT);
   
           header        = &packet->packetHeader;
           isMemoryOwner = takeMemoryOwnership;
       }
   
       SpecialEventPacket(caerEventPacketHeader packetHeader, bool takeMemoryOwnership = true) {
           constructorCheckNullptr(packetHeader);
   
           constructorCheckEventType(packetHeader, SPECIAL_EVENT);
   
           header        = packetHeader;
           isMemoryOwner = takeMemoryOwnership;
       }
   
   protected:
       // Event access methods.
       reference virtualGetEvent(size_type index) noexcept override {
           caerSpecialEvent evtBase
               = caerSpecialEventPacketGetEvent(reinterpret_cast<caerSpecialEventPacket>(header), index);
           SpecialEvent *evt = static_cast<SpecialEvent *>(evtBase);
   
           return (*evt);
       }
   
       const_reference virtualGetEvent(size_type index) const noexcept override {
           caerSpecialEventConst evtBase
               = caerSpecialEventPacketGetEventConst(reinterpret_cast<caerSpecialEventPacketConst>(header), index);
           const SpecialEvent *evt = static_cast<const SpecialEvent *>(evtBase);
   
           return (*evt);
       }
   
   public:
       reference findEventByType(uint8_t type) {
           caerSpecialEvent evtBase
               = caerSpecialEventPacketFindEventByType(reinterpret_cast<caerSpecialEventPacket>(header), type);
           if (evtBase == nullptr) {
               throw std::range_error("Special Event of particular type not found.");
           }
   
           SpecialEvent *evt = static_cast<SpecialEvent *>(evtBase);
   
           return (*evt);
       }
   
       const_reference findEventByType(uint8_t type) const {
           caerSpecialEventConst evtBase
               = caerSpecialEventPacketFindEventByTypeConst(reinterpret_cast<caerSpecialEventPacketConst>(header), type);
           if (evtBase == nullptr) {
               throw std::range_error("Special Event of particular type not found.");
           }
   
           const SpecialEvent *evt = static_cast<const SpecialEvent *>(evtBase);
   
           return (*evt);
       }
   
       reference findValidEventByType(uint8_t type) {
           caerSpecialEvent evtBase
               = caerSpecialEventPacketFindValidEventByType(reinterpret_cast<caerSpecialEventPacket>(header), type);
           if (evtBase == nullptr) {
               throw std::range_error("Valid Special Event of particular type not found.");
           }
   
           SpecialEvent *evt = static_cast<SpecialEvent *>(evtBase);
   
           return (*evt);
       }
   
       const_reference findValidEventByType(uint8_t type) const {
           caerSpecialEventConst evtBase = caerSpecialEventPacketFindValidEventByTypeConst(
               reinterpret_cast<caerSpecialEventPacketConst>(header), type);
           if (evtBase == nullptr) {
               throw std::range_error("Valid Special Event of particular type not found.");
           }
   
           const SpecialEvent *evt = static_cast<const SpecialEvent *>(evtBase);
   
           return (*evt);
       }
   };
   } // namespace events
   } // namespace libcaer
   
   #endif /* LIBCAER_EVENTS_SPECIAL_HPP_ */