.. _program_listing_file_include_depthai_device_Device.hpp:

Program Listing for File Device.hpp
===================================

|exhale_lsh| :ref:`Return to documentation for file <file_include_depthai_device_Device.hpp>` (``include/depthai/device/Device.hpp``)

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

.. code-block:: cpp

   #pragma once
   
   // std
   #include <chrono>
   #include <condition_variable>
   #include <deque>
   #include <memory>
   #include <mutex>
   #include <string>
   #include <unordered_map>
   
   // project
   #include "DataQueue.hpp"
   #include "depthai/device/DeviceBase.hpp"
   
   namespace dai {
   class Device : public DeviceBase {
      public:
       using DeviceBase::DeviceBase;  // inherit the ctors
   
       explicit Device(const Pipeline& pipeline);
   
       template <typename T, std::enable_if_t<std::is_same<T, bool>::value, bool> = true>
       [[deprecated("Use constructor taking 'UsbSpeed' instead")]] Device(const Pipeline& pipeline, T usb2Mode);
   
       Device(const Pipeline& pipeline, UsbSpeed maxUsbSpeed);
   
       Device(const Pipeline& pipeline, const dai::Path& pathToCmd);
   
       Device(const Pipeline& pipeline, const DeviceInfo& devInfo);
   
       template <typename T, std::enable_if_t<std::is_same<T, bool>::value, bool> = true>
       [[deprecated("Use constructor taking 'UsbSpeed' instead")]] Device(const Pipeline& pipeline, const DeviceInfo& devInfo, T usb2Mode);
   
       Device(const Pipeline& pipeline, const DeviceInfo& devInfo, UsbSpeed maxUsbSpeed);
   
       Device(const Pipeline& pipeline, const DeviceInfo& devInfo, const dai::Path& pathToCmd);
   
       Device();
   
       ~Device() override;
   
       static constexpr std::size_t EVENT_QUEUE_MAXIMUM_SIZE{2048};
   
       std::shared_ptr<DataOutputQueue> getOutputQueue(const std::string& name);
   
       std::shared_ptr<DataOutputQueue> getOutputQueue(const std::string& name, unsigned int maxSize, bool blocking = true);
   
       std::vector<std::string> getOutputQueueNames() const;
   
       std::shared_ptr<DataInputQueue> getInputQueue(const std::string& name);
   
       std::shared_ptr<DataInputQueue> getInputQueue(const std::string& name, unsigned int maxSize, bool blocking = true);
   
       std::vector<std::string> getInputQueueNames() const;
   
       // void setCallback(const std::string& name, std::function<std::shared_ptr<RawBuffer>(std::shared_ptr<RawBuffer>)> cb);
   
       std::vector<std::string> getQueueEvents(const std::vector<std::string>& queueNames,
                                               std::size_t maxNumEvents = std::numeric_limits<std::size_t>::max(),
                                               std::chrono::microseconds timeout = std::chrono::microseconds(-1));
       std::vector<std::string> getQueueEvents(const std::initializer_list<std::string>& queueNames,
                                               std::size_t maxNumEvents = std::numeric_limits<std::size_t>::max(),
                                               std::chrono::microseconds timeout = std::chrono::microseconds(-1));
   
       std::vector<std::string> getQueueEvents(std::string queueName,
                                               std::size_t maxNumEvents = std::numeric_limits<std::size_t>::max(),
                                               std::chrono::microseconds timeout = std::chrono::microseconds(-1));
   
       std::vector<std::string> getQueueEvents(std::size_t maxNumEvents = std::numeric_limits<std::size_t>::max(),
                                               std::chrono::microseconds timeout = std::chrono::microseconds(-1));
   
       std::string getQueueEvent(const std::vector<std::string>& queueNames, std::chrono::microseconds timeout = std::chrono::microseconds(-1));
       std::string getQueueEvent(const std::initializer_list<std::string>& queueNames, std::chrono::microseconds timeout = std::chrono::microseconds(-1));
   
       std::string getQueueEvent(std::string queueName, std::chrono::microseconds timeout = std::chrono::microseconds(-1));
   
       std::string getQueueEvent(std::chrono::microseconds timeout = std::chrono::microseconds(-1));
   
      private:
       std::unordered_map<std::string, std::shared_ptr<DataOutputQueue>> outputQueueMap;
       std::unordered_map<std::string, std::shared_ptr<DataInputQueue>> inputQueueMap;
       std::unordered_map<std::string, DataOutputQueue::CallbackId> callbackIdMap;
   
       // Event queue
       std::mutex eventMtx;
       std::condition_variable eventCv;
       std::deque<std::string> eventQueue;
   
       bool startPipelineImpl(const Pipeline& pipeline) override;
       void closeImpl() override;
   };
   
   }  // namespace dai