NOISSUE reformat MeshMC to new clang format rules and fixed macOS portability issue and java find issue

Signed-off-by: Mehmet Samet Duman <yongdohyun@projecttick.org>

1 files changed, 104 insertions, 110 deletions

diff --git a/launcher/LoggedProcess.cpp b/launcher/LoggedProcess.cpp
index fb965c2ba8..a8b78eabdd 100644
--- a/launcher/LoggedProcess.cpp
+++ b/launcher/LoggedProcess.cpp
@@ -23,159 +23,153 @@
 #include "MessageLevel.h"
 #include <QDebug>
 
-LoggedProcess::LoggedProcess(QObject *parent) : QProcess(parent)
+LoggedProcess::LoggedProcess(QObject* parent) : QProcess(parent)
 {
-    // QProcess has a strange interface... let's map a lot of those into a few.
-    connect(this, &QProcess::readyReadStandardOutput, this, &LoggedProcess::on_stdOut);
-    connect(this, &QProcess::readyReadStandardError, this, &LoggedProcess::on_stdErr);
-    connect(this, SIGNAL(finished(int,QProcess::ExitStatus)), SLOT(on_exit(int,QProcess::ExitStatus)));
-    connect(this, SIGNAL(errorOccurred(QProcess::ProcessError)), this, SLOT(on_error(QProcess::ProcessError)));
-    connect(this, &QProcess::stateChanged, this, &LoggedProcess::on_stateChange);
+	// QProcess has a strange interface... let's map a lot of those into a few.
+	connect(this, &QProcess::readyReadStandardOutput, this,
+			&LoggedProcess::on_stdOut);
+	connect(this, &QProcess::readyReadStandardError, this,
+			&LoggedProcess::on_stdErr);
+	connect(this, SIGNAL(finished(int, QProcess::ExitStatus)),
+			SLOT(on_exit(int, QProcess::ExitStatus)));
+	connect(this, SIGNAL(errorOccurred(QProcess::ProcessError)), this,
+			SLOT(on_error(QProcess::ProcessError)));
+	connect(this, &QProcess::stateChanged, this,
+			&LoggedProcess::on_stateChange);
 }
 
 LoggedProcess::~LoggedProcess()
 {
-    if(m_is_detachable)
-    {
-        setProcessState(QProcess::NotRunning);
-    }
+	if (m_is_detachable) {
+		setProcessState(QProcess::NotRunning);
+	}
 }
 
-QStringList reprocess(const QByteArray & data, QString & leftover)
+QStringList reprocess(const QByteArray& data, QString& leftover)
 {
-    QString str = leftover + QString::fromLocal8Bit(data);
+	QString str = leftover + QString::fromLocal8Bit(data);
 
-    str.remove('\r');
-    QStringList lines = str.split("\n");
-    leftover = lines.takeLast();
-    return lines;
+	str.remove('\r');
+	QStringList lines = str.split("\n");
+	leftover = lines.takeLast();
+	return lines;
 }
 
 void LoggedProcess::on_stdErr()
 {
-    auto lines = reprocess(readAllStandardError(), m_err_leftover);
-    emit log(lines, MessageLevel::StdErr);
+	auto lines = reprocess(readAllStandardError(), m_err_leftover);
+	emit log(lines, MessageLevel::StdErr);
 }
 
 void LoggedProcess::on_stdOut()
 {
-    auto lines = reprocess(readAllStandardOutput(), m_out_leftover);
-    emit log(lines, MessageLevel::StdOut);
+	auto lines = reprocess(readAllStandardOutput(), m_out_leftover);
+	emit log(lines, MessageLevel::StdOut);
 }
 
 void LoggedProcess::on_exit(int exit_code, QProcess::ExitStatus status)
 {
-    // save the exit code
-    m_exit_code = exit_code;
-
-    // Flush console window
-    if (!m_err_leftover.isEmpty())
-    {
-        emit log({m_err_leftover}, MessageLevel::StdErr);
-        m_err_leftover.clear();
-    }
-    if (!m_out_leftover.isEmpty())
-    {
-        emit log({m_err_leftover}, MessageLevel::StdOut);
-        m_out_leftover.clear();
-    }
-
-    // based on state, send signals
-    if (!m_is_aborting)
-    {
-        if (status == QProcess::NormalExit)
-        {
-            //: Message displayed on instance exit
-            emit log({tr("Process exited with code %1.").arg(exit_code)}, MessageLevel::MeshMC);
-            changeState(LoggedProcess::Finished);
-        }
-        else
-        {
-            //: Message displayed on instance crashed
-            if(exit_code == -1)
-                emit log({tr("Process crashed.")}, MessageLevel::MeshMC);
-            else
-                emit log({tr("Process crashed with exitcode %1.").arg(exit_code)}, MessageLevel::MeshMC);
-            changeState(LoggedProcess::Crashed);
-        }
-    }
-    else
-    {
-        //: Message displayed after the instance exits due to kill request
-        emit log({tr("Process was killed by user.")}, MessageLevel::Error);
-        changeState(LoggedProcess::Aborted);
-    }
+	// save the exit code
+	m_exit_code = exit_code;
+
+	// Flush console window
+	if (!m_err_leftover.isEmpty()) {
+		emit log({m_err_leftover}, MessageLevel::StdErr);
+		m_err_leftover.clear();
+	}
+	if (!m_out_leftover.isEmpty()) {
+		emit log({m_err_leftover}, MessageLevel::StdOut);
+		m_out_leftover.clear();
+	}
+
+	// based on state, send signals
+	if (!m_is_aborting) {
+		if (status == QProcess::NormalExit) {
+			//: Message displayed on instance exit
+			emit log({tr("Process exited with code %1.").arg(exit_code)},
+					 MessageLevel::MeshMC);
+			changeState(LoggedProcess::Finished);
+		} else {
+			//: Message displayed on instance crashed
+			if (exit_code == -1)
+				emit log({tr("Process crashed.")}, MessageLevel::MeshMC);
+			else
+				emit log(
+					{tr("Process crashed with exitcode %1.").arg(exit_code)},
+					MessageLevel::MeshMC);
+			changeState(LoggedProcess::Crashed);
+		}
+	} else {
+		//: Message displayed after the instance exits due to kill request
+		emit log({tr("Process was killed by user.")}, MessageLevel::Error);
+		changeState(LoggedProcess::Aborted);
+	}
 }
 
 void LoggedProcess::on_error(QProcess::ProcessError error)
 {
-    switch(error)
-    {
-        case QProcess::FailedToStart:
-        {
-            emit log({tr("The process failed to start.")}, MessageLevel::Fatal);
-            changeState(LoggedProcess::FailedToStart);
-            break;
-        }
-        // we'll just ignore those... never needed them
-        case QProcess::Crashed:
-        case QProcess::ReadError:
-        case QProcess::Timedout:
-        case QProcess::UnknownError:
-        case QProcess::WriteError:
-            break;
-    }
+	switch (error) {
+		case QProcess::FailedToStart: {
+			emit log({tr("The process failed to start.")}, MessageLevel::Fatal);
+			changeState(LoggedProcess::FailedToStart);
+			break;
+		}
+		// we'll just ignore those... never needed them
+		case QProcess::Crashed:
+		case QProcess::ReadError:
+		case QProcess::Timedout:
+		case QProcess::UnknownError:
+		case QProcess::WriteError:
+			break;
+	}
 }
 
 void LoggedProcess::kill()
 {
-    m_is_aborting = true;
-    QProcess::kill();
+	m_is_aborting = true;
+	QProcess::kill();
 }
 
 int LoggedProcess::exitCode() const
 {
-    return m_exit_code;
+	return m_exit_code;
 }
 
 void LoggedProcess::changeState(LoggedProcess::State state)
 {
-    if(state == m_state)
-        return;
-    m_state = state;
-    emit stateChanged(m_state);
+	if (state == m_state)
+		return;
+	m_state = state;
+	emit stateChanged(m_state);
 }
 
 LoggedProcess::State LoggedProcess::state() const
 {
-    return m_state;
+	return m_state;
 }
 
 void LoggedProcess::on_stateChange(QProcess::ProcessState state)
 {
-    switch(state)
-    {
-        case QProcess::NotRunning:
-            break; // let's not - there are too many that handle this already.
-        case QProcess::Starting:
-        {
-            if(m_state != LoggedProcess::NotRunning)
-            {
-                qWarning() << "Wrong state change for process from state" << m_state << "to" << (int) LoggedProcess::Starting;
-            }
-            changeState(LoggedProcess::Starting);
-            return;
-        }
-        case QProcess::Running:
-        {
-            if(m_state != LoggedProcess::Starting)
-            {
-                qWarning() << "Wrong state change for process from state" << m_state << "to" << (int) LoggedProcess::Running;
-            }
-            changeState(LoggedProcess::Running);
-            return;
-        }
-    }
+	switch (state) {
+		case QProcess::NotRunning:
+			break; // let's not - there are too many that handle this already.
+		case QProcess::Starting: {
+			if (m_state != LoggedProcess::NotRunning) {
+				qWarning() << "Wrong state change for process from state"
+						   << m_state << "to" << (int)LoggedProcess::Starting;
+			}
+			changeState(LoggedProcess::Starting);
+			return;
+		}
+		case QProcess::Running: {
+			if (m_state != LoggedProcess::Starting) {
+				qWarning() << "Wrong state change for process from state"
+						   << m_state << "to" << (int)LoggedProcess::Running;
+			}
+			changeState(LoggedProcess::Running);
+			return;
+		}
+	}
 }
 
 #if defined Q_OS_WIN32
@@ -184,10 +178,10 @@ void LoggedProcess::on_stateChange(QProcess::ProcessState state)
 
 qint64 LoggedProcess::processId() const
 {
-    return QProcess::processId();
+	return QProcess::processId();
 }
 
 void LoggedProcess::setDetachable(bool detachable)
 {
-    m_is_detachable = detachable;
+	m_is_detachable = detachable;
 }