PrmDbImpl.hpp

Go to the documentation of this file.

#ifndef PRMDBIMPL_HPP_
#define PRMDBIMPL_HPP_

#include <Fw/DataStructures/ArrayMap.hpp>
#include <Fw/Types/String.hpp>
#include <Os/Mutex.hpp>
#include <Os/SandboxedFile.hpp>
#include <Svc/PrmDb/PrmDbComponentAc.hpp>
#include <Svc/PrmDb/PrmDb_PrmDbFileLoadStateEnumAc.hpp>
#include <Svc/PrmDb/PrmDb_PrmDbTypeEnumAc.hpp>
#include <Utils/Hash/Hash.hpp>
#include <config/PrmDbImplCfg.hpp>
#include <cstring>

namespace Svc {

typedef PrmDb_PrmWriteError PrmWriteError;
typedef PrmDb_PrmReadError PrmReadError;
typedef PrmDb_PrmDbType PrmDbType;
typedef PrmDb_PrmDbFileLoadState PrmDbFileLoadState;


class PrmDbImpl final : public PrmDbComponentBase {
    friend class PrmDbTester;

    using PrmDbStore = Fw::ArrayMap<FwPrmIdType, Fw::ParamBuffer, PRMDB_NUM_DB_ENTRIES>;

  public:
    PrmDbImpl(const char* name);

    void configure(const char* file);

    void configureSandbox(const char* directory);

    void readParamFile();  // NOTE: Assumed to run at initialization time. No guard of data structure.

    virtual ~PrmDbImpl();

    // Parameter update status for an individual parameter update or add
    enum PrmUpdateType {
        NO_SLOTS,       
        PARAM_ADDED,    
        PARAM_UPDATED,  
        MAX_PARAM_UPDATE_TYPES
    };

    // Enum to return status of parameter file load
    enum PrmLoadStatus {
        SUCCESS,  
        ERROR,    
    };

  protected:
  private:
    Fw::String m_fileName;    
    Fw::String m_sandboxDir;  

    PrmDbFileLoadState m_state;  // Current file load state of the parameter database

    // Pointers to the active and staging databases
    // These point to the actual storage arrays below
    // The active database is the ONLY one used for getting parameters
    // The staging database is used for loading parameters from a file
    // when commanded. Upon reading the file, the parameters are "staged"
    // into the staging database, and then committed to the active database
    // when a commit command is received.
    PrmDbStore* m_activeDb;   
    PrmDbStore* m_stagingDb;  

    // Actual storage for the active and staging databases
    PrmDbStore m_dbStore1;
    PrmDbStore m_dbStore2;


    PrmLoadStatus readParamFileImpl(const Fw::StringBase& fileName, PrmDbType dbType);

    void applySandbox(Os::SandboxedFile& file) const;

    bool writeSaveFileChunk(Os::SandboxedFile& paramFile,
                            const U8* data,
                            FwSizeType size,
                            PrmWriteError::T statusStage,
                            PrmWriteError::T sizeStage,
                            U32 numRecords,
                            FwOpcodeType opCode,
                            U32 cmdSeq,
                            Utils::Hash& crc);

    Fw::ParamValid getPrm_handler(FwIndexType portNum, FwPrmIdType id, Fw::ParamBuffer& val);

    void setPrm_handler(FwIndexType portNum, FwPrmIdType id, Fw::ParamBuffer& val);

    PrmDbImpl::PrmUpdateType updateAddPrmImpl(FwPrmIdType id, Fw::ParamBuffer& val, PrmDbType prmDbType);

    void pingIn_handler(FwIndexType portNum, U32 key);

    void PRM_SAVE_FILE_cmdHandler(FwOpcodeType opCode, U32 cmdSeq);

    void PRM_LOAD_FILE_cmdHandler(FwOpcodeType opCode,
                                  U32 cmdSeq,
                                  const Fw::CmdStringArg& fileName,
                                  const PrmDb_Merge& merge);

    void PRM_COMMIT_STAGED_cmdHandler(FwOpcodeType opCode, U32 cmdSeq);


    void clearDb(PrmDbType prmDbType);

    PrmDbStore* getDbPtr(PrmDbType dbType);

    static Fw::String getDbString(PrmDbType dbType);

    void dbCopy(PrmDbType dest, PrmDbType src);
};
}  // namespace Svc

#endif /* PRMDBIMPL_HPP_ */