#include <MetricFileExists.h>

Inheritance diagram for Nektar::MetricFileExists:

Public Member Functions
	~MetricFileExists () override

Public Member Functions inherited from Nektar::Metric
	Metric (TiXmlElement *metric, bool generate)
	Constructor. More...

virtual	~Metric ()=default

bool	Test (std::istream &pStdout, std::istream &pStderr)
	Calls a metric's `v_Test` function (or `v_Generate` if `m_generate`). More...

void	Generate (std::istream &pStdout, std::istream &pStderr)

std::string	GetType ()
	Return metric type. More...

int	GetID ()
	Return metric ID. More...

bool	SupportsAverage () const
	Return whether this metric supports averaging results from multiple runs. More...

Static Public Member Functions
static MetricSharedPtr	create (TiXmlElement *metric, bool generate)

Static Public Attributes
static std::string	type

Protected Member Functions
	MetricFileExists (TiXmlElement *metric, bool generate)

bool	v_Test (std::istream &pStdout, std::istream &pStderr) override
	Virtual function to test the metric. Should be redefined in derived classes. More...

void	v_Generate (std::istream &pStdout, std::istream &pStderr) override
	Virtual function to generate the metric. Should be redefined in derived classes. More...

virtual bool	v_Test (std::istream &pStdout, std::istream &pStderr)=0
	Virtual function to test the metric. Should be redefined in derived classes. More...

virtual void	v_Generate (std::istream &pStdout, std::istream &pSrderr)=0
	Virtual function to generate the metric. Should be redefined in derived classes. More...

Protected Attributes
std::map< std::string, int >	m_fileCounts

Protected Attributes inherited from Nektar::Metric
int	m_id
	Stores the ID of this metric. More...

std::string	m_type
	Stores the type of this metric (uppercase). More...

bool	m_generate
	Determines whether to generate this metric or not. More...

bool	m_average = false
	Indicates whether a metric supports averaging results from multiple runs. More...

TiXmlElement *	m_metric
	Pointer to XML structure containing metric definition. More...

Detailed Description

Definition at line 43 of file MetricFileExists.h.

Constructor & Destructor Documentation

◆ ~MetricFileExists()

Nektar::MetricFileExists::~MetricFileExists ( )

inlineoverride

Definition at line 46 of file MetricFileExists.h.

47 {

48 }

◆ MetricFileExists()

Nektar::MetricFileExists::MetricFileExists	(	TiXmlElement *	metric,
		bool	generate
	)

protected

Definition at line 50 of file MetricFileExists.cpp.

    : Metric(metric, generate)
{
    TiXmlElement *file = metric->FirstChildElement("file");
    ASSERTL0(file, "Missing file tag for FileExists metric!");
 
    // Read metric and populate list of patterns to search for.
    while (file)
    {
        std::string pattern, count;
 
        // Check the pattern has been defined as an attribute and store.
        ASSERTL0(file->Attribute("pattern"), "Missing filename for file tag!");
        pattern = file->Attribute("pattern");
 
        // If we are testing, extract and store the expected file count
        // from the content portion of the tag.
        if (!m_generate)
        {
            count                 = file->GetText();
            m_fileCounts[pattern] = std::stoi(count);
        }
        // If we are generating, put a default value of zero so as to still
        // have the pattern in the map.
        else
        {
            m_fileCounts[pattern] = 0;
        }
 
        file = file->NextSiblingElement("file");
    }
}

References ASSERTL0, m_fileCounts, and Nektar::Metric::m_generate.

Referenced by create().

Member Function Documentation

◆ create()

static MetricSharedPtr Nektar::MetricFileExists::create	(	TiXmlElement *	metric,
		bool	generate
	)

inlinestatic

Definition at line 50 of file MetricFileExists.h.

    {
        return MetricSharedPtr(new MetricFileExists(metric, generate));
    }

References MetricFileExists().

◆ v_Generate()

void Nektar::MetricFileExists::v_Generate	(	std::istream &	pStdout,
		std::istream &	pSrderr
	)

overrideprotectedvirtual

Virtual function to generate the metric. Should be redefined in derived classes.

Parameters

pStdout	Reference to test output stream.
pSrderr	Reference to test error stream.

Implements Nektar::Metric.

Definition at line 124 of file MetricFileExists.cpp.

{
    boost::ignore_unused(pStdout, pStderr);
 
    // Update File counts.
    auto pwd = fs::current_path();
 
    for (auto it = m_fileCounts.begin(); it != m_fileCounts.end(); ++it)
    {
        int cnt = 0;
        std::regex r(it->first.c_str());
        for (auto &e : fs::directory_iterator(pwd))
        {
            std::smatch matches;
            std::string filename = e.path().string();
            if (std::regex_match(filename, matches, r))
            {
                if (matches.size() == 1)
                {
                    cnt++;
                }
            }
        }
        m_fileCounts[it->first] = cnt;
    }
 
    // Write new XML structure.
    TiXmlElement *file = m_metric->FirstChildElement("file");
    while (file)
    {
        std::string pattern = file->Attribute("pattern");
        file->Clear();
 
        ASSERTL0(m_fileCounts.count(pattern) != 0, "Couldn't find pattern " +
                                                       pattern +
                                                       " in list of calculated"
                                                       "hashes");
 
        file->LinkEndChild(
            new TiXmlText(std::to_string(m_fileCounts[pattern]).c_str()));
        file = file->NextSiblingElement("file");
    }
}

References ASSERTL0, m_fileCounts, and Nektar::Metric::m_metric.

◆ v_Test()

bool Nektar::MetricFileExists::v_Test	(	std::istream &	pStdout,
		std::istream &	pStderr
	)

overrideprotectedvirtual

Virtual function to test the metric. Should be redefined in derived classes.

Parameters

pStdout	Reference to test output stream.
pStderr	Reference to test error stream.

Returns: true if the test passes, false otherwise.

Implements Nektar::Metric.

Definition at line 83 of file MetricFileExists.cpp.

{
    boost::ignore_unused(pStdout, pStderr);
 
    bool success = true;
    auto pwd     = fs::current_path();
 
    // Check each pattern in turn
    for (auto it = m_fileCounts.begin(); it != m_fileCounts.end(); ++it)
    {
        int cnt = 0;
        std::regex r(it->first.c_str());
 
        // Examine each file in the current path and check if it matches the
        // pattern provided. Count the number of files which match.
        for (auto &e : fs::directory_iterator(pwd))
        {
            std::smatch matches;
            std::string filename = e.path().string();
            if (std::regex_match(filename, matches, r))
            {
                if (matches.size() == 1)
                {
                    cnt++;
                }
            }
        }
 
        // Check if the count matches what we expect.
        if (it->second != cnt)
        {
            std::cerr << "Failed test." << std::endl;
            std::cerr << "  Expected file matches: " << it->second << std::endl;
            std::cerr << "  Found file matches:    " << cnt << std::endl;
            success = false;
        }
    }
 
    return success;
}