1 /* 2 * Copyright (C) 2016 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef CHRE_UTIL_FIXED_SIZE_BLOCKING_QUEUE_IMPL_H_ 18 #define CHRE_UTIL_FIXED_SIZE_BLOCKING_QUEUE_IMPL_H_ 19 20 #include "chre/util/fixed_size_blocking_queue.h" 21 #include "chre/util/lock_guard.h" 22 23 namespace chre { 24 25 template<typename ElementType, size_t kSize> 26 bool FixedSizeBlockingQueue<ElementType, kSize>::push( 27 const ElementType& element) { 28 bool success; 29 { 30 LockGuard<Mutex> lock(mMutex); 31 success = mQueue.push(element); 32 } 33 if (success) { 34 mConditionVariable.notify_one(); 35 } 36 return success; 37 } 38 39 template<typename ElementType, size_t kSize> 40 bool FixedSizeBlockingQueue<ElementType, kSize>::push(ElementType&& element) { 41 bool success; 42 { 43 LockGuard<Mutex> lock(mMutex); 44 success = mQueue.push(std::move(element)); 45 } 46 if (success) { 47 mConditionVariable.notify_one(); 48 } 49 return success; 50 } 51 52 template<typename ElementType, size_t kSize> 53 ElementType FixedSizeBlockingQueue<ElementType, kSize>::pop() { 54 LockGuard<Mutex> lock(mMutex); 55 while (mQueue.empty()) { 56 mConditionVariable.wait(mMutex); 57 } 58 59 ElementType element(std::move(mQueue.front())); 60 mQueue.pop(); 61 return element; 62 } 63 64 template<typename ElementType, size_t kSize> 65 bool FixedSizeBlockingQueue<ElementType, kSize>::empty() { 66 LockGuard<Mutex> lock(mMutex); 67 return mQueue.empty(); 68 } 69 70 template<typename ElementType, size_t kSize> 71 size_t FixedSizeBlockingQueue<ElementType, kSize>::size() { 72 LockGuard<Mutex> lock(mMutex); 73 return mQueue.size(); 74 } 75 76 template<typename ElementType, size_t kSize> 77 bool FixedSizeBlockingQueue<ElementType, kSize>::remove(size_t index) { 78 LockGuard<Mutex> lock(mMutex); 79 return mQueue.remove(index); 80 } 81 82 template<typename ElementType, size_t kCapacity> 83 ElementType& FixedSizeBlockingQueue<ElementType, kCapacity>::operator[]( 84 size_t index) { 85 LockGuard<Mutex> lock(mMutex); 86 return mQueue[index]; 87 } 88 89 template<typename ElementType, size_t kCapacity> 90 const ElementType& FixedSizeBlockingQueue<ElementType, kCapacity>::operator[]( 91 size_t index) const { 92 LockGuard<Mutex> lock(mMutex); 93 return mQueue[index]; 94 } 95 96 } // namespace chre 97 98 #endif // CHRE_UTIL_BLOCKING_QUEUE_IMPL_H_ 99
