LibraryInfo.h

#ifndef LIBRARY_INFO_H
#define LIBRARY_INFO_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS

#include <Rose/BinaryAnalysis/AstHash.h>
#include <time.h>
#include "Combinatorics.h"

namespace LibraryIdentification
{
    const std::string unknownLibraryName = "UNKNOWN";
    const std::string multiLibraryName = "MULTIPLE_LIBS";
    

    class LibraryInfo
    {
    public:
    LibraryInfo(const std::string& ilibName, const std::string& ilibVersion, const std::string& ilibHash, const std::string& iarchitecture) :
        libName(ilibName), libVersion(ilibVersion), libHash(ilibHash), architecture(iarchitecture) {
            analysisTime = time(NULL);
        };
        
        
        /*    LibraryInfo(const std::string& ilibName, const std::string& ilibVersion, SgAsmGenericFile* libraryFile) :
        libName(ilibName), libVersion(ilibVersion)
        {
            SgAsmGenericHeader* genericHeader = libraryFile->get_header(SgAsmExecutableFileFormat::ExecFamily::FAMILY_ELF);
            SgAsmElfFileHeader* elfHeader = dynamic_cast<SgAsmElfFileHeader*>(genericHeader);
            ASSERT_require(elfHeader != NULL);

            //Get the architecture
            //SgAsmExecutableFileFormat::InsSetArchitecture enumArchitecture = elfHeader->get_isa();
            architecture = "x86"; //stringify::SgAsmExecutableFileFormat::InsSetArchitecture(enumArchitecture);
            
            //Generate hash of library contents
            //Should make the hash optional via factory method in Combinatorics.h
            Rose::Combinatorics::HasherFnv fnvHash;
            
            SgFileContentList content = libraryFile->content();
            fnvHash.append(&content[0], content.size());
            libHash = fnvHash.toString();
        }
        */
    LibraryInfo(const std::string& ilibHash) : libName(unknownLibraryName), libVersion(unknownLibraryName), libHash(ilibHash), architecture(unknownLibraryName) { };
        

        friend bool operator<(const LibraryInfo& lhs,const LibraryInfo& rhs) 
        {
            return lhs.libHash < rhs.libHash;
        }
        

        static LibraryInfo getUnknownLibraryInfo() 
        {
            return LibraryInfo(unknownLibraryName, unknownLibraryName, unknownLibraryName,  unknownLibraryName);
        };

        static LibraryInfo getMultiLibraryInfo() 
        {
            return LibraryInfo(multiLibraryName, multiLibraryName, multiLibraryName,  multiLibraryName);
        };

        
        std::string toString()
        {
            return libName + "." + libVersion;
        }
        
        

        //   TODO:  add accessors
        //    private:
        //@brief The name of the library
        std::string libName;

        //@brief The version of the library
        std::string libVersion;

        //@brief A hash that should uniquely identify the library
        std::string libHash;

        //@brief Enumeration of instruction set library was build for
        std::string architecture;

        //@brief The time when this library was processed
        time_t analysisTime;

    };
    
}

#endif
#endif