RequestManager.h

// Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
// SPDX-License-Identifier: BSD-3-Clause-Clear
 
#ifndef REQUEST_MANAGER_H
#define REQUEST_MANAGER_H
 
#include <unordered_set>
#include <unordered_map>
#include <memory>
 
#include "Request.h"
#include "CocoTable.h"
#include "ClientDataManager.h"
 
enum RequestListType {
    ACTIVE_TUNE,
    PENDING_TUNE,
};
 
enum RequestProcessingStatus {
    REQ_UNCHANGED = -2,
    REQ_CANCELLED,
    REQ_COMPLETED
};
 
class RequestManager {
private:
    static std::shared_ptr<RequestManager> mReqeustManagerInstance;
    static std::mutex instanceProtectionLock;
 
    int64_t mActiveRequestCount;
    std::unordered_set<Request*> mRequestsList[4];
    std::unordered_map<int64_t, Request*> mActiveRequests;
    std::unordered_map<int64_t, int64_t> mRequestProcessingStatus;
    std::shared_timed_mutex mRequestMapMutex;
 
    RequestManager();
 
    int8_t checkOwnership(Request* request, Request* targetRequest);
    int8_t isSane(Request* request);
    int8_t requestMatch(Request* request);
 
public:
    ~RequestManager();
 
    int8_t verifyHandle(int64_t handle);
 
    int8_t shouldRequestBeAdded(Request* request);
 
    void addRequest(Request* request);
 
    void removeRequest(Request* request);
 
    Request* getRequestFromMap(int64_t handle);
 
    int64_t getActiveReqeustsCount();
 
    void disableRequestProcessing(int64_t handle);
 
    void modifyRequestDuration(int64_t handle, int64_t duration);
 
    void markRequestAsComplete(int64_t handle);
 
    int64_t getRequestProcessingStatus(int64_t handle);
 
    std::vector<Request*> getPendingList();
 
    void moveToPendingList();
 
    void clearPending();
 
    static std::shared_ptr<RequestManager> getInstance() {
        if(mReqeustManagerInstance == nullptr) {
            instanceProtectionLock.lock();
            if(mReqeustManagerInstance == nullptr) {
                try {
                    mReqeustManagerInstance = std::shared_ptr<RequestManager> (new RequestManager());
                } catch(const std::bad_alloc& e) {
                    instanceProtectionLock.unlock();
                    return nullptr;
                }
            }
            instanceProtectionLock.unlock();
        }
        return mReqeustManagerInstance;
    }
};
 
#endif