SignalRegistry.h

// Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
// SPDX-License-Identifier: BSD-3-Clause-Clear
 
#ifndef SIGNAL_REGISTRY_H
#define SIGNAL_REGISTRY_H
 
#include <vector>
#include <memory>
#include <unordered_map>
#include <unordered_set>
#include <algorithm>
 
#include "Utils.h"
#include "Logger.h"
#include "Resource.h"
#include "MemoryPool.h"
 
typedef struct {
    uint16_t mSignalID;
 
    uint8_t mSignalCategory;
 
    std::string mSignalName;
 
    int8_t mIsEnabled;
 
    int32_t mTimeout;
 
    std::unordered_set<std::string>* mTargetsEnabled;
 
    std::unordered_set<std::string>* mTargetsDisabled;
 
    std::vector<enum Permissions>* mPermissions;
 
    std::vector<std::string>* mDerivatives;
 
    std::vector<Resource*>* mSignalResources;
 
} SignalInfo;
 
class SignalRegistry {
private:
    static std::shared_ptr<SignalRegistry> signalRegistryInstance;
    int32_t mTotalSignals;
    std::vector<SignalInfo*> mSignalsConfigs;
 
    std::unordered_map<uint32_t, int32_t> mSystemIndependentLayerMappings;
 
    SignalRegistry();
 
public:
    ~SignalRegistry();
 
    void registerSignal(SignalInfo* signalInfo, int8_t isBuSpecified=false);
 
    int8_t isSignalConfigMalformed(SignalInfo* sConf);
 
    std::vector<SignalInfo*> getSignalConfigs();
 
    SignalInfo* getSignalConfigById(uint32_t signalCode);
 
    int32_t getSignalsConfigCount();
    int32_t getSignalTableIndex(uint32_t signalCode);
    void displaySignals();
 
    static std::shared_ptr<SignalRegistry> getInstance() {
        if(signalRegistryInstance == nullptr) {
            try {
                signalRegistryInstance = std::shared_ptr<SignalRegistry>(new SignalRegistry());
            } catch(const std::bad_alloc& e) {
                LOGE("RESTUNE_SIGNAL_REGISTRY",
                     "Failed to allocate memory for SignalRegistry instance: " + std::string(e.what()));
                return nullptr;
            }
        }
        return signalRegistryInstance;
    }
};
 
class SignalInfoBuilder {
private:
    SignalInfo* mSignalInfo;
 
public:
    SignalInfoBuilder();
    ~SignalInfoBuilder();
 
    ErrCode setSignalID(const std::string& signalOpIdString);
    ErrCode setSignalCategory(const std::string& categoryString);
    ErrCode setName(const std::string& signalName);
    ErrCode setTimeout(const std::string& timeoutString);
    ErrCode setIsEnabled(const std::string& isEnabledString);
    ErrCode addTargetEnabled(const std::string& target);
    ErrCode addTargetDisabled(const std::string& target);
    ErrCode addPermission(const std::string& permissionString);
    ErrCode addDerivative(const std::string& derivative);
    ErrCode addResource(Resource* resource);
 
    SignalInfo* build();
};
 
class ResourceBuilder {
private:
    Resource* mResource;
 
public:
    ResourceBuilder();
 
    ErrCode setResCode(const std::string& resCodeString);
    ErrCode setResInfo(const std::string& resInfoString);
    ErrCode setNumValues(int32_t valuesCount);
    ErrCode addValue(const std::string& value);
 
    Resource* build();
};
 
#endif