Essential COM

Product Information

Simplicity Leads to Malleability mal·le·a·ble (mal'e-e-bel) adjective 1. Capable of being shaped or formed, as by hammering or pressure: a malleable metal. 2. Easily controlled or influenced; tractable. 3. Able to adjust to changing circumstances; adaptable: the malleable mind of the pragmatist. 3 Despite the fact that pCat, pPug, and pUnk all point to the same object, it is illegal for the client to counterbalance the AddRefs that occurred on pPug and pCat when Querylnterface was called with calls to Rel ease through pUnk. The correct form of this code is cleanup: if (pCat) pCat->Release(); II use AddRefed ptr if (pPug) pPug->Release(); II use AddRefed ptr Here, Release is called through exactly the same interface pointer that received the AddRef (which happened implicitly when the pointer was returned from QueryInterface). This requirement affords the developer a great deal of flexibility when implementing an object. For example, an object may elect to perform per-interface reference counting to allow aggressive reclamation ofre- sources that are used only by a particular interface on an object. One additional subtlety related to Querylnterface concerns its second parameter, which is of type void **. It is very ironic that Querylnterface, the underpinning of the COM type system, has a fairly type-unsafe prototype in C++: HRESULT __stdcall Querylnterface(REFIID riid, void** ppv);

Essential Communications Executive Coaching Los Angeles - Essential Communications

object, uuid(DF12E153-A29A-lldO-8C2D-0080C73925BA)] interface IOog : IAnimal { HRESULT Bark(void); } severity>_ For example, the HRESULT STG_S_CONVERTED indicates that the facility code is FACILITY_STORAGE (which means that this result is related to Structured Storage or Persistence); the severity bit is SEVERITY_SUCCESS (which means that the call was able to perform the operation successfully) and that, in this case, the operation converted the underlying file to support structured storage. HRESULTs that are universal and are not tied to a particular technology use FACILITY_NULL and their symbolic name does not contain the facility code prefix. Some common FACILITY_NULL HRESULTs are class IExtensibleObject { public: virtual void *Dynamic_Cast(const char* pszType) =0; virtual void Delete(void) = 0; } ; This does not prohibit the FastStri ng implementation from becoming persistent; it simply means that the persistent version of FastStr; ng must implement both the IFastStri ng and IPersi stentObj ect interfaces: class FastString : public IFastString, public IPersistentObject { interface IUnknown { HRESULT Querylnterface([in] REFIID riid, [out] void **ppv); ULONG AddRef(void); ULONG Release(void); }Optimizing Querylnterface The de facto implementation of Querylnterface shown earlier in this chapter is fairly straightforward and easily maintained by anyone who has a basic understanding of COM and C++. However, many production environments and frameworks favor a data-driven implementation to achieve greater extensibility and better performance due to code size reduction. Such implementations assume that each COM-compliant class provides a table that maps each supported lID onto some aspect of the object using fixed offsets or some other technique. In essence, the implementation of Querylnterface shown earlier in this chapter builds a table based on the compiled machine code for each sequential if statement and the fixed offsets are calculated using the stati c_cast operator (stat; c_cast simply adds the offset of the base class to find the typecompatible vptr). To implement a table-driven Querylnterface, one first needs to define what the table will contain. At a minimum, each table entry will need to contain a pointer to an lID and some additional state that allows the implementation to find the object's vptr for the requested interface. For maximum flexibility, storing a function pointer at each table entry would support the When the client calls the function with no second parameter pfs = CallCreateFastString("Hi Bob!"); n = pfs->Find("ob"); the original FastStri ng DLL is loaded and the search is performed from left to right. If the client indicates that the string is in a spoken language that parses from right to left pfs = CallCreateFastString("Hi Bob!", false); n = pfs->Find("ob"); the alternative version of the DLL (FastStri ngRL. DLL) is loaded and the search will be performed starting at the rightmost position of the string. The key observation is that callers of Call CreateFastStri ng do not care which DLL is used to implement the object's methods. All that matters is that a pointer to an IFastStri ng-compatible vptr is returned by the function and that the vptr provides useful and semantically correct functionality. This form of runtime polymorphism is extremely useful for building a dynamically composed system from binary components. The exact pronunciation of GUID is a subject of heated debate among COM developers. Although the COM Specification states that GUID rhymes with fluid, not squid, the author believes that the COM Specification is simply incorrect, citing the word languid as setting the precedent. bool SaveString(IFastString *pfs, const char *pszFN){ bool bResult = false; IPersistentObject *ppo = (IPersistentObject*) pfs->Dynamic_Cast("IPersistentObject"); if (ppo) bResult = ppo->Save(pszFN); return bResult; } To allow comparison of GUID values, COM provides equivalence functions and overloads operator == and operator != for constant GUID references:

Essential Mod | Home - The Mod You Need For Minecraft Java Essential Mod | Home - The Mod You Need For Minecraft Java

IFastString* CreateFastString(const char *psz) { IFastString *pfsResult = new FastString(psz); if (pfsResul t) pfsResult->DuplicatePointer(); return pfsResult; } Function Method2(argl as Integer) As Integer Because C++ uses no supporting runtime to access COM interfaces, the Microsoft C++ mapping of this method looks like this:i nt f(voi d) { IFastStri ng ''rpfs = CreateFastStri ng("Deface me"); int n = pfs->Find("ace me delete pfs; return n; ll extern "C" const lID IID_IUnknown; interface IUnknown { virtual HRESULT STDMETHODCALLTYPE Querylnterface(REFIID riid, void **ppv) = 0; virtual ULONG STDMETHODCALLTYPE AddRef(void) = 0; virtual ULONG STDMETHODCALLTYPE Release(void) = 0; } ; if (riid == IID_IUnknown) *ppv = static_cast (this); Either of these two code fragments is legal for the implementation of PugCat. The former version is preferred, as many compilers produce slightly more efficient code when the leftmost base class is used. 4 class IFastString { public: II faux version 1.0 virtual void Delete(void) = 0; virtual int Length(void) = 0; virtual int Find(const char *psz) = 0; II faux version 2.0 virtual int FindN(const char *psz, int As previously described, clients call Querylnterface providing the object with a pointer to an interface pointer as the second parameter together with an lID that identifies the type of interface pointer that is expected: IPug *pPug = 0; hr = punk->QueryInterface(IID_IPug, (void**)&pPug); Unfortunately, the following looks equally correct to the C++ compiler: IPug *pPug = 0; hr = punk->QueryInterface(IID_ICat, (void**)&pPug); This more subtle variation also compiles correctly: IPug *pPug = 0; hr = punk->QueryInterface(IID_IPug, (void**)pPug); Given that the rules of inheritance do not apply to pointers, this alternative definition of QueryInterface does not alleviate the problem: HRESULT QueryInterface(REFIID riid, IUnknown** ppv); as implicit upcasting applies only to instances and pointers to instances, not pointers to pointers to instances: IDe ri ved *~'rppd; IBase **ppb = ppd; II illegal This same limitation applies to references to pointers as well. The following alternative definition is arguably more convenient for clients to use: HRESULT QueryInterface(const IID& riid, void* ppv); as it allows clients to forgo the cast. Unfortunately, this solution does not reduce the number of errors (both of the preceding errors are still possible) and, by eliminating the need for a cast, removes a visual indicator that C++ type safety might be in jeopardy. Given the desired semantics of QueryInterface, the argument types Microsoft chose are reasonable, if not type safe or elegant. The simplest way to avoid QueryInterface-related errors is to always be certain that the lID matches the type of the interface pointer that is passed as the second parameter to QueryInterface. In effect, the first parameter to

Essentials for Men FW23 Collection | SSENSE UK Fear Of God Essentials for Men FW23 Collection | SSENSE UK

lCat cat; try { cat = (ICat)obj; II VM calls Querylnterface cat.lgnoreMaster(); } catch (Throwable ex) { II ignore method or QI failures } } To Judith S., who helped me master the one thing more daunting than COM and made this book possible, and Barbara, who stayed long enough to see how it all turned out. faststring.cpp (part of DLL) IIIIIIIIIII IFastString *CreateFastString (canst char *psz) { return new FastString(psz); other versions may be present on the system. Unfortunately, over time, the number of versioned DLLs present on the end-user's system could conceivably exceed the number of actual client applications due to poor software configuration practices. Simply examining the system directory of any computer that has been in use for more than six months would reinforce this. Ultimately, this versioning problem is rooted in the compilation model of C++, which was not designed to support independent binary components. By requiring client knowledge of object layout, C++ introduces a tight binary coupling between the client and object executables. Normally, binary coupling works to C++'s favor, as it allows compilers to produce extremely efficient code. Unfortunately, this tight binary coupling prevents class implementations from being replaced without client recompilation. Because of this coupling and the compiler and linker incompatibilities mentioned in the previous section, simply exporting C++ class definitions from DLLs does not provide a reasonable binary component architecture.

addition of new techniques for finding interfaces beyond the normal offset calculation used when simply casting to a base class. The source code that accompanies this book includes a header file, i nttabl e. h, that defines interface table entries as follows: