Fix error messages in C++-Impl

Author: martinweismann

Examples/Calculator/Calculator.xml

@@ -61,7 +61,7 @@
 		</method>
 	</class>
 
-	<global baseclassname="Base" releasemethod="ReleaseInstance" versionmethod="GetVersion" errormethod="GetLastError">
+	<global baseclassname="Base" releasemethod="ReleaseInstance" acquiremethod="AcquireInstance" versionmethod="GetVersion" errormethod="GetLastError">
 
 		<method name="GetVersion" description = "retrieves the binary version of this library.">
 			<param name="Major" type="uint32" pass="out" description="returns the major version of this library" />
@@ -73,7 +73,10 @@
 			<param name="ErrorMessage" type="string" pass="out" description="Message of the last error" />
 			<param name="HasError" type="bool" pass="return" description="Is there a last error to query" />
 		</method>
-		<method name="ReleaseInstance" description="Releases the memory of an Instance">
+		<method name="ReleaseInstance" description="Releases shared ownership of an Instance">
+			<param name="Instance" type="class" class="Base" pass="in" description="Instance Handle" />
+		</method>
+		<method name="AcquireInstance" description="Acquires shared ownership of an Instance">
 			<param name="Instance" type="class" class="Base" pass="in" description="Instance Handle" />
 		</method>
 		<method name="CreateVariable" description="Creates a new Variable instance">

Examples/Calculator/Calculator_component/Bindings/CppDynamic/calculator_abi.hpp

@@ -28,6 +28,7 @@ Interface version: 1.0.0
 
 #include "calculator_types.hpp"
 
+
 extern "C" {
 
 /*************************************************************************************************************************
@@ -132,13 +133,21 @@ CALCULATOR_DECLSPEC CalculatorResult calculator_getversion(Calculator_uint32 * p
 CALCULATOR_DECLSPEC CalculatorResult calculator_getlasterror(Calculator_Base pInstance, const Calculator_uint32 nErrorMessageBufferSize, Calculator_uint32* pErrorMessageNeededChars, char * pErrorMessageBuffer, bool * pHasError);
 
 /**
-* Releases the memory of an Instance
+* Releases shared ownership of an Instance
 *
 * @param[in] pInstance - Instance Handle
 * @return error code or 0 (success)
 */
 CALCULATOR_DECLSPEC CalculatorResult calculator_releaseinstance(Calculator_Base pInstance);
 
+/**
+* Acquires shared ownership of an Instance
+*
+* @param[in] pInstance - Instance Handle
+* @return error code or 0 (success)
+*/
+CALCULATOR_DECLSPEC CalculatorResult calculator_acquireinstance(Calculator_Base pInstance);
+
 /**
 * Creates a new Variable instance
 *

Examples/Calculator/Calculator_component/Bindings/CppDynamic/calculator_dynamic.h

@@ -19,6 +19,7 @@ Interface version: 1.0.0
 #include "calculator_types.hpp"
 
 
+
 /*************************************************************************************************************************
  Class definition for Base
 **************************************************************************************************************************/
@@ -121,13 +122,21 @@ typedef CalculatorResult (*PCalculatorGetVersionPtr) (Calculator_uint32 * pMajor
 typedef CalculatorResult (*PCalculatorGetLastErrorPtr) (Calculator_Base pInstance, const Calculator_uint32 nErrorMessageBufferSize, Calculator_uint32* pErrorMessageNeededChars, char * pErrorMessageBuffer, bool * pHasError);
 
 /**
-* Releases the memory of an Instance
+* Releases shared ownership of an Instance
 *
 * @param[in] pInstance - Instance Handle
 * @return error code or 0 (success)
 */
 typedef CalculatorResult (*PCalculatorReleaseInstancePtr) (Calculator_Base pInstance);
 
+/**
+* Acquires shared ownership of an Instance
+*
+* @param[in] pInstance - Instance Handle
+* @return error code or 0 (success)
+*/
+typedef CalculatorResult (*PCalculatorAcquireInstancePtr) (Calculator_Base pInstance);
+
 /**
 * Creates a new Variable instance
 *
@@ -161,6 +170,7 @@ typedef struct {
 	PCalculatorGetVersionPtr m_GetVersion;
 	PCalculatorGetLastErrorPtr m_GetLastError;
 	PCalculatorReleaseInstancePtr m_ReleaseInstance;
+	PCalculatorAcquireInstancePtr m_AcquireInstance;
 	PCalculatorCreateVariablePtr m_CreateVariable;
 	PCalculatorCreateCalculatorPtr m_CreateCalculator;
 } sCalculatorDynamicWrapperTable;

Examples/Calculator/Calculator_component/Bindings/CppDynamic/calculator_dynamic.hpp

@@ -19,6 +19,7 @@ Interface version: 1.0.0
 #include "calculator_types.hpp"
 #include "calculator_dynamic.h"
 
+
 #ifdef _WIN32
 #include <windows.h>
 #else // _WIN32
@@ -150,6 +151,14 @@ using CCalculatorInputVector = CInputVector<T>;
 class CWrapper {
 public:
 
+	CWrapper(void* pSymbolLookupMethod)
+	{
+		CheckError(nullptr, initWrapperTable(&m_WrapperTable));
+		CheckError(nullptr, loadWrapperTableFromSymbolLookupMethod(&m_WrapperTable, pSymbolLookupMethod));
+		
+		CheckError(nullptr, checkBinaryVersion());
+	}
+	
 	CWrapper(const std::string &sFileName)
 	{
 		CheckError(nullptr, initWrapperTable(&m_WrapperTable));
@@ -163,6 +172,11 @@ class CWrapper {
 		return std::make_shared<CWrapper>(sFileName);
 	}
 
+	static PWrapper loadLibraryFromSymbolLookupMethod(void* pSymbolLookupMethod)
+	{
+		return std::make_shared<CWrapper>(pSymbolLookupMethod);
+	}
+	
 	~CWrapper()
 	{
 		releaseWrapperTable(&m_WrapperTable);
@@ -173,6 +187,7 @@ class CWrapper {
 	inline void GetVersion(Calculator_uint32 & nMajor, Calculator_uint32 & nMinor, Calculator_uint32 & nMicro);
 	inline bool GetLastError(CBase * pInstance, std::string & sErrorMessage);
 	inline void ReleaseInstance(CBase * pInstance);
+	inline void AcquireInstance(CBase * pInstance);
 	inline PVariable CreateVariable(const Calculator_double dInitialValue);
 	inline PCalculator CreateCalculator();
 
@@ -191,6 +206,7 @@ class CWrapper {
 	CalculatorResult initWrapperTable(sCalculatorDynamicWrapperTable * pWrapperTable);
 	CalculatorResult releaseWrapperTable(sCalculatorDynamicWrapperTable * pWrapperTable);
 	CalculatorResult loadWrapperTable(sCalculatorDynamicWrapperTable * pWrapperTable, const char * pLibraryFileName);
+	CalculatorResult loadWrapperTableFromSymbolLookupMethod(sCalculatorDynamicWrapperTable * pWrapperTable, void* pSymbolLookupMethod);
 
 	friend class CBase;
 	friend class CVariable;
@@ -217,7 +233,7 @@ class CBase {
 		if (m_pWrapper != nullptr)
 			m_pWrapper->CheckError(this, nResult);
 	}
-
+public:
 	/**
 	* CBase::CBase - Constructor for Base class.
 	*/
@@ -236,7 +252,6 @@ class CBase {
 		m_pWrapper = nullptr;
 	}
 
-public:
 	/**
 	* CBase::GetHandle - Returns handle to instance.
 	*/
@@ -317,11 +332,12 @@ class CCalculator : public CBase {
 		std::vector<char> bufferErrorMessage(bytesNeededErrorMessage);
 		CheckError(nullptr,m_WrapperTable.m_GetLastError(hInstance, bytesNeededErrorMessage, &bytesWrittenErrorMessage, &bufferErrorMessage[0], &resultHasError));
 		sErrorMessage = std::string(&bufferErrorMessage[0]);
+		
 		return resultHasError;
 	}
 
 	/**
-	* CWrapper::ReleaseInstance - Releases the memory of an Instance
+	* CWrapper::ReleaseInstance - Releases shared ownership of an Instance
 	* @param[in] pInstance - Instance Handle
 	*/
 	inline void CWrapper::ReleaseInstance(CBase * pInstance)
@@ -333,6 +349,19 @@ class CCalculator : public CBase {
 		CheckError(nullptr,m_WrapperTable.m_ReleaseInstance(hInstance));
 	}
 
+	/**
+	* CWrapper::AcquireInstance - Acquires shared ownership of an Instance
+	* @param[in] pInstance - Instance Handle
+	*/
+	inline void CWrapper::AcquireInstance(CBase * pInstance)
+	{
+		CalculatorHandle hInstance = nullptr;
+		if (pInstance != nullptr) {
+			hInstance = pInstance->GetHandle();
+		};
+		CheckError(nullptr,m_WrapperTable.m_AcquireInstance(hInstance));
+	}
+	
 	/**
 	* CWrapper::CreateVariable - Creates a new Variable instance
 	* @param[in] dInitialValue - Initial value of the new Variable
@@ -342,6 +371,10 @@ class CCalculator : public CBase {
 	{
 		CalculatorHandle hInstance = nullptr;
 		CheckError(nullptr,m_WrapperTable.m_CreateVariable(dInitialValue, &hInstance));
+		
+		if (!hInstance) {
+			CheckError(nullptr,CALCULATOR_ERROR_INVALIDPARAM);
+		}
 		return std::make_shared<CVariable>(this, hInstance);
 	}
 
@@ -353,6 +386,10 @@ class CCalculator : public CBase {
 	{
 		CalculatorHandle hInstance = nullptr;
 		CheckError(nullptr,m_WrapperTable.m_CreateCalculator(&hInstance));
+		
+		if (!hInstance) {
+			CheckError(nullptr,CALCULATOR_ERROR_INVALIDPARAM);
+		}
 		return std::make_shared<CCalculator>(this, hInstance);
 	}
 
@@ -384,6 +421,7 @@ class CCalculator : public CBase {
 		pWrapperTable->m_GetVersion = nullptr;
 		pWrapperTable->m_GetLastError = nullptr;
 		pWrapperTable->m_ReleaseInstance = nullptr;
+		pWrapperTable->m_AcquireInstance = nullptr;
 		pWrapperTable->m_CreateVariable = nullptr;
 		pWrapperTable->m_CreateCalculator = nullptr;
 
@@ -524,6 +562,15 @@ class CCalculator : public CBase {
 		if (pWrapperTable->m_ReleaseInstance == nullptr)
 			return CALCULATOR_ERROR_COULDNOTFINDLIBRARYEXPORT;
 
+		#ifdef _WIN32
+		pWrapperTable->m_AcquireInstance = (PCalculatorAcquireInstancePtr) GetProcAddress(hLibrary, "calculator_acquireinstance");
+		#else // _WIN32
+		pWrapperTable->m_AcquireInstance = (PCalculatorAcquireInstancePtr) dlsym(hLibrary, "calculator_acquireinstance");
+		dlerror();
+		#endif // _WIN32
+		if (pWrapperTable->m_AcquireInstance == nullptr)
+			return CALCULATOR_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
 		#ifdef _WIN32
 		pWrapperTable->m_CreateVariable = (PCalculatorCreateVariablePtr) GetProcAddress(hLibrary, "calculator_createvariable");
 		#else // _WIN32
@@ -545,6 +592,74 @@ class CCalculator : public CBase {
 		pWrapperTable->m_LibraryHandle = hLibrary;
 		return CALCULATOR_SUCCESS;
 	}
+
+	inline CalculatorResult CWrapper::loadWrapperTableFromSymbolLookupMethod(sCalculatorDynamicWrapperTable * pWrapperTable, void* pSymbolLookupMethod)
+{
+		if (pWrapperTable == nullptr)
+			return CALCULATOR_ERROR_INVALIDPARAM;
+		if (pSymbolLookupMethod == nullptr)
+			return CALCULATOR_ERROR_INVALIDPARAM;
+		
+		typedef CalculatorResult(*SymbolLookupType)(const char*, void**);
+		
+		SymbolLookupType pLookup = (SymbolLookupType)pSymbolLookupMethod;
+		
+		CalculatorResult eLookupError = CALCULATOR_SUCCESS;
+		eLookupError = (*pLookup)("calculator_variable_getvalue", (void**)&(pWrapperTable->m_Variable_GetValue));
+		if ( (eLookupError != 0) || (pWrapperTable->m_Variable_GetValue == nullptr) )
+			return CALCULATOR_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("calculator_variable_setvalue", (void**)&(pWrapperTable->m_Variable_SetValue));
+		if ( (eLookupError != 0) || (pWrapperTable->m_Variable_SetValue == nullptr) )
+			return CALCULATOR_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("calculator_calculator_enlistvariable", (void**)&(pWrapperTable->m_Calculator_EnlistVariable));
+		if ( (eLookupError != 0) || (pWrapperTable->m_Calculator_EnlistVariable == nullptr) )
+			return CALCULATOR_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("calculator_calculator_getenlistedvariable", (void**)&(pWrapperTable->m_Calculator_GetEnlistedVariable));
+		if ( (eLookupError != 0) || (pWrapperTable->m_Calculator_GetEnlistedVariable == nullptr) )
+			return CALCULATOR_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("calculator_calculator_clearvariables", (void**)&(pWrapperTable->m_Calculator_ClearVariables));
+		if ( (eLookupError != 0) || (pWrapperTable->m_Calculator_ClearVariables == nullptr) )
+			return CALCULATOR_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("calculator_calculator_multiply", (void**)&(pWrapperTable->m_Calculator_Multiply));
+		if ( (eLookupError != 0) || (pWrapperTable->m_Calculator_Multiply == nullptr) )
+			return CALCULATOR_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("calculator_calculator_add", (void**)&(pWrapperTable->m_Calculator_Add));
+		if ( (eLookupError != 0) || (pWrapperTable->m_Calculator_Add == nullptr) )
+			return CALCULATOR_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("calculator_getversion", (void**)&(pWrapperTable->m_GetVersion));
+		if ( (eLookupError != 0) || (pWrapperTable->m_GetVersion == nullptr) )
+			return CALCULATOR_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("calculator_getlasterror", (void**)&(pWrapperTable->m_GetLastError));
+		if ( (eLookupError != 0) || (pWrapperTable->m_GetLastError == nullptr) )
+			return CALCULATOR_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("calculator_releaseinstance", (void**)&(pWrapperTable->m_ReleaseInstance));
+		if ( (eLookupError != 0) || (pWrapperTable->m_ReleaseInstance == nullptr) )
+			return CALCULATOR_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("calculator_acquireinstance", (void**)&(pWrapperTable->m_AcquireInstance));
+		if ( (eLookupError != 0) || (pWrapperTable->m_AcquireInstance == nullptr) )
+			return CALCULATOR_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("calculator_createvariable", (void**)&(pWrapperTable->m_CreateVariable));
+		if ( (eLookupError != 0) || (pWrapperTable->m_CreateVariable == nullptr) )
+			return CALCULATOR_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		eLookupError = (*pLookup)("calculator_createcalculator", (void**)&(pWrapperTable->m_CreateCalculator));
+		if ( (eLookupError != 0) || (pWrapperTable->m_CreateCalculator == nullptr) )
+			return CALCULATOR_ERROR_COULDNOTFINDLIBRARYEXPORT;
+		
+		return CALCULATOR_SUCCESS;
+}
+
 
 
 	/**
@@ -563,6 +678,7 @@ class CCalculator : public CBase {
 	{
 		Calculator_double resultValue = 0;
 		CheckError(m_pWrapper->m_WrapperTable.m_Variable_GetValue(m_pHandle, &resultValue));
+		
 		return resultValue;
 	}
 
@@ -601,6 +717,10 @@ class CCalculator : public CBase {
 	{
 		CalculatorHandle hVariable = nullptr;
 		CheckError(m_pWrapper->m_WrapperTable.m_Calculator_GetEnlistedVariable(m_pHandle, nIndex, &hVariable));
+		
+		if (!hVariable) {
+			CheckError(CALCULATOR_ERROR_INVALIDPARAM);
+		}
 		return std::make_shared<CVariable>(m_pWrapper, hVariable);
 	}
 
@@ -620,6 +740,10 @@ class CCalculator : public CBase {
 	{
 		CalculatorHandle hInstance = nullptr;
 		CheckError(m_pWrapper->m_WrapperTable.m_Calculator_Multiply(m_pHandle, &hInstance));
+		
+		if (!hInstance) {
+			CheckError(CALCULATOR_ERROR_INVALIDPARAM);
+		}
 		return std::make_shared<CVariable>(m_pWrapper, hInstance);
 	}
 
@@ -631,6 +755,10 @@ class CCalculator : public CBase {
 	{
 		CalculatorHandle hInstance = nullptr;
 		CheckError(m_pWrapper->m_WrapperTable.m_Calculator_Add(m_pHandle, &hInstance));
+		
+		if (!hInstance) {
+			CheckError(CALCULATOR_ERROR_INVALIDPARAM);
+		}
 		return std::make_shared<CVariable>(m_pWrapper, hInstance);
 	}