Includes alias methods and macro. You can include this header or boost/dll/shared_library.hpp to reduce dependencies in case you do not use the refcountable functions.

BOOST_DLL_FORCE_ALIAS_INSTANTIATION
BOOST_DLL_FORCE_NO_WEAK_EXPORTS
BOOST_DLL_SELECTANY
BOOST_DLL_SECTION(SectionName, Permissions)
BOOST_DLL_ALIAS(FunctionOrVar, AliasName)
BOOST_DLL_ALIAS_SECTIONED(FunctionOrVar, AliasName, SectionName)
BOOST_DLL_AUTO_ALIAS(FunctionOrVar)

Imports filesystem, error_code, errc, system_error, make_error_code from Boost or C++17 into boost::dll::fs namespace.

BOOST_DLL_USE_STD_FS

  
    
      typedef  ;
      typedef  ;
      typedef  ;
    }
  }
}

Contains only the boost::dll::library_info class that is capable of extracting different information from binaries.

  
    class library_info;
  }
}

Provides methods for getting acceptable by boost::dll::shared_library location of symbol, source line or program.

  
    template<typename T> 
       
      (, boost::dll::fs::error_code &);
    template<typename T> 
       ( ptr_to_symbol);
    template<typename T> 
       
      (, boost::dll::fs::error_code &);
    template<typename T> 
       ( symbol);
     (boost::dll::fs::error_code &);
     ();
     (boost::dll::fs::error_code &);
     ();
  }
}

Contains the boost::dll::shared_library class, core class for all the DLL/DSO operations.

  
    class shared_library;

    // Very fast equality check that compares the actual DLL/DSO objects. Throws nothing. 
     (shared_library & lhs, shared_library & rhs);

    // Very fast inequality check that compares the actual DLL/DSO objects. Throws nothing. 
     (shared_library & lhs, shared_library & rhs);

    // Compare the actual DLL/DSO objects without any guarantee to be stable between runs. Throws nothing. 
     (shared_library & lhs, shared_library & rhs);

    // Swaps two shared libraries. Does not invalidate symbols and functions loaded from libraries. Throws nothing. 
     (shared_library & lhs, shared_library & rhs);
  }
}

Contains only the boost::dll::load_mode::type enum and operators related to it.

  
    
      enum type;

      // Free operators for load_mode::type flag manipulation. 
       ( left,  right);
       ( left,  right);
       ( left,  right);
       ( left,  right);
       ( left,  right);
       ( left,  right);
       ( left);
    }
  }
}

Contains the boost::dll::experimental::smart_library class for loading mangled symbols.

	Warning
	Extremely experimental! Requires C++11! Will change in next version of Boost! boost/dll/smart_library.hpp is not included in boost/dll.hpp

  
    
      class smart_library;

      // Very fast equality check that compares the actual DLL/DSO objects. Throws nothing. 
       (smart_library & lhs, smart_library & rhs);

      // Very fast inequality check that compares the actual DLL/DSO objects. Throws nothing. 
       (smart_library & lhs, smart_library & rhs);

      // Compare the actual DLL/DSO objects without any guarantee to be stable between runs. Throws nothing. 
       (smart_library & lhs, smart_library & rhs);

      // Swaps two shared libraries. Does not invalidate symbols and functions loaded from libraries. Throws nothing. 
       (smart_library & lhs, smart_library & rhs);
      template<typename T, typename T2> 
         (smart_library &, );
      template<typename T> 
         
        (smart_library & sm,  name);
      template<typename T> 
         
        (smart_library & sm,  name);
      template<typename Class, typename Signature> 
         (smart_library & sm,  name);
    }
  }
}

Contains all the boost::dll::import* reference counting functions that hold a shared pointer to the instance of boost::dll::shared_library.

  
    template<typename T> 
       (, , 
                                 = );
    template<typename T> 
       ( lib, 
                                 name, 
                                 mode = );
    template<typename T> 
       ( lib,  name);
    template<typename T> 
       ( lib, 
                                 name);
    template<typename T> 
       ( lib,  name);
    template<typename T> 
       ( lib, 
                                 name);
    template<typename T> 
       (, , 
                                = );
    template<typename T> 
       ( lib, 
                                name, 
                                mode = );
    template<typename T> 
       ( lib,  name);
    template<typename T> 
       ( lib, 
                                name);
    template<typename T> 
       ( lib,  name);
    template<typename T> 
       ( lib, 
                                name);
  }
}

Contains the boost::dll::experimental::import_class function for importing classes.

	Warning
	Extremely experimental! Requires C++11! Will change in next version of Boost! boost/dll/import_class.hpp is not included in boost/dll.hpp

  
    
      template<typename T> class imported_class;
      template<typename T,  Args> 
        imported_class<  
        ( lib,  args);
      template<typename T,  Args> 
        imported_class<  
        ( lib, 
                      alias_name,  args);
      template<typename T,  Args> 
        imported_class<  
        (, , );
      template<typename T,  Args> 
        imported_class<  
        ( lib,  size, 
                      alias_name,  args);
      template<typename T,  Args> 
        imported_class<  
        ( lib_, 
                      alias_name,  size, 
                      args);
      template<typename T,  Args> 
        imported_class<  ( lib,  args);
      template<typename T,  Args> 
        imported_class<  
        ( lib,  alias_name, 
                      args);
      template<typename T,  Args> 
        imported_class<  
        ( lib,  size,  args);
      template<typename T,  Args> 
        imported_class<  
        ( lib,  size, 
                      alias_name,  args);
      template<typename T,  Args> 
        imported_class<  
        ( lib,  alias_name, 
                      size,  args);
      template<typename T,  Args> 
        imported_class<  ( lib,  args);
      template<typename T,  Args> 
        imported_class<  
        ( lib,  alias_name, 
                      args);
      template<typename T,  Args> 
        imported_class<  
        ( lib,  size,  args);
      template<typename T,  Args> 
        imported_class<  
        ( lib,  size, 
                      alias_name,  args);
      template<typename T,  Args> 
        imported_class<  
        ( lib,  alias_name, 
                      size,  args);
    }
  }
}

Contains the boost::dll::experimental::import_mangled function for importing mangled symbols.

	Warning
	Extremely experimental! Requires C++11! Will change in next version of Boost! boost/dll/import_mangled.hpp is not included in boost/dll.hpp

  
    
      template< Args> 
         (, , 
                                    = );
      template< Args> 
         ( lib, 
                                    name, 
                                    mode = );
      template< Args> 
         ( lib, 
                                    name);
      template< Args> 
         ( lib, 
                                    name);
      template< Args> 
         ( lib,  name);
      template< Args> 
         ( lib, 
                                    name);
      template< Args> 
         ( lib, 
                                    name);
      template< Args> 
         ( lib, 
                                    name);
      template< Args> 
         ( lib,  name);
      template< Args> 
         ( lib, 
                                    name);
    }
  }
}