decl_notify_observable.hpp

#pragma once
 
#include <cstring>
#include <vector>
 
#include "../../global.hpp"
#include "../../string.hpp"
 
#include "../driver.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  namespace Driver
  {


    class NotifyArgs
    {
    public:
      NotifyArgs(void *data, int size, NotifyDataType dataType) noexcept
          : data_(data)
          , size_(size)
          , dataType_(dataType)
      {
      }


      void *Data() const noexcept
      {
        return data_;
      }
      void *Data() const noexcept {…}


      int Size() const noexcept
      {
        return size_;
      }
      int Size() const noexcept {…}


      NotifyDataType DataType() const noexcept
      {
        return dataType_;
      }
      NotifyDataType DataType() const noexcept {…}


      template <typename T>
      T Data() const noexcept
      {
        static_assert(std::is_same<T, std::int64_t>::value || std::is_same<T, double>::value
                          || std::is_same<T, String>::value || std::is_same<T, bool>::value
                          || std::is_same<T, std::vector<std::uint8_t>>::value,
                      "CVB: Unsupported notify data type!");
      }
      T Data() const noexcept {…}
 
    private:
      mutable void *data_      = nullptr;
      int size_                = 0;
      NotifyDataType dataType_ = NotifyDataType::Void;
    };
    class NotifyArgs {…};
 
    template <>
    inline std::int64_t NotifyArgs::Data<std::int64_t>() const noexcept
    {
      return *reinterpret_cast<std::int64_t *>(data_);
    }
 
    template <>
    inline double NotifyArgs::Data<double>() const noexcept
    {
      return *reinterpret_cast<double *>(data_);
    }
 
    template <>
    inline String NotifyArgs::Data<String>() const noexcept
    {
      std::string ansiString(reinterpret_cast<char *>(data_));
      return String(ansiString.begin(), ansiString.end());
    }
 
    template <>
    inline bool NotifyArgs::Data<bool>() const noexcept
    {
      return *reinterpret_cast<bool *>(data_);
    }
 
    template <>
    inline std::vector<std::uint8_t> NotifyArgs::Data<std::vector<std::uint8_t>>() const noexcept
    {
      std::vector<std::uint8_t> data(static_cast<std::size_t>(size_));
      std::memcpy(&data[0], data_, data.size());
      return data;
    }


    class NotifyObservable
    {
 
    public:
      NotifyObservable(const NotifyObservable &other)            = delete;
      NotifyObservable &operator=(const NotifyObservable &other) = delete;
      NotifyObservable(NotifyObservable &&other)                 = delete;
      NotifyObservable &operator=(NotifyObservable &&other)      = delete;
      ~NotifyObservable();
 
      NotifyObservable(const DevicePtr &parent, int index);


      int ID() const noexcept
      {
        return eventNumber_;
      }
      int ID() const noexcept {…}


      String Description() const noexcept
      {
        return description_;
      }
      String Description() const noexcept {…}


      bool IsAvailable() const;


      EventCookie RegisterEvent(std::function<void(NotifyArgs)> handler);


      void UnregisterEvent(EventCookie eventCookie) noexcept;
 
    private:
      static void __stdcall Callback(CExports::CVNotifyEvent_t, void *Buf, size_t Size,
                                     CExports::CVNotifyDatatype_t DataType, void *UserData)
      {
        try
        {
          auto notifyObservable = reinterpret_cast<NotifyObservable *>(UserData);
          notifyObservable->carrierContainer_.Call<void(NotifyArgs)>(
              NotifyArgs(Buf, static_cast<int>(Size), static_cast<NotifyDataType>(DataType)));
        }
        catch (...)
        {
          // swallow exception so they don't propagate to native library.
        }
      }
 
      DevicePtr parent_;
 
      int eventNumber_ = 0;
 
      String description_;
 
      std::intptr_t cookie_ = 0;
 
      Internal::CarrierContainer carrierContainer_;
    };
    class NotifyObservable {…};
 
  }  // namespace Driver
 
  using Driver::NotifyArgs;
  using Driver::NotifyObservable;
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb