DTXMessageTransmitterTest MultipleFragments

Author: sandin

include/idevice/blockingqueue.h

@@ -2,12 +2,12 @@
 #define IDEVICE_BLOCKING_QUEUE_H
 
 #include <chrono>
-#include <queue>
-#include <mutex>
 #include <condition_variable>
-#include <functional> // std::function
+#include <functional>  // std::function
+#include <mutex>
+#include <queue>
 
-#include "idevice/macro_def.h" // IDEVICE_DISALLOW_COPY_AND_ASSIGN
+#include "idevice/macro_def.h"  // IDEVICE_DISALLOW_COPY_AND_ASSIGN
 
 namespace idevice {
 
@@ -19,29 +19,29 @@ class BlockingQueue {
  public:
   BlockingQueue() {}
   ~BlockingQueue() {}
-  
+
   IDEVICE_DISALLOW_COPY_AND_ASSIGN(BlockingQueue);
-  
+
   /**
    * add(copy) a new element to the end of the queue
    * @param data new element
    */
   void Push(const T& data) {
     std::unique_lock<std::mutex> lock(mutex_);
-    queue_.push(data); // copy
+    queue_.push(data);  // copy
     not_empty_.notify_all();
   }
-  
+
   /**
    * add(move) a new element to the end of the queue
    * @param data new element
    */
   void Push(T&& data) {
     std::unique_lock<std::mutex> lock(mutex_);
-    queue_.push(std::forward<T>(data)); // move
+    queue_.push(std::forward<T>(data));  // move
     not_empty_.notify_all();
   }
-  
+
   /**
    * take(move) the first element from the head of the queue
    * if the queue is empty, it will wait blocking.
@@ -52,11 +52,11 @@ class BlockingQueue {
     while (queue_.empty()) {
       not_empty_.wait(lock);
     }
-    T data = std::move(queue_.front()); // move
+    T data = std::move(queue_.front());  // move
     queue_.pop();
-    return data; // move
+    return data;  // move
   }
-  
+
   /**
    * waiting queue is not empty with a timeout
    * @param timeout_ms timeout
@@ -65,13 +65,14 @@ class BlockingQueue {
   bool WaitToTake(uint32_t timeout_ms) {
     std::unique_lock<std::mutex> lock(mutex_);
     while (queue_.empty()) {
-      if (not_empty_.wait_for(lock, std::chrono::microseconds(timeout_ms)) == std::cv_status::timeout) {
+      if (not_empty_.wait_for(lock, std::chrono::microseconds(timeout_ms)) ==
+          std::cv_status::timeout) {
         return false;
       }
     }
     return true;
   }
-  
+
   /**
    * checks whether the queue is empty
    * @return return true if the queue is empty
@@ -80,7 +81,7 @@ class BlockingQueue {
     std::unique_lock<std::mutex> lock(mutex_);
     return queue_.empty();
   }
-  
+
   /**
    * clear the queue
    */
@@ -96,21 +97,21 @@ class BlockingQueue {
       std::swap(queue_, empty);
     }
   }
-  
+
   /**
    * Get size of the queue
    */
   size_t Size() const { return queue_.size(); }
-  
-private:
+
+ private:
   mutable std::mutex mutex_;
   std::queue<T> queue_;
   std::condition_variable not_empty_;
-  
-}; // class BlockingQueue
+
+};  // class BlockingQueue
 
 }  // namespace idevice
 
 #include "idevice/macro_undef.h"
 
-#endif // IDEVICE_BLOCKING_QUEUE_H
+#endif  // IDEVICE_BLOCKING_QUEUE_H

include/idevice/bytebuffer.h

@@ -2,45 +2,42 @@
 #define IDEVICE_BYTE_BUFFER_H
 
 #include <cstdint>
+#include <memory>  // std::unique_ptr
 #include <vector>
-#include <memory> // std::unique_ptr
 
-#include "idevice/macro_def.h" // IDEVICE_MEM_ALIGN, IDEVICE_DISALLOW_COPY_AND_ASSIGN
+#include "idevice/macro_def.h"  // IDEVICE_MEM_ALIGN, IDEVICE_DISALLOW_COPY_AND_ASSIGN
 
 namespace idevice {
 
 class BufferMemory {
  public:
-  BufferMemory() {
-  }
+  BufferMemory() {}
   ~BufferMemory() {
     if (buffer_) {
       free(buffer_);
     }
   }
-  
+
   IDEVICE_DISALLOW_COPY_AND_ASSIGN(BufferMemory);
-  
+
   char* Allocate(size_t req_size) {
     if (capacity_ - size_ < req_size) {
       if (!Reserve(size_ + req_size)) {
         printf("Error: can not allocate memory, size=%zu\n", req_size);
         return nullptr;
       }
     }
-    
+
     char* ptr = buffer_ + size_;
     size_ += req_size;
     return ptr;
   }
-  
-  char* GetPtr(size_t offset) {
-    return buffer_ + offset;
-  }
-  
+
+  char* GetPtr(size_t offset) { return buffer_ + offset; }
+
   size_t Size() const { return size_; }
   void SetSize(size_t size) { size_ = size; }
-  
+
  private:
   bool Reserve(size_t capacity) {
     size_t new_capacity = IDEVICE_MEM_ALIGN(capacity, 128);
@@ -55,7 +52,7 @@ class BufferMemory {
     }
     return false;
   }
-  
+
   char* buffer_ = nullptr;
   size_t size_ = 0;
   size_t capacity_ = 0;
@@ -68,7 +65,7 @@ class ByteBuffer {
  public:
   using DataType = uint8_t;
   using DataArray = std::vector<DataType>;
-  
+
   /**
    * constructor
    * @param reserve_size reserve size
@@ -77,25 +74,23 @@ class ByteBuffer {
     buffer_->reserve(reserve_size);
   };
   ~ByteBuffer() {}
-  
+
   IDEVICE_DISALLOW_COPY_AND_ASSIGN(ByteBuffer);
-  
+
   // allow move and assign
   ByteBuffer(ByteBuffer&& other) : buffer_(std::move(other.buffer_)) {}
   ByteBuffer& operator=(ByteBuffer&& other) {
     buffer_ = std::unique_ptr<DataArray>(std::move(other.buffer_));
     return *this;
   }
-  
+
   /**
    * get a mutable pointer to the buffer
    * @param offset offset from head
    * @return the pointer to the buffer
    */
-  void* GetBuffer(size_t offset) {
-    return reinterpret_cast<uint8_t*>(buffer_->data()) + offset;
-  }
-  
+  void* GetBuffer(size_t offset) { return reinterpret_cast<uint8_t*>(buffer_->data()) + offset; }
+
   /**
    * get unmutable pointer to the buffer
    * @param offset offset from head
@@ -104,7 +99,7 @@ class ByteBuffer {
   const void* GetReadOnlyBuffer(size_t offset) {
     return reinterpret_cast<const uint8_t*>(buffer_->data()) + offset;
   }
-  
+
   /**
    * read(copy) some data from the buffer
    * @param buffer the dest buffer
@@ -133,7 +128,7 @@ class ByteBuffer {
     }
     return true;
   }
-  
+
   /**
    * write(copy) some data to the specified offset position of the buffer
    * @param buffer the src buffer
@@ -159,7 +154,7 @@ class ByteBuffer {
     }
     return true;
   }
-  
+
   /**
    * write(copy) some data to the end of the buffer
    * @param buffer the src buffer
@@ -170,7 +165,7 @@ class ByteBuffer {
     size_t size_written;
     return Write(buffer, buffer_size, Size(), &size_written) && buffer_size == size_written;
   }
-  
+
   /**
    * resize the buffer
    * @param new_size the new size
@@ -180,22 +175,20 @@ class ByteBuffer {
     buffer_->resize(new_size);
     return true;
   }
-  
+
   /**
    * get the current size of buffer
    * @return the size
    */
-  size_t Size() const {
-    return buffer_->size();
-  }
+  size_t Size() const { return buffer_->size(); }
 
  private:
   uint32_t alignment_;
   std::unique_ptr<DataArray> buffer_;
-}; // class ByteBuffer
+};  // class ByteBuffer
 
 }  // namespace idevice
 
 #include "idevice/macro_undef.h"
 
-#endif // IDEVICE_BYTE_BUFFER_H
+#endif  // IDEVICE_BYTE_BUFFER_H

include/idevice/dtxchannel.h

@@ -1,7 +1,7 @@
 #ifndef IDEVICE_DTXCHANNEL_H
 #define IDEVICE_DTXCHANNEL_H
 
-#include <cstdint> // uint32_t
+#include <cstdint>  // uint32_t
 #include <string>
 
 #include "idevice/dtxmessenger.h"
@@ -10,13 +10,14 @@ namespace idevice {
 
 class DTXChannel /*: public DTXMessenger */ {
  public:
-  DTXChannel(DTXMessenger* connection, const std::string& label, uint32_t channel_identifier) : connection_(connection), label_(label), channel_identifier_(channel_identifier) {}
+  DTXChannel(DTXMessenger* connection, const std::string& label, uint32_t channel_identifier)
+      : connection_(connection), label_(label), channel_identifier_(channel_identifier) {}
   DTXChannel() : DTXChannel(nullptr, "", 0) {}
   virtual ~DTXChannel() {}
 
   // virtual bool SendMessageSync(std::shared_ptr<DTXMessage> msg, ReplyHandler callback) override;
   void SendMessageAsync(std::shared_ptr<DTXMessage> msg, DTXMessenger::ReplyHandler callback);
-  
+
   const std::string& Label() const { return label_; }
   uint32_t ChannelIdentifier() const { return channel_identifier_; }
 
@@ -25,8 +26,8 @@ class DTXChannel /*: public DTXMessenger */ {
   uint32_t channel_identifier_ = 0;
   DTXMessenger* connection_ = nullptr;
 
-}; // class DTXChannel
+};  // class DTXChannel
 
 }  // namespace idevice
 
-#endif // IDEVICE_DTXCHANNEL_H
+#endif  // IDEVICE_DTXCHANNEL_H