MD5Checksum Class Reference

#include <checksum_model.h>

Public Member Functions
	MD5Checksum ()
void	parse (std::string filenam)
int	count ()
void	member (int N, char *checksum_title, int *len_title, char *checksum, int *len_checksum)
std::list< std::string >	get_checksums ()
void	print ()

Private Member Functions
void	remove_carriage_return (std::string &line)
std::string	separator ()
std::string	get_path (const std::string &filepath)
void	new_checksum (std::string title, std::list< std::tuple< int, std::string, md5_state_t, std::string > > *md5_states_tmp)
void	process_checksum (std::string line, std::list< std::tuple< int, std::string, md5_state_t, std::string > > *md5_states_tmp)
void	end_checksum (std::list< std::tuple< int, std::string, md5_state_t, std::string > > *md5_states_tmp)
void	finalize_checksum (std::list< std::tuple< int, std::string, md5_state_t, std::string > > *md5_states_tmp)
int	file_read (std::string filename, std::string deck_directory, int level, std::list< std::tuple< int, std::string, md5_state_t, std::string > > *md5_states_tmp)

Private Attributes
std::list< std::tuple< int, std::string, md5_state_t, std::string > >	md5_states
int	debug =0

Detailed Description

Definition at line 40 of file checksum_model.h.

Constructor & Destructor Documentation

MD5Checksum()

MD5Checksum::MD5Checksum

(

)

Definition at line 232 of file checksum_model.cpp.

   {};

Member Function Documentation

count()

int MD5Checksum::count

(

)

Definition at line 252 of file checksum_model.cpp.

                           {
   // --------------------------------------------------------------------------------------------------------
     return md5_states.size();
   }

end_checksum()

void MD5Checksum::end_checksum ( std::list< std::tuple< int, std::string, md5_state_t, std::string > > * md5_states_tmp )

private

Definition at line 107 of file checksum_model.cpp.

                                                                                            {
  // --------------------------------------------------------------------------------------------------------------------
      int state=-1;
      for (auto& item : *md5_states_tmp ) {
            state=get<0>(item);
             if (state == 1) {
                get<0>(item) = 0;   // Set Active flag to 0
 
                // Finish the MD5 checksum
                md5_state_t state = get<2>(item);
                unsigned char md5[16];
                md5_finish (&state, md5);  
 
                // Add MD5 in hexadecimal format in tuplet
                ostringstream formatted_line;
                for (int i = 0; i < 16; ++i) {
                    formatted_line << hex << setw(2) << setfill('0') << static_cast<int>(md5[i]);
                }
                get<3>(item)=formatted_line.str();
                break;
             }
      }
  };

file_read()

int MD5Checksum::file_read ( std::string filename, std::string deck_directory, int level, std::list< std::tuple< int, std::string, md5_state_t, std::string > > * md5_states_tmp )

private

Definition at line 169 of file checksum_model.cpp.

                                                                                                                                         {
  // -----------------------------------------------------------------------------------------------------------------------------
       string chksum_start=( "/CHECKSUM/START");
       string chksum_end=(   "/CHECKSUM/END");
       string chksum_include=( "#include ");
       fstream new_file;
       new_file.open(filename, ios::in);
       
       // Stop  after 15 levels of recursion
       if (level > 15) return 0;
 
       if ( !new_file.is_open() ) {
          return -1;
       }
 
       string line;
       while (getline(new_file, line)) {
 
          remove_carriage_return(line); // Remove carriage return characters
          // Search for /CHECKSUM/START keyword
         if (line == chksum_start) {
           string title;
           getline(new_file, title);
           remove_carriage_return(title); // Remove carriage return characters
           new_checksum(title,md5_states_tmp);
           continue;
         }
         // Search for /CHECKSUM/END keyword
         if (line == chksum_end) {
           end_checksum(md5_states_tmp);
           continue;
         }
 
         string comp=line.substr(0,chksum_include.length());
         if (comp == chksum_include) {
           // Process include files
           string include_file = line.substr(chksum_include.length());
           if (deck_directory.length() > 0){
              include_file = deck_directory+separator()+include_file; // Get the path of the file
           }
           if (debug){
              cout << "Include file: " << include_file << endl;
           }
        //   include_file.erase( remove(include_file.rbegin(), include_file.end(), ' '), include_file.end());
           // debug cout << "Include file: " << include_file << endl;
           file_read(include_file,deck_directory, level + 1,md5_states_tmp);
           continue;
         }
 
         if (line[0] == '#') {
           // Skip comment lines
           continue;
         }
         process_checksum(line,md5_states_tmp);
        
       }
       new_file.close();
       return 0;
      }

finalize_checksum()

void MD5Checksum::finalize_checksum ( std::list< std::tuple< int, std::string, md5_state_t, std::string > > * md5_states_tmp )

private

Definition at line 137 of file checksum_model.cpp.

                                                                                                 {
    // --------------------------------------------------------------------------------------------------------------------
        int state=-1;
        for (auto& item : *md5_states_tmp ) {
              state=get<0>(item);
               if (state == 1) {
                  get<0>(item) = 0;   // Set Active flag to 0
  
                  // Finish the MD5 checksum
                  md5_state_t state = get<2>(item);
                  unsigned char md5[16];
                  md5_finish (&state, md5);  
  
                  // Add MD5 in hexadecimal format in tuplet
                  ostringstream formatted_line;
                  for (int i = 0; i < 16; ++i) {
                      formatted_line << hex << setw(2) << setfill('0') << static_cast<int>(md5[i]);
                  }
                  get<3>(item)=formatted_line.str();
               }
        }
    };

get_checksums()

list< string > MD5Checksum::get_checksums

(

)

Definition at line 303 of file checksum_model.cpp.

                                          {
   // --------------------------------------------------------------------------------------------------------
      list<string> checksums;
      for (const auto& item : md5_states){
        if (get<0>(item) == 0){
            string chksum_item=get<1>(item)+"_"+get<3>(item);
            checksums.push_back(chksum_item);
        }
      }
      return checksums;
   }

get_path()

std::string MD5Checksum::get_path ( const std::string & filepath )

private

Definition at line 50 of file checksum_model.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 "";
  }

member()

void MD5Checksum::member	(	int	N,
		char *	checksum_title,
		int *	len_title,
		char *	checksum,
		int *	len_checksum )

Definition at line 268 of file checksum_model.cpp.

                                                                                                        {
   // --------------------------------------------------------------------------------------------------------
    int count= md5_states.size();
    if (N > count) {
      cout << "Error: N=" << N << " is greater than the number of checksums " << count << endl;
      checksum[0]='\0';
      checksum_title[0]='\0';
      *len_checksum=0;
      *len_title=0;
    }else{
      auto it = md5_states.begin();
      advance(it, N-1); // Move iterator to the N-th element (0-based index)
 
      // Copy checksum_title
      int size_title = get<1>(*it).size();
      get<1>(*it).copy(checksum_title ,size_title);
      checksum_title[size_title]='\0';
      *len_title=size_title;
 
      // Copy checksum
      int size_checksum = get<3>(*it).size();
      get<3>(*it).copy(checksum ,size_checksum);
      checksum[size_checksum]='\0';
      *len_checksum=size_checksum;
 
      // cout << "Member " << *N << " Checksum : " << get<1>(*it) << " " <<  get<3>(*it) << endl;
    }
  }

new_checksum()

void MD5Checksum::new_checksum ( std::string title, std::list< std::tuple< int, std::string, md5_state_t, std::string > > * md5_states_tmp )

private

Definition at line 69 of file checksum_model.cpp.

                                                                                                           {
  // ------------------------------------------------------------------------------------------------------------------------  
  // CHECKSUM/START was met, create a new checksum state
  // input:
  // title : title of the checksum
  // input / output:
  // md5_states_tmp : list of checksums computed in the file
  // ------------------------------------------------------------------------------------------------------------------------
    md5_state_t new_md5;
    md5_init(&new_md5);
    string md5_digest(16,'0');
    md5_states_tmp->push_front(make_tuple(1,title,new_md5,md5_digest));
  };

parse()

void MD5Checksum::parse

(

std::string

filenam

)

Definition at line 236 of file checksum_model.cpp.

                                          {
      list<tuple<int,string, md5_state_t, string>>  md5_states_tmp;
      string deck_directory = get_path(filenam); // Get the directory of the file
      file_read(filenam,deck_directory,0,&md5_states_tmp);
      finalize_checksum(&md5_states_tmp); // Finalize all active checksums
      // intvert the list to have it in deck order
      for (const auto& item : md5_states_tmp){
          md5_states.push_front(item); // Add the checksums to the main list
      }
 
      md5_states_tmp.clear(); // Clear the temporary list
   };

print()

void MD5Checksum::print

(

)

Definition at line 318 of file checksum_model.cpp.

                          {
   // ------------------------
      cout << "Checksum list " << endl;
      cout << "==============" << endl;
      for (const auto& item : md5_states){
        if (get<0>(item) == 0){
            cout << "Checksum : " << get<1>(item) << " " <<  get<3>(item) << endl;
        }
      }
   }

process_checksum()

void MD5Checksum::process_checksum ( std::string line, std::list< std::tuple< int, std::string, md5_state_t, std::string > > * md5_states_tmp )

private

Definition at line 90 of file checksum_model.cpp.

                                                                                                             {
  // ------------------------------------------------------------------------------------------------------------------------
      for (auto& item : *md5_states_tmp ) {
         if (get<0>(item) == 1){
            md5_state_t state = get<2>(item);
            md5_append( &state, (const md5_byte_t *) line.c_str(), line.length() );
            get<2>(item) = state;
         }
        }
  };

remove_carriage_return()

void MD5Checksum::remove_carriage_return ( std::string & line )

private

Definition at line 30 of file checksum_model.cpp.

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

separator()

string MD5Checksum::separator ( )

private

Definition at line 39 of file checksum_model.cpp.

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

Field Documentation

debug

int MD5Checksum::debug =0

private

Definition at line 48 of file checksum_model.h.

md5_states

std::list<std::tuple<int,std::string, md5_state_t, std::string> > MD5Checksum::md5_states

private

Definition at line 41 of file checksum_model.h.

---

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

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