policyStats.h

 
#ifndef POLICY_STATS_H
#define POLICY_STATS_H
 
#include <iostream>
#include <map>
#include <vector>
 
#include "instructions/instruction.h"
 
#include "program/program.h"
 
#include "tpg/tpgAction.h"
#include "tpg/tpgGraph.h"
#include "tpg/tpgTeam.h"
 
namespace TPG {
 
    class PolicyStats
    {
      private:
        const Environment* environment = nullptr;
 
        std::vector<std::reference_wrapper<const Data::DataHandler>>
            dataSourcesAndRegisters;
 
      public:
        std::map<const Program::Program*, size_t> nbUsePerProgram;
 
        std::map<const Program::Program*, size_t> nbUsePerActionProgram;
 
        std::map<const TPGTeam*, size_t> nbUsePerTPGTeam;
 
        std::map<const TPGAction*, size_t> nbUsePerTPGAction;
 
        std::vector<size_t> nbLinesPerProgram;
 
        std::vector<size_t> nbLinesPerActionProgram;
 
        std::vector<size_t> nbIntronPerProgram;
 
        std::vector<size_t> nbIntronPerActionProgram;
 
        std::map<size_t, size_t> nbUsagePerInstruction;
 
        std::map<size_t, size_t> nbUsagePerInstructionActionProg;
 
        std::map<std::pair<size_t, size_t>, size_t> nbUsagePerDataLocation;
 
        std::map<std::pair<size_t, size_t>, size_t>
            nbUsagePerDataLocationActionProg;
 
        std::vector<size_t> nbOutgoingEdgesPerTeam;
 
        std::map<size_t, size_t> nbUsagePerActionID;
 
        size_t maxPolicyDepth = 0;
 
        std::map<size_t, size_t> nbTPGVertexPerDepthLevel;
 
        size_t nbDistinctTeams = 0;
 
        PolicyStats() = default;
 
        void clear();
 
        void setEnvironment(const Environment& env);
 
        void analyzeLine(const Program::Line* line, bool actionProgram = false);
 
        void analyzeProgram(const Program::Program* prog);
 
        void analyzeTPGTeam(const TPG::TPGTeam* team);
 
        void analyzeTPGAction(const TPG::TPGAction* action);
 
        void analyzePolicy(const TPG::TPGVertex* vertex);
 
        friend std::ostream& operator<<(std::ostream& os,
                                        const PolicyStats& policyStats);
    };
 
    std::ostream& operator<<(std::ostream& os, const PolicyStats& policyStats);
} // namespace TPG
 
#endif