.. _program_listing_file_include_libcaercpp_events_polarity.hpp:

Program Listing for File polarity.hpp
=====================================

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

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

.. code-block:: cpp

   #ifndef LIBCAER_EVENTS_POLARITY_HPP_
   #define LIBCAER_EVENTS_POLARITY_HPP_
   
   #include "../../libcaer/events/polarity.h"
   
   #include "common.hpp"
   
   namespace libcaer {
   namespace events {
   
   struct PolarityEvent : public caer_polarity_event {
       int32_t getTimestamp() const noexcept {
           return (caerPolarityEventGetTimestamp(this));
       }
   
       int64_t getTimestamp64(const EventPacket &packet) const noexcept {
           return (caerPolarityEventGetTimestamp64(
               this, reinterpret_cast<caerPolarityEventPacketConst>(packet.getHeaderPointer())));
       }
   
       void setTimestamp(int32_t ts) {
           if (ts < 0) {
               throw std::invalid_argument("Negative timestamp not allowed.");
           }
   
           caerPolarityEventSetTimestamp(this, ts);
       }
   
       bool isValid() const noexcept {
           return (caerPolarityEventIsValid(this));
       }
   
       void validate(EventPacket &packet) noexcept {
           caerPolarityEventValidate(this, reinterpret_cast<caerPolarityEventPacket>(packet.getHeaderPointer()));
       }
   
       void invalidate(EventPacket &packet) noexcept {
           caerPolarityEventInvalidate(this, reinterpret_cast<caerPolarityEventPacket>(packet.getHeaderPointer()));
       }
   
       bool getPolarity() const noexcept {
           return (caerPolarityEventGetPolarity(this));
       }
   
       void setPolarity(bool pol) noexcept {
           caerPolarityEventSetPolarity(this, pol);
       }
   
       uint16_t getY() const noexcept {
           return (caerPolarityEventGetY(this));
       }
   
       void setY(uint16_t y) noexcept {
           caerPolarityEventSetY(this, y);
       }
   
       uint16_t getX() const noexcept {
           return (caerPolarityEventGetX(this));
       }
   
       void setX(uint16_t x) noexcept {
           caerPolarityEventSetX(this, x);
       }
   };
   
   static_assert(std::is_standard_layout<PolarityEvent>::value, "PolarityEvent is not standard layout.");
   
   class PolarityEventPacket : public EventPacketCommon<PolarityEventPacket, PolarityEvent> {
   public:
       // Constructors.
       PolarityEventPacket(size_type eventCapacity, int16_t eventSource, int32_t tsOverflow) {
           constructorCheckCapacitySourceTSOverflow(eventCapacity, eventSource, tsOverflow);
   
           caerPolarityEventPacket packet = caerPolarityEventPacketAllocate(eventCapacity, eventSource, tsOverflow);
           constructorCheckNullptr(packet);
   
           header        = &packet->packetHeader;
           isMemoryOwner = true; // Always owner on new allocation!
       }
   
       PolarityEventPacket(caerPolarityEventPacket packet, bool takeMemoryOwnership = true) {
           constructorCheckNullptr(packet);
   
           constructorCheckEventType(&packet->packetHeader, POLARITY_EVENT);
   
           header        = &packet->packetHeader;
           isMemoryOwner = takeMemoryOwnership;
       }
   
       PolarityEventPacket(caerEventPacketHeader packetHeader, bool takeMemoryOwnership = true) {
           constructorCheckNullptr(packetHeader);
   
           constructorCheckEventType(packetHeader, POLARITY_EVENT);
   
           header        = packetHeader;
           isMemoryOwner = takeMemoryOwnership;
       }
   
   protected:
       // Event access methods.
       reference virtualGetEvent(size_type index) noexcept override {
           caerPolarityEvent evtBase
               = caerPolarityEventPacketGetEvent(reinterpret_cast<caerPolarityEventPacket>(header), index);
           PolarityEvent *evt = static_cast<PolarityEvent *>(evtBase);
   
           return (*evt);
       }
   
       const_reference virtualGetEvent(size_type index) const noexcept override {
           caerPolarityEventConst evtBase
               = caerPolarityEventPacketGetEventConst(reinterpret_cast<caerPolarityEventPacketConst>(header), index);
           const PolarityEvent *evt = static_cast<const PolarityEvent *>(evtBase);
   
           return (*evt);
       }
   };
   } // namespace events
   } // namespace libcaer
   
   #endif /* LIBCAER_EVENTS_POLARITY_HPP_ */