ApplicationPathHelpers.cxx.in

/***********************************************************************************************************************
 *  OpenStudio(R), Copyright (c) 2008-2017, Alliance for Sustainable Energy, LLC. All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
 *  following conditions are met:
 *
 *  (1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
 *  disclaimer.
 *
 *  (2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
 *  following disclaimer in the documentation and/or other materials provided with the distribution.
 *
 *  (3) Neither the name of the copyright holder nor the names of any contributors may be used to endorse or promote
 *  products derived from this software without specific prior written permission from the respective party.
 *
 *  (4) Other than as required in clauses (1) and (2), distributions in any form of modifications or other derivative
 *  works may not use the "OpenStudio" trademark, "OS", "os", or any other confusingly similar designation without
 *  specific prior written permission from Alliance for Sustainable Energy, LLC.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
 *  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 *  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER, THE UNITED STATES GOVERNMENT, OR ANY CONTRIBUTORS BE LIABLE FOR
 *  ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 *  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 *  AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 **********************************************************************************************************************/

#include <utilities/core/ApplicationPathHelpers.hpp>
#include <utilities/core/PathHelpers.hpp>

#include <OpenStudio.hxx>

#include <sstream>
#include <boost/regex.hpp>
#include <boost/algorithm/string.hpp>
#include <boost/algorithm/string/case_conv.hpp>
#include <iostream>
#include <QtGlobal>

#if defined _WIN32 
#include <windows.h>
#else
#include <stdio.h>
#include <dlfcn.h>
#endif


  bool pathBeginsWith(const openstudio::path &t_shorter, const openstudio::path &t_longer)
  {
    openstudio::path::const_iterator begin1 = t_shorter.begin();
    openstudio::path::const_iterator end1 = t_shorter.end();

    openstudio::path::const_iterator begin2 = t_longer.begin();
    openstudio::path::const_iterator end2 = t_longer.end();

    if (std::distance(begin1, end1) > std::distance(begin2, end2))
    {
      return false; // the run dir has fewer elements than the build dir - cannot be running from builddir
    }

    // if the rundir begins with the builddir, we know it's running from the builddir
    return std::equal(begin1, end1, begin2);

  }


namespace openstudio {

  openstudio::path getApplicationSourceDirectory() {
    return openstudio::toPath("${CMAKE_SOURCE_DIR}");
  }

  openstudio::path getApplicationBuildDirectory() {
    return openstudio::toPath("${CMAKE_BINARY_DIR}");
  }

  openstudio::path getApplicationPath() {

    #if defined _WIN32 
      TCHAR szPath[MAX_PATH];
      if( GetModuleFileName( nullptr, szPath, MAX_PATH ) ) {
        return completeAndNormalize(toPath(szPath));
      }
    #else
      Dl_info info;
      if (dladdr("main", &info)) {
         return completeAndNormalize(toPath(info.dli_fname));
      }
    #endif

    return openstudio::path();
  }

  openstudio::path getApplicationDirectory() {
    openstudio::path p = getApplicationPath();
    if (!p.empty()){
      return p.parent_path();
    }
    return openstudio::path();
  }

  bool applicationIsRunningFromBuildDirectory()
  {
#ifdef _WIN32
    openstudio::path buildDir = openstudio::toPath(boost::algorithm::to_upper_copy(openstudio::toString(getApplicationBuildDirectory())));
    openstudio::path runDir = openstudio::toPath(boost::algorithm::to_upper_copy(openstudio::toString(getApplicationDirectory())));
#else
    openstudio::path buildDir = getApplicationBuildDirectory();
    openstudio::path runDir = getApplicationDirectory();
#endif

    return pathBeginsWith(buildDir, runDir);
  }

  openstudio::path getEnergyPlusDirectory() {
    return getEnergyPlusExecutable().parent_path();
  }

  // define the function GetCurrentModule so we can get its address
  #if defined _WIN32 
  HMODULE GetCurrentModule()
  {
	  HMODULE hModule = NULL;
	  // hModule is NULL if GetModuleHandleEx fails.
	  GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS
						  | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
						  (LPCTSTR)GetCurrentModule, &hModule);
	  return hModule;
  }
  #else
  bool GetCurrentModule()
  {
    return true;
  }
  #endif

  openstudio::path getOpenStudioModule()
  {
    openstudio::path openstudioDirPath;
    #if defined _WIN32 
      TCHAR szPath[MAX_PATH];
      if( GetModuleFileName( GetCurrentModule(), szPath, MAX_PATH ) ) {
        openstudioDirPath = completeAndNormalize(toPath(szPath));
      }
    #else
      Dl_info info;
      if (dladdr("GetCurrentModule", &info)) {
          openstudioDirPath = completeAndNormalize(toPath(info.dli_fname));
      }
    #endif
    return openstudioDirPath;
  }

  openstudio::path getOpenStudioModuleDirectory()
  {
    return getOpenStudioModule().parent_path();
  }

  bool moduleIsRunningFromBuildDirectory()
  {
#ifdef _WIN32
    openstudio::path buildDir = openstudio::toPath(boost::algorithm::to_upper_copy(openstudio::toString(getApplicationBuildDirectory())));
    openstudio::path runDir = openstudio::toPath(boost::algorithm::to_upper_copy(openstudio::toString(getOpenStudioModuleDirectory())));
#else
    openstudio::path buildDir = getApplicationBuildDirectory();
    openstudio::path runDir = getOpenStudioModuleDirectory();
#endif

    return pathBeginsWith(buildDir, runDir);
  }

  openstudio::path getOpenStudioCLI(){
    openstudio::path cliPath;
    #if defined _WIN32 
      cliPath = getOpenStudioModuleDirectory() / toPath("openstudio.exe");
      if (!openstudio::filesystem::exists(cliPath)){
        #if _DEBUG
          cliPath = getOpenStudioModuleDirectory() / toPath("../../Debug/openstudio.exe");
        #else
          cliPath = getOpenStudioModuleDirectory() / toPath("../../Release/openstudio.exe");
        #endif
      }
    #else
      cliPath = getOpenStudioModuleDirectory() / toPath("openstudio");
      if (!openstudio::filesystem::exists(cliPath)){
        cliPath = getOpenStudioModuleDirectory() / toPath("../openstudio");
      }
    #endif

    if( openstudio::filesystem::exists(cliPath) ){
      return cliPath;
    }

    #if defined _WIN32 
      cliPath = getOpenStudioModuleDirectory() / toPath("../bin/openstudio.exe");
    #else
      cliPath = getOpenStudioModuleDirectory() / toPath("../bin/openstudio");
    #endif

    if( openstudio::filesystem::exists(cliPath) ){
      return cliPath;
    }

    return openstudio::path();
  }

  openstudio::path getEnergyPlusExecutable() {
    
    openstudio::path cmakeEnergyPlusPath = openstudio::toPath("${ENERGYPLUS_EXE}");
    openstudio::path cmakeEnergyPlusDirectory = cmakeEnergyPlusPath.parent_path();

    // handle developer case first
    if (moduleIsRunningFromBuildDirectory()){
      if( openstudio::filesystem::exists(cmakeEnergyPlusPath) ){
        return cmakeEnergyPlusPath;
      }
    }

    // next check environment variable
    auto envPathString = std::getenv("ENERGYPLUS_EXE_PATH");
    if( envPathString ) {
      openstudio::path envPath = openstudio::toPath(envPathString);
      if( openstudio::filesystem::exists(envPath) ) {
        return envPath;
      }
    }

    // next check for installed energyplus
#ifdef _WIN32
    openstudio::path installPath = getOpenStudioModuleDirectory() / toPath("/../EnergyPlus/energyplus.exe");
#else
    openstudio::path installPath = getOpenStudioModuleDirectory() / toPath("/../EnergyPlus/energyplus");
#endif
    if( openstudio::filesystem::exists(installPath) ) {
      return installPath;
    } 

    // next check default location
    openstudio::path energyPlusExeName = cmakeEnergyPlusPath.filename();
    openstudio::path energyPlusDirectoryName = cmakeEnergyPlusDirectory.filename();

    #ifdef Q_OS_LINUX
      auto systemPath = openstudio::toPath("/usr/local") / energyPlusDirectoryName / energyPlusExeName;
    #elif defined(Q_OS_MAC)
      auto systemPath = openstudio::toPath("/Applications") / energyPlusDirectoryName / energyPlusExeName;
    #else
      auto systemPath = openstudio::toPath("C:/") / energyPlusDirectoryName / energyPlusExeName;
    #endif

    if( openstudio::filesystem::exists(systemPath) ) {
      return systemPath;
    }

    std::string energyPlusDirectoryNameStr = toString(energyPlusDirectoryName);
    std::string energyPlusDirectoryNameStr2 = boost::replace_first_copy(energyPlusDirectoryNameStr,"EnergyPlus-","EnergyPlusV");
    if (energyPlusDirectoryNameStr != energyPlusDirectoryNameStr2){
      #ifdef Q_OS_LINUX
       systemPath = openstudio::toPath("/usr/local") / toPath(energyPlusDirectoryNameStr2) / energyPlusExeName;
      #elif defined(Q_OS_MAC)
        systemPath = openstudio::toPath("/Applications") / toPath(energyPlusDirectoryNameStr2) / energyPlusExeName;
      #else
        systemPath = openstudio::toPath("C:/") / toPath(energyPlusDirectoryNameStr2) / energyPlusExeName;
      #endif

      if( openstudio::filesystem::exists(systemPath) ) {
        return systemPath;
      }
    }

    // next check user path
    //QString userPath = QStandardPaths::findExecutable("energyplus");
    //if (!userPath.isEmpty()){
    //  openstudio::path path = openstudio::toPath(userPath);
    //  if( openstudio::filesystem::exists(path) ) {
    //    return path;
    //  }
    //}
    
    return openstudio::path();
  }

  openstudio::path getRadianceDirectory() {
    // handle developer case first
    if (moduleIsRunningFromBuildDirectory()){
      openstudio::path cmakeRadianceDirectory = openstudio::toPath("${RADIANCE_LOCATION}");
      if( openstudio::filesystem::exists(cmakeRadianceDirectory) ){
        return cmakeRadianceDirectory;
      }
    }

    // next check environment variable
    auto envPathString = std::getenv("OS_RAYPATH");
    if( envPathString ) {
      openstudio::path envPath = openstudio::toPath(envPathString);
      if( openstudio::filesystem::exists(envPath) ) {
        return envPath;
      }
    }

    // next check for installed energyplus
    openstudio::path installPath = getOpenStudioModuleDirectory() / toPath("/../Radiance");
    if( openstudio::filesystem::exists(installPath) ) {
      return installPath;
    } 

    // next check default location
    #ifdef Q_OS_LINUX
      auto systemPath = openstudio::toPath("/usr/local/radiance");
    #elif defined(Q_OS_MAC)
      auto systemPath = openstudio::toPath("/usr/local/radiance");
    #else
      auto systemPath = openstudio::toPath("C:/Program Files/radiance");
    #endif

    if( openstudio::filesystem::exists(systemPath) ) {
      return systemPath;
    }
    
    return openstudio::path();
  }

  openstudio::path getPerlExecutable() {
    #if defined (Q_OS_LINUX) || defined (Q_OS_MAC)
      // check environment variable
      auto envPathString = std::getenv("PERL_EXE_PATH");
      if( envPathString ) {
        openstudio::path envPath = openstudio::toPath(envPathString);
        if( openstudio::filesystem::exists(envPath) ) {
          return envPath;
        }
      }

      // next check for system perl
      openstudio::path systemPath = toPath("/usr/bin/perl");
      if( openstudio::filesystem::exists(systemPath) ) {
        return systemPath;
      } 
    #else
      // handle developer case first
      if (moduleIsRunningFromBuildDirectory()){
        openstudio::path cmakePerlPath = openstudio::toPath("${PERL_EXE}");
        if( openstudio::filesystem::exists(cmakePerlPath) ){
          return cmakePerlPath;
        }
      }

      // next check environment variable
      auto envPathString = std::getenv("PERL_EXE_PATH");
      if( envPathString ) {
        openstudio::path envPath = openstudio::toPath(envPathString);
        if( openstudio::filesystem::exists(envPath) ) {
          return envPath;
        }
      }

      // next check for installed perl
      openstudio::path installPath = getOpenStudioModuleDirectory() / toPath("/../Perl/bin/perl.exe");
      if( openstudio::filesystem::exists(installPath) ) {
        return installPath;
      } 

      // alternate install location (to be removed)
      installPath = getOpenStudioModuleDirectory() / toPath("/../Perl/perl/bin/perl.exe");
      if( openstudio::filesystem::exists(installPath) ) {
        return installPath;
      } 
    #endif

    return openstudio::path();
  }

} // openstudio