Essential COM

Product Information

requires all persistent objects to support the Length and Find operations as well. For some very small subset of objects, this might make sense. However, to make the IPers; stentObject interface as generic as possible, it should really be its own interface and not derive from IFastStri ng: class IPersistentObject { public: virtual void Delete(void) = 0; virtual bool Load(const char *pszFileName) virtual bool Save(const char *pszFileName) II faststringitf.cPPIII (part of DLL, not client) II #include "faststring.h" #include "faststringitf.h" FastStringltf::FastStringltf(const char *psz) m_pThis(new FastString(psz)) { assert(m_pThis != 0); } The [1 oca1] attribute suppresses the generation of networking code for this interface. This attribute is necessary to relax COM's requirement that all remotable methods must return HRESULTs. As discussed in later chapters, IUnknown is treated specially when dealing with remote objects. Note that the actual IDL interface definitions found in the SDK headers will vary slightly from the definitions found in this text. The actual definitions often contain additional attributes to optimize the generated networking code that are not relevant to the discussion at hand. When in doubt, consult the latest version of the SDK header files for the complete definition. IUnknown is the root of all COM interfaces. IUnknown is the only COM interface that does not derive from another COM interface. Every other legal COM interface must derive from IUnknown directly or from one other legal COM interface, which itself must derive either from IUnknown directly or from one other legal COM interface. This means that at the binary level all COM interfaces are pointers to vtbls that begin with the three entries Que rylnte rface, AddRef, and Release. Any interface-specific methods will have vtbl entries that appear after these common three entries. To derive from an interface in IDL, either define the base interface in the same IDL file or use the import directive to make the external IDL definition of the base interface visible in the current scope: class FastString : public IFastString, public IPersistentObject { int m_cPtrs; II count of outstanding ptrs public: II initialize pointer count to zero FastString(const char *psz) : m_cPtrs(O) {} void DuplicatePointer(void) { II note duplication of pointer ++m_cPtrs; } Methods and Results Method results are one aspect of COM where the logical and physical worlds diverge. Virtually all COM methods physically return an error number of type HRESULT. The use of a uniform result type allows COM's remoting architecture to overload the result of a method and also indicate communications errors simply by reserving a range of values for RPC errors. HRESULTs are 32-bit integers that provide information to the caller's runtime environment about what type of error may have occurred (e.g., network errors, server failures). For many COM-compatible implementation languages (e.g., Visual Basic, Java), these HRESULTs are intercepted by a supporting runtime or virtual machine and mapped to programmatic exceptions.

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

At the time of this writing, the author did not have a working implementation of this algorithm suitable for publication. The details of such an implementation are left as an exercise for the reader. With these methods in place, all users of IExtensi bl eObject must now adhere to the following two mandates: (1) When an interface pointer is duplicated, a call to Dupl i catePoi nter is required. (2) When an interface pointer is no longer in use, a call to DestroyPoi nter is required. These methods could be implemented in each object simply by noting the number of live pointers and destroying the object when no outstanding pointers remain: II ifaststring.h IIIIIIIIIII class IFastString { public: virtual int Length(void) canst = 0; virtual int Find(const char *psz) canst interface IUnknown { HRESULT Querylnterface([in] REFIID riid, [out] void **ppv); ULONG AddRef(void); ULONG Release(void); }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 return static_cast (this); else if (strcmp(pszType, "IPersistentObject") 0) return static_cast (this); else if (strcmp(pszType, "IExtensibleObject") 0) return static_cast (this); else return 0; II request for unsupported interface } object, uuid(DF12E155-A29A-lldO-8C2D-0080C73925BA)] interface IOldPug : IPug { HRESULT SnoreLoudly(void); } The Dynami c_Cast method was used for runtime type discovery and was analogous to C++'s dynami c_cast operator. The Dupl i catePoi nter method was used to notify the object that an interface pointer had been duplicated. The DestroyPoi nter method was used to notify the object that an interface pointer had been destroyed and any resources it held could be released. The following is the C++ definition of IUnknown: The unexpected behavior stems from the fact that the destructor for the interface class is not virtual. This means that the call to the delete operator will not dynamically find the mDst derived destructor and recursively destroy the object from the outermost type to the base type. Because the FastStri ng destructor is never called, the preceding example leaks the buffer memory used to hold the string "Deface me". One obvious solution to this problem is to make the destructor virtual in the interface class. Unfortunately, this pollutes the compiler independence of

Essential Education GED Academy™ | Essential Education

To save a FastStri ng to disk, clients can simply use RTTI to bind a pointer to the IPersi stentObject interface that is exposed by the object: FastString::FastString(const char *psz) m_cch(strlen(psz)), m_psz(new char[m_cch + 1]) { strcpy(m_psz, psz); } Que rylnte rface describes the "shape" of the second parameter's pointer type. This relationship can be enforced at compile time through the use of the following C preprocessor macro: #define llD_PPV-ARG(Type, Expr) llD_##Type, \ reinterpret_cast (static_cast (Expr)) Given this macro,3 the compiler will ensure that the expression used in the following call to Que rylnte rface is of the correct type and that the appropriate level of indirection is in use: works to the C++ programmer's advantage, as C++ can produce code that is potentially more performant than languages that require a runtime layer to deal with COM. Unlike C++ programmers, Visual Basic and Java programmers never see Querylnterface, AddRef, or Release. For these two languages, the details of IUnknown are hidden deep below each language's supporting virtual machine. In Java, Querylnterface simply maps to a type-cast: COM does impose one limitation on interface inheritance: COM interfaces cannot derive directly from more than one interface. The following is not legal in COM:shaped much of the mindset of the C++ community at large. One of the principal goals for C++ was to allow programmers to build user-defined types (UDTs) that could be reused outside their original implementation context. This principle underpins the idea of class libraries or frameworks as we know them today. Since the introduction of C++, a marketplace for C++ class libraries emerged, albeit rather slowly. One reason that this marketplace has not grown as fast as one might expect is related to the lCat cat; try { cat = (ICat)obj; II VM calls Querylnterface cat.lgnoreMaster(); } catch (Throwable ex) { II ignore method or QI failures } } Figure 2.4 shows the standard notation for the CatDog class. Note that the only inference one can make from this diagram is that, barring catastrophic failure, CatDog objects will expose the four interfaces ICat, 1D09, IAnimal, and IUnknown. To allow comparison of GUID values, COM provides equivalence functions and overloads operator == and operator != for constant GUID references: With these two modifications in place, the corresponding client code now becomes much more uniform and unambiguous:

ESSENTIAL Mod - Minecraft Mods - CurseForge ESSENTIAL Mod - Minecraft Mods - CurseForge

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; } ;object, uuid(DF12E153-A29A-lldO-8C2D-0080C73925BA)] interface IOog : IAnimal { HRESULT Bark(void); } void GetObject([out] IUnknown **ppUnk); and that there is another global function that performs some useful work on an object: Note that the binary layout of this interface class does not change as data members are added to or removed from the implementation class, FastStri ng. Also, the use of forward declaration means that the class definition for FastStri ng is not needed for this header file to compile. This effectively hides all details of FastStri ng's implementation from the client's compiler. When using this technique, the machine code for the interface methods becomes the only entry point into the object's DLL and their binary signatures will never change. The implementations of the interface class's methods simply forward the method calls on to the actual implementation class:

Essential Communications Executive Coaching Los Angeles - Essential Communications

Simply modifying the interface class to have additional virtual function declarations after the existing method declarations would result in a binary vtbl format that is a superset of the original version, as any new vtbl entries would appear after those that correspond to the original methods. Object implementations that compile against the new interface definition would have any additional method entries appended to the original vtbllayout: define END_INTERFACE_TABLE() \ { 0, 0, 0 } }; return table; } All that is required is a routine tha This technique works because the compiler has enough knowledge about the layout and type hierarchy of the implementation class to examine an object at runtime to determine whether it in fact derives from IPersistentObject. Therein lies the problem. RTTI is a very compiler-dependent feature. Again, the DWP mandates the syntax and semantics for RTTI, but each compiler vendor's implementation of RTTI is unique and proprietary. This effectively destroys the compiler independence that has been achieved by using abstract base classes as interfaces. This is unacceptable for a vendor-neutral component architecture. One very tractable solution to the problem is to leverage the semantics of dynami c_cast without using the actual compiler-dependent language feature. Exposing a well-known method explicitly from each interface that will perform the semantic equivalent of dynami c_cast can achieve the desired effect without requiring all entities to use the same C++ compiler: is dedicated to explaining every nuance of this statement. However, it is worth noting up front that the client must not treat AddRef and Release as operations on an object. Instead, they must be treated as operations on an interface pointer. That means that the following code is illegal: void BadCOMCodeC/*[inJ*1 IUnknown *pUnk) { lCat *pCat = 0; lPug *pPug = 0; HRESULT hr; hr = pUnk->Querylnterface(lID_lCat, (void**)&pCat); if (FAILED(hr)) goto cleanup; hr = pUnk->Querylnterface(lID_lPug, (void**)&pPug); if (FAILED(hr)) goto cleanup; pPug->Bark(); pCat->IgnoreMaster(); cleanup: if (pCat) pUnk->Release(); II pCat got AddRefed in QI if (pPug) pUnk->Release(); II pDog got AddRefed in QI } The implementation of Release notes the destruction of an interface pointer by simply decrementing the reference count and taking the appropriate action when the reference count reaches zero. For heap-based objects, this means ~alling the delete operator to destroy the object:

Our most popular departments

adjustor thunks and place the leftmost base at the top of the object layout. The Microsoft C++ compiler fits this description. lCat ''(pCat = 0; hr = pUnk->Querylnterface(llD_lCat, (void**)&pCat); if (SUCCEEDED(hr)) {II the object is Cat-compatible pCat->lgnoreMaster(); pCat->Release(); II R2 } } faststring.h ///////////////////////////// class FastString { char *m_psz; public: FastString(const char *psz); ~FastString(void); enum COLOR { RED, GREEN, BLUE }; the vl_enum attribute applies to the enumeration definition COLOR. This particular attribute informs the IDL compiler that the network representation for COLOR should be 32 bits, not 16 bits, which is the default. The hel pstri ng attribute also applies to COLOR and injects the string "This is a color!" into the