module.h

Go to the documentation of this file.

/*
 * #%L
 * OME-COMMON C++ library for C++ compatibility/portability
 * %%
 * Copyright © 2006 - 2016 Open Microscopy Environment:
 *   - Massachusetts Institute of Technology
 *   - National Institutes of Health
 *   - University of Dundee
 *   - Board of Regents of the University of Wisconsin-Madison
 *   - Glencoe Software, Inc.
 * %%
 * 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.
 *
 * 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 HOLDERS OR 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.
 *
 * The views and conclusions contained in the software and documentation are
 * those of the authors and should not be interpreted as representing official
 * policies, either expressed or implied, of any organization.
 * #L%
 */

#ifndef OME_COMMON_MODULE_H
#define OME_COMMON_MODULE_H

#include <boost/filesystem/operations.hpp>
#include <boost/filesystem/path.hpp>

#include <ome/common/config.h>
#include <ome/common/filesystem.h>

namespace ome
{
  namespace common
  {

    const boost::filesystem::path&
    module_runtime_path(const std::string& dtype);

    void
    register_module_paths();

    struct Module
    {
      std::string name;
      std::string envvar;
      std::string module_envvar;
      std::string root_envvar;
      boost::filesystem::path abspath;
      boost::filesystem::path relpath;
      boost::filesystem::path install_prefix;
      boost::filesystem::path shlibpath;
      boost::filesystem::path realpath;
      boost::filesystem::path (*module_path)();

      Module(const std::string&               name,
             const std::string&               envvar,
             const std::string&               module_envvar,
             const std::string&               root_envvar,
             const boost::filesystem::path&   abspath,
             const boost::filesystem::path&   relpath,
             const boost::filesystem::path&   install_prefix,
             const boost::filesystem::path&   shlibpath,
             boost::filesystem::path        (*module_path)());
    };

    struct RegisterModule
    {
      std::string name;
      bool registered;

      RegisterModule(const std::string&               name,
                     const std::string&               envvar,
                     const std::string&               module_envvar,
                     const std::string&               root_envvar,
                     const boost::filesystem::path&   abspath,
                     const boost::filesystem::path&   relpath,
                     const boost::filesystem::path&   install_prefix,
                     const boost::filesystem::path&   shlibpath,
                     boost::filesystem::path        (*module_path)());

      ~RegisterModule();
    };
  }
}

// Set to include introspection functionality (used for registering
// paths; not for normal use).
#ifdef OME_COMMON_MODULE_INTROSPECTION

#ifdef OME_HAVE_DLADDR
#ifndef _GNU_SOURCE
# define _GNU_SOURCE 1
#endif
#include <dlfcn.h>
#endif // OME_HAVE_DLADDR

#ifdef _MSC_VER
# include <windows.h>
#endif

namespace
{

#ifdef OME_HAVE_DLADDR
  Dl_info this_module;

  __attribute__((constructor))
  void
  find_module(void)
  {
    if(!dladdr(reinterpret_cast<void *>(find_module), &this_module))
      {
        this_module.dli_fname = 0;
      }
  }

  boost::filesystem::path
  module_path()
  {
    if (this_module.dli_fname)
      return canonical(boost::filesystem::path(this_module.dli_fname));
    return boost::filesystem::path();
  }
#elif _MSC_VER
  HMODULE
  find_module(void)
  {
    static bool found_module = false;
    static HMODULE this_module;

    if (!found_module)
      {
        if (!GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS |
                                GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
                                reinterpret_cast<LPCWSTR>(&find_module),
                                &this_module))
          {
            this_module = 0;
          }
        found_module = true;
      }
    return this_module;
  }

  boost::filesystem::path
  module_path()
  {
    HMODULE this_module = find_module();
    if (this_module)
      {
        WCHAR win_wide_path[MAX_PATH];
        GetModuleFileNameW(this_module, win_wide_path, sizeof(win_wide_path));
        return boost::filesystem::path(win_wide_path);
      }
    return boost::filesystem::path();
  }
#else // No introspection available
  boost::filesystem::path
  module_path()
  {
    return boost::filesystem::path();
  }
#endif // _MSC_VER
}
#endif // OME_COMMON_MODULE_INTROSPECTION

#endif // OME_COMMON_MODULE_H

/*
 * Local Variables:
 * mode:C++
 * End:
 */