HRESULT STDMETHODCALLTYPE CAAFTypeDefObjectRef::CreateValue (IUnknown * pObj, IAAFPropertyValue ** ppPropVal) { HRESULT hr; ImplAAFTypeDefObjectRef * ptr; ImplAAFRoot * pO; pO = GetRepObject (); assert (pO); ptr = static_cast<ImplAAFTypeDefObjectRef*> (pO); assert (ptr); // // set up for pObj // ImplAAFRoot * internalpObj = NULL; if (pObj) { HRESULT hStat; IAAFRoot * iObj; ImplAAFRoot *arg; hStat = pObj->QueryInterface (IID_IAAFRoot, (void **)&iObj); if (FAILED(hStat)) { // If input IUnknown argument MUST supprt our private IAAFRoot interface. // If it does not than the argument is not one of our implementation objects! assert(E_NOINTERFACE == hStat); if (E_NOINTERFACE == hStat) return AAFRESULT_INVALID_PARAM; else return hStat; } assert (iObj); hStat = iObj->GetImplRep((void **)&arg); assert (SUCCEEDED (hStat)); iObj->Release(); // we are through with this interface pointer. internalpObj = static_cast<ImplAAFRoot*>(arg); assert (internalpObj); } // // set up for ppPropVal // ImplAAFPropertyValue * internalppPropVal = NULL; ImplAAFPropertyValue ** pinternalppPropVal = NULL; if (ppPropVal) { pinternalppPropVal = &internalppPropVal; } try { hr = ptr->CreateValue (internalpObj, pinternalppPropVal); } catch (OMException& e) { // OMExceptions should be handled by the impl code. However, if an // unhandled OMException occurs, control reaches here. We must not // allow the unhandled exception to reach the client code, so we // turn it into a failure status code. // // If the OMException contains an HRESULT, it is returned to the // client, if not, AAFRESULT_UHANDLED_EXCEPTION is returned. // hr = OMExceptionToResult(e, AAFRESULT_UNHANDLED_EXCEPTION); } catch (OMAssertionViolation &) { // Control reaches here if there is a programming error in the // impl code that was detected by an assertion violation. // We must not allow the assertion to reach the client code so // here we turn it into a failure status code. // hr = AAFRESULT_ASSERTION_VIOLATION; } catch (...) { // We CANNOT throw an exception out of a COM interface method! // Return a reasonable exception code. // hr = AAFRESULT_UNEXPECTED_EXCEPTION; } // // no cleanup necessary for pObj // // // cleanup for ppPropVal // if (SUCCEEDED(hr)) { IUnknown *pUnknown; HRESULT hStat; if (internalppPropVal) { pUnknown = static_cast<IUnknown *> (internalppPropVal->GetContainer()); hStat = pUnknown->QueryInterface(IID_IAAFPropertyValue, (void **)ppPropVal); assert (SUCCEEDED (hStat)); //pUnknown->Release(); internalppPropVal->ReleaseReference(); // We are through with this pointer. } } return hr; }
HRESULT STDMETHODCALLTYPE CAAFTypeDefRecord::CreateValueFromValues (IAAFPropertyValue ** pMemberValues, aafUInt32 numMembers, IAAFPropertyValue ** ppPropVal) { HRESULT hr; ImplAAFTypeDefRecord * ptr; ImplAAFRoot * pO; pO = GetRepObject (); assert (pO); ptr = static_cast<ImplAAFTypeDefRecord*> (pO); assert (ptr); // // set up for pMemberValues // ImplAAFPropertyValue ** internalpMemberValues = NULL; if (pMemberValues) { aafUInt32 localIdx; assert (numMembers >= 0); internalpMemberValues = new ImplAAFPropertyValue*[numMembers]; assert (internalpMemberValues); for (localIdx = 0; localIdx < numMembers; localIdx++) { HRESULT hStat; IAAFRoot * iObj; ImplAAFRoot *arg; hStat = pMemberValues[localIdx]->QueryInterface (IID_IAAFRoot, (void **)&iObj); assert (SUCCEEDED (hStat)); assert (iObj); hStat = iObj->GetImplRep((void **)&arg); assert (SUCCEEDED (hStat)); iObj->Release(); // we are through with this interface pointer. internalpMemberValues[localIdx] = static_cast<ImplAAFPropertyValue*>(arg); assert (internalpMemberValues[localIdx]); } } // // set up for ppPropVal // ImplAAFPropertyValue * internalppPropVal = NULL; ImplAAFPropertyValue ** pinternalppPropVal = NULL; if (ppPropVal) { pinternalppPropVal = &internalppPropVal; } try { hr = ptr->CreateValueFromValues (internalpMemberValues, numMembers, pinternalppPropVal); } catch (OMException& e) { // OMExceptions should be handled by the impl code. However, if an // unhandled OMException occurs, control reaches here. We must not // allow the unhandled exception to reach the client code, so we // turn it into a failure status code. // // If the OMException contains an HRESULT, it is returned to the // client, if not, AAFRESULT_UHANDLED_EXCEPTION is returned. // hr = OMExceptionToResult(e, AAFRESULT_UNHANDLED_EXCEPTION); } catch (OMAssertionViolation &) { // Control reaches here if there is a programming error in the // impl code that was detected by an assertion violation. // We must not allow the assertion to reach the client code so // here we turn it into a failure status code. // hr = AAFRESULT_ASSERTION_VIOLATION; } catch (...) { // We CANNOT throw an exception out of a COM interface method! // Return a reasonable exception code. // hr = AAFRESULT_UNEXPECTED_EXCEPTION; } // // cleanup for pMemberValues // if (internalpMemberValues) { delete[] internalpMemberValues; internalpMemberValues = 0; } // // cleanup for ppPropVal // if (SUCCEEDED(hr)) { IUnknown *pUnknown; HRESULT hStat; if (internalppPropVal) { pUnknown = static_cast<IUnknown *> (internalppPropVal->GetContainer()); hStat = pUnknown->QueryInterface(IID_IAAFPropertyValue, (void **)ppPropVal); assert (SUCCEEDED (hStat)); //pUnknown->Release(); internalppPropVal->ReleaseReference(); // We are through with this pointer. } } return hr; }
HRESULT STDMETHODCALLTYPE CAAFTypeDefRecord::CreateValueFromStruct (aafMemPtr_t pInitData, aafUInt32 initDataSize, IAAFPropertyValue ** ppPropVal) { HRESULT hr; ImplAAFTypeDefRecord * ptr; ImplAAFRoot * pO; pO = GetRepObject (); assert (pO); ptr = static_cast<ImplAAFTypeDefRecord*> (pO); assert (ptr); // // set up for ppPropVal // ImplAAFPropertyValue * internalppPropVal = NULL; ImplAAFPropertyValue ** pinternalppPropVal = NULL; if (ppPropVal) { pinternalppPropVal = &internalppPropVal; } try { hr = ptr->CreateValueFromStruct (pInitData, initDataSize, pinternalppPropVal); } catch (OMException& e) { // OMExceptions should be handled by the impl code. However, if an // unhandled OMException occurs, control reaches here. We must not // allow the unhandled exception to reach the client code, so we // turn it into a failure status code. // // If the OMException contains an HRESULT, it is returned to the // client, if not, AAFRESULT_UHANDLED_EXCEPTION is returned. // hr = OMExceptionToResult(e, AAFRESULT_UNHANDLED_EXCEPTION); } catch (OMAssertionViolation &) { // Control reaches here if there is a programming error in the // impl code that was detected by an assertion violation. // We must not allow the assertion to reach the client code so // here we turn it into a failure status code. // hr = AAFRESULT_ASSERTION_VIOLATION; } catch (...) { // We CANNOT throw an exception out of a COM interface method! // Return a reasonable exception code. // hr = AAFRESULT_UNEXPECTED_EXCEPTION; } // // cleanup for ppPropVal // if (SUCCEEDED(hr)) { IUnknown *pUnknown; HRESULT hStat; if (internalppPropVal) { pUnknown = static_cast<IUnknown *> (internalppPropVal->GetContainer()); hStat = pUnknown->QueryInterface(IID_IAAFPropertyValue, (void **)ppPropVal); assert (SUCCEEDED (hStat)); //pUnknown->Release(); internalppPropVal->ReleaseReference(); // We are through with this pointer. } } return hr; }
AAFRESULT STDMETHODCALLTYPE ImplAAFTypeDefArray::CreateValueFromValues ( ImplAAFPropertyValue ** ppElementValues, aafUInt32 numElements, ImplAAFPropertyValue ** ppPropVal) { AAFRESULT hr = AAFRESULT_SUCCESS; //first validate params ... if (!ppPropVal) return AAFRESULT_NULL_PARAM; hr = ValidateInputParams(ppElementValues, numElements); if (AAFRESULT_FAILED (hr)) return hr; // All params validated; proceed .... // PATCH DR4_CPR: transdel. Create the appropriate ImplAAFRefArray without an associated // property. The property value's writeTo method needs to copy (or replace) the contents // of the current property. This a hybrid of the old-pseudo "direct access" and the new // more direct property access. ImplAAFTypeDefSP pElementType; hr = GetType(&pElementType); if (AAFRESULT_FAILED(hr)) return hr; if (dynamic_cast<ImplAAFTypeDefObjectRef*>((ImplAAFTypeDef*) pElementType)) { ImplAAFPropertyValue *pPropertyValue = NULL; hr = CreateEmptyValue(&pPropertyValue); if (AAFRESULT_SUCCEEDED(hr)) { ImplAAFRefArrayValue *pRefArray = dynamic_cast<ImplAAFRefArrayValue *>(pPropertyValue); ASSERTU(NULL != pRefArray); if (NULL == pRefArray) hr = AAFRESULT_INVALID_OBJ; aafUInt32 index; for (index = 0; (index < numElements) && AAFRESULT_SUCCEEDED(hr); ++index) { hr = pRefArray->AppendElement(ppElementValues[index]); } if (AAFRESULT_SUCCEEDED(hr)) *ppPropVal = pPropertyValue; // refcount already incremented else pPropertyValue->ReleaseReference(); pPropertyValue = NULL; } } else { //2nd step - Create the value; defer to base impl //first, calculate the total size needed for allocation, based on type //get Base TD ImplAAFTypeDefSP spTargetTD; hr = GetType(&spTargetTD); //gets base elem type if (AAFRESULT_FAILED (hr)) return hr; //Get Elem size aafUInt32 targetElemSize = spTargetTD->NativeSize(); //Total size ... aafUInt32 totalSize = targetElemSize * numElements; //size based on "n" Elements //create the value hr = ImplAAFTypeDefArray::CreateValue(ppPropVal, totalSize); if (AAFRESULT_FAILED(hr)) return hr; //... Copy the values ; defer to base impl hr = ImplAAFTypeDefArray::CopyValuesIntoValue(ppElementValues,numElements, targetElemSize, ppPropVal); } return hr; }