You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
956 lines
23 KiB
C++
956 lines
23 KiB
C++
/*
|
|
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
|
* its licensors.
|
|
*
|
|
* For complete copyright and license terms please see the LICENSE at the root of this
|
|
* distribution (the "License"). All use of this software is governed by the License,
|
|
* or, if provided, by the license below or the license accompanying this file. Do not
|
|
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
*
|
|
*/
|
|
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
|
|
|
// Description : Part of CryEngine's extension framework.
|
|
|
|
|
|
#include "CrySystem_precompiled.h"
|
|
#include "TestExtensions.h"
|
|
|
|
#ifdef EXTENSION_SYSTEM_INCLUDE_TESTCASES
|
|
|
|
#include <CryExtension/Impl/ClassWeaver.h>
|
|
#include <CryExtension/Impl/ICryFactoryRegistryImpl.h>
|
|
#include <CryExtension/CryCreateClassInstance.h>
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
namespace TestComposition
|
|
{
|
|
struct ITestExt1
|
|
: public ICryUnknown
|
|
{
|
|
CRYINTERFACE_DECLARE(ITestExt1, 0x9d9e0dcfa5764cb0, 0xa73701595f75bd32)
|
|
|
|
virtual void Call1() const = 0;
|
|
};
|
|
|
|
DECLARE_SMART_POINTERS(ITestExt1);
|
|
|
|
|
|
class CTestExt1
|
|
: public ITestExt1
|
|
{
|
|
CRYINTERFACE_BEGIN()
|
|
CRYINTERFACE_ADD(ITestExt1)
|
|
CRYINTERFACE_END()
|
|
|
|
CRYGENERATE_CLASS(CTestExt1, "TestExt1", 0x43b04e7cc1be45ca, 0x9df6ccb1c0dc1ad8)
|
|
|
|
public:
|
|
virtual void Call1() const;
|
|
|
|
private:
|
|
int i;
|
|
};
|
|
|
|
CRYREGISTER_CLASS(CTestExt1)
|
|
|
|
CTestExt1::CTestExt1()
|
|
{
|
|
i = 1;
|
|
}
|
|
|
|
CTestExt1::~CTestExt1()
|
|
{
|
|
printf("Inside CTestExt1 dtor\n");
|
|
}
|
|
|
|
void CTestExt1::Call1() const
|
|
{
|
|
printf("Inside CTestExt1::Call1()\n");
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
struct ITestExt2
|
|
: public ICryUnknown
|
|
{
|
|
CRYINTERFACE_DECLARE(ITestExt2, 0x8eb7a4b399874b9c, 0xb96bd6da7a8c72f9)
|
|
|
|
virtual void Call2() = 0;
|
|
};
|
|
|
|
DECLARE_SMART_POINTERS(ITestExt2);
|
|
|
|
|
|
class CTestExt2
|
|
: public ITestExt2
|
|
{
|
|
CRYINTERFACE_BEGIN()
|
|
CRYINTERFACE_ADD(ITestExt2)
|
|
CRYINTERFACE_END()
|
|
|
|
CRYGENERATE_CLASS(CTestExt2, "TestExt2", 0x25b3ebf8f1754b9a, 0xb5494e3da7cdd80f)
|
|
|
|
public:
|
|
virtual void Call2();
|
|
|
|
private:
|
|
int i;
|
|
};
|
|
|
|
CRYREGISTER_CLASS(CTestExt2)
|
|
|
|
CTestExt2::CTestExt2()
|
|
{
|
|
i = 2;
|
|
}
|
|
|
|
CTestExt2::~CTestExt2()
|
|
{
|
|
printf("Inside CTestExt2 dtor\n");
|
|
}
|
|
|
|
void CTestExt2::Call2()
|
|
{
|
|
printf("Inside CTestExt2::Call2()\n");
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
class CComposed
|
|
: public ICryUnknown
|
|
{
|
|
CRYGENERATE_CLASS(CComposed, "Composed", 0x0439d74b8dcd4b7f, 0x9287dcdf7e26a3a5)
|
|
|
|
CRYCOMPOSITE_BEGIN()
|
|
CRYCOMPOSITE_ADD(m_pTestExt1, "Ext1")
|
|
CRYCOMPOSITE_ADD(m_pTestExt2, "Ext2")
|
|
CRYCOMPOSITE_END(CComposed)
|
|
|
|
CRYINTERFACE_BEGIN()
|
|
CRYINTERFACE_END()
|
|
|
|
private:
|
|
ITestExt1Ptr m_pTestExt1;
|
|
ITestExt2Ptr m_pTestExt2;
|
|
};
|
|
|
|
CRYREGISTER_CLASS(CComposed)
|
|
|
|
CComposed::CComposed()
|
|
: m_pTestExt1()
|
|
, m_pTestExt2()
|
|
{
|
|
CryCreateClassInstance("TestExt1", m_pTestExt1);
|
|
CryCreateClassInstance("TestExt2", m_pTestExt2);
|
|
}
|
|
|
|
CComposed::~CComposed()
|
|
{
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
struct ITestExt3
|
|
: public ICryUnknown
|
|
{
|
|
CRYINTERFACE_DECLARE(ITestExt3, 0xdd017935a2134898, 0xbd2fffa145551876)
|
|
|
|
virtual void Call3() = 0;
|
|
};
|
|
|
|
DECLARE_SMART_POINTERS(ITestExt3);
|
|
|
|
class CTestExt3
|
|
: public ITestExt3
|
|
{
|
|
CRYGENERATE_CLASS(CTestExt3, "TestExt3", 0xeceab40bc4bb4988, 0xa9f63c1db85a69b1)
|
|
|
|
CRYINTERFACE_BEGIN()
|
|
CRYINTERFACE_ADD(ITestExt3)
|
|
CRYINTERFACE_END()
|
|
|
|
public:
|
|
virtual void Call3();
|
|
|
|
private:
|
|
int i;
|
|
};
|
|
|
|
CRYREGISTER_CLASS(CTestExt3)
|
|
|
|
CTestExt3::CTestExt3()
|
|
{
|
|
i = 3;
|
|
}
|
|
|
|
CTestExt3::~CTestExt3()
|
|
{
|
|
printf("Inside CTestExt3 dtor\n");
|
|
}
|
|
|
|
void CTestExt3::Call3()
|
|
{
|
|
printf("Inside CTestExt3::Call3()\n");
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
class CComposed2
|
|
: public ICryUnknown
|
|
{
|
|
CRYGENERATE_CLASS(CComposed2, "Composed2", 0x0439d74b8dcd4b7e, 0x9287dcdf7e26a3a6)
|
|
|
|
CRYCOMPOSITE_BEGIN()
|
|
CRYCOMPOSITE_ADD(m_pTestExt3, "Ext3")
|
|
CRYCOMPOSITE_END(CComposed2)
|
|
|
|
CRYINTERFACE_BEGIN()
|
|
CRYINTERFACE_END()
|
|
|
|
private:
|
|
ITestExt3Ptr m_pTestExt3;
|
|
};
|
|
|
|
CRYREGISTER_CLASS(CComposed2)
|
|
|
|
CComposed2::CComposed2()
|
|
: m_pTestExt3()
|
|
{
|
|
CryCreateClassInstance("TestExt3", m_pTestExt3);
|
|
}
|
|
|
|
CComposed2::~CComposed2()
|
|
{
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
class CTestExt4
|
|
: public ITestExt1
|
|
, public ITestExt2
|
|
, public ITestExt3
|
|
{
|
|
CRYINTERFACE_BEGIN()
|
|
CRYINTERFACE_ADD(ITestExt1)
|
|
CRYINTERFACE_ADD(ITestExt2)
|
|
CRYINTERFACE_ADD(ITestExt3)
|
|
CRYINTERFACE_END()
|
|
|
|
CRYGENERATE_CLASS(CTestExt4, "TestExt4", 0x43204e7cc1be45ca, 0x9df4ccb1c0dc1ad8)
|
|
|
|
public:
|
|
virtual void Call1() const;
|
|
virtual void Call2();
|
|
virtual void Call3();
|
|
|
|
private:
|
|
int i;
|
|
};
|
|
|
|
CRYREGISTER_CLASS(CTestExt4)
|
|
|
|
CTestExt4::CTestExt4()
|
|
{
|
|
i = 4;
|
|
}
|
|
|
|
CTestExt4::~CTestExt4()
|
|
{
|
|
printf("Inside CTestExt4 dtor\n");
|
|
}
|
|
|
|
void CTestExt4::Call1() const
|
|
{
|
|
printf("Inside CTestExt4::Call1()\n");
|
|
}
|
|
|
|
void CTestExt4::Call2()
|
|
{
|
|
printf("Inside CTestExt4::Call2()\n");
|
|
}
|
|
|
|
void CTestExt4::Call3()
|
|
{
|
|
printf("Inside CTestExt4::Call3()\n");
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
class CMegaComposed
|
|
: public CComposed
|
|
, public CComposed2
|
|
{
|
|
CRYGENERATE_CLASS(CMegaComposed, "MegaComposed", 0x512787559f84503, 0x421ac1af66f2fb6f)
|
|
|
|
CRYCOMPOSITE_BEGIN()
|
|
CRYCOMPOSITE_ADD(m_pTestExt4, "Ext4")
|
|
CRYCOMPOSITE_ENDWITHBASE2(CMegaComposed, CComposed, CComposed2)
|
|
|
|
CRYINTERFACE_BEGIN()
|
|
CRYINTERFACE_END()
|
|
|
|
private:
|
|
AZStd::shared_ptr<CTestExt4> m_pTestExt4;
|
|
};
|
|
|
|
CRYREGISTER_CLASS(CMegaComposed)
|
|
|
|
CMegaComposed::CMegaComposed()
|
|
: m_pTestExt4()
|
|
{
|
|
printf("Inside CMegaComposed ctor\n");
|
|
m_pTestExt4 = CTestExt4::CreateClassInstance();
|
|
}
|
|
|
|
CMegaComposed::~CMegaComposed()
|
|
{
|
|
printf("Inside CMegaComposed dtor\n");
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
static void TestComposition()
|
|
{
|
|
printf("\nTest composition:\n");
|
|
|
|
ICryUnknownPtr p;
|
|
if (CryCreateClassInstance("MegaComposed", p))
|
|
{
|
|
ITestExt1Ptr p1 = cryinterface_cast<ITestExt1>(crycomposite_query(p, "Ext1"));
|
|
if (p1)
|
|
{
|
|
p1->Call1(); // calls CTestExt1::Call1()
|
|
}
|
|
ITestExt2Ptr p2 = cryinterface_cast<ITestExt2>(crycomposite_query(p, "Ext2"));
|
|
if (p2)
|
|
{
|
|
p2->Call2(); // calls CTestExt2::Call2()
|
|
}
|
|
ITestExt3Ptr p3 = cryinterface_cast<ITestExt3>(crycomposite_query(p, "Ext3"));
|
|
if (p3)
|
|
{
|
|
p3->Call3(); // calls CTestExt3::Call3()
|
|
}
|
|
p3 = cryinterface_cast<ITestExt3>(crycomposite_query(p, "Ext4"));
|
|
if (p3)
|
|
{
|
|
p3->Call3(); // calls CTestExt4::Call3()
|
|
}
|
|
p1 = cryinterface_cast<ITestExt1>(crycomposite_query(p.get(), "Ext4"));
|
|
p2 = cryinterface_cast<ITestExt2>(crycomposite_query(p.get(), "Ext4"));
|
|
|
|
bool b = CryIsSameClassInstance(p1, p2); // true
|
|
}
|
|
|
|
{
|
|
ICryUnknownConstPtr pCUnk = p;
|
|
ICryUnknownConstPtr pComp1 = crycomposite_query(pCUnk.get(), "Ext1");
|
|
//ICryUnknownPtr pComp1 = crycomposite_query(pCUnk, "Ext1"); // must fail to compile due to const rules
|
|
|
|
ITestExt1ConstPtr p1 = cryinterface_cast<const ITestExt1>(pComp1);
|
|
if (p1)
|
|
{
|
|
p1->Call1();
|
|
}
|
|
}
|
|
}
|
|
} // namespace TestComposition
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
namespace TestExtension
|
|
{
|
|
class CFoobar
|
|
: public IFoobar
|
|
{
|
|
CRYINTERFACE_BEGIN()
|
|
CRYINTERFACE_ADD(IFoobar)
|
|
CRYINTERFACE_END()
|
|
|
|
CRYGENERATE_CLASS(CFoobar, "Foobar", 0x76c8dd6d16634531, 0x95d3b1cfabcf7ef4)
|
|
|
|
public:
|
|
virtual void Foo();
|
|
};
|
|
|
|
CRYREGISTER_CLASS(CFoobar)
|
|
|
|
CFoobar::CFoobar()
|
|
{
|
|
}
|
|
|
|
CFoobar::~CFoobar()
|
|
{
|
|
}
|
|
|
|
void CFoobar::Foo()
|
|
{
|
|
printf("Inside CFoobar::Foo()\n");
|
|
}
|
|
|
|
static void TestFoobar()
|
|
{
|
|
AZStd::shared_ptr<CFoobar> p = CFoobar::CreateClassInstance();
|
|
{
|
|
CryInterfaceID iid = cryiidof<IFoobar>();
|
|
CryClassID clsid = p->GetFactory()->GetClassID();
|
|
int t = 0;
|
|
}
|
|
|
|
{
|
|
IAPtr sp_ = cryinterface_cast<IA>(p); // sp_ == NULL
|
|
|
|
ICryUnknownPtr sp1 = cryinterface_cast<ICryUnknown>(p);
|
|
IFoobarPtr sp = cryinterface_cast<IFoobar>(sp1);
|
|
sp->Foo();
|
|
}
|
|
|
|
{
|
|
CFoobar* pF = p.get();
|
|
pF->Foo();
|
|
ICryUnknown* p1 = cryinterface_cast<ICryUnknown>(pF);
|
|
}
|
|
|
|
IFoobar* pFoo = cryinterface_cast<IFoobar>(p.get());
|
|
ICryFactory* pF1 = pFoo->GetFactory();
|
|
pFoo->Foo();
|
|
|
|
int t = 0;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
class CRaboof
|
|
: public IRaboof
|
|
{
|
|
CRYINTERFACE_BEGIN()
|
|
CRYINTERFACE_ADD(IRaboof)
|
|
CRYINTERFACE_END()
|
|
|
|
CRYGENERATE_SINGLETONCLASS(CRaboof, "Raabof", 0xba482ce12b2e4309, 0x8238ed8b52cb1f1e)
|
|
|
|
public:
|
|
virtual void Rab();
|
|
};
|
|
|
|
CRYREGISTER_SINGLETON_CLASS(CRaboof)
|
|
|
|
CRaboof::CRaboof()
|
|
{
|
|
}
|
|
|
|
CRaboof::~CRaboof()
|
|
{
|
|
}
|
|
|
|
void CRaboof::Rab()
|
|
{
|
|
printf("Inside CRaboof::Rab()\n");
|
|
}
|
|
|
|
static void TestRaboof()
|
|
{
|
|
AZStd::shared_ptr<CRaboof> pFoo0_ = CRaboof::CreateClassInstance();
|
|
IRaboofPtr pFoo0 = cryinterface_cast<IRaboof>(pFoo0_);
|
|
ICryUnknownPtr p0 = cryinterface_cast<ICryUnknown>(pFoo0);
|
|
|
|
CryInterfaceID iid = cryiidof<IRaboof>();
|
|
CryClassID clsid = p0->GetFactory()->GetClassID();
|
|
|
|
AZStd::shared_ptr<CRaboof> pFoo1 = CRaboof::CreateClassInstance();
|
|
|
|
pFoo0->Rab();
|
|
pFoo1->Rab();
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
class CAB
|
|
: public IA
|
|
, public IB
|
|
{
|
|
CRYINTERFACE_BEGIN()
|
|
CRYINTERFACE_ADD(IA)
|
|
CRYINTERFACE_ADD(IB)
|
|
CRYINTERFACE_END()
|
|
|
|
CRYGENERATE_CLASS(CAB, "AB", 0xb9e54711a64448c0, 0xa4819b4ed3024d04)
|
|
|
|
public:
|
|
virtual void A();
|
|
virtual void B();
|
|
|
|
private:
|
|
int i;
|
|
};
|
|
|
|
CRYREGISTER_CLASS(CAB)
|
|
|
|
CAB::CAB()
|
|
{
|
|
i = 0x12345678;
|
|
}
|
|
|
|
CAB::~CAB()
|
|
{
|
|
}
|
|
|
|
void CAB::A()
|
|
{
|
|
printf("Inside CAB::A()\n");
|
|
}
|
|
|
|
void CAB::B()
|
|
{
|
|
printf("Inside CAB::B()\n");
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
class CABC
|
|
: public CAB
|
|
, public IC
|
|
{
|
|
CRYINTERFACE_BEGIN()
|
|
CRYINTERFACE_ADD(IC)
|
|
CRYINTERFACE_ENDWITHBASE(CAB)
|
|
|
|
CRYGENERATE_CLASS(CABC, "ABC", 0x4e61feae11854be7, 0xa16157c5f8baadd9)
|
|
|
|
public:
|
|
virtual void C();
|
|
|
|
private:
|
|
int a;
|
|
};
|
|
|
|
CRYREGISTER_CLASS(CABC)
|
|
|
|
CABC::CABC()
|
|
//: CAB()
|
|
{
|
|
a = 0x87654321;
|
|
}
|
|
|
|
CABC::~CABC()
|
|
{
|
|
}
|
|
|
|
void CABC::C()
|
|
{
|
|
printf("Inside CABC::C()\n");
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
class CCustomC
|
|
: public ICustomC
|
|
{
|
|
CRYINTERFACE_BEGIN()
|
|
CRYINTERFACE_ADD(IC)
|
|
CRYINTERFACE_ADD(ICustomC)
|
|
CRYINTERFACE_END()
|
|
|
|
CRYGENERATE_CLASS(CCustomC, "CustomC", 0xee61760b98a44b71, 0xa05e7372b44bd0fd)
|
|
|
|
public:
|
|
virtual void C();
|
|
virtual void C1();
|
|
|
|
private:
|
|
int a;
|
|
};
|
|
|
|
CRYREGISTER_CLASS(CCustomC)
|
|
|
|
CCustomC::CCustomC()
|
|
{
|
|
a = 0x87654321;
|
|
}
|
|
|
|
CCustomC::~CCustomC()
|
|
{
|
|
}
|
|
|
|
void CCustomC::C()
|
|
{
|
|
printf("Inside CCustomC::C()\n");
|
|
}
|
|
|
|
void CCustomC::C1()
|
|
{
|
|
printf("Inside CCustomC::C1()\n");
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
class CMultiBase
|
|
: public CAB
|
|
, public CCustomC
|
|
{
|
|
CRYINTERFACE_BEGIN()
|
|
CRYINTERFACE_ENDWITHBASE2(CAB, CCustomC)
|
|
|
|
CRYGENERATE_CLASS(CMultiBase, "MultiBase", 0x75966b8f98644d42, 0x8fbdd489e94cc29e)
|
|
|
|
public:
|
|
virtual void A();
|
|
virtual void C1();
|
|
|
|
int i;
|
|
};
|
|
|
|
CRYREGISTER_CLASS(CMultiBase)
|
|
|
|
CMultiBase::CMultiBase()
|
|
{
|
|
i = 0x87654321;
|
|
}
|
|
|
|
CMultiBase::~CMultiBase()
|
|
{
|
|
}
|
|
|
|
void CMultiBase::C1()
|
|
{
|
|
printf("Inside CMultiBase::C1()\n");
|
|
}
|
|
|
|
void CMultiBase::A()
|
|
{
|
|
printf("Inside CMultiBase::A()\n");
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
static void TestComplex()
|
|
{
|
|
{
|
|
ICPtr p;
|
|
if (CryCreateClassInstance(MAKE_CRYGUID(0x75966b8f98644d42, 0x8fbdd489e94cc29e), p))
|
|
{
|
|
p->C();
|
|
}
|
|
}
|
|
|
|
{
|
|
ICustomCPtr p;
|
|
if (CryCreateClassInstance("MultiBase", p))
|
|
{
|
|
p->C();
|
|
}
|
|
}
|
|
|
|
{
|
|
IFoobarPtr p;
|
|
if (CryCreateClassInstance(MAKE_CRYGUID(0x75966b8f98644d42, 0x8fbdd489e94cc29e), p))
|
|
{
|
|
p->Foo();
|
|
}
|
|
}
|
|
|
|
{
|
|
AZStd::shared_ptr<CMultiBase> p = CMultiBase::CreateClassInstance();
|
|
AZStd::shared_ptr<const CMultiBase> pc = p;
|
|
|
|
{
|
|
ICryUnknownPtr pUnk = cryinterface_cast<ICryUnknown>(p);
|
|
ICryUnknownConstPtr pCUnk0 = cryinterface_cast<const ICryUnknown>(p);
|
|
ICryUnknownConstPtr pCUnk1 = cryinterface_cast<const ICryUnknown>(pc);
|
|
//ICryUnknownPtr pUnkF = cryinterface_cast<ICryUnknown>(pc); // must fail to compile due to const rules
|
|
|
|
ICryFactory* pF = pUnk->GetFactory();
|
|
|
|
int t = 0;
|
|
}
|
|
|
|
ICPtr pC = cryinterface_cast<IC>(p);
|
|
ICustomCPtr pCC = cryinterface_cast<ICustomC>(pC);
|
|
|
|
p->C();
|
|
p->C1();
|
|
|
|
pC->C();
|
|
pCC->C1();
|
|
|
|
IAPtr pA = cryinterface_cast<IA>(p);
|
|
pA->A();
|
|
p->A();
|
|
}
|
|
|
|
{
|
|
AZStd::shared_ptr<CCustomC> p = CCustomC::CreateClassInstance();
|
|
|
|
ICPtr pC = cryinterface_cast<IC>(p);
|
|
ICustomCPtr pCC = cryinterface_cast<ICustomC>(pC);
|
|
|
|
p->C();
|
|
p->C1();
|
|
|
|
pC->C();
|
|
pCC->C1();
|
|
}
|
|
{
|
|
CryInterfaceID ia = cryiidof<IA>();
|
|
CryInterfaceID ib = cryiidof<IB>();
|
|
CryInterfaceID ic = cryiidof<IC>();
|
|
CryInterfaceID ico = cryiidof<ICryUnknown>();
|
|
}
|
|
|
|
{
|
|
AZStd::shared_ptr<CAB> p = CAB::CreateClassInstance();
|
|
CryClassID clsid = p->GetFactory()->GetClassID();
|
|
|
|
IAPtr pA = cryinterface_cast<IA>(p);
|
|
IBPtr pB = cryinterface_cast<IB>(p);
|
|
|
|
IBPtr pB1 = cryinterface_cast<IB>(pA);
|
|
IAPtr pA1 = cryinterface_cast<IA>(pB);
|
|
|
|
pA->A();
|
|
pB->B();
|
|
|
|
ICryUnknownPtr p1 = cryinterface_cast<ICryUnknown>(pA);
|
|
ICryUnknownPtr p2 = cryinterface_cast<ICryUnknown>(pB);
|
|
const ICryUnknown* p3 = cryinterface_cast<const ICryUnknown>(pB.get());
|
|
|
|
int t = 0;
|
|
}
|
|
|
|
{
|
|
AZStd::shared_ptr<CABC> pABC = CABC::CreateClassInstance();
|
|
CryClassID clsid = pABC->GetFactory()->GetClassID();
|
|
|
|
ICryFactory* pFac = pABC->GetFactory();
|
|
pFac->ClassSupports(cryiidof<IA>());
|
|
pFac->ClassSupports(cryiidof<IRaboof>());
|
|
|
|
IAPtr pABC0 = cryinterface_cast<IA>(pABC);
|
|
IBPtr pABC1 = cryinterface_cast<IB>(pABC0);
|
|
ICPtr pABC2 = cryinterface_cast<IC>(pABC1);
|
|
|
|
pABC2->C();
|
|
pABC1->B();
|
|
|
|
pABC2->GetFactory();
|
|
|
|
const IC* pCconst = pABC2.get();
|
|
const ICryUnknown* pOconst = cryinterface_cast<const ICryUnknown>(pCconst);
|
|
const IA* pAconst = cryinterface_cast<const IA>(pOconst);
|
|
const IB* pBconst = cryinterface_cast<const IB>(pAconst);
|
|
|
|
//const IA* pA11 = cryinterface_cast<IA>(pOconst);
|
|
|
|
pCconst = cryinterface_cast<const IC>(pBconst);
|
|
|
|
IC* pC = static_cast<IC*>(static_cast<void*>(pABC1.get()));
|
|
pC->C(); // calls IB::B()
|
|
|
|
int t = 0;
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// use of extension system without any of the helper macros/templates
|
|
|
|
class CDontLikeMacrosFactory
|
|
: public ICryFactory
|
|
{
|
|
// ICryFactory
|
|
public:
|
|
virtual const char* GetClassName() const
|
|
{
|
|
return "DontLikeMacros";
|
|
}
|
|
virtual const CryClassID& GetClassID() const
|
|
{
|
|
static const CryClassID cid = {0x73c3ab0042e6488aull, 0x89ca1a3763365565ull};
|
|
return cid;
|
|
}
|
|
virtual bool ClassSupports(const CryInterfaceID& iid) const
|
|
{
|
|
return iid == cryiidof<ICryUnknown>() || iid == cryiidof<IDontLikeMacros>();
|
|
}
|
|
virtual void ClassSupports(const CryInterfaceID*& pIIDs, size_t& numIIDs) const
|
|
{
|
|
static const CryInterfaceID iids[2] = {cryiidof<ICryUnknown>(), cryiidof<IDontLikeMacros>()};
|
|
pIIDs = iids;
|
|
numIIDs = 2;
|
|
}
|
|
virtual ICryUnknownPtr CreateClassInstance() const;
|
|
|
|
public:
|
|
static CDontLikeMacrosFactory& Access()
|
|
{
|
|
return s_factory;
|
|
}
|
|
|
|
private:
|
|
CDontLikeMacrosFactory() {}
|
|
~CDontLikeMacrosFactory() {}
|
|
|
|
private:
|
|
static CDontLikeMacrosFactory s_factory;
|
|
};
|
|
|
|
CDontLikeMacrosFactory CDontLikeMacrosFactory::s_factory;
|
|
|
|
class CDontLikeMacros
|
|
: public IDontLikeMacros
|
|
{
|
|
// ICryUnknown
|
|
public:
|
|
virtual ICryFactory* GetFactory() const
|
|
{
|
|
return &CDontLikeMacrosFactory::Access();
|
|
};
|
|
|
|
// only needed to be able to create initial shared_ptr<CDontLikeMacros> so we don't lose type info for debugging (i.e. inspecting shared_ptr<>)
|
|
template <class T>
|
|
friend void AZStd::Internal::sp_ms_deleter<T>::destroy();
|
|
template <class T>
|
|
friend AZStd::shared_ptr<T> AZStd::make_shared<T>();
|
|
|
|
protected:
|
|
virtual void* QueryInterface(const CryInterfaceID& iid) const
|
|
{
|
|
if (iid == cryiidof<ICryUnknown>())
|
|
{
|
|
return (void*) (ICryUnknown*) this;
|
|
}
|
|
else if (iid == cryiidof<IDontLikeMacros>())
|
|
{
|
|
return (void*) (IDontLikeMacros*) this;
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
virtual void* QueryComposite(const char*) const
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
// IDontLikeMacros
|
|
public:
|
|
virtual void CallMe()
|
|
{
|
|
printf("Yey, no macros...\n");
|
|
}
|
|
|
|
CDontLikeMacros() {}
|
|
|
|
protected:
|
|
virtual ~CDontLikeMacros() {}
|
|
};
|
|
|
|
ICryUnknownPtr CDontLikeMacrosFactory::CreateClassInstance() const
|
|
{
|
|
AZStd::shared_ptr<CDontLikeMacros> p = AZStd::make_shared<CDontLikeMacros>();
|
|
return ICryUnknownPtr(*static_cast<AZStd::shared_ptr<ICryUnknown>*>(static_cast<void*>(&p)));
|
|
}
|
|
|
|
static SRegFactoryNode g_dontLikeMacrosFactory(&CDontLikeMacrosFactory::Access());
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
static void TestDontLikeMacros()
|
|
{
|
|
ICryFactory* f = &CDontLikeMacrosFactory::Access();
|
|
|
|
f->ClassSupports(cryiidof<ICryUnknown>());
|
|
f->ClassSupports(cryiidof<IDontLikeMacros>());
|
|
|
|
const CryInterfaceID* pIIDs = 0;
|
|
size_t numIIDs = 0;
|
|
f->ClassSupports(pIIDs, numIIDs);
|
|
|
|
ICryUnknownPtr p = f->CreateClassInstance();
|
|
IDontLikeMacrosPtr pp = cryinterface_cast<IDontLikeMacros>(p);
|
|
|
|
ICryUnknownPtr pq = crycomposite_query(p, "blah");
|
|
|
|
pp->CallMe();
|
|
}
|
|
} // namespace TestExtension
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
void TestExtensions(ICryFactoryRegistryImpl* pReg)
|
|
{
|
|
printf("Test extensions:\n");
|
|
|
|
struct MyCallback
|
|
: public ICryFactoryRegistryCallback
|
|
{
|
|
virtual void OnNotifyFactoryRegistered(ICryFactory* pFactory)
|
|
{
|
|
int test = 0;
|
|
}
|
|
virtual void OnNotifyFactoryUnregistered(ICryFactory* pFactory)
|
|
{
|
|
int test = 0;
|
|
}
|
|
};
|
|
|
|
//pReg->RegisterCallback((ICryFactoryRegistryCallback*) 0x4);
|
|
//pReg->RegisterCallback((ICryFactoryRegistryCallback*) 0x1);
|
|
//pReg->RegisterCallback((ICryFactoryRegistryCallback*) 0x3);
|
|
//pReg->RegisterCallback((ICryFactoryRegistryCallback*) 0x3);
|
|
//pReg->RegisterCallback((ICryFactoryRegistryCallback*) 0x2);
|
|
|
|
//pReg->UnregisterCallback((ICryFactoryRegistryCallback*) 0x2);
|
|
//pReg->UnregisterCallback((ICryFactoryRegistryCallback*) 0x2);
|
|
//pReg->UnregisterCallback((ICryFactoryRegistryCallback*) 0x4);
|
|
//pReg->UnregisterCallback((ICryFactoryRegistryCallback*) 0x3);
|
|
//pReg->UnregisterCallback((ICryFactoryRegistryCallback*) 0x1);
|
|
|
|
//MyCallback callback0;
|
|
//pReg->RegisterCallback(&callback0);
|
|
//pReg->RegisterFactories(g_pHeadToRegFactories);
|
|
|
|
//pReg->RegisterFactories(g_pHeadToRegFactories);
|
|
//pReg->UnregisterFactories(g_pHeadToRegFactories);
|
|
|
|
ICryFactory* pF[4];
|
|
size_t numFactories = 4;
|
|
pReg->IterateFactories(cryiidof<IA>(), pF, numFactories);
|
|
pReg->IterateFactories(MAKE_CRYGUID(-1, -1), pF, numFactories);
|
|
|
|
numFactories = (size_t) -1;
|
|
pReg->IterateFactories(cryiidof<ICryUnknown>(), 0, numFactories);
|
|
|
|
MyCallback callback1;
|
|
pReg->RegisterCallback(&callback1);
|
|
pReg->UnregisterCallback(&callback1);
|
|
|
|
ICryFactory* p;
|
|
p = pReg->GetFactory(MAKE_CRYGUID(0xee61760b98a44b71, 0xa05e7372b44bd0fd));
|
|
p = pReg->GetFactory("CustomC");
|
|
p = pReg->GetFactory("ABC");
|
|
p = pReg->GetFactory((const char*)0);
|
|
|
|
p = pReg->GetFactory("DontLikeMacros");
|
|
p = pReg->GetFactory(MAKE_CRYGUID(0x73c3ab0042e6488a, 0x89ca1a3763365565));
|
|
|
|
TestExtension::TestFoobar();
|
|
TestExtension::TestRaboof();
|
|
TestExtension::TestComplex();
|
|
TestExtension::TestDontLikeMacros();
|
|
|
|
TestComposition::TestComposition();
|
|
}
|
|
|
|
#endif // #ifdef EXTENSION_SYSTEM_INCLUDE_TESTCASES
|