List_checksum Class Reference

#include <checksum_list.h>

Public Member Functions
std::list< std::tuple< std::string, std::list< std::string > > >	chk_list (std::string input, std::string directory)
std::string	get_path (const std::string &filepath)
	List_checksum ()

Private Member Functions
bool	is_integer (const std::string s)
void	sort_in_lists (std::string file, std::string rootname)
std::string	format_as_4_digits (int number)
std::string	format_as_3_digits (int number)
void	remove_cr (std::string &line)
std::string	separator ()
int	compare_lists (std::list< std::string > list1, std::list< std::string > list2)
bool	is_file_valid (std::string file)
void	file_list (std::string directory, std::string rootname)
void	parse_output_files (std::string directory, std::string rootname)
void	parse_animation_files (std::string directory, std::string rootname)
void	parse_th_files (std::string directory, std::string rootname)
void	parse_checksum_files (std::string directory, std::string rootname)

Private Attributes
int	debug =0
std::list< std::string >	deck_file_list
std::list< std::string >	out_file_list
std::list< std::string >	th_file_list
std::list< std::string >	anim_file_list
std::list< std::string >	checksum_file_list
std::map< std::string, std::string >	file_checksum_list
std::list< std::tuple< std::string, std::list< std::string > > >	checksum_list

Detailed Description

Definition at line 53 of file checksum_list.h.

Constructor & Destructor Documentation

List_checksum()

List_checksum::List_checksum

(

)

Definition at line 450 of file checksum_list.cpp.

  {};

Member Function Documentation

chk_list()

list< tuple< string, list< string > > > List_checksum::chk_list	(	std::string	input,
		std::string	directory )

Definition at line 485 of file checksum_list.cpp.

                                                                                          {
  // -------------------------------------------------------------------------------
 
    // Debug prints
    if (debug){
      cout <<  endl;
      cout << "Directory: " << directory << endl;  
      cout << "Rootname: " << rootname << endl;
      cout << endl;
    }
 
    file_list(directory,rootname); // List all files in the directory
  
 
    for (const auto& deck_file : deck_file_list){ 
 
         // If deck is present:
        // Compute checksum from input deck
        MD5Checksum my_checksums;
        my_checksums.parse(deck_file);
        list<string> deck_checksum_list=my_checksums.get_checksums();    // Compute checksum from input deck
 
        // Add Starter computed checksum to the list
        checksum_list.push_back(make_tuple(deck_file,deck_checksum_list)); // Add the checksum list to the collection
 
        if (debug){    
          cout << "Commputed Checksum list from deck: " << endl;
          cout << "===================================" << endl; 
          for (const auto& item : deck_checksum_list){
            cout << item << endl;
          }
          cout << "==============================" << endl;
          cout << endl;
        }
    }
 
    
    // Parse all .out files in the directory
    parse_output_files(directory, rootname);
 
    // parse all animation files in the directory
    parse_animation_files(directory, rootname);
 
    // parse all animation files in the directory
    parse_th_files(directory, rootname);
 
    // Parse all checksum files in the directory
    parse_checksum_files(directory, rootname); 
 
    // print the checksum list from all output files
    if (debug){
      cout << "Checksum list from output files: " << endl;
      cout << "==============================" << endl; 
      for (const auto& item : checksum_list){
        cout << "File: " << get<0>(item) << endl;
        for (const auto& checksum : get<1>(item)){
          cout << "       "<< checksum << endl;
        }
        cout << "==============================" << endl; 
      }
    }
 
    return checksum_list ;
  }

compare_lists()

int List_checksum::compare_lists ( std::list< std::string > list1, std::list< std::string > list2 )

private

Definition at line 102 of file checksum_list.cpp.

                                                                        {
  // -----------------------------------------------------------------------------------  
      if (list1.size() != list2.size()) {
          return 0; // Lists are not equal in size
      }
      auto it1 = list1.begin();
      auto it2 = list2.begin();
      while (it1 != list1.end() && it2 != list2.end()) {
          if (*it1 != *it2) {
              return 0; // Lists are not equal
          }
          ++it1;
          ++it2;
      }
      return 1; // Lists are equal
  }

file_list()

void List_checksum::file_list ( std::string directory, std::string rootname )

private

Definition at line 187 of file checksum_list.cpp.

                                                                     {
 
    std::vector<std::string> files;
 
#ifdef _WIN64
    std::string search_path = directory + rootname + "*";
    WIN32_FIND_DATAA fd;
    HANDLE hFind = ::FindFirstFileA(search_path.c_str(), &fd);
    if (hFind != INVALID_HANDLE_VALUE) {
        do {
            if (!(fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
                string fname(fd.cFileName);
                sort_in_lists(fname,rootname);
            }
        } while (::FindNextFileA(hFind, &fd));
        ::FindClose(hFind);
    }
#else
    string directory_cp = directory;
    if ( directory_cp.length()==0){
         directory_cp="."; 
    }
    DIR* dir = opendir(directory_cp.c_str());
    if (dir) {
        struct dirent* entry;
        while ((entry = readdir(dir)) != nullptr) {
            std::string fname(entry->d_name);
            if (fname.find(rootname) == 0) { // starts with rootname
                sort_in_lists(fname,rootname);
            }
        }
        closedir(dir);
    }
#endif
 
};

format_as_3_digits()

string List_checksum::format_as_3_digits ( int number )

private

Definition at line 64 of file checksum_list.cpp.

                                                     {
    // -----------------------------------------------------------------------------------
        ostringstream oss;
        oss << setw(3) << setfill('0') << number;
        return oss.str();
    }

format_as_4_digits()

string List_checksum::format_as_4_digits ( int number )

private

Definition at line 50 of file checksum_list.cpp.

                                                     {
  // -----------------------------------------------------------------------------------
      ostringstream oss;
      oss << setw(4) << setfill('0') << number;
      return oss.str();
  }

get_path()

std::string List_checksum::get_path

(

const std::string &

filepath

)

Definition at line 457 of file checksum_list.cpp.

                                                           {
  // Find the last occurrence of the path separator
#ifdef _WIN64
  size_t pos = filepath.find_last_of("/\\");
  if (pos == std::string::npos) {
     pos = filepath.find_last_of("/");
  }
#else
  size_t pos = filepath.find_last_of("/");
#endif
  if (pos != std::string::npos) {
      // Extract the substring up to the last separator
      return filepath.substr(0, pos);
  }
  // If no separator is found, return an empty string
  return "";
}

is_file_valid()

bool List_checksum::is_file_valid ( std::string file )

private

Definition at line 229 of file checksum_list.cpp.

                                                 {
      return true;
  }

is_integer()

bool List_checksum::is_integer ( const std::string s )

private

Definition at line 29 of file checksum_list.cpp.

                                                {
   char * p;
   char * s_cchar = (char*)s.c_str();
    // strtol will convert the string to a long integer
    // If the conversion is successful, p will point to the first character after the number
    // If the conversion fails, p will point to the original string
   long converted = strtol(s_cchar, &p, 10);
   if (*p) {
       return false; // Not a valid integer
   }
   return true;
    
 
}

parse_animation_files()

void List_checksum::parse_animation_files ( std::string directory, std::string rootname )

private

Definition at line 291 of file checksum_list.cpp.

                                                                            { 
  // -------------------------------------------------------------------------------------------------------------------------------------------------
    int run_number=1;
    int found_out_file=1;
 
    for (const auto& item : anim_file_list){ 
 
      string anim_file;
      if ( directory.length() > 0 ){
          anim_file = directory + item;
      }else{
          anim_file = item;
      }
 
      CheckSum_Output_Files out;
      FILE *new_file;
      int success=0;
      success=out.open_binary_file(anim_file);
 
      if ( success == 0 ) {
          // cout << "Error: Unable to open file " << anim_file << endl;
          found_out_file=0; // No more .out files to process
      }else{
             if (debug){
                cout << "Parsing file: " << anim_file << endl;
             }
 
 
             list<string> checksum_list_out=out.Animation( );
             out.close_binary_file();
             // Compute file checksum
             checksum file_cs;
             string file_checksum = file_cs.compute_checksum(anim_file);
             string formated_out = anim_file + " : " + file_checksum;
             
             checksum_list.push_back(make_tuple(formated_out,checksum_list_out)); // Add the checksum list to the collection
             file_checksum_list.insert(pair<string,string>(anim_file, file_checksum)); // Add the file,checksum tuple in specific list
 
      
            }
            run_number++;
    }
  }

parse_checksum_files()

void List_checksum::parse_checksum_files ( std::string directory, std::string rootname )

private

Definition at line 391 of file checksum_list.cpp.

                                                                           {
 
    for (const auto& item : checksum_file_list){ 
 
      string chkfile;
      if ( directory.length() > 0 ){
          chkfile = directory + item;
      }else{
          chkfile = item;
      }
             
      bool valid_file = is_file_valid(chkfile);
      string valid_message;
      if (valid_file) {
          valid_message = "Valid Fingerprint";
      }else{
          valid_message = "Invalid Fingerprint";
      }
 
      fstream new_file;
      new_file.open(chkfile, ios::in);
 
      if ( !new_file.is_open() ) {
          // cout << "Error: Unable to open file " << outfile << endl;
      }else{
             if (debug){
                cout << "Parsing file: " << chkfile << endl;
             }
             // Grab file checksums
             CheckSum_Output_Files out;
             std::list<std::tuple<std::string,std::string>> checksum_list_chk;
             checksum_list_chk=out.Checksum_File( &new_file );
             new_file.close();
 
             string formated_out = chkfile + " : " ;
             list<string> verify_checksum_list;
 
             // print the checksum list
             for (const auto& item2 :checksum_list_chk){
                string filename = get<0>(item2);
                string checksum = get<1>(item2);
 
                string computed_checksum= file_checksum_list[filename];
 
                if (computed_checksum.length() > 0){
                   if (checksum == computed_checksum){
                      verify_checksum_list.push_back(filename + "_" + "Valid Checksum" );
                   }else{
                      verify_checksum_list.push_back(filename + "_" + "Failed checksum check : File: "+ checksum + "   Computed: " + computed_checksum);
                   }
                }
             }
             checksum_list.push_back(make_tuple(formated_out,verify_checksum_list)); // Add the checksum list to the collection
 
      }
    }
  };

parse_output_files()

void List_checksum::parse_output_files ( std::string directory, std::string rootname )

private

Definition at line 244 of file checksum_list.cpp.

                                                                         {
  // -------------------------------------------------------------------------------------------------------------------------------------------------
  
    for (const auto& item : out_file_list){ 
 
      string outfile;
      if ( directory.length() > 0 ){
          outfile = directory + item;
      }else{
          outfile = item;
      }
 
      fstream new_file;
      new_file.open(outfile, ios::in);
 
      if ( !new_file.is_open() ) {
          // cout << "Error: Unable to open file " << outfile << endl;
      }else{
             if (debug){
                cout << "Parsing file: " << outfile << endl;
             }
             // Grab file checksums
             CheckSum_Output_Files out;
             list<string> checksum_list_out=out.Out_File( &new_file );
             new_file.close();
 
             // Compute file checksum
             checksum file_cs;
             string file_checksum = file_cs.compute_checksum(outfile);
             string formated_out = outfile + " : " + file_checksum;
 
             checksum_list.push_back(make_tuple(formated_out,checksum_list_out)); // Add the checksum list to the collection
             file_checksum_list.insert(pair<string,string>(outfile, file_checksum)); // Add the file,checksum tuple in specific list
      }
    }
  }

parse_th_files()

void List_checksum::parse_th_files ( std::string directory, std::string rootname )

private

Definition at line 345 of file checksum_list.cpp.

                                                                     { 
  // -------------------------------------------------------------------------------------------------------------------------------------------------
      int found_out_file=1;
  
    for (const auto& item : th_file_list){ 
 
      string th_file;
      if ( directory.length() > 0 ){
          th_file = directory + item;
      }else{
          th_file = item;
      }
 
      CheckSum_Output_Files out;
      int success = out.open_binary_file(th_file);
  
        if ( success == 0 ) {
            // cout << "Error: Unable to open file " << anim_file << endl;
            found_out_file=0; // No more .out files to process
        }else{
                 if (debug){
                    cout << "Parsing file: " << th_file << endl;
                 }
                 list<string> checksum_list_th=out.Time_History();
                 out.close_binary_file();
 
                 checksum file_cs;
                 string file_checksum = file_cs.compute_checksum(th_file);
                 string formated_out = th_file + " : " + file_checksum;
 
                 checksum_list.push_back(make_tuple(formated_out,checksum_list_th)); // Add the checksum list to the collection
                 file_checksum_list.insert(pair<string,string>(th_file, file_checksum)); // Add the file,checksum tuple in specific list
              }
      }
    }

remove_cr()

void List_checksum::remove_cr ( std::string & line )

private

Definition at line 74 of file checksum_list.cpp.

                                               {
    line.erase(std::remove(line.begin(), line.end(), '\r'), line.end());
 }

separator()

string List_checksum::separator ( )

private

Definition at line 85 of file checksum_list.cpp.

                                 {
  // -----------------------------------------------------------------------------------
    #ifdef _WIN64
      return "\\"; // Windows separator
    #else
      return "/";  // Unix separator
    #endif
  }

sort_in_lists()

void List_checksum::sort_in_lists ( std::string file, std::string rootname )

private

Definition at line 127 of file checksum_list.cpp.

                                                                     {
 
      // Grab the file extension
      size_t pos = string(fname).find_last_of('.');
      std::string extension = fname.substr(pos + 1);
 
      // Input deck
      string input_deck=rootname+"_0000.rad";
      if (fname == input_deck){
          deck_file_list.push_back(fname);
      }
 
      if (extension == "out") {
             out_file_list.push_back(fname);
      }
      if (extension == "thy") {
             th_file_list.push_back(fname);
      }
 
      if (extension == "checksum") {
          int filename_length = rootname.length()+5+extension.length()+1;
          if (fname.length() == filename_length){
             std::string str_runnumber=fname.substr(rootname.length()+1,4); 
             if (is_integer(str_runnumber)){
                   checksum_file_list.push_back(fname);
             }
          }
      }
 
      // Old styled files Axxx, Txxx
      string rd_run;
      string file_A;
      if (extension == "gz"){
            rd_run = fname.substr(fname.length()-6,3);
            file_A=fname.substr(0,fname.length()-6);
      }else{
            rd_run = fname.substr(fname.length()-3);
            file_A=fname.substr(0,fname.length()-3);        
      }
      string anim_pattern=rootname+ "A";
      if ( is_integer(rd_run)  && anim_pattern == file_A){
          anim_file_list.push_back(fname);
      }
      string th_pattern=rootname+ "T";
      string file_T=fname.substr(0,fname.length()-2);
      rd_run = fname.substr(fname.length()-2);
      if ( is_integer(rd_run)  && th_pattern == file_T){
          th_file_list.push_back(fname);
      }
 
  }

Field Documentation

anim_file_list

std::list<std::string> List_checksum::anim_file_list

private

Definition at line 69 of file checksum_list.h.

checksum_file_list

std::list<std::string> List_checksum::checksum_file_list

private

Definition at line 70 of file checksum_list.h.

checksum_list

std::list<std::tuple<std::string,std::list<std::string> > > List_checksum::checksum_list

private

Definition at line 72 of file checksum_list.h.

debug

int List_checksum::debug =0

private

Definition at line 62 of file checksum_list.h.

deck_file_list

std::list<std::string> List_checksum::deck_file_list

private

Definition at line 66 of file checksum_list.h.

file_checksum_list

std::map<std::string,std::string> List_checksum::file_checksum_list

private

Definition at line 71 of file checksum_list.h.

out_file_list

std::list<std::string> List_checksum::out_file_list

private

Definition at line 67 of file checksum_list.h.

th_file_list

std::list<std::string> List_checksum::th_file_list

private

Definition at line 68 of file checksum_list.h.

---

The documentation for this class was generated from the following files:

• starter/share/includes/checksum_list.h
• starter/source/output/checksum/checksum_list.cpp