1/*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 *     http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16#include "message_queue.h"
17#include "tools/log.h"
18
19namespace Commonlibrary::Concurrent::WorkerModule {
20void MessageQueue::EnQueue(MessageDataType data)
21{
22    queueLock_.lock();
23    queue_.push(data);
24    queueLock_.unlock();
25}
26
27bool MessageQueue::DeQueue(MessageDataType *data)
28{
29    queueLock_.lock();
30    if (queue_.empty()) {
31        queueLock_.unlock();
32        return false;
33    }
34    if (data != nullptr) {
35        *data = queue_.front();
36        queue_.pop();
37    } else {
38        HILOG_ERROR("worker:: data is nullptr.");
39    }
40    queueLock_.unlock();
41    return true;
42}
43
44bool MessageQueue::IsEmpty() const
45{
46    return queue_.empty();
47}
48
49void MessageQueue::Clear(napi_env env)
50{
51    queueLock_.lock();
52    size_t size = queue_.size();
53    for (size_t i = 0; i < size; i++) {
54        MessageDataType data = queue_.front();
55        napi_delete_serialization_data(env, data);
56        queue_.pop();
57    }
58    queueLock_.unlock();
59}
60
61void MarkedMessageQueue::Push(uint32_t id, MessageDataType data)
62{
63    std::unique_lock<std::mutex> lock(queueLock_);
64    queue_.push({id, data});
65}
66
67void MarkedMessageQueue::Pop()
68{
69    std::unique_lock<std::mutex> lock(queueLock_);
70    queue_.pop();
71}
72
73std::pair<uint32_t, MessageDataType> MarkedMessageQueue::Front()
74{
75    std::unique_lock<std::mutex> lock(queueLock_);
76    return queue_.front();
77}
78
79bool MarkedMessageQueue::IsEmpty()
80{
81    std::unique_lock<std::mutex> lock(queueLock_);
82    return queue_.empty();
83}
84
85void MarkedMessageQueue::Clear(napi_env env)
86{
87    std::unique_lock<std::mutex> lock(queueLock_);
88    while (!queue_.empty()) {
89        std::pair<uint32_t, MessageDataType> pair = queue_.front();
90        napi_delete_serialization_data(env, pair.second);
91        queue_.pop();
92    }
93}
94}  // namespace Commonlibrary::Concurrent::WorkerModule
95