group_collection.h

Go to the documentation of this file.

#pragma once
 
#include <vector>
 
#include "deserializer.h"
#include "serializer.h"
#include "types.h"
#include "uniq_lock.h"
 
namespace kuzu {
namespace storage {
 
template<class T>
class GroupCollection {
public:
 GroupCollection() {}
 
 common::UniqLock lock() { return common::UniqLock{mtx}; }
 
 void loadGroups(common::Deserializer& deSer) {
 lock();
 deSer.deserializeVectorOfPtrs<T>(groups);
 }
 void serializeGroups(common::Serializer& ser) {
 lock();
 ser.serializeVectorOfPtrs<T>(groups);
 }
 
 void appendGroup(const common::UniqLock& lock, std::unique_ptr<T> group) {
 KU_ASSERT(group);
 KU_ASSERT(lock.isLocked());
 KU_UNUSED(lock);
 groups.push_back(std::move(group));
 }
 T* getGroup(const common::UniqLock& lock, common::idx_t groupIdx) {
 KU_ASSERT(lock.isLocked());
 KU_UNUSED(lock);
 if (groupIdx >= groups.size()) {
 return nullptr;
 }
 return groups[groupIdx].get();
 }
 T* getGroupNoLock(common::idx_t groupIdx) {
 if (groupIdx >= groups.size()) {
 return nullptr;
 }
 return groups[groupIdx].get();
 }
 void replaceGroup(const common::UniqLock& lock, common::idx_t groupIdx,
 std::unique_ptr<T> group) {
 KU_ASSERT(group);
 KU_ASSERT(lock.isLocked());
 KU_UNUSED(lock);
 if (groupIdx >= groups.size()) {
 groups.resize(groupIdx + 1);
 }
 groups[groupIdx] = std::move(group);
 }
 
 void resize(const common::UniqLock& lock, common::idx_t newSize) {
 KU_ASSERT(lock.isLocked());
 KU_UNUSED(lock);
 if (newSize <= groups.size()) {
 return;
 }
 groups.resize(newSize);
 }
 
 bool isEmpty(const common::UniqLock& lock) {
 KU_ASSERT(lock.isLocked());
 KU_UNUSED(lock);
 return groups.empty();
 }
 common::idx_t getNumGroups(const common::UniqLock& lock) const {
 KU_ASSERT(lock.isLocked());
 KU_UNUSED(lock);
 return groups.size();
 }
 
 const std::vector<std::unique_ptr<T>>& getAllGroups(const common::UniqLock& lock) {
 KU_ASSERT(lock.isLocked());
 KU_UNUSED(lock);
 return groups;
 }
 std::unique_ptr<T> moveGroup(const common::UniqLock& lock, common::idx_t groupIdx) {
 KU_ASSERT(groupIdx < groups.size());
 KU_ASSERT(lock.isLocked());
 KU_UNUSED(lock);
 return std::move(groups[groupIdx]);
 }
 T* getFirstGroup(const common::UniqLock& lock) {
 KU_ASSERT(lock.isLocked());
 KU_UNUSED(lock);
 if (groups.empty()) {
 return nullptr;
 }
 return groups.front().get();
 }
 T* getFirstGroupNoLock() {
 if (groups.empty()) {
 return nullptr;
 }
 return groups.front().get();
 }
 T* getLastGroup(const common::UniqLock& lock) {
 KU_ASSERT(lock.isLocked());
 KU_UNUSED(lock);
 if (groups.empty()) {
 return nullptr;
 }
 return groups.back().get();
 }
 
 void clear(const common::UniqLock& lock) {
 KU_ASSERT(lock.isLocked());
 KU_UNUSED(lock);
 groups.clear();
 }
 
private:
 std::mutex mtx;
 std::vector<std::unique_ptr<T>> groups;
};
 
} // namespace storage
} // namespace kuzu