parserManager.h

#pragma once
 
#include <vector>
#include <string>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <iostream>
 
#include "bfp.h"
 
namespace irio {
enum class GroupResource {
    Common,
    AI,
    AO,
    AuxAI,
    AuxAO,
    DI,
    DO,
    AuxDI,
    AuxDO,
    DMA,
    DAQ,
    IMAQ,
    IO,
    SG,
    CRIO,
    FlexRIO
};
 
struct CustomStringComparator {
    bool operator()(const std::string& a, const std::string& b) const;
};
 
struct GroupInfo {
    std::set<std::string, CustomStringComparator>
        found; 
    std::set<std::string, CustomStringComparator>
        notFound; 
    std::unordered_map<std::string, std::string>
        error; 
    GroupInfo();
};
 
class ParserManager {
 public:
    explicit ParserManager(const bfp::BFP &bfp);
 
    bool findRegister(const std::string &resourceName,
                      const GroupResource &group, bfp::Register *reg,
                      const bool optional = false);
 
    bool findDMA(const std::string &resourceName,
                 const GroupResource &group, bfp::DMA *dma,
                 const bool optional = false);
 
    bool findRegisterAddress(const std::string &resourceName,
                             const GroupResource &group, std::uint32_t *address,
                             const bool optional = false);
 
    bool findDMANum(const std::string &resourceName,
                    const GroupResource &group, std::uint32_t *address,
                    const bool optional = false);
 
    bool findRegisterEnumAddress(const std::string &resourceName,
                                 std::uint32_t nResource, const GroupResource &group,
                                 std::unordered_map<std::uint32_t, const std::uint32_t> *mapInsert,
                                 const bool optional = false);
 
    bool findDMAEnumNum(const std::string &resourceName,
                        std::uint32_t nResource, const GroupResource &group,
                        std::unordered_map<std::uint32_t, const std::uint32_t> *mapInsert,
                        const bool optional = false);
 
    void compareResourcesMap(
        const std::unordered_map<std::uint32_t, const std::uint32_t> &mapA,
        const std::string &nameTermA,
        const std::unordered_map<std::uint32_t, const std::uint32_t> &mapB,
        const std::string &nameTermB,
        const GroupResource &group);
 
    void logResourceError(const std::string &resourceName,
                          const std::string &errMsg,
                          const GroupResource &group);
 
    bool hasErrorOccurred() const;
 
    void printInfo(std::ostream &os = std::cout,
                   const bool onlyErrors = false) const;
 
    void printInfoError(std::ostream &os = std::cerr) const;
 
    void printInfoXML(const std::string& filename) const;
 
    void logResourceFound(const std::string &resourceName,
                          const GroupResource &group);
 
    void logResourceNotFound(const std::string &resourceName,
                             const GroupResource &group);
 
 private:
    bfp::BFP m_bfp;
    std::unordered_map<GroupResource, GroupInfo> m_groupInfo;
    bool m_error = false;
};
 
}  // namespace irio