Nektar::MetricFile Class Reference

#include <MetricFile.h>

Inheritance diagram for Nektar::MetricFile:

Public Member Functions
virtual	~MetricFile ()
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
	MetricFile (TiXmlElement *metric, bool generate)
std::string	CalculateHash (std::string filename)
virtual bool	v_Test (std::istream &pStdout, std::istream &pStderr)
	Virtual function to test the metric. Should be redefined in derived classes. More...
virtual void	v_Generate (std::istream &pStdout, std::istream &pStderr)
	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, std::string >	m_filehash
	Stores filenames to perform hash on. More...
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 MetricFile.h.

Constructor & Destructor Documentation

~MetricFile()

virtual Nektar::MetricFile::~MetricFile ( )

inlinevirtual

Definition at line 46 of file MetricFile.h.

    {
    }

MetricFile()

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

protected

Definition at line 50 of file MetricFile.cpp.

    : Metric(metric, generate)
{
    TiXmlElement *file = metric->FirstChildElement("file");
    ASSERTL0(file, "Missing file tag for file metric!");
 
    while (file)
    {
        std::string filename, sha1hash;
 
        if (file->Attribute("filename"))
        {
            filename = file->Attribute("filename");
        }
        else
        {
            ASSERTL0(false, "Missing filename for file tag!");
        }
 
        if (!m_generate)
        {
            TiXmlElement *sha1 = file->FirstChildElement("sha1");
            ASSERTL0(sha1, "Missing SHA1 hash for file " + filename);
            sha1hash = sha1->GetText();
            ASSERTL0(sha1hash.size() == 40, "Incorrect length for SHA1 hash");
        }
 
        m_filehash[filename] = sha1hash;
 
        file = file->NextSiblingElement("file");
    }
}

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

Referenced by create().

Member Function Documentation

CalculateHash()

std::string Nektar::MetricFile::CalculateHash ( std::string  filename )

protected

Definition at line 83 of file MetricFile.cpp.

{
    int fdot      = pfilename.find_last_of('.');
    string ending = pfilename.substr(fdot);
    string filename;
 
    if (ending == ".fld" || ending == ".chk" || ending == ".rst")
    {
        TiXmlDocument *xmlFldFile;
        fs::path pathfilename(pfilename);
 
        if (fs::is_directory(pathfilename))
        {
            std::vector<fs::path> dirfiles;
 
            // make list of all files in directoryj
            copy(fs::directory_iterator(pathfilename), fs::directory_iterator(),
                 back_inserter(dirfiles));
 
            xmlFldFile = new TiXmlDocument;
 
            // load all them into the
            for (int i = 0; i < dirfiles.size(); ++i)
            {
                std::string infile = PortablePath(dirfiles[i]);
                std::ifstream file(infile.c_str());
                ASSERTL0(file.good(), "Unable to open file: " + infile);
                file >> (*xmlFldFile);
            }
        }
        else
        {
            xmlFldFile = new TiXmlDocument(pfilename);
            xmlFldFile->LoadFile(pfilename);
        }
 
        // strip out meta data before check
        TiXmlElement *vNektar = xmlFldFile->FirstChildElement("NEKTAR");
        while (vNektar)
        {
 
            TiXmlNode *vMetaData = vNektar->FirstChild("Metadata");
 
            // delete MetaData section
            if (vMetaData)
            {
                vNektar->RemoveChild(vMetaData);
            }
            vNektar = vNektar->NextSiblingElement("NEKTAR");
        }
 
        filename = pfilename + ".tmp";
        xmlFldFile->SaveFile(filename);
    }
    else
    {
        filename = pfilename;
    }
 
    // Open file.
    std::ifstream testFile(filename.c_str(), std::ios::binary);
    ASSERTL0(testFile.is_open(), "Error opening file " + filename);
 
    // Read in file contents.
    std::vector<char> fileContents((std::istreambuf_iterator<char>(testFile)),
                                   std::istreambuf_iterator<char>());
 
    // Calculate SHA1 hash.
    unsigned char hash[20];
    char strhash[41];
 
    sha1::calc((void *)&fileContents[0], fileContents.size(), hash);
    sha1::toHexString(hash, strhash);
 
    // Close file and return string containing SHA1 hash.
    testFile.close();
 
    return std::string(strhash);
}

References ASSERTL0, sha1::calc(), CellMLToNektar.pycml::copy(), Nektar::LibUtilities::PortablePath(), and sha1::toHexString().

Referenced by v_Generate(), and v_Test().

create()

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

inlinestatic

Definition at line 50 of file MetricFile.h.

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

References MetricFile().

v_Generate()

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

protectedvirtual

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 185 of file MetricFile.cpp.

{
    boost::ignore_unused(pStdout, pStderr);
 
    std::map<std::string, std::string>::iterator it;
 
    // Update SHA1 hashes.
    for (it = m_filehash.begin(); it != m_filehash.end(); ++it)
    {
        std::string filehash  = CalculateHash(it->first);
        m_filehash[it->first] = filehash;
    }
 
    // Write new XML structure.
    TiXmlElement *file = m_metric->FirstChildElement("file");
    while (file)
    {
        std::string filename = file->Attribute("filename");
        file->Clear();
 
        TiXmlElement *sha1 = new TiXmlElement("sha1");
 
        ASSERTL0(m_filehash.count(filename) != 0, "Couldn't find file " +
                                                      filename +
                                                      " in list of calculated"
                                                      "hashes");
 
        sha1->LinkEndChild(new TiXmlText(m_filehash[filename]));
        file->LinkEndChild(sha1);
        file = file->NextSiblingElement("file");
    }
}

References ASSERTL0, CalculateHash(), m_filehash, and Nektar::Metric::m_metric.

v_Test()

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

protectedvirtual

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 163 of file MetricFile.cpp.

{
    boost::ignore_unused(pStdout, pStderr);
 
    std::map<std::string, std::string>::iterator it;
    bool success = true;
 
    for (it = m_filehash.begin(); it != m_filehash.end(); ++it)
    {
        std::string filehash = CalculateHash(it->first);
        if (!boost::iequals(filehash, it->second))
        {
            std::cerr << "Failed SHA1 hash test." << std::endl;
            std::cerr << "  Expected: " << it->second << std::endl;
            std::cerr << "  Result:   " << filehash << std::endl;
            success = false;
        }
    }
 
    return success;
}

References CalculateHash(), and m_filehash.

Member Data Documentation

m_filehash

std::map<std::string, std::string> Nektar::MetricFile::m_filehash

protected

Stores filenames to perform hash on.

Definition at line 66 of file MetricFile.h.

Referenced by MetricFile(), v_Generate(), and v_Test().

type

std::string Nektar::MetricFile::type

static

Initial value:

=
    GetMetricFactory().RegisterCreatorFunction("FILE", MetricFile::create)

Definition at line 55 of file MetricFile.h.