//*********************************************************** // // SetIntegerPropOnObject() // // Set an integer property to the AAF object specified by pObj. // The value of the property is specified in value. // // Returns: // // On Success: AAFRESULT_SUCCESS // On Failure: An exception. // HRESULT AAFDomainUtils::SetIntegerPropOnObject(IAAFObject* pObj, aafUID_t* pClassID, aafUID_t* pPropID, const aafUID_t* pIntTypeID, aafMemPtr_t pValue, aafUInt32 ValueSize, IAAFDictionary *dict) { AAFCheck hr; // Create a property value from the supplied value (pValue) IAAFTypeDef* pTD; hr = dict->LookupTypeDef(*pIntTypeID, &pTD); AutoRelease<IAAFTypeDef> r1( pTD ); IAAFTypeDefInt* pTDInt; hr = pTD->QueryInterface(IID_IAAFTypeDefInt, (void**)&pTDInt); AutoRelease<IAAFTypeDefInt> r2( pTDInt ); // Now create a property value object with that value. IAAFPropertyValue* pPV; hr = pTDInt->CreateValue(pValue, ValueSize, &pPV); AutoRelease<IAAFPropertyValue> r3( pPV ); // Add the property to the target object. // Get the class def for the object IAAFClassDef* pCD; hr = dict->LookupClassDef(*pClassID, &pCD); AutoRelease<IAAFClassDef> r4( pCD ); IAAFPropertyDef* pPD; hr = pCD->LookupPropertyDef(*pPropID, &pPD); AutoRelease<IAAFPropertyDef> r5( pPD ); // Set the propeter value on the target object hr = pObj->SetPropertyValue(pPD, pPV); return AAFRESULT_SUCCESS; }
static HRESULT TestPropertyValue ( testMode_t mode, aafUID_constref fileKind, testRawStorageType_t rawStorageType, aafProductIdentification_constref productID) { // HRESULT hr = E_FAIL; long hr = E_FAIL; const size_t fileNameBufLen = 128; aafWChar testFileName[ fileNameBufLen ] = L""; GenerateTestFileName( productID.productName, fileKind, fileNameBufLen, testFileName ); IAAFFile* pFile = NULL; if(mode == kAAFUnitTestReadWrite) { RemoveTestFile (testFileName); checkResult (CreateTestFile( testFileName, fileKind, rawStorageType, productID, &pFile )); assert (pFile); } else { checkResult (AAFFileOpenExistingRead(testFileName, 0, &pFile)); assert (pFile); } IAAFHeader * pHeader = NULL; hr = pFile->GetHeader (&pHeader); if (! SUCCEEDED (hr)) return hr; assert (pHeader); IAAFDictionary * pDict = NULL; hr = pHeader->GetDictionary (&pDict); if (! SUCCEEDED (hr)) return hr; assert (pDict); CAAFBuiltinDefs defs (pDict); // Let's try to do something interesting with a type definition IAAFTypeDefInt * pTypeDef = NULL; hr = defs.tdInt32()->QueryInterface (IID_IAAFTypeDefInt, (void **) &pTypeDef); if (! SUCCEEDED (hr)) return hr; assert (pTypeDef); if(mode == kAAFUnitTestReadWrite) { // Now attempt to create invalid property values; check for errors. const aafInt32 forty_two = 42; IAAFPropertyValue * pv = NULL; // This is what a correct one would look like; we're not ready for that yet: // hr = pTypeDef->CreateValue (&forty_two, 4, &pv); // set this to -1 to see if it gets modified pv = (IAAFPropertyValue *) (-1); // Try null pVal hr = pTypeDef->CreateValue (NULL, 4, &pv); if (AAFRESULT_NULL_PARAM != hr) return AAFRESULT_TEST_FAILED; if ((IAAFPropertyValue *)(-1) != pv) return AAFRESULT_TEST_FAILED; // Try valSize too large hr = pTypeDef->CreateValue ((aafMemPtr_t) &forty_two, 8, &pv); if (AAFRESULT_BAD_SIZE != hr) return AAFRESULT_TEST_FAILED; if ((IAAFPropertyValue *)(-1) != pv) return AAFRESULT_TEST_FAILED; // Now try correct one pv = NULL; hr = pTypeDef->CreateValue ((aafMemPtr_t) &forty_two, 4, &pv); if (! SUCCEEDED (hr)) return hr; if (! pv) return AAFRESULT_TEST_FAILED; // That one worked; let's try one with a smaller init size (should // also work) pv->Release(); pv = NULL; const aafInt16 fifty_seven = 57; hr = pTypeDef->CreateValue ((aafMemPtr_t) &fifty_seven, 2, &pv); if (! SUCCEEDED (hr)) return hr; if (! pv) return AAFRESULT_TEST_FAILED; // cool. Now we should have a good property value whose value is 57. // check GetType() for error condition hr = pv->GetType (NULL); if (AAFRESULT_NULL_PARAM != hr) return AAFRESULT_TEST_FAILED; // this GetType() call should work, and return the original type def. IAAFTypeDef * propType = NULL; hr = pv->GetType (&propType); if (! SUCCEEDED (hr)) return hr; if (! propType) return AAFRESULT_TEST_FAILED; // Convert both to IUnknown for comparison IUnknown * pPropUnknown = NULL; IUnknown * pTypeDefUnknown = NULL; hr = propType->QueryInterface(IID_IUnknown, (void **)&pPropUnknown); if (! SUCCEEDED (hr)) return hr; assert (pPropUnknown); hr = pTypeDef->QueryInterface(IID_IUnknown, (void **)&pTypeDefUnknown); if (! SUCCEEDED (hr)) return hr; assert (pTypeDefUnknown); if (pPropUnknown != pTypeDefUnknown) return AAFRESULT_TEST_FAILED; // Test IsDefinedType () // (Currently only returns true.) aafBool b = kAAFFalse; hr = pv->IsDefinedType (&b); if (! SUCCEEDED (hr)) return hr; if (kAAFTrue != b) return AAFRESULT_TEST_FAILED; pTypeDefUnknown->Release(); pPropUnknown->Release(); pTypeDef->Release(); propType->Release(); pv->Release(); pDict->Release(); pHeader->Release(); hr = pFile->Save(); } if (! SUCCEEDED (hr)) return hr; hr = pFile->Close(); if (! SUCCEEDED (hr)) return hr; pFile->Release(); return AAFRESULT_SUCCESS; }