koalaa.cpp

英文版的 想要的话可以下载了 为大家服务

/*
 * KOALAA.CPP
 *
 * Koala Object Reusing Animal via Aggregation, Chapter 2
 *
 * Copyright (c)1993-1995 Microsoft Corporation, All Rights Reserved
 *
 * Kraig Brockschmidt, Microsoft
 * Internet  :  [e-mail]
 * Compuserve:  >INTERNET:[e-mail]
 */

#include <windows.h>
#include "reuse.h"
#include "koalaa.h"


/*
 * CreateKoalaAggregation
 *
 * Purpose:
 *  Creates an instance of KoalaA returning an IUnknown
 *  interface.
 *
 * Parameters:
 *  ppUnk           IUnknown ** in which to return the pointer.
 *
 * Return Value:
 *  BOOL            TRUE if successful, FALSE otherwise.
 */

BOOL CreateKoalaAggregation(IUnknown **ppUnk)
    {
    CKoalaA    *pObj;
    HRESULT     hr;

    pObj=new CKoalaA();

    if (NULL==pObj)
        return FALSE;

    if (!pObj->Init())
        return FALSE;

    hr=pObj->QueryInterface(IID_IUnknown, (PPVOID)ppUnk);
    return SUCCEEDED(hr);
    }





/*
 * CKoalaA::CKoalaA
 * CKoalaA::~CKoalaA
 *
 * Constructor Parameters:
 *  None
 */

CKoalaA::CKoalaA(void)
    {
    m_cRef=0;
    m_pImpIKoala=NULL;
    m_pIUnknown=NULL;
    m_pIAnimal=NULL;
    return;
    }

CKoalaA::~CKoalaA(void)
    {
    /*
     * Since this KoalaA is not aggregatable, we can use the
     * 32-bit rule under Win16 as well.
     */
    AddRef();
    ReleaseInterface(m_pIAnimal);

    ReleaseInterface(m_pIUnknown);
    DeleteInterfaceImp(m_pImpIKoala);
    return;
    }



/*
 * CKoalaA::Init
 *
 * Purpose:
 *  Instantiates the interface implementations for this object.
 *
 * Parameters:
 *  None
 *
 * Return Value:
 *  BOOL            TRUE if initialization succeeds, FALSE otherwise.
 */

BOOL CKoalaA::Init(void)
    {
    HRESULT     hr;

    //Create our interface
    m_pImpIKoala=new CImpIKoala_A(this);

    if (NULL==m_pImpIKoala)
        return FALSE;

    /*
     * Create an instance of the Animal object, saving an
     * IUnknown but also saving a released IAnimal.  We use
     * Animal's global API function for this.
     */
    hr=CreateAnimal(this, IID_IUnknown, (void **)&m_pIUnknown);

    if (FAILED(hr))
        return FALSE;

    /*
     * Grab an IAnimal to show the Release rule.  We don't do
     * anything with this pointer, but we want to show the Release.
     */
    hr=m_pIUnknown->QueryInterface(IID_IAnimal, (void **)&m_pIAnimal);

    if (FAILED(hr))
        return FALSE;

    /*
     * In caching the IAnimal pointer we have to fix our
     * reference count.  SInce KoalaC is not aggregatable itself,
     * we can use the 32-bit rule for this case in 16-bit
     * compilations as well.
     *
     * Our reference count may be as little as one at this pointer
     * so calling our own Release (or m_pIAnimal's) is a bad idea.
     * Since we just need to fix the count, we can just decrement
     * m_cRef.  If we have to call someone's Release, then we'd
     * need to wrap that call in m_cRef++ and m_cRef--.
     */
    m_cRef--;

    return TRUE;
    }






/*
 * CKoalaA::QueryInterface
 * CKoalaA::AddRef
 * CKoalaA::Release
 *
 * Purpose:
 *  KoalaA's IUnknown implementation which serves as the outer
 *  unknown in the aggregation.
 */

STDMETHODIMP CKoalaA::QueryInterface(REFIID riid, PPVOID ppv)
    {
    *ppv=NULL;

    if (IID_IUnknown==riid)
        *ppv=this;

    //Alternately *ppv=m_pIAnimal; works for this case
    if (IID_IAnimal==riid)
        return m_pIUnknown->QueryInterface(riid, ppv);

    if (IID_IKoala==riid)
        *ppv=m_pImpIKoala;

    if (NULL==*ppv)
        return ResultFromScode(E_NOINTERFACE);

    ((LPUNKNOWN)*ppv)->AddRef();
    return NOERROR;
    }


DWORD CKoalaA::AddRef(void)
    {
    return ++m_cRef;
    }

DWORD CKoalaA::Release(void)
    {
    if (0!=--m_cRef)
        return m_cRef;

    m_cRef++;       //Artificial count preventing reentrancy
    delete this;
    return 0;
    }






//CImpIKoala_A interface implementation


/*
 * CImpIKoala_A::CImpIKoala_A
 * CImpIKoala_A::~CImpIKoala_A
 *
 * Constructor Parameters:
 *  pObj            PCKoalaA to the outer object
 */

CImpIKoala_A::CImpIKoala_A(PCKoalaA pObj)
    {
    m_cRef=0;
    m_pObj=pObj;
    return;
    }

CImpIKoala_A::~CImpIKoala_A(void)
    {
    return;
    }



/*
 * CImpIKoala_A::QueryInterface
 * CImpIKoala_A::AddRef
 * CImpIKoala_A::Release
 *
 * IUnknown members that delegate to KoalaA
 */

STDMETHODIMP CImpIKoala_A::QueryInterface(REFIID riid, PPVOID ppv)
    {
    return m_pObj->QueryInterface(riid, ppv);
    }

DWORD CImpIKoala_A::AddRef(void)
    {
    ++m_cRef;
    return m_pObj->AddRef();
    }

DWORD CImpIKoala_A::Release(void)
    {
    --m_cRef;
    return m_pObj->Release();
    }



/*
 * CImpIKoala_A::ClimbEucalyptusTrees
 * CImpIKoala_A::PouchOpensDown
 * CImpIKoala_A::SleepForHoursAfterEating
 *
 * Purpose:
 *  Empty sample functions, no parameters, return NOERROR
 */

STDMETHODIMP CImpIKoala_A::ClimbEucalyptusTrees(void)
    {
    ODS("KoalaA's IKoala::ClimbEucalyptusTrees called");
    return NOERROR;
    }

STDMETHODIMP CImpIKoala_A::PouchOpensDown(void)
    {
    ODS("KoalaA's IKoala::PouchOpensDown called");
    return NOERROR;
    }

STDMETHODIMP CImpIKoala_A::SleepForHoursAfterEating(void)
    {
    ODS("KoalaA's IKoala::SleepForHoursAfterEating called");
    return NOERROR;
    }