EnvironmentImpl.h

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////////////
///
/// \file
/// \author Gerald Fahrnholz
/// 
/// \brief
/// Implementation of class Environment
/// 
////////////////////////////////////////////////////////////////////////////////

#pragma once


#include <iostream>
#include <fstream>
#include <sstream>
#include <assert.h>

#include "TestToolBox\Environment.h"

#include <Lmcons.h> //UNLEN

#include <cctype> // for toupper
#include <algorithm>

///\cond do not document


//*****************************************************************************
//*****************************************************************************


/// Helper macro to simplify exception handling
#define CATCH_ALL(M_funcName,M_successFlag) \
    catch(std::exception& exc)                                                      \
    {                                                                               \
        exc;                                                                        \
        M_successFlag = false;                                                      \
        TRC(TL_ERROR, "[%s]: EXCEPTION (std::Exception): %s",                       \
            #M_funcName, exc.what());                                               \
    }                                                                               \
    catch(...)                                                                      \
    {                                                                               \
        M_successFlag = false;                                                      \
        TRC(TL_ERROR, "[%s]: EXCEPTION of unknown type detected!",#M_funcName);     \
    }                                                                               \
    if (!M_successFlag)                                                             \
    {                                                                               \
        TRC(TL_ERROR, "[%s]: returned false!",#M_funcName);                         \
    }


//*****************************************************************************
//*****************************************************************************


namespace TestToolBox
{

TTB_INLINE Environment::Environment()
    : m_exeFileFullPath()
    , m_exeDir ()
    , m_exeDrive ()
    , m_outputDir   ()
    , m_referenceDir ()
{
    TRCF("Environment::Environment");
    TRC(TL_DEBUG, "Constructor");

    // Get executable path informations
    {
        // Get complete path for exe file (e.g. "C:\MyTargetBin\MyAppname.exe")
        char appName [MAX_PATH+1];
        ::GetModuleFileNameA (0, appName, MAX_PATH+1);
            m_exeFileFullPath = appName;

        // Get directory path (e.g. "C:\MyTargetBin")
            std::string::size_type pos = m_exeFileFullPath.find_last_of("\\");
        if (pos!=std::string::npos)
        {
            m_exeDir = m_exeFileFullPath.substr(0, pos);
            std::string::size_type posExt = m_exeFileFullPath.find_last_of(".");
            if (posExt!=std::string::npos)
            {
                m_appName = m_exeFileFullPath.substr(pos+1,posExt-pos-1);
            }
        }

        // Get drive letter (e.g. "C:")
        pos = m_exeDir.find_first_of(":");
        if (pos!=std::string::npos)
        {
            m_exeDrive = m_exeFileFullPath.substr(0, pos+1);
        }
    }

    // Get source directory
    {
        // Get path of the VOB where the sources were compiled
        m_sourceDir = __FILE__;
            std::string::size_type pos = m_sourceDir.find_last_of("\\");
        if (pos!=std::string::npos)
        {
            m_sourceDir = m_sourceDir.substr(0, pos);
        }
        CalculateSourceDrive();
    }

    // Default settings for output and reference directory
    {
        // Initially use exe path for test purposes
        m_outputDir = m_exeDir;
        m_referenceDir = m_exeDir;
    }

    ParseCommandLine();

} // Environment::Environment


//************************************************************************
//************************************************************************


TTB_INLINE Environment::~Environment()
{
    TRCF("Environment::~Environment");
    TRC(TL_DEBUG, "Destructor");

} // Environment::~Environment


TTB_INLINE void Environment::CutSourceDirAfter (std::string const & in_findStr)
{
    // perform compare which is not case sensitive !
    std::string sourceDirLowerCase = m_sourceDir;
        std::transform(sourceDirLowerCase.begin(), sourceDirLowerCase.end(),
        sourceDirLowerCase.begin(), tolower);
    std::string findStrLowerCase = in_findStr;
        std::transform(findStrLowerCase.begin(), findStrLowerCase.end(),
        findStrLowerCase.begin(), tolower);

    std::string::size_type pos = sourceDirLowerCase.find(findStrLowerCase);
    if (pos!=std::string::npos)
    {
        m_sourceDir = m_sourceDir.substr(0, pos + in_findStr.length());
    }

    // Remove trailing "\"
    if (    (m_sourceDir.length()>0)
         && (m_sourceDir[m_sourceDir.length()-1]=='\\'))
    {
        m_sourceDir.erase(m_sourceDir.length()-1,1);
    }

} // Environment::CutSourceDirAfter


//************************************************************************
//************************************************************************


TTB_INLINE void Environment::CalculateSourceDrive (void)
{
    // Get drive letter (e.g. "C:")
    std::string::size_type pos = m_sourceDir.find_first_of(":");
    if (pos!=std::string::npos)
    {
        m_sourceDrive = m_sourceDir.substr(0, pos+1);
    }

} // Environment::CalculateSourceDrive


//************************************************************************
//************************************************************************


TTB_INLINE std::string Environment::GetNameOfComputer (void)
{
    char computerName [MAX_COMPUTERNAME_LENGTH + 1];
    DWORD lenComp = MAX_COMPUTERNAME_LENGTH + 1;
    ::GetComputerNameA  (computerName, &lenComp);
    return std::string(computerName);

} // Environment::GetNameOfComputer


//************************************************************************
//************************************************************************


TTB_INLINE std::string Environment::GetNameOfUser (void)
{
    char userName     [UNLEN + 1];
    DWORD lenUser = UNLEN + 1;
    ::GetUserNameA (userName, &lenUser);
    return std::string(userName);

} // Environment::GetNameOfUser


//************************************************************************
//************************************************************************


TTB_INLINE std::string Environment::GetCommandLineStr (void)
{
    return std::string(::GetCommandLineA());

} // Environment::GetCommandLineStr


//************************************************************************
//************************************************************************


TTB_INLINE std::string Environment::GetArgsStr (void)
{
    std::string retVal;
    std::string cmdLineArgs(::GetCommandLineA());
    TrimStr(cmdLineArgs);
    assert (!cmdLineArgs.empty());

    // skip arg 0 (executable path)
    std::string::size_type tokenEndPos;
    if (cmdLineArgs[0]=='\"')
    {
        tokenEndPos = cmdLineArgs.find_first_of ("\"", 1);
    }
    else
    {
        tokenEndPos = cmdLineArgs.find_first_of (" ", 1);
    }

    if (tokenEndPos == std::string::npos)
    {
        retVal="";
    }
    else
    {
        retVal = cmdLineArgs.substr(tokenEndPos+1, cmdLineArgs.length() - tokenEndPos);
        TrimStr (retVal);
    }

    return retVal;

} // Environment::GetArgsStr


//************************************************************************
//************************************************************************


TTB_INLINE std::string Environment::GetCommandLineOption (
    std::string const & in_nameOption)
{
    CmdLineOptions::iterator it = m_cmdLineOptions.find(in_nameOption);
    return it != m_cmdLineOptions.end()
        ? it->second : std::string();

} // Environment::GetCommandLineOption


//************************************************************************
//************************************************************************


TTB_INLINE bool Environment::GetSystemEnvVariable (
    std::string const & in_envVarName,
    std::string&        out_envVarVal)
{
    const int MYBUFSIZE = 4096;
    bool varExists = false;

    TRCF("Environment::GetSystemEnvVariable");

    DWORD dwRet;
    DWORD dwErr;

    TCHAR envVarValue [MYBUFSIZE];

    dwRet = ::GetEnvironmentVariable(TEXT(in_envVarName.c_str()), envVarValue,
                MYBUFSIZE);
    if(0 == dwRet)
    {
       dwErr = GetLastError();
       if( ERROR_ENVVAR_NOT_FOUND == dwErr )
       {
          TRC(TL_ERROR, "variable >%s< is not existing", in_envVarName.c_str());
       }
       else
       {
           std::ostringstream oss;
           oss << "ERROR: Environment variable " << in_envVarName.c_str() << " could not be accessed (LastError="
                << dwErr << "/" << Environment::GetErrorDescription(dwErr).c_str() << ")" << std::endl;
           TRC(TL_ERROR, "throwing exception: %s", oss.str().c_str());
           throw std::exception(oss.str().c_str());
       }
    }
    else
    {
        if(MYBUFSIZE < dwRet)
        {
           TRC(TL_ERROR, "WARNING: Environment variable >%s< too long! Value is ignored!", in_envVarName.c_str());
        }
        else // value is accessible
        {
            out_envVarVal = envVarValue;
            varExists = true;
        }
    }
    TRC(TL_DEBUG, "variable >%s< returns value >%s<", in_envVarName.c_str(), out_envVarVal.c_str());
    return varExists;

} // Environment::GetSystemEnvVariable


//************************************************************************
//************************************************************************


TTB_INLINE std::string Environment::GetSystemEnvVariable (
    std::string const & in_envVarName)
{
    std::string retVal;
    GetSystemEnvVariable (in_envVarName, retVal);
    return retVal;

} // Environment::GetSystemEnvVariable


//************************************************************************
//************************************************************************


TTB_INLINE void Environment::SetSystemEnvVariable (
    std::string const & in_envVarName,
    std::string CONST & in_envVarValue)
{
    DWORD dwErr;
    TRCF("Environment::SetSystemEnvVariable");
    TRC(TL_DEBUG, "set variable >%s< to >%s<", in_envVarName.c_str(), in_envVarValue.c_str());

    if(!::SetEnvironmentVariable(TEXT(in_envVarName.c_str()),
        TEXT(in_envVarValue.c_str())))
    {
       dwErr = ::GetLastError();
       {
           std::ostringstream oss;
           oss << "ERROR: Environment variable " << in_envVarName.c_str()
               << " could not be set (LastError="
               << dwErr << "/"
               << Environment::GetErrorDescription(dwErr).c_str() << ")" << std::endl;
           TRC(TL_ERROR, "throwing exception: %s", oss.str().c_str());
           throw std::exception(oss.str().c_str());
       }
    }

} // Environment::SetSystemEnvVariable


//*****************************************************************************
//*****************************************************************************


TTB_INLINE std::string Environment::GetErrorDescription (int in_systemError)
{
    static char charBuf [4096]; 
    TCHAR* msgBufPtr = 0;

    if (::FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
            FORMAT_MESSAGE_FROM_SYSTEM,
            0,
            static_cast<DWORD> (in_systemError),
            MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
            (LPTSTR)&msgBufPtr,
            0,
            0))
    {
        char* chBufPtr = static_cast<char*> (msgBufPtr);
        if (chBufPtr)
        {
            char* chPtr;
            // Remark: The returned system message string may contain a carriage
            // return (ASCII 13) which has to be eliminated.
            if (chPtr = strchr(chBufPtr,13))
            {
                size_t len = chPtr - chBufPtr;
                strncpy_s (charBuf, chBufPtr, len);
                charBuf[len] = '\0';
            }
            else
            {
                strcpy_s (charBuf, chBufPtr);
            }
        }
        else
            strcpy_s (charBuf, "GetErrorDescription: ERROR 1");
    }
    else
        strcpy_s (charBuf, "GetErrorDescription: ERROR 2");

    if (msgBufPtr)
        LocalFree (msgBufPtr);

    return std::string(charBuf);

} // Environment::GetErrorDescription


//*****************************************************************************
//*****************************************************************************


TTB_INLINE bool Environment::StartExeFile (
    std::string const & in_executableToStart,
    std::string const & in_startArguments)
{
    TRCF("Environment::StartExeFile");

    bool succeeded = false;

    std::string executableToStart = in_executableToStart;
    // Add " at begin and end if not already done
    if (    (executableToStart.length() > 0)
         && (executableToStart.at(0) != '\"'))
    {
        executableToStart = "\"" + executableToStart + "\"";
    }

    try
    {
        // Definition of startinfo struct
        STARTUPINFO         startInfo;
        startInfo. cb              = sizeof (STARTUPINFO);
        startInfo. lpReserved      = 0;
        startInfo. lpDesktop       = 0;
        startInfo. lpTitle         = 0;
        startInfo. dwX             = 0;
        startInfo. dwY             = 0;
        startInfo. dwXSize         = 0;
        startInfo. dwYSize         = 0;
        startInfo. dwXCountChars   = 0;
        startInfo. dwYCountChars   = 0;
        startInfo. dwFillAttribute = 0;
        startInfo. dwFlags         = STARTF_USEPOSITION |
                                         STARTF_USESHOWWINDOW;
        startInfo. wShowWindow     = SW_SHOW;
        startInfo. cbReserved2     = 0;
        startInfo. lpReserved2     = 0;
        startInfo. lpReserved      = 0;
        startInfo. hStdInput       = 0;
        startInfo. hStdOutput      = 0;
        startInfo. hStdError       = 0;


        std::string cmdStr = executableToStart;
        if (in_startArguments.length()>0)
        {
            cmdStr += in_startArguments;
        }

        // Information about the started process
        PROCESS_INFORMATION procInfo;

        if (CreateProcess (
            NULL,
            LPTSTR (cmdStr. c_str()),
            NULL,
            NULL,
            FALSE,
            0,
            NULL,
            NULL,
            &startInfo,
            &procInfo))
        {
            TRC(TL_DEBUG, "Successfully started %s",  cmdStr.c_str());
            CloseHandle (procInfo. hThread); // we dont need the thread and process handles
            CloseHandle (procInfo. hProcess);
            succeeded = true;
        }
        else // exe could not be started
        {
            int err = GetLastError();
            TRC(TL_ERROR, "ERROR: File %s could not be started (LastError=%d/%s)",
                executableToStart.c_str(),err,GetErrorDescription(err).c_str());
        }
    }
    CATCH_ALL(Environment::StartExeFile,succeeded)
    return succeeded;

} // Environment::StartExeFile


//*****************************************************************************
//*****************************************************************************


TTB_INLINE void Environment::ParseCommandLine (void)
{
    TRCF("Environment::ParseCommandLine");

    std::string cmdLine = Environment::GetCommandLineStr();

    std::string opt;
    std::string par;

    while (GetNextOption (cmdLine, opt, par))
    {
        TRC(TL_DEBUG, "command line option >%s< with param >%s<", opt.c_str(),par.c_str());
        m_cmdLineOptions[opt] = par;
    }

} // Environment::ParseCommandLine


//*****************************************************************************
//*****************************************************************************


TTB_INLINE bool Environment::GetNextOption (
    std::string&  inOut_rCmdLine,
    std::string&  out_rOpt,
    std::string&  out_rPar)
{
    TRCF("Environment::GetNextOption");

    // Assume that each command has the form "-option [parameter]"
    // "--option" is ignored, all additional params are skipped

    out_rOpt    = "";
    out_rPar    = "";
    bool optionFound = false;
    bool paramFound = false;
    std::string option;
    std::string param;
    std::string::size_type endPos;

    // Get next token from command line and remove spaces and " at begin and end
    // of the token

    while (!optionFound)
    {
        if (!GetNextToken(inOut_rCmdLine, option, endPos))
            break; // no more options available
        if (    (option.length()>=2)
             && (option.at(0) == '-')
             && (option.at(1) != '-'))
        {
            optionFound = true;
        }
        else
        {
            TRC(TL_DEBUG, "token is skipped");
        }
        // option string or invalid token to skip is already read in,
        // therefore delete it from command line string
        inOut_rCmdLine.erase (0, endPos);
    }

    // Try to read optional param
    if (optionFound)
    {
        if (GetNextToken(inOut_rCmdLine, param, endPos))
        {
            if (    (param.length()>=1)
                 && (param.at(0) != '-'))
            {
                paramFound = true;
                // param read in, now delete from command line
                inOut_rCmdLine.erase (0, endPos);
            }
            else
            {
                // leave command line string unchanged token just read
                // may be the next option which will be read again with the
                // next call to this function
                TRC(TL_DEBUG, "token belongs to next option and will be read in again");
            }

        }
    }

    if (optionFound) out_rOpt = option;
    if (paramFound) out_rPar = param;

    return optionFound;

} // Environment::GetNextOption


//*****************************************************************************
//*****************************************************************************


TTB_INLINE bool Environment::GetNextToken (
    std::string&            inOut_rCmdLine,
    std::string&            out_token,
    std::string::size_type& out_tokenEndPos)
{
    TRCF("Environment::GetNextToken");

    std::string            token;
    std::string::size_type tokenEndPos(inOut_rCmdLine.length());

    std::string whiteSpace(" \t\n");

    std::string::size_type tokenStartPos = inOut_rCmdLine.find_first_not_of (
        whiteSpace);
    if (tokenStartPos != std::string::npos) // there is really some contents left
    {
        // Special case: if starting with " find the terminating " or read until end of line
        if (inOut_rCmdLine.at(tokenStartPos)== '\"')
        {
            tokenEndPos = inOut_rCmdLine.find_first_of ("\"", tokenStartPos+1);
            if (tokenEndPos == std::string::npos)
            {
                tokenEndPos = inOut_rCmdLine.length();
            }
            else // inkrement position to make trailing " part of the token
            {
                ++tokenEndPos;
            }
        }
        else // string should be without "
        {
            tokenEndPos = inOut_rCmdLine.find_first_of (whiteSpace, tokenStartPos+1);
            if (tokenEndPos == std::string::npos)
            {
                tokenEndPos = inOut_rCmdLine.length();
            }
        }


        token = inOut_rCmdLine.substr(
            tokenStartPos, tokenEndPos - tokenStartPos);

        // Remove leading "
        if (    (token.length() > 0)
             && (token.at(0) =='"'))
        {
            token.erase(0,1);
        }
        // Remove trailing "
        if (    (token.length() > 0)
             && (token.at(token.length()-1) =='"'))
        {
            token.erase(token.length()-1,1);
        }
    }

    out_token       = token;
    out_tokenEndPos = tokenEndPos;
    TRC(TL_DEBUG, "next token = >%s<", out_token.c_str());

    return token.length()>0;

} // Environment::GetNextToken


//*****************************************************************************
//*****************************************************************************

///\endcond

} // namespace TestToolBox

---