Instantiate the Thread Worker Class. More...

#include <worker.h>

Inheritance diagram for Worker:

Collaboration diagram for Worker:

Public Slots
void	DoWork (PROJECT_INFORMATION *ProjectInfo)
	Process the Generation of Documentation by Doxygen & other processes.

Signals
void	WorkDone (PROJECT_INFORMATION *ProjectInfo)
void	SendLogEntry (REMOTE_LOG_ENTRY LogEntry)

Public Member Functions
	Worker (QObject *parent=nullptr)
	Worker Class Constructor.

Private Member Functions
void	LogAdd (LOGGING_SEVERITY Severity, LOGGING_MODE Mode, const QString Message)
	Send Message to the Log.
void	DoDoxygen (PROJECT_INFORMATION *ProjectInfo)
	Run Doxygen to Generate the Source Documentaiton.
QString	UpdateLine (PROJECT_INFORMATION *Project, QString SourceLine)
	Process text substitutions for a single line.
bool	UpdateFile (PROJECT_INFORMATION *Project, QString SourceFile, QString DestinationFile)
	Process text substituitions for a complete text file.
bool	TranslateRecursively (PROJECT_INFORMATION *Store, const QString &srcFilePath, const QString &tgtFilePath)
	Recursively process text substituition for a Directory Tree.
bool	CleanDirectory (QString Directory)
	Clean a Directory Tree by recursively removing all files and subdirectories.
bool	PreProcessProject (PROJECT_INFORMATION *ProjectInfo)
	Preprocess the Project's Documentation.
bool	TrimDirectory (QString Directory, QStringList FileFilter)
	Remove files defined by the FileFilter from the Directory.
QString	CountLines (PROJECT_INFORMATION *Store, QString Directory)
QString	FindLibraries (PROJECT_INFORMATION *Store)
	Find the shared libraries the program needs to run.
QString	ParserLddResults (QString ResultFilename)
	Converts the Library List into an HTML compatible format.
bool	CreateSourceArchive (PROJECT_INFORMATION *Store)
	Create an Archive using git.
QString	CppCheck (PROJECT_INFORMATION *ProjectInfo)
	Conduct Static Analysis of C++ code.
bool	CreateSourceListFile (const QString Directory, const QString ResultFileName, const QString DevLanguage)
	Create a List of Project Software Source Files.
bool	RecursiveCopy (QString Source, QString Destination)
bool	CreateInstallScript (PROJECT_INFORMATION *ProjectInfo)
bool	CreatePublishList (PROJECT_INFORMATION *ProjectInfo)

Private Attributes
QString	autodoc_dir
QStringList	source_dirs
QStringList	source_filter
QStringList	docs_dirs
QStringList	docs_filter
QStringList	all_filter
QString	leadin_string
QString	leadout_string
QSqlDatabase	db

Detailed Description

Instantiate the Thread Worker Class.

Class for running on the Thread.

Constructor & Destructor Documentation

◆ Worker()

Worker::Worker ( QObject * parent = nullptr )

explicit

Worker Class Constructor.

Parameters

parent Pointer to the Parent Object

Definition at line 9 of file worker.cpp.

    : QObject{ parent }, leadin_string ("[#"), leadout_string ("#]")
{
    // Define the List of Source Directories of Containing Possible Documentation or Source Files
    // Documentation files are composed exclussively of .dox files along with .dia files and .uml
    // files.
 
    docs_filter   << "*.dox" << "Doxyfile" << "footer.html" << "header.html" << "customdoxygen.css" << "*.dia" << "*.uml" << "*.txt" << "*.pdf" << "*.doc" << "*.docx" << "*.tcw" << "*.tct" << "*.dwg" ;
 
    source_dirs << "/autoinstall/" << "/autosrc/";
    source_filter << "*.c" << "*.cpp" << "*.h" << ".hpp" << "*.ui" << "*.pro" << "*.pro.user" << "*.qrc" << "*.php" << "*.php" << "*.php4" << "*.php5" << "*.py" << "*.f" << "*.for" << "*.js" << "*.sh" << "*.sql";
 
    all_filter << "*";
}

References all_filter, docs_filter, leadin_string, leadout_string, source_dirs, and source_filter.

Member Function Documentation

◆ CleanDirectory()

bool Worker::CleanDirectory ( QString Directory )

private

Clean a Directory Tree by recursively removing all files and subdirectories.

Parameters

Directory Directory to be removed recursively and recreated

Returns: Success (true) or Failure (false)

Definition at line 387 of file worker.cpp.

{
    bool result = false;
    // Check if the Directory Exists
    QDir dir(Directory);
 
    // Delete the Directory if it Exists
    if (dir.exists())
    {
        dir.removeRecursively();
    }
 
    // Recreate the Main Directory
    result = dir.mkpath(Directory);
 
    return(result);
}

Referenced by PreProcessProject().

Here is the caller graph for this function:

◆ CountLines()

QString Worker::CountLines	(	PROJECT_INFORMATION *	Store,
		QString	Directory )

private

Definition at line 426 of file worker.cpp.

{
    QString html_result_table = "<TABLE BORDER=1><TR><TH>Language</TH><TH>Files</TH><TH>Blank</TH><TH>Comment</TH><TH>Code</TH></TR>";
    QString html_result_rows = "";
    QString html_result_totals = "";
 
    QDir::setCurrent( Directory );
    // Get the Lines Of Code Information
    QProcess cloc;
    QString scratchdir = Store->ProgramInformation.LocalDevelopmentDirectory + "/" + Store->ProjectDesc.ProjectIdent + "/scratch/";
    QString output_file = scratchdir + "cloc_output.txt";
 
    cloc.setStandardErrorFile( scratchdir + "cloc_error.txt",  QIODevice::WriteOnly | QIODevice::Text  );
    cloc.setStandardOutputFile( scratchdir + "cloc_output.txt", QIODevice::WriteOnly | QIODevice::Text  );
    QStringList Arg;
    Arg << Directory << "--no-recurse";
    cloc.start( "cloc", QStringList() << Arg );
    if (!cloc.waitForStarted())
    {
        LogAdd( LOG_ERROR, MODE_THREAD, "cloc Process did NOT Start." );
        html_result_table += "<TR><TD COLSPAN=5>Unable to Count Lines of Code.</TD></TR>";
    }
    else
    {
        LogAdd( LOG_DEBUG, MODE_THREAD, QString( "Started cloc Process " ) );
    }
    if (!cloc.waitForFinished(100000))
    {
        LogAdd( LOG_ERROR, MODE_THREAD, "cloc Process did NOT End." );
        html_result_table += "<TR><TD COLSPAN=5>Error occurred during Count Lines of Code.</TD></TR>";
    }
    else
    {
        LogAdd( LOG_DEBUG, MODE_THREAD, "cloc Process finished." );
 
        // Read the Ouptut of the CLOC Program
        QFile cloc_file(output_file);
        if ( !cloc_file.open( QIODevice::ReadOnly | QIODevice::Text ) )
        {
            LogAdd( LOG_ERROR, MODE_FILE, "Unable to open cloc result file." );
            html_result_table += "<TR><TD COLSPAN=5>Error occurred reading cloc results.</TD></TR>";
        }
        else
        {
            int     comment_count = 0;
            QString text_line;
 
            while( !cloc_file.atEnd() )
            {
                text_line = cloc_file.readLine();
                if ( text_line.contains( "----", Qt::CaseInsensitive ) )
                {
                    comment_count++;
                }
                else
                {
                    // Process Column Headers
                    if ( comment_count == 1 )
                    {
                        QStringList tokens= text_line.split(" ",Qt::SkipEmptyParts);
 
                        html_result_table += "<TR><TD>" + tokens[0] + "</TD><TD>" + tokens[1] + "</TD><TD>" + tokens[2] + "</TD><TD>" +
                                             tokens[3] + "</TD><TD>" + tokens[4] + "</TD></TR>";
                    }
 
                    //Process Report Rows
                    else if ( comment_count == 2 )
                    {
 
                        QString language_name = text_line.first(25);
                        language_name = language_name.trimmed();
                        text_line = text_line.mid(25);
                        QStringList tokens= text_line.split(" ",Qt::SkipEmptyParts);
 
                        html_result_rows += "<TR><TD><B><span style=\"color:red\">" + language_name + "</span></B></TD><TD><B><span style=\"color:red\">" + tokens[0] +
                                            "</span></B></TD><TD><B><span style=\"color:red\">" + tokens[1] + "</span></B></TD><TD><B><span style=\"color:red\">" +
                                            tokens[2] + "</span></B></TD><TD><B><span style=\"color:red\">" + tokens[3] + "</span></B></TD></TR>";
                    }
                    else if (comment_count ==3)
                    {
                        QStringList tokens= text_line.split(" ",Qt::SkipEmptyParts);
 
                        html_result_totals = "<TR><TD><B>" + tokens[0] + "</B></TD><TD>" + tokens[1] + "</TD><TD>" + tokens[2] + "</TD><TD>" +
                                             tokens[3] + "</TD><TD>" + tokens[4] + "</TD></TR>";
                    }
                }
            }
        }
    }
 
    // Finish table and Return Result
    html_result_table += html_result_rows + html_result_totals + "</TABLE>";
 
    // Remove Scratch Files
    QFile::remove(Store->ProgramInformation.LocalDevelopmentDirectory + "cloc_error.txt"  );
    QFile::remove( Store->ProgramInformation.LocalDevelopmentDirectory + "cloc_output.txt" );
    return ( html_result_table );
};

References PROGRAM_INFORMATION::LocalDevelopmentDirectory, LOG_DEBUG, LOG_ERROR, LogAdd(), MODE_FILE, MODE_THREAD, PROJECT_INFORMATION::ProgramInformation, PROJECT_INFORMATION::ProjectDesc, and PROJECT_DESCRIPTION::ProjectIdent.

Referenced by PreProcessProject().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CppCheck()

QString Worker::CppCheck ( PROJECT_INFORMATION * ProjectInfo )

private

Conduct Static Analysis of C++ code.

Parameters

ProjectInfo Pointer to Inforamtion about the Project

Returns: String containing the result of the Static Analysis

Definition at line 803 of file worker.cpp.

{
    QString result_table;
    QString output_file = ProjectInfo->ProjectDesc.ProjectDirectory + "/scratch/cppcheck_output.txt";
    QString error_file = ProjectInfo->ProjectDesc.ProjectDirectory + "/scratch/cppcheck_error.txt";
    QString file_list  = ProjectInfo->ProjectDesc.ProjectDirectory + "/scratch/file_list.txt";
 
    // Remove any legacy file list so that any file that exists after this routine will be current
    QFile file(file_list);
    if (file.remove())
    {
        LogAdd( LOG_DEBUG, MODE_FILE, QString("Deleted File List: %1").arg(file_list));
    }
    else
    {
        LogAdd( LOG_ERROR, MODE_FILE, QString("Could not delete File List: %1").arg(file_list));
    }
 
    // Set the Directory
    QString directory = ProjectInfo->ProjectDesc.ProjectDirectory + "/source/" + ProjectInfo->ProjectDesc.ExeName;
    QDir::setCurrent(directory);
 
    // Select the Files to Process
    if ( CreateSourceListFile( directory, file_list, ProjectInfo->LangFamilyInfo.ShortName ) )
    {
        // Initialise the cppcheck command line
        QProcess cppcheck;
        cppcheck.setStandardErrorFile(  error_file,  QIODevice::WriteOnly | QIODevice::Text  );
        cppcheck.setStandardOutputFile( output_file, QIODevice::WriteOnly | QIODevice::Text  );
        QStringList arg;
        arg << "--enable=all" << "-UDEBUG" << "--inconclusive" << QString( "--file-list=" ) + file_list;
 
        cppcheck.start( "cppcheck", arg );
        if (!cppcheck.waitForStarted(10000))
        {
            LogAdd( LOG_ERROR, MODE_THREAD, "cppcheck Process did NOT Start." );
            result_table += "ERROR - Unable to scan .cpp code.<BR>";
        }
        else
        {
            LogAdd( LOG_DEBUG, MODE_THREAD, QString( "Started cppcheck Process " ) );
        }
        if (!cppcheck.waitForFinished(100000))
        {
            LogAdd( LOG_ERROR, MODE_THREAD, "ccpcheck Process did NOT End." );
            result_table += "ERROR - cppcheck failed during execution.<BR>";
        }
        else
        {
            LogAdd( LOG_DEBUG, MODE_THREAD, "ccpcheck Process finished." );
 
            // Read the Ouptut of the ccpcheck Program
            QFile ccpcheck_file( error_file );
            if ( !ccpcheck_file.open( QIODevice::ReadOnly | QIODevice::Text ) )
            {
                LogAdd( LOG_ERROR, MODE_FILE, "Unable to open ccpcheck result file." );
                result_table += "ERROR - Unable to read ccpcheck results.<BR>";
            }
            else
            {
                while( !ccpcheck_file.atEnd() )
                {
                    QString line = ccpcheck_file.readLine();
                    line.replace("/*!<", "[").replace("*/", "]");
                    result_table += line  + "<BR>";
                }
 
                // Write to the Website Directory
                QString check_filename = ProjectInfo->ProgramInformation.PrimaryWebsiteDirectory + "/projects/" + ProjectInfo->ProjectDesc.ProjectIdent + "/html/" + CPP_CHECK_FILE;
                QFile cpp_file(check_filename);
                if (cpp_file.open(QIODevice::ReadWrite))
                {
                    QTextStream stream(&cpp_file);
                    stream << result_table << Qt::endl;
 
                     LogAdd( LOG_DEBUG, MODE_THREAD, check_filename + " CCP Check written to Web Directory" );
                }
                else
                {
                    LogAdd( LOG_ERROR, MODE_THREAD, check_filename + " CCP Check NOT written to Web Directory" );
                }
            }
        }
    }
    else
    {
        LogAdd( LOG_ERROR, MODE_FILE, "Unable to list Files for cppcheck." );
    }
    return(result_table);
};

References CPP_CHECK_FILE, CreateSourceListFile(), PROJECT_DESCRIPTION::ExeName, PROJECT_INFORMATION::LangFamilyInfo, LOG_DEBUG, LOG_ERROR, LogAdd(), MODE_FILE, MODE_THREAD, PROGRAM_INFORMATION::PrimaryWebsiteDirectory, PROJECT_INFORMATION::ProgramInformation, PROJECT_INFORMATION::ProjectDesc, PROJECT_DESCRIPTION::ProjectDirectory, PROJECT_DESCRIPTION::ProjectIdent, and LANG_FAMILY_INFO::ShortName.

Referenced by PreProcessProject().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CreateInstallScript()

bool Worker::CreateInstallScript ( PROJECT_INFORMATION * ProjectInfo )

private

Definition at line 935 of file worker.cpp.

{
    bool result;
 
    // Find the Source Directory
    QString source_directory = ProjectInfo->ProjectDesc.ProjectDirectory + "/autoinstall";
 
    // Set the Destination Directory
    QString destination_directory = ProjectInfo->ProjectDesc.ProjectDirectory + "/scripts";
 
    // Translate the File Recuresively
    result = TranslateRecursively(ProjectInfo, source_directory, destination_directory);
 
    return(result);
}

References PROJECT_INFORMATION::ProjectDesc, PROJECT_DESCRIPTION::ProjectDirectory, and TranslateRecursively().

Referenced by DoWork().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CreatePublishList()

bool Worker::CreatePublishList ( PROJECT_INFORMATION * ProjectInfo )

private

Definition at line 799 of file worker.cpp.

800{

801}

Referenced by DoWork().

Here is the caller graph for this function:

◆ CreateSourceArchive()

bool Worker::CreateSourceArchive ( PROJECT_INFORMATION * Store )

private

Create an Archive using git.

Parameters

Store Pointer to the Project's Inforamtion

Returns: Success (true) or Failure (false)

Definition at line 650 of file worker.cpp.

{
    bool result = false;
 
    // Check if this should be Invoked
    if (!(ProjectInfo->ProjectDesc.ProjectOptions & CREATE_SOURCE_ARCHIVE))
    {
        return(false);
    }
    else
    {
        QString destination_path = ProjectInfo->ProgramInformation.PrimaryWebsiteDirectory + "/projects/" + ProjectInfo->ProjectDesc.ProjectIdent + "/archive";
        QDir dir;
        if (!dir.mkpath(destination_path))
        {
            LogAdd( LOG_ERROR, MODE_FILE, destination_path + QString( " archive directory NOT created" ) );
        }
        else
        {
            LogAdd( LOG_DEBUG, MODE_FILE, destination_path + QString( " archive directory created" ) );
 
            // Generate the Archive
            QString source_path = ProjectInfo->ProgramInformation.LocalDevelopmentDirectory + "/" + ProjectInfo->ProjectDesc.ProjectIdent + "/source/" + ProjectInfo->ProjectDesc.ExeName + "/";
            dir.cd( source_path );
            QString archive_file = destination_path + "/" + ProjectInfo->ProjectDesc.ExeName + ".tar.gz";
 
            QProcess tar;
            QStringList Arg;
            Arg << "-czf" << archive_file << "--exclude=build" << source_path;
            tar.start( "tar", QStringList() << Arg );
            if (!tar.waitForStarted())
            {
                LogAdd( LOG_ERROR, MODE_THREAD, "tar did NOT Start." );
            }
            else
            {
                LogAdd( LOG_DEBUG, MODE_THREAD, QString( "Started tar Process with " ) + QChar('"' ) + Arg.join( " " )+ QChar('"' ) );
            }
            tar.closeWriteChannel();
            if (!tar.waitForFinished())
            {
                LogAdd( LOG_ERROR, MODE_THREAD, "tar did NOT End." );
            }
            else
            {
                LogAdd( LOG_DEBUG, MODE_THREAD, "tar finished." );
                result = true;
            }
        }
        return(result);
    }
}

References CREATE_SOURCE_ARCHIVE, PROJECT_DESCRIPTION::ExeName, PROGRAM_INFORMATION::LocalDevelopmentDirectory, LOG_DEBUG, LOG_ERROR, LogAdd(), MODE_FILE, MODE_THREAD, PROGRAM_INFORMATION::PrimaryWebsiteDirectory, PROJECT_INFORMATION::ProgramInformation, PROJECT_INFORMATION::ProjectDesc, PROJECT_DESCRIPTION::ProjectIdent, and PROJECT_DESCRIPTION::ProjectOptions.

Referenced by DoWork().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CreateSourceListFile()

bool Worker::CreateSourceListFile	(	const QString	Directory,
		const QString	ResultFileName,
		const QString	DevLanguage )

private

Create a List of Project Software Source Files.

Parameters

Directory	Directory Holding the Source Files
ResultFileName	The name of the file holding the results
DevLanguage	The Software Development Language

Returns: Success (true) or Failure (false)

Definition at line 703 of file worker.cpp.

{
    bool result;
 
    QString dev_language = DevLanguage.toUpper();
 
    // Define What Filename To Search For
    QStringList file_filter;
 
    // Set the Filter based on the Language
    if ( dev_language == "ASM" )
    {
        file_filter << "*.asm" << "*.s";
    }
    else if ( dev_language == "BASH" )
    {
        file_filter << "*.sh";
    }
    else if ( dev_language == "BASIC" )
    {
        file_filter << "*.bas" << "*.vb";
    }
    else if ( dev_language == "C++" )
    {
        file_filter << "*.cpp" << "*.c" << "*.cxx" << "*.ino" << "*.h" << "*.hpp";
    }
    else if ( dev_language == "CAD" )
    {
        file_filter << "*.tcw" << "*.tct" << "*.dwg" << "*.stl" << "*.dxf";
    }
    else if ( dev_language == "FORTRAN" )
    {
        file_filter << "*.f" << "*.f90" << "*.f95" << "*.f03";
    }
    else if ( dev_language == "HTML" )
    {
        file_filter << "*.htm" << "*.html" << "*.css" << "*.js" << "*.php";
    }
    else if ( dev_language == "JAVA" )
    {
        file_filter << "*.java" << "*.jar" << "*.ins";
    }
    else if ( dev_language == "JAVASCRIPT" )
    {
        file_filter << "*.js";
    }
    else if ( dev_language == "OCTAVE" )
    {
        file_filter << "*.m";
    }
    else if ( dev_language == "PERL" )
    {
        file_filter << "*.pl" << "*.pm";
    }
    else if ( dev_language == "PHP" )
    {
        file_filter << "*.php" << "*.phtml" << "*.php3" <<  "*.php4" << "*.php5" << "*.php7" << "*.phps";
    }
    else if (dev_language == "LINDENSCRIPT")
    {
      file_filter << "*.lsl" << "*.osl" << "*.conf" << "*.config";
    }
 
    // Set the Directory and What to Look For
    QDir source_directory( Directory );
    source_directory.setFilter( QDir::Files | QDir::NoDotAndDotDot | QDir::Readable );
 
    // Get the List of the Files
    QStringList file_list;
    file_list = source_directory.entryList( file_filter );
 
    // Put the Filename into the Result File
    QFile result_file( ResultFileName );
    if ( !result_file.open( QIODevice::WriteOnly | QIODevice::Text ) )
    {
        result = false;
        LogAdd( LOG_ERROR, MODE_FILE, QString( "Unable to open File List File " ) + ResultFileName );
    }
    else
    {
        LogAdd( LOG_DEBUG, MODE_FILE, QString( "Opened File List File " ) + ResultFileName );
 
        QTextStream out( &result_file );
 
        // Add the Filenames to the File
        for ( const auto& filename : file_list )
        {
            out << filename << "\n";
        }
        result_file.close();
        result = true;
    }
    return( result );
}

References LOG_DEBUG, LOG_ERROR, LogAdd(), and MODE_FILE.

Referenced by CppCheck().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DoDoxygen()

void Worker::DoDoxygen ( PROJECT_INFORMATION * ProjectInfo )

private

Run Doxygen to Generate the Source Documentaiton.

Parameters

ProjectInfo Pointer to the Project's Inforamtion

Definition at line 102 of file worker.cpp.

{
    QString project_ident = ProjectInfo->ProjectDesc.ProjectIdent;
    // Generate the Doxygen Documentation
    QProcess doxygen;
    doxygen.start("doxygen", QStringList() << ProjectInfo->ProjectDesc.ProjectDirectory + "/source/" + ProjectInfo->ProjectDesc.ExeName + QString( "/Doxyfile" ) );
 
    if (!doxygen.waitForStarted())
    {
        LogAdd( LOG_ERROR, MODE_THREAD, QString("Doxygen did NOT Start for Project %1.").arg(project_ident) );
    }
    else
    {
        LogAdd( LOG_DEBUG, MODE_THREAD, QString("Started Doxygen Process for Project %1.").arg(project_ident) );
    }
 
    doxygen.closeWriteChannel();
    if (!doxygen.waitForFinished( 480000 ))        // Maximum of 8 minutes.
    {
        LogAdd( LOG_ERROR, MODE_THREAD, QString("Doxygen did NOT end for Project %1.").arg(project_ident) );
        ProjectInfo->ExecutionStatus = EXECUTION_FAILURE;
    }
    else
    {
        // Copy the Doxygen Log File into the Web Directory for Later Use.
        QString source_file    = ProjectInfo->ProjectDesc.ProjectDirectory + "/scratch/" + DOXY_LOG_FILE;
        QString dest_directory = ProjectInfo->ProgramInformation.PrimaryWebsiteDirectory + "/projects/" + ProjectInfo->ProjectDesc.ProjectIdent + "/html/";
        QFile file(source_file);
        if (file.copy(dest_directory + DOXY_LOG_FILE))
        {
            LogAdd( LOG_DEBUG, MODE_THREAD, QString("Project %1 doxygen log file copied to web directory").arg(ProjectInfo->ProjectDesc.ProjectIdent));
        }
        else
        {
            LogAdd( LOG_ERROR, MODE_THREAD, QString("Project %1 doxygen log file NOT copied to web directory").arg(ProjectInfo->ProjectDesc.ProjectIdent));
        }
 
        LogAdd( LOG_DEBUG, MODE_THREAD, QString("Doxygen finished for Project %1.").arg(project_ident) );
 
        // Flag Success
        ProjectInfo->ExecutionStatus = EXECUTION_SUCCESS;
    }
}

References DOXY_LOG_FILE, EXECUTION_FAILURE, EXECUTION_SUCCESS, PROJECT_INFORMATION::ExecutionStatus, PROJECT_DESCRIPTION::ExeName, LOG_DEBUG, LOG_ERROR, LogAdd(), MODE_THREAD, PROGRAM_INFORMATION::PrimaryWebsiteDirectory, PROJECT_INFORMATION::ProgramInformation, PROJECT_INFORMATION::ProjectDesc, PROJECT_DESCRIPTION::ProjectDirectory, and PROJECT_DESCRIPTION::ProjectIdent.

Referenced by DoWork().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DoWork

void Worker::DoWork ( PROJECT_INFORMATION * ProjectInfo )

slot

Process the Generation of Documentation by Doxygen & other processes.

Parameters

ProjectInfo Pointer to the Project's Information Structure

Definition at line 35 of file worker.cpp.

{
    LogAdd( LOG_INFO, MODE_THREAD, QString("Project %1 documentation processing started in Thread.").arg(ProjectInfo->ProjectDesc.ProjectIdent) );
    docs_dirs.clear(); docs_dirs << "defaults";
    autodoc_dir = "/autodocs/";
 
    switch (ProjectInfo->TargetFamilyInfo.TargetFamilyIndex)
    {
        case TARGET_NOT_DEFINED:
            autodoc_dir += "not_defined";
        break;
 
        case TARGET_OPEN_SIM_PROJECT:
            autodoc_dir += "open_sim_project";
        break;
 
        case TARGET_OPEN_SIM_SCRIPT:
            autodoc_dir += "open_sim_script";
        break;
 
        case TARGET_SOFTWARE:
            autodoc_dir += "software";
        break;
 
        case TARGET_HARDWARE:
            autodoc_dir += "hardware";
        break;
 
        case TARGET_DEVELOPMENT:
            autodoc_dir += "development";
        break;
 
        case TARGET_DOCUMENTATION:
            autodoc_dir += "documentation";
        break;
    }
    docs_dirs << autodoc_dir << source_dirs;
 
    if (PreProcessProject(ProjectInfo))
    {
        DoDoxygen(ProjectInfo);
    }
 
    // Create the Source Archive
    if (project_opts_manager->CheckCreateSourceArchive(ProjectInfo->ProjectDesc.ProjectOptions))
    {
        CreateSourceArchive(ProjectInfo);
    }
 
    // Create the Publish List
    if (project_opts_manager->CheckCreatePublishList (
            ProjectInfo->ProjectDesc.ProjectOptions))
      {
        CreatePublishList (ProjectInfo);
      }
 
    // Create the Installation Script, if required
    if (project_opts_manager->CheckAutomaticInstall(ProjectInfo->ProjectDesc.ProjectOptions))
    {
        CreateInstallScript(ProjectInfo);
    }
 
    // Finish Off
    LogAdd( LOG_INFO, MODE_THREAD, QString("Project %1 documentation processing ended in Thread.").arg(ProjectInfo->ProjectDesc.ProjectIdent) );
    emit WorkDone (ProjectInfo);
}

References autodoc_dir, CreateInstallScript(), CreatePublishList(), CreateSourceArchive(), docs_dirs, DoDoxygen(), LOG_INFO, LogAdd(), MODE_THREAD, PreProcessProject(), project_opts_manager, PROJECT_INFORMATION::ProjectDesc, PROJECT_DESCRIPTION::ProjectIdent, PROJECT_DESCRIPTION::ProjectOptions, source_dirs, TARGET_DEVELOPMENT, TARGET_DOCUMENTATION, TARGET_HARDWARE, TARGET_NOT_DEFINED, TARGET_OPEN_SIM_PROJECT, TARGET_OPEN_SIM_SCRIPT, TARGET_SOFTWARE, TARGET_FAMILY_INFO::TargetFamilyIndex, PROJECT_INFORMATION::TargetFamilyInfo, and WorkDone().

Here is the call graph for this function:

◆ FindLibraries()

QString Worker::FindLibraries ( PROJECT_INFORMATION * Store )

private

Find the shared libraries the program needs to run.

Parameters

Store Pointer to Project's Information

Returns: String holding the list of requied libraries

NOTE: The program must have been compiled before this function will work as it extracts the information from the program's executable file.

Definition at line 551 of file worker.cpp.

{
    QString scratchdir = Store->ProgramInformation.LocalDevelopmentDirectory + "/" + Store->ProjectDesc.ProjectIdent + "/scratch/";
    QString program_file = Store->ProjectDesc.ExeDirectory + "/" + Store->ProjectDesc.ExeName;
 
    QString html_result_table = "<table><tr><th>Dynamic Libraries Linked to Program</th></tr>";
    if ( QSysInfo::kernelType() == "linux" )
    {
        QFile exe_file(program_file);
 
        // Check if the File Exists and is executable
        if (exe_file.exists())
        {
            QFileDevice::Permissions permissions = exe_file.permissions();
            if(permissions & QFileDevice::ExeOwner)
            {
                // Get the Lines Of Code Information
                QProcess ldd;
                ldd.setStandardErrorFile(  scratchdir + "ldd_error.txt",  QIODevice::WriteOnly | QIODevice::Text  );
                ldd.setStandardOutputFile( scratchdir + "ldd_output.txt", QIODevice::WriteOnly | QIODevice::Text  );
                QStringList Arg;
                Arg << program_file;
                ldd.start( "ldd", QStringList() << Arg );
                if (!ldd.waitForStarted(10000))
                {
                    LogAdd( LOG_ERROR, MODE_THREAD, " Process did NOT Start." );
                    html_result_table += "<tr><td>Error - Unable to find dynamically lined libraries.</td></tr>";
                }
                else
                {
                    LogAdd( LOG_DEBUG, MODE_THREAD, QString( "Started  Process " ) );
                }
                if ( !ldd.waitForFinished(100000))
                {
                    LogAdd( LOG_ERROR, MODE_THREAD, " ldd Process did NOT Flag an  End." );
                    html_result_table += "<tr><td>Error occurred while finding Dynamically Linked Libraries.</td></tr>";
                }
                else
                {
                    LogAdd( LOG_DEBUG, MODE_THREAD, " ldd Process finished." );
                    html_result_table += ParserLddResults( scratchdir + "ldd_output.txt" );
                }
 
                // Remove Scratch Files
                QFile::remove( scratchdir + "ldd_error.txt"  );
                QFile::remove( scratchdir + "ldd_output.txt" );
            }
            else
            {
                html_result_table += "<tr><td>File is not currently directly executable.</td></tr>";
            }
        }
        else
        {
            html_result_table += "<tr><td>File does not currently exist.</td></tr>";
        }
    }
    else
    {
        html_result_table += "Currently only Linux Files can be checked for library requirements.</td></tr>";
    }
    html_result_table += "</TABLE>";
 
    return ( html_result_table );
};

References PROJECT_DESCRIPTION::ExeDirectory, PROJECT_DESCRIPTION::ExeName, PROGRAM_INFORMATION::LocalDevelopmentDirectory, LOG_DEBUG, LOG_ERROR, LogAdd(), MODE_THREAD, ParserLddResults(), PROJECT_INFORMATION::ProgramInformation, PROJECT_INFORMATION::ProjectDesc, and PROJECT_DESCRIPTION::ProjectIdent.

Referenced by PreProcessProject().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LogAdd()

void Worker::LogAdd	(	LOGGING_SEVERITY	Severity,
		LOGGING_MODE	Mode,
		const QString	Message )

private

Send Message to the Log.

Parameters

Severity	Severity of the Log Message
Mode	Which part of the program does the message relate to
Message	Text message to be added to the Log

Definition at line 25 of file worker.cpp.

{
    REMOTE_LOG_ENTRY log_entry;
    log_entry.Severity = Severity;
    log_entry.Mode = Mode;
    log_entry.Message = Message;
    emit SendLogEntry(log_entry);
}

References REMOTE_LOG_ENTRY::Message, REMOTE_LOG_ENTRY::Mode, SendLogEntry(), and REMOTE_LOG_ENTRY::Severity.

Referenced by CountLines(), CppCheck(), CreateSourceArchive(), CreateSourceListFile(), DoDoxygen(), DoWork(), FindLibraries(), ParserLddResults(), PreProcessProject(), TranslateRecursively(), and UpdateFile().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParserLddResults()

QString Worker::ParserLddResults ( QString ResultFilename )

private

Converts the Library List into an HTML compatible format.

Parameters

ResultFilename Name of the file holding hte result of the ldd scan

Returns: The List of Libraries in a format compatible with HTML display

Definition at line 526 of file worker.cpp.

{
    QString table_string;
    // Read the Ouptut of the ldd Program
    QFile ldd_file( ResultFilename );
    if ( !ldd_file.open( QIODevice::ReadOnly | QIODevice::Text ) )
    {
        LogAdd( LOG_ERROR, MODE_FILE, "Unable to open ldd result file." );
        table_string += "<tr><td>Error occurred reading ldd results.</td></tr>";
    }
    else
    {
        while( !ldd_file.atEnd() )
        {
            QString text_line = ldd_file.readLine();
            table_string += QString( "<tr><td>" + text_line + QString( "</td></tr>" ) );
        }
    }
 
    // Finish table and Return Result
    table_string += QString( "</table>" );
 
    return( table_string );
}

References LOG_ERROR, LogAdd(), and MODE_FILE.

Referenced by FindLibraries().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PreProcessProject()

bool Worker::PreProcessProject ( PROJECT_INFORMATION * ProjectInfo )

private

Preprocess the Project's Documentation.

Parameters

ProjectInfo Pointer to the Projects's Info

Returns: Success (true) or Failure (false)

This routine checks to see that the Project is available to Process, then cleans out the destination directory. It then check to see if only the default page is to be processed or all files should be processed. If all files, it counts the lines of code, checks which libraries are rquired, checks the C++ source files with cpp_check and then updates the files recursively.

The routine then copies associated documents and images to the destination directory.

Definition at line 277 of file worker.cpp.

{
    bool result = false;
 
    // Get ProjectData
    QString project_ident = ProjectInfo->ProjectDesc.ProjectIdent;
    QString source_directory = ProjectInfo->ProjectDesc.ProjectDirectory;
    QString destination_directory = ProjectInfo->ProgramInformation.PrimaryWebsiteDirectory + "/projects/" + project_ident;
    QString code_directory = source_directory + "/source/" + ProjectInfo->ProjectDesc.ExeName;
 
    // Don't touch it if the Project is Locked or Excluded by Option
    if (ProjectInfo->ProjectLock && !(ProjectInfo->ProjectDesc.ProjectOptions & EXCLUDE_PROJECT_LIST))
    {
        // Time to Clean out the Destination Directory
        CleanDirectory(destination_directory);
 
        QDir dir;
        if (!dir.mkpath(destination_directory + "/html"))
        {
            LogAdd( LOG_ERROR, MODE_FILE, QString("Default webpage directory for Project %1 was NOT created.").arg(project_ident));
        }
        else
        {
            // Check to See if Only the Default Page Should be Produced
            if ((ProjectInfo->ProjectDesc.ProjectOptions & CONTROL_DOC_ACCESS) && (ProjectInfo->ProjectDesc.ProjectOptions & ONLY_DEFAULT_PAGE))
            {
                   if (UpdateFile (ProjectInfo, source_directory + "/defaults/index.html", destination_directory + "/html/index.html"))
                    {
                        LogAdd( LOG_DEBUG, MODE_FILE, QString("Default webpage for Project %1 updated.").arg(project_ident));
                    }
                    else
                    {
                        LogAdd( LOG_ERROR, MODE_FILE, QString("Default webpage for Project %1 was NOT updated.").arg(project_ident));
                    }
            }
 
            // Otherwise Process the Entire Project using Doxygen
            else
            {
                // Trim the Code Directory
                TrimDirectory(code_directory, docs_filter);
 
                // Count the Number of Lines in the files in the Code Directory
                QString cloc_output = CountLines(ProjectInfo, code_directory);
                ProjectInfo->SubsMap.insert("[#CLOC_INFO#]", cloc_output);
 
                // Try to Find the Libraries that may be used by the Release Version of the Program
                QString ldd_output = FindLibraries(ProjectInfo);
                ProjectInfo->SubsMap.insert("[#LIBRARY_LIST#]", ldd_output);
 
                // Check the C++ Source Files
                QString cpp_check;
                if (ProjectInfo->LangFamilyInfo.LangFamilyIndex == 5) // Test if C++
                {
                    cpp_check = CppCheck( ProjectInfo );
                }
                else
                {
                    cpp_check = "Currently Only available for C/C++ language.";
                }
                ProjectInfo->SubsMap.insert("[#CPP_CHECK#]", cpp_check);
 
                // Update the Auto Source Files in the Code Directory
                QString dir_name = source_directory + "/autosrc";
                TranslateRecursively (ProjectInfo, dir_name, code_directory);
 
                // Translate the Auto Documentation Files into the Code Directory
                TranslateRecursively(ProjectInfo, source_directory + autodoc_dir, code_directory);
 
                // Translate the Doxy Files into the Code Directory
                TranslateRecursively(ProjectInfo, source_directory + "/doxy", code_directory);
 
                // Translate the Installation File Template
 
                //Transfer the Images into the Image Directory
                QString source_image_directory = source_directory + "/images";
                QString destination_image_directory = destination_directory + "/images";
                //CleanDirectory(destination_image_directory);
                if (RecursiveCopy(source_image_directory, destination_image_directory))
                {
                     LogAdd( LOG_DEBUG, MODE_FILE, QString("Image Directiory for Project %1 was updated.").arg(project_ident));
                }
                else
                {
                    LogAdd( LOG_ERROR, MODE_FILE, QString("Image Directiory for Project %1 was NOT updated.").arg(project_ident));
                }
 
                // Transfer the Documents into the Documentation Directory
                QString source_docs_directory = source_directory + "/docs";
                QString destination_docs_directory = destination_directory + "/docs";
                //CleanDirectory(destination_docs_directory);
 
                if (RecursiveCopy(source_docs_directory, destination_docs_directory))
                {
                    LogAdd( LOG_DEBUG, MODE_FILE, QString("Docs Directiory for Project %1 was updated.").arg(project_ident));
                }
                else
                {
                    LogAdd( LOG_ERROR, MODE_FILE, QString("Docs Directiory for Project %1 was NOT updated.").arg(project_ident));
                }
 
 
                // Send to the Worker
                result = true;
            }
        }
    }
    return(result);
}

References autodoc_dir, CleanDirectory(), CONTROL_DOC_ACCESS, CountLines(), CppCheck(), docs_filter, EXCLUDE_PROJECT_LIST, PROJECT_DESCRIPTION::ExeName, FindLibraries(), LANG_FAMILY_INFO::LangFamilyIndex, PROJECT_INFORMATION::LangFamilyInfo, LOG_DEBUG, LOG_ERROR, LogAdd(), MODE_FILE, ONLY_DEFAULT_PAGE, PROGRAM_INFORMATION::PrimaryWebsiteDirectory, PROJECT_INFORMATION::ProgramInformation, PROJECT_INFORMATION::ProjectDesc, PROJECT_DESCRIPTION::ProjectDirectory, PROJECT_DESCRIPTION::ProjectIdent, PROJECT_INFORMATION::ProjectLock, PROJECT_DESCRIPTION::ProjectOptions, RecursiveCopy(), PROJECT_INFORMATION::SubsMap, TranslateRecursively(), TrimDirectory(), and UpdateFile().

Referenced by DoWork().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RecursiveCopy()

bool Worker::RecursiveCopy	(	QString	Source,
		QString	Destination )

private

Definition at line 895 of file worker.cpp.

{
    // Check if the Source is a File or a Directory
    QFileInfo srcFileInfo(Source);
    if (srcFileInfo.isDir())
    {
        // If the Target Directory Doesn't Exist, Create It
        QDir targetDir(Destination);
        if ( !targetDir.exists() )
        {
            // Go Up a Level and Create the Directory
            targetDir.cdUp();
            if (!targetDir.mkpath(QFileInfo(Destination).fileName()))
            {
                return false;
            }
        }
 
        // Copy Each Entry in the Directory to the Target
        QDir sourceDir(Source);
        QStringList fileNames = sourceDir.entryList(QDir::Files | QDir::Dirs | QDir::NoDotAndDotDot | QDir::Hidden | QDir::System);
        foreach (const QString &fileName, fileNames)
        {
            const QString newSrcFilePath = Source + QLatin1Char('/') + fileName;
            const QString newTgtFilePath = Destination + QLatin1Char('/') + fileName;
            if (!RecursiveCopy(newSrcFilePath, newTgtFilePath))
            {
                return false;
            }
        }
    }
 
    // If it is a File Copy It
    else
    {
        if (!QFile(Source).copy(Destination)) return(false);
    }
    return true;
}

References RecursiveCopy().

Referenced by PreProcessProject(), and RecursiveCopy().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SendLogEntry

void Worker::SendLogEntry ( REMOTE_LOG_ENTRY LogEntry )

signal

Referenced by DoxygenManager::DoxygenManager(), and LogAdd().

Here is the caller graph for this function:

◆ TranslateRecursively()

bool Worker::TranslateRecursively	(	PROJECT_INFORMATION *	Store,
		const QString &	SrcDirPath,
		const QString &	TgtDirPath )

private

Recursively process text substituition for a Directory Tree.

Parameters

SrcDirPath	Source Directory Path holding the files to be processed
TgtDirPath	Destination Directory Path to hold the Processed Files

Returns: Success (treu) or Failure (false)

Definition at line 232 of file worker.cpp.

{
    // Check if the Source is a File or a Directory
    QFileInfo srcFileInfo(srcFilePath);
    if (srcFileInfo.isDir())
    {
        // If the Target Directory Doesn't Exist, Create It
        QDir targetDir(tgtFilePath);
        if ( !targetDir.exists() )
        {
            // Go Up a Level and Create the Directory
            targetDir.cdUp ();
            if (!targetDir.mkpath (QFileInfo (tgtFilePath).fileName ()))
              {
                return false;
              }
        }
 
        // Copy Each Entry in the Directory to the Target
        QDir sourceDir(srcFilePath);
        QStringList fileNames = sourceDir.entryList(QDir::Files | QDir::Dirs | QDir::NoDotAndDotDot | QDir::Hidden | QDir::System);
        foreach (const QString &fileName, fileNames) {
            const QString newSrcFilePath
                = srcFilePath + QLatin1Char('/') + fileName;
            const QString newTgtFilePath
                = tgtFilePath + QLatin1Char('/') + fileName;
            if (!TranslateRecursively(Store, newSrcFilePath, newTgtFilePath))
            {
                return false;
            }
        }
    }
 
    // If it is a File Translate It
    else
    {
        if (!UpdateFile(Store, srcFilePath, tgtFilePath ))
        {
            LogAdd( LOG_ERROR, MODE_FILE, QString( "Error in file translation from '" ) + srcFilePath + QString("' to '") + tgtFilePath + "." );
            return false;
        }
    }
    return true;
}

References LOG_ERROR, LogAdd(), MODE_FILE, TranslateRecursively(), and UpdateFile().

Referenced by CreateInstallScript(), PreProcessProject(), and TranslateRecursively().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TrimDirectory()

bool Worker::TrimDirectory	(	QString	Directory,
		QStringList	FileFilter )

private

Remove files defined by the FileFilter from the Directory.

Parameters

Directory	Name of teh Directory to be trimmed
FileFilter	Filter String that defines the files to remove

Returns: Success (true) or Failure (false)

This function is used to remove previous versions of documentation files so that old information is not left hanging around in the directory.

Definition at line 405 of file worker.cpp.

{
    bool result = true;
 
    // Check if the Directory Exists
    QDir dir(Directory);
 
    // Check the Directory Exists
    if (dir.exists())
    {
        // Get the Files in the Code Directory to Delete and Delete Them
        dir.setNameFilters(FileFilter);
        QStringList file_list = dir.entryList(QDir::Files | QDir::NoDotAndDotDot | QDir::NoSymLinks, QDir::NoSort);
        for (int index = 0; index < file_list.size(); ++index)
        {
            if (!dir.remove(file_list.at(index))) result = false;
        }
    }
    return(result);
}

Referenced by PreProcessProject().

Here is the caller graph for this function:

◆ UpdateFile()

bool Worker::UpdateFile	(	PROJECT_INFORMATION *	Project,
		QString	SourceFile,
		QString	DestinationFile )

private

Process text substituitions for a complete text file.

Parameters

Project	Pointer to the Project's Data Structure
SourceFile	Name of the File to be processed
DestinationFile	Name of the file to hold the processed file

Returns: Success (true) or Failure (false)

Definition at line 166 of file worker.cpp.

{
    bool result = true;
 
    // Line Buffer
    //QString line; QString output_line;
 
    // If the Destination File Already Exists, Remove it.
    QFile output_file( DestinationFile );
 
    // Remove Existing File (If it exists)
    if ( output_file.remove() )
    {
        LogAdd( LOG_DEBUG, MODE_FILE, QString( "File " + DestinationFile + QString( " was removed." ) ) );
    }
    else
    {
        if (output_file.exists())
        {
            LogAdd( LOG_ERROR, MODE_FILE, QString( "File " + DestinationFile + QString( " was NOT removed." ) ) );
            result = false;
        }
        else
        {
            LogAdd( LOG_DEBUG, MODE_FILE, QString( "File " + DestinationFile + QString( " did not Exist." ) ) );
        }
    }
 
    // Update the Template File and Put into the Destination Location (If Possible)
    if (result)
    {
        if (output_file.open(QIODevice::ReadWrite))
        {
            QTextStream out( &output_file );
 
            QFile input_file( SourceFile );
            if (input_file.open(QIODevice::ReadOnly))
            {
                QTextStream in( &input_file );
 
                while (!in.atEnd())
                {
                    QString line = in.readLine();
                    QString output_line = UpdateLine(Project, line);
                    out << output_line << "\n";
                }
                input_file.close();
                output_file.close();
                LogAdd( LOG_DEBUG, MODE_FILE, QString( "Update of File " ) + SourceFile + " to " + DestinationFile + QString( " completed." ) );
                result = true;
            }
            else
            {
                LogAdd( LOG_ERROR, MODE_FILE, "Unable to Open Input " + SourceFile );
                result = false;
            }
        }
        else
        {
            LogAdd( LOG_ERROR, MODE_FILE, "Unable to Open Output " + DestinationFile );
            result = false;
        }
    }
    return( result );
}

References LOG_DEBUG, LOG_ERROR, LogAdd(), MODE_FILE, and UpdateLine().

Referenced by PreProcessProject(), and TranslateRecursively().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateLine()

QString Worker::UpdateLine	(	PROJECT_INFORMATION *	Project,
		QString	SourceLine )

private

Process text substitutions for a single line.

Parameters

Project Pointer to the Project's Data Structure \parame SourceLine Line to the be proceassed

Returns: The source line with substitutions included

Definition at line 147 of file worker.cpp.

{
    // Get the Map holding the Keys and Values
    QMap<QString, QString> subs_map = Project->SubsMap;
 
    // Scan the Line Looking for a valid key construction
    while(SourceLine.contains(leadin_string) && SourceLine.contains(leadout_string))
    {
        int key_start   = SourceLine.indexOf(leadin_string);
        int key_end     = SourceLine.indexOf(leadout_string) + 2;
        QString found_key   = SourceLine.sliced(key_start, (key_end - key_start));
        QString found_value = subs_map.value(found_key);
        SourceLine.replace(found_key, found_value);
    }
 
    // return the Updated Line
    return(SourceLine);
}

References leadin_string, leadout_string, and PROJECT_INFORMATION::SubsMap.

Referenced by UpdateFile().

Here is the caller graph for this function:

◆ WorkDone

void Worker::WorkDone ( PROJECT_INFORMATION * ProjectInfo )

signal

Referenced by DoWork(), and DoxygenManager::DoxygenManager().

Here is the caller graph for this function:

Field Documentation

◆ all_filter

QStringList Worker::all_filter

private

Definition at line 192 of file worker.h.

Referenced by Worker().

◆ autodoc_dir

QString Worker::autodoc_dir

private

Definition at line 35 of file worker.h.

Referenced by DoWork(), and PreProcessProject().

◆ db

QSqlDatabase Worker::db

private

Definition at line 195 of file worker.h.

◆ docs_dirs

QStringList Worker::docs_dirs

private

Definition at line 190 of file worker.h.

Referenced by DoWork().

◆ docs_filter

QStringList Worker::docs_filter

private

Definition at line 191 of file worker.h.

Referenced by PreProcessProject(), and Worker().

◆ leadin_string

QString Worker::leadin_string

private

Definition at line 193 of file worker.h.

Referenced by UpdateLine(), and Worker().

◆ leadout_string

QString Worker::leadout_string

private

Definition at line 194 of file worker.h.

Referenced by UpdateLine(), and Worker().

◆ source_dirs

QStringList Worker::source_dirs

private

Definition at line 188 of file worker.h.

Referenced by DoWork(), and Worker().

◆ source_filter

QStringList Worker::source_filter

private

Definition at line 189 of file worker.h.

Referenced by Worker().

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

Public Slots

Signals

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ Worker()

Member Function Documentation

◆ CleanDirectory()

◆ CountLines()

◆ CppCheck()

◆ CreateInstallScript()

◆ CreatePublishList()

◆ CreateSourceArchive()

◆ CreateSourceListFile()

◆ DoDoxygen()

◆ DoWork

◆ FindLibraries()

◆ LogAdd()

◆ ParserLddResults()

◆ PreProcessProject()

◆ RecursiveCopy()

◆ SendLogEntry

◆ TranslateRecursively()

◆ TrimDirectory()

◆ UpdateFile()

◆ UpdateLine()

◆ WorkDone

Field Documentation

◆ all_filter

◆ autodoc_dir

◆ db

◆ docs_dirs

◆ docs_filter

◆ leadin_string

◆ leadout_string

◆ source_dirs

◆ source_filter