Tiny local class to load a PLUMED kernel. More...

#include <PlumedHandle.h>

Inheritance diagram for PLMD::PlumedHandle:

Public Member Functions
	PlumedHandle ()
	Default constructor.
	PlumedHandle (PlumedHandle &&other) noexcept
	Move constructor.
virtual	~PlumedHandle ()
	Destructor.
void	cmd (const std::string &key, const TypesafePtr &ptr=nullptr)
	Execute cmd.
void	cmd (const std::string &key, const TypesafePtr &val, const std::size_t *shape)
	Bring in the possibility to pass shape/nelem.
void	cmd (const std::string &key, const TypesafePtr &val, std::size_t nelem, const std::size_t *shape=nullptr)
	Bring in the possibility to pass shape/nelem.
PlumedHandle &	operator= (PlumedHandle &&other) noexcept
	Move assignment.

Static Public Member Functions
static PlumedHandle	dlopen (const char *path)
	Construct a PlumedHandle given the path to a kernel.

Private Member Functions
	PlumedHandle (const char *path)
	Constructor using the path to a kernel.

Private Attributes
void *	loaded =nullptr
	Pointer to loaded Plumed object;.
std::unique_ptr< PlumedMain >	local
	Pointer to PlumedMain.

Detailed Description

Tiny local class to load a PLUMED kernel.

Maps command to either a loaded PLUMED kernel or to the present one. It provides a wrapper around the official interface located at wrapper/Plumed.h, with some changes. Differences are:

It does not use the PLUMED_KERNEL env var. Indeed, it would not make sense to use it, since this class is meant to load different kernels.
It does not implement interoperability with C/FORTRAN interfaces.
It does not implement global versions (e.g. PLMD::Plumed::gcmd).
It does not implement PLMD::Plumed::valid. If kernel cannot be loaded, its constructor throws. This will make sure that once constructed the object is usable.

In its implementation, this class uses the PLMD::Plumed class in wrapper/Plumed.h and thus has the same capability to load PLUMED kernels of any version (starting with 2.0). It can also be created without passing any kernel path. In that case it refers to the current one (the one to which this class belongs).

The following syntax creates a handle referring to the current kernel

PlumedHandle p;
// Alternatively:
// auto p=PlumedHandle();
p.cmd("init");

The following syntax instead creates a handle referring to a loaded kernel

PlumedHandle p(PlumedHandle::dlopen("/path/to/libplumedkernel.so");
// Alternatively:
// auto p=PlumedHandle::dlopen("/path/to/libplumedkernel.so");
p.cmd("init");

Notice that if there are problems loading the kernel an exception is thrown. Thus, once constructed the object is guaranteed to be functional.

Constructor & Destructor Documentation

◆ PlumedHandle() [1/3]

PLMD::PlumedHandle::PlumedHandle ( const char * path )

explicitprivate

Constructor using the path to a kernel.

I keep it private to avoid confusion wrt the similar constructor of PLMD::Plumed that accepts a string (conversion from FORTRAN).

◆ PlumedHandle() [2/3]

PLMD::PlumedHandle::PlumedHandle ( )

Default constructor.

Maps following commands to the current kernel.

◆ ~PlumedHandle()

PLMD::PlumedHandle::~PlumedHandle ( )

virtual

Destructor.

In case a kernel was dlopened, it dlcloses it. I make it virtual for future extensibility, though this is not necessary now.

◆ PlumedHandle() [3/3]

PLMD::PlumedHandle::PlumedHandle ( PlumedHandle && other )

noexcept

Move constructor.

Member Function Documentation

◆ cmd() [1/3]

void PLMD::PlumedHandle::cmd	(	const std::string &	key,
		const TypesafePtr &	ptr = nullptr )

virtual

Execute cmd.

Implements PLMD::WithCmd.

◆ cmd() [2/3]

void PLMD::WithCmd::cmd	(	const std::string &	key,
		const TypesafePtr &	val,
		const std::size_t *	shape )

inline

Bring in the possibility to pass shape/nelem.

◆ cmd() [3/3]

void PLMD::WithCmd::cmd	(	const std::string &	key,
		const TypesafePtr &	val,
		std::size_t	nelem,
		const std::size_t *	shape = nullptr )

inline

Bring in the possibility to pass shape/nelem.

◆ dlopen()

PlumedHandle PLMD::PlumedHandle::dlopen ( const char * path )

static

Construct a PlumedHandle given the path to a kernel.

It just uses the private constructor PlumedHandle(const char* path).

◆ operator=()

PlumedHandle & PLMD::PlumedHandle::operator= ( PlumedHandle && other )

noexcept

Move assignment.

Member Data Documentation

◆ loaded

void* PLMD::PlumedHandle::loaded =nullptr

private

Pointer to loaded Plumed object;.

◆ local

std::unique_ptr<PlumedMain> PLMD::PlumedHandle::local

private

Pointer to PlumedMain.

Used when using the current kernel in order to avoid unneeded indirections.

The documentation for this class was generated from the following files:

tools/PlumedHandle.h
tools/PlumedHandle.cpp

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes