Reading SAFEARRAY of UDT containing SAFEARRAY - c++

Question

I'm trying to create and read a SAFEARRAY(MyUDT)* where MyUDT contains a SAFEARRAY, but when I try to read it I got an "Access violation" exception.
I defined the following struct and enum:
typedef [uuid(...)]
enum CollisionDetectorMoveType
{
CollisionDetectorMoveType_Unknown = -1,
CollisionDetectorMoveType_Move = 0,
CollisionDetectorMoveType_Measure
} CollisionDetectorMoveType;
typedef [uuid(...)]
struct CollisionDetectorXYZ
{
double X;
double Y;
double Z;
} CollisionDetectorXYZ;
typedef [uuid(...)]
struct CollisionDetectorMultiPosition
{
SAFEARRAY(CollisionDetectorXYZ) pos;
CollisionDetectorMoveType type;
} CollisionDetectorMultiPosition;
bool createTestCollisionDetectorMultiPositionSafeArray(SAFEARRAY** psa)
{
IRecordInfoPtr recordset_info = nullptr;
HRESULT hr = GetRecordInfoFromGuids(LIBID_CollisionDetectorLib, 1, 0, 0, UUID_CollisionDetectorMultiPosition, &recordset_info);
if (FAILED(hr))
{
return false;
}
SAFEARRAYBOUND safearray_bound;
memset(&safearray_bound, 0, sizeof(safearray_bound));
safearray_bound.cElements = 10;
safearray_bound.lLbound = 0;
*psa = ::SafeArrayCreateEx(VT_RECORD, 1, &safearray_bound, (PVOID)recordset_info);
for (size_t i = 0; i < 10; ++i)
{
CollisionDetectorMultiPosition multiPosition;
multiPosition.type = i % 2 == 0 ? CollisionDetectorMoveType_Move : CollisionDetectorMoveType_Measure;
if (!createTestCollisionDetectorXYZSafeArray(&multiPosition.pos))
{
return false;
}
LONG current_position = i;
::SafeArrayPutElement(*psa, &current_position, &multiPosition);
}
::SafeArrayUnaccessData(*psa);
return true;
}
}
bool createTestCollisionDetectorXYZSafeArray(SAFEARRAY** psa)
{
IRecordInfoPtr recordset_info = nullptr;
HRESULT hr = GetRecordInfoFromGuids(LIBID_CollisionDetectorLib, 1, 0, 0, UUID_CollisionDetectorXYZ, &recordset_info);
if (FAILED(hr))
{
return false;
}
SAFEARRAYBOUND safearray_bound;
memset(&safearray_bound, 0, sizeof(safearray_bound));
safearray_bound.cElements = 10;
safearray_bound.lLbound = 0;
*psa = ::SafeArrayCreateEx(VT_RECORD, 1, &safearray_bound, (PVOID)recordset_info);
for (size_t i = 0; i < 10; ++i)
{
CollisionDetectorXYZ current_point;
current_point.X = i;
current_point.Y = i;
current_point.Z = i;
LONG current_position = i;
::SafeArrayPutElement(*psa, &current_position, &current_point);
}
::SafeArrayUnaccessData(*psa);
return true;
}
Then I try to create and read the SAFEARRAY:
SAFEARRAY* psa2 = NULL;
if (!createTestCollisionDetectorMultiPositionSafeArray(&psa2))
{
*retVal = SYSERR;
return S_OK;
}
CollisionDetectorMultiPosition* current_pointer_to_element;
auto access_result = ::SafeArrayAccessData(psa2, (void **)&current_pointer_to_element);
if (FAILED(access_result))
{
return S_OK;
}
LONG upper_bound, lower_bound;
::SafeArrayGetLBound(psa2, 1, &lower_bound);
::SafeArrayGetUBound(psa2, 1, &upper_bound);
std::vector<CollisionDetectorMultiPosition> multiPositionVector;
LONG size = upper_bound - lower_bound + 1;
for (LONG i = 0; i < size; i++)
{
CollisionDetectorMultiPosition this_value;
::SafeArrayGetElement(psa2, &i, (void *)&this_value);
multiPositionVector.push_back(this_value);
}
However when I call ::SafeArrayGetElement(psa2, &i, (void *)&this_value); I got the exception.
What I'm doing wrong?
If I simply call
CollisionDetectorMultiPosition multiPosition;
multiPosition.type = CollisionDetectorMoveType_Move;
if (!createTestCollisionDetectorXYZSafeArray(&multiPosition.pos))
{
*retVal = SYSERR;
return S_OK;
}
I can read the multiPosition.pos SAFEARRAY without any problem.
Thanks for your help.
Solved
I found a solution, I report the code for all the users which could have the same problem. Basically the trick is to create a SAFEARRAY of VARIANT, and fill the VARIANT struct with the CollisionDetectorMultiPosition.
CComVariant variant;
variant.vt = VT_RECORD;
variant.pvRecord = &multiPosition;
variant.pRecInfo = recordset_info;
Creation of SAFEARRAY
bool createTestCollisionDetectorMultiPositionSafeArray(SAFEARRAY** psa)
{
IRecordInfoPtr recordset_info;
HRESULT hr = GetRecordInfoFromGuids(LIBID_CollisionDetectorLib, 1, 0, 0, UUID_CollisionDetectorMultiPosition, &recordset_info);
if (FAILED(hr))
{
return false;
}
SAFEARRAYBOUND safearray_bound;
memset(&safearray_bound, 0, sizeof(safearray_bound));
safearray_bound.cElements = 10;
safearray_bound.lLbound = 0;
*psa = SafeArrayCreate(VT_VARIANT, 1, &safearray_bound);
for (size_t i = 0; i < 10; ++i)
{
CollisionDetectorMultiPosition multiPosition;
multiPosition.type = i % 2 == 0 ? CollisionDetectorMoveType_Move : CollisionDetectorMoveType_Measure;
if (!createTestCollisionDetectorXYZSafeArray(&multiPosition.pos))
{
return false;
}
CComVariant variant;
variant.vt = VT_RECORD;
variant.pvRecord = &multiPosition;
variant.pRecInfo = recordset_info;
LONG current_position = i;
::SafeArrayPutElement(*psa, &current_position, &variant);
variant.vt = VT_EMPTY;
}
::SafeArrayUnaccessData(*psa);
return true;
}
Reading the SAFEARRAY
SAFEARRAY* psa2 = NULL;
if (!createTestCollisionDetectorMultiPositionSafeArray(&psa2))
{
*retVal = AC3SYSERR;
return S_OK;
}
LONG upper_bound, lower_bound;
::SafeArrayGetLBound(psa2, 1, &lower_bound);
::SafeArrayGetUBound(psa2, 1, &upper_bound);
std::vector<std::pair<CollisionDetectorMoveType, std::vector<CollisionDetectorXYZ>>> multiPositionVector;
LONG size = upper_bound - lower_bound + 1;
for (LONG i = 0; i < size; i++)
{
VARIANT this_value;
VariantInit(&this_value);
VariantClear(&this_value);
::SafeArrayGetElement(psa2, &i, (void *)&this_value);
CollisionDetectorMultiPosition* this_value2 = (CollisionDetectorMultiPosition *)this_value.pvRecord;
CollisionDetectorXYZ* current_pointer_to_element;
auto access_result = ::SafeArrayAccessData(this_value2->pos, (void **)&current_pointer_to_element);
if (FAILED(access_result))
{
return S_OK;
}
LONG upper_bound, lower_bound;
::SafeArrayGetLBound(this_value2->pos, 1, &lower_bound);
::SafeArrayGetUBound(this_value2->pos, 1, &upper_bound);
std::vector<CollisionDetectorXYZ> moves;
LONG size = upper_bound - lower_bound + 1;
for (LONG i = 0; i < size; i++)
{
CollisionDetectorXYZ this_value;
::SafeArrayGetElement(this_value2->pos, &i, (void *)&this_value);
moves.push_back(this_value);
}
multiPositionVector.push_back(std::make_pair(this_value2->type, moves));
::SafeArrayUnaccessData(this_value2->pos);
}

Answer 1

Actually I had similar problem and this thread helped me a lot, but there are some details specific to MFC ActiveX that took me a couple of days to demystify and I want to share them with the community.
My objective was to add a method in an MFC/ATL ActiveX that would return an Array of UDT to COM enabled programming languages.
My first problem was exposing the UUID of the UDT to the C++ code; for some reason despite giving a GUID to the UDT it was not being generated nor becoming available to C++. I found that I had to add cpp_quote in IDL to force it.
[
uuid(GUID_LIBRARY),
version(VERSION)
...
]
library WebKitXCEF3Lib
{
importlib(STDOLE_TLB);
typedef [public, uuid(<your guid here>)] struct Cookie
{
BSTR Name;
BSTR Domain;
BSTR Path;
BSTR Value;
VARIANT_BOOL HttpOnly;
VARIANT_BOOL Secure;
VARIANT_BOOL Expires;
VARIANT ExpiryDateUTC;
} Cookie;
cpp_quote("struct __declspec(uuid(\"{<your guid here>}\")) Cookie;")
...
}
Next, the return type of the method returning the UDT Array has to be VARIANT:
[id(100)] VARIANT GetCookies(BSTR Domain);
The DISPATCH MAP should define the return type as VT_VARIANT too:
BEGIN_DISPATCH_MAP(CMyCtrl, COleControl)
DISP_FUNCTION_ID(CMyCtrl, "GetCookies", dispidGetCookies, GetCookies, VT_VARIANT, VTS_BSTR)
END_DISPATCH_MAP()
And finally the C++ code must create a SAFEARRAY using SafeArrayCreateEx and provide the IRecordInfo of the UDT, which finally wraps to this:
VARIANT CMyCtrl::GetCookies(LPCTSTR Domain)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
SAFEARRAY* psaCookies = nullptr;
if(AmbientUserMode() && !Unloading || BROWSER_READY)
{
LONG L = Cookies.size();
SAFEARRAYBOUND rgsabound[1];
rgsabound[0].lLbound = 0;
rgsabound[0].cElements = L;
IRecordInfoPtr pRecInfo = nullptr; // DO NOT RELEASE !!!
if(SUCCEEDED(GetRecordInfoFromGuids(LIBID_MyLib, VERSION_MAJOR, VERSION_MINOR, 0, __uuidof(Cookie), &pRecInfo)))
{
psaCookies = ::SafeArrayCreateEx(VT_RECORD, 1, rgsabound, pRecInfo);
if(psaCookies)
{
Cookie* pCookies = NULL;
if(SUCCEEDED(SafeArrayAccessData(psaCookies, reinterpret_cast<PVOID*>(&pCookies))))
{
for(LONG i = 0; i < L; i++)
{
pCookies[i].Name = WSTR_to_BSTR(Cookies[i].Name);
pCookies[i].Domain = WSTR_to_BSTR(Cookies[i].Domain);
pCookies[i].Path = WSTR_to_BSTR(Cookies[i].Path);
pCookies[i].Value = WSTR_to_BSTR(Cookies[i].Value);
pCookies[i].HttpOnly = Cookies[i].HttpOnly;
pCookies[i].Secure = Cookies[i].Secure;
pCookies[i].Expires = Cookies[i].Expires;
VariantCopy(&(pCookies[i].ExpiryDateUTC), &(Cookies[i].ExpiryDateUTC));
}
SafeArrayUnaccessData(psaCookies);
}
}
}
}
VARIANT result;
VariantInit(&result);
if(psaCookies)
{
result.vt = VT_ARRAY | VT_RECORD;
result.parray = psaCookies;
}
return result;
}
Be careful NOT to release the IRecordInfo and the returning VARIANT must be of type VT_ARRAY | VT_RECORD.
The VB6 code looks like this:
Private Sub wxDesigner_OnPageComplete(ByVal URL As String)
Dim Cookies As Variant
Cookies = wxDesigner.GetCookies("foo.com")
End Sub
And in Watches the VARIANT looks like this: