PrmDbImpl.hpp

Go to the documentation of this file.

#ifndef PRMDBIMPL_HPP_
#define PRMDBIMPL_HPP_

#include <Fw/Types/String.hpp>
#include <Os/Mutex.hpp>
#include <Svc/PrmDb/PrmDbComponentAc.hpp>
#include <Svc/PrmDb/PrmDb_PrmDbFileLoadStateEnumAc.hpp>
#include <Svc/PrmDb/PrmDb_PrmDbTypeEnumAc.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;

  public:
    PrmDbImpl(const char* name);

    void configure(const char* file);

    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;  

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

    // Structure for a single parameter entry
    struct t_dbStruct {
        bool used;            
        FwPrmIdType id;       
        Fw::ParamBuffer val;  

        bool operator==(const t_dbStruct& other) const {
            if (used != other.used)
                return false;
            if (id != other.id)
                return false;
            // Compare lengths first
            if (val.getSize() != other.val.getSize())
                return false;
            // Compare buffer contents
            return std::memcmp(val.getBuffAddr(), other.val.getBuffAddr(), val.getSize()) == 0;
        }
    };

    // helper to compute CRC over a buffer
    U32 computeCrc(U32 crc, const BYTE* buff, FwSizeType size);

    // 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.
    t_dbStruct* m_activeDb;   
    t_dbStruct* m_stagingDb;  

    // Actual storage for the active and staging databases
    t_dbStruct m_dbStore1[PRMDB_NUM_DB_ENTRIES];
    t_dbStruct m_dbStore2[PRMDB_NUM_DB_ENTRIES];


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

    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, PrmDb_Merge merge);

    void PRM_COMMIT_STAGED_cmdHandler(FwOpcodeType opCode, U32 cmdSeq);


    void clearDb(PrmDbType prmDbType);

    t_dbStruct* getDbPtr(PrmDbType dbType);

    static Fw::String getDbString(PrmDbType dbType);

    bool dbEqual();

    void dbCopy(PrmDbType dest, PrmDbType src);

    void dbCopySingle(PrmDbType dest, PrmDbType src, FwSizeType index);
};
}  // namespace Svc

#endif /* PRMDBIMPL_HPP_ */