pegasus/src/Pegasus/Repository/Attic/MetaRepository.cpp - diff

Return to MetaRepository.cpp CVS log

Up to [Pegasus] / pegasus / src / Pegasus / Repository / Attic

Diff for /pegasus/src/Pegasus/Repository/Attic/MetaRepository.cpp between version 1.1.2.6 and 1.1.2.9

version 1.1.2.6, 2007/10/03 00:03:14

version 1.1.2.9, 2007/10/04 22:25:54

Line 31

//%/////////////////////////////////////////////////////////////////////////////

#include "MetaTypes.h"

#include <cstdarg>

#include <cassert>

#include "MetaRepository.h"

#include <Pegasus/Common/System.h>

#include <Pegasus/Common/Once.h>

#if 0

#include "MetaTypes.h"

# define TEST_META_REPOSITORY

#endif

#if defined(TEST_META_REPOSITORY)

# include "root_cimv2_namespace.h"

# include "root_PG_Internal_namespace.h"

# include "root_PG_InterOp_namespace.h"

#endif

PEGASUS_NAMESPACE_BEGIN

typedef const MetaClass* ConstMetaClassPtr;

#define PEGASUS_ARRAY_T ConstMetaClassPtr

# include <Pegasus/Common/ArrayInter.h>

# include <Pegasus/Common/ArrayImpl.h>

#undef PEGASUS_ARRAY_T

static const size_t _MAX_NAMESPACES = 32;

static const MetaNameSpace* _nameSpaces[_MAX_NAMESPACES];

static size_t _nameSpacesSize = 0;

Line 56

Line 53

static const size_t _MAX_FEATURES = 1024;

static const size_t _MAX_QUALIFIERS = 1024;

static inline void _init()

{

#if defined(TEST_META_REPOSITORY)

if (_nameSpacesSize == 0)

{

MetaRepository::addNameSpace(&root_PG_InterOp_namespace);

MetaRepository::addNameSpace(&root_cimv2_namespace);

MetaRepository::addNameSpace(&root_PG_Internal_namespace);

}

#endif

}

//==============================================================================

// Local definitions:

//==============================================================================

PEGASUS_FORMAT(2, 3)

static void _throw(CIMStatusCode code, const char* format, ...)

{

Line 139

Line 118

return sub->super == super;

}

static const MetaClass* _findClass(

const MetaNameSpace* ns,

const char* name)

{

for (size_t i = 0; ns->classes[i]; i++)

{

const MetaClass* mc = ns->classes[i];

if (_eqi(mc->name, name))

return mc;

}

// Not found!

return 0;

}

static const MetaQualifierDecl* _findQualifierDecl(

const MetaNameSpace* ns,

const char* name)

{

for (size_t i = 0; ns->classes[i]; i++)

{

const MetaQualifierDecl* mqd = ns->qualifiers[i];

if (_eqi(mqd->name, name))

return mqd;

}

// Not found!

return 0;

}

static char** _makePropertyList(const CIMPropertyList& propertyList)

{

if (propertyList.isNull())

Line 209

Line 156

printf("pl[%s]\n", pl[i]);

}

static bool _contains(const Array<const MetaClass*>& x, const MetaClass* mc)

{

Uint32 n = x.size();

const MetaClass* const* p = x.getData();

while (n--)

{

if (*p++ == mc)

return true;

}

return false;

}

static void _associators(

const MetaNameSpace* ns,

const CIMName& className,

const CIMName& assocClass,

const CIMName& resultClass,

const String& role,

const String& resultRole,

Array<const MetaClass*>& result)

{

// Lookup source class:

const MetaClass* mc = FindClass(ns, *Str(className));

if (!mc)

_throw(CIM_ERR_NOT_FOUND, "unknown class: %s", *Str(className));

// Lookup result class (if any).

const MetaClass* rmc = 0;

if (!resultClass.isNull())

{

rmc = FindClass(ns, *Str(resultClass));

if (!rmc)

_throw(CIM_ERR_NOT_FOUND, "unknown class: %s", *Str(resultClass));

}

// Convert these to UTF8 now to avoid doing so in loop below.

Str ac(assocClass);

Str r(role);

Str rr(resultRole);

// Process association classes:

for (size_t i = 0; ns->classes[i]; i++)

{

MetaClass* amc = ns->classes[i];

// Skip non-association classes:

if (!(amc->flags & META_FLAG_ASSOCIATION))

continue;

// Filter by assocClass parameter:

if (!assocClass.isNull() && !_eqi(ac, amc->name))

continue;

// Process reference properties:

MetaFeatureInfo features[META_MAX_FEATURES];

size_t size = 0;

MergeFeatures(amc, false, META_FLAG_REFERENCE, features, size);

for (size_t j = 0; j < size; j++)

{

const MetaFeature* mf = features[j].mf;

// Skip non references:

if (!(mf->flags & META_FLAG_REFERENCE))

continue;

const MetaReference* mr = (const MetaReference*)mf;

// Filter by role parameter.

if (role.size() && !_eqi(r, mf->name))

continue;

// Filter by source class:

if (!IsA(mr->ref, mc))

continue;

// Process result reference:

for (size_t k = 0; k < size; k++)

{

const MetaFeature* rmf = features[k].mf;

// Skip the feature under consideration:

if (rmf == mf)

continue;

// Skip non references:

if (!(rmf->flags & META_FLAG_REFERENCE))

continue;

const MetaReference* rmr = (const MetaReference*)rmf;

// Filter by resultRole parameter.

if (resultRole.size() && !_eqi(rr, rmf->name))

continue;

// Skip references not of the result class kind:

if (rmc && !IsA(rmr->ref, rmc))

continue;

// ATTN: should we include entire class hierarchy under

// result class?

// If reached, then save this one.

if (!_contains(result, rmr->ref))

result.append(rmr->ref);

}

static void _references(

const MetaNameSpace* ns,

const CIMName& className,

const CIMName& resultClass,

const String& role,

Array<const MetaClass*>& result)

{

// Lookup source class:

const MetaClass* mc = FindClass(ns, *Str(className));

if (!mc)

_throw(CIM_ERR_NOT_FOUND, "unknown class: %s", *Str(className));

// Lookup result class (if any).

const MetaClass* rmc = 0;

if (!resultClass.isNull())

{

rmc = FindClass(ns, *Str(resultClass));

if (!rmc)

_throw(CIM_ERR_NOT_FOUND, "unknown class: %s", *Str(resultClass));

}

// Convert these to UTF8 now to avoid doing so in loop below.

Str r(role);

// Process association classes:

for (size_t i = 0; ns->classes[i]; i++)

{

MetaClass* amc = ns->classes[i];

// Skip non-association classes:

if (!(amc->flags & META_FLAG_ASSOCIATION))

continue;

// Filter by result class:

if (rmc && !IsA(rmc, amc))

continue;

// Process reference properties:

MetaFeatureInfo features[META_MAX_FEATURES];

size_t size = 0;

MergeFeatures(amc, false, META_FLAG_REFERENCE, features, size);

for (size_t j = 0; j < size; j++)

{

const MetaFeature* mf = features[j].mf;

// Skip non references:

if (!(mf->flags & META_FLAG_REFERENCE))

continue;

const MetaReference* mr = (const MetaReference*)mf;

// Filter by role parameter.

if (role.size() && !_eqi(r, mf->name))

continue;

// Filter by source class:

if (!IsA(mr->ref, mc))

continue;

// Add this one to the output:

if (!_contains(result, amc))

result.append((MetaClass*)amc);

}

//==============================================================================

// _getHostName()

//==============================================================================

static Once _once = PEGASUS_ONCE_INITIALIZER;

static const char* _hostName = 0;

static void _initHostName()

{

String hn = System::getHostName();

_hostName = strdup(*Str(hn));

}

static inline const char* _getHostName()

{

once(&_once, _initHostName);

return _hostName;

}

//==============================================================================

// class MetaRepository

Line 246

Line 427

Boolean includeClassOrigin,

const CIMPropertyList& propertyList)

{

printf("===== MetaRepository::getClass()\n");

_init();

// Lookup namespace:

const MetaNameSpace* ns = _findNameSpace(*Str(nameSpace));

Line 258

Line 436

// Lookup class:

const MetaClass* mc = _findClass(ns, *Str(className));

const MetaClass* mc = FindClass(ns, *Str(className));

if (!mc)

_throw(CIM_ERR_NOT_FOUND, "unknown class: %s", *Str(className));

Line 271

Line 449

CIMClass cc;

if (MakeClass(ns, mc, localOnly, includeQualifiers,

if (MakeClass(_getHostName(), ns, mc, localOnly, includeQualifiers,

includeQualifiers, pl, cc) != 0)

includeClassOrigin, pl, cc) != 0)

{

_freePropertyList(pl);

_throw(CIM_ERR_FAILED, "conversion failed: %s", mc->name);

Line 290

Line 468

Boolean includeQualifiers,

Boolean includeClassOrigin)

{

printf("===== MetaRepository::enumerateClasses()\n");

_init();

// Lookup namespace:

const MetaNameSpace* ns = _findNameSpace(*Str(nameSpace));

Line 306

Line 481

if (!className.isNull())

{

super = _findClass(ns, *Str(className));

super = FindClass(ns, *Str(className));

if (!super)

_throw(CIM_ERR_NOT_FOUND, "unknown class: %s", *Str(className));

Line 337

Line 512

{

CIMClass cc;

if (MakeClass(ns, mc, localOnly, includeQualifiers,

if (MakeClass(_getHostName(), ns, mc, localOnly, includeQualifiers,

includeQualifiers, 0, cc) != 0)

includeClassOrigin, 0, cc) != 0)

{

_throw(CIM_ERR_FAILED, "conversion failed: %s", mc->name);

}

else

result.append(cc);

}

Line 355

Line 530

const CIMName& className,

Boolean deepInheritance)

{

printf("===== MetaRepository::enumerateClassNames()\n");

_init();

// Lookup namespace:

const MetaNameSpace* ns = _findNameSpace(*Str(nameSpace));

Line 371

Line 543

if (!className.isNull())

{

super = _findClass(ns, *Str(className));

super = FindClass(ns, *Str(className));

if (!super)

_throw(CIM_ERR_NOT_FOUND, "unknown class: %s", *Str(className));

Line 427

Line 599

Boolean deepInheritance,

Array<CIMName>& subClassNames)

{

printf("===== MetaRepository::getSubClassNames()\n");

_init();

subClassNames = MetaRepository::enumerateClassNames(

nameSpace, className, deepInheritance);

}

Line 439

Line 608

const CIMName& className,

Array<CIMName>& superClassNames)

{

printf("===== MetaRepository::getSuperClassNames()\n");

_init();

superClassNames.clear();

// Lookup namespace:

Line 453

Line 619

// Lookup class:

const MetaClass* mc = _findClass(ns, *Str(className));

const MetaClass* mc = FindClass(ns, *Str(className));

if (!mc)

_throw(CIM_ERR_NOT_FOUND, "unknown class: %s", *Str(className));

Line 468

Line 634

const CIMNamespaceName& nameSpace,

const NameSpaceAttributes& attributes)

{

printf("===== MetaRepository::createNameSpace()\n");

_throw(CIM_ERR_NOT_SUPPORTED, "createNameSpace()");

}

Line 477

Line 641

const CIMNamespaceName& nameSpace,

const NameSpaceAttributes& attributes)

{

printf("===== MetaRepository::modifyNameSpace()\n");

_throw(CIM_ERR_NOT_SUPPORTED, "modifyNameSpace()");

}

Array<CIMNamespaceName> MetaRepository::enumerateNameSpaces()

{

printf("===== MetaRepository::enumerateNameSpaces()\n");

_init();

Array<CIMNamespaceName> nameSpaces;

for (size_t i = 0; i < _nameSpacesSize; i++)

Line 498

Line 657

void MetaRepository::deleteNameSpace(

const CIMNamespaceName& nameSpace)

{

printf("===== MetaRepository::deleteNameSpace()\n");

_throw(CIM_ERR_NOT_SUPPORTED, "deleteNameSpace()");

}

Line 507

Line 664

const CIMNamespaceName& nameSpace,

NameSpaceAttributes& attributes)

{

printf("===== MetaRepository::getNameSpaceAttributes()\n");

_throw(CIM_ERR_NOT_SUPPORTED, "getNameSpaceAttributes()");

return false;

Line 518

Line 673

const CIMNamespaceName& nameSpace,

String& remoteInfo)

{

printf("===== MetaRepository::isRemoteNameSpace()\n");

return false;

}

Line 527

Line 680

const CIMNamespaceName& nameSpace,

const CIMName& qualifierName)

{

printf("===== MetaRepository::getQualifier()\n");

_init();

// Lookup namespace:

const MetaNameSpace* ns = _findNameSpace(*Str(nameSpace));

Line 539

Line 689

// Lookup qualifier:

const MetaQualifierDecl* mqd = _findQualifierDecl(ns, *Str(qualifierName));

const MetaQualifierDecl* mqd = FindQualifierDecl(ns, *Str(qualifierName));

if (!mqd)

_throw(CIM_ERR_NOT_FOUND, "unknown qualifier: %s", *Str(qualifierName));

Line 560

Line 710

const CIMNamespaceName& nameSpace,

const CIMQualifierDecl& qualifierDecl)

{

printf("===== MetaRepository::setQualifier()\n");

_throw(CIM_ERR_NOT_SUPPORTED, "setQualifier()");

}

Line 570

Line 718

const CIMNamespaceName& nameSpace,

const CIMName& qualifierName)

{

printf("===== MetaRepository::deleteQualifier()\n");

_throw(CIM_ERR_NOT_SUPPORTED, "deleteQualifier()");

}

Array<CIMQualifierDecl> MetaRepository::enumerateQualifiers(

const CIMNamespaceName& nameSpace)

{

printf("===== MetaRepository::enumerateQualifiers()\n");

_init();

// Lookup namespace:

const MetaNameSpace* ns = _findNameSpace(*Str(nameSpace));

Line 608

Line 751

return result;

}

Array<CIMObjectPath> MetaRepository::associatorClassPaths(

const CIMNamespaceName& nameSpace,

const CIMName& className,

const CIMName& assocClass,

const CIMName& resultClass,

const String& role,

const String& resultRole)

{

// Lookup namespace:

const MetaNameSpace* ns = _findNameSpace(*Str(nameSpace));

if (!ns)

_throw(CIM_ERR_INVALID_NAMESPACE, "%s", *Str(nameSpace));

// Get associator meta-classes:

Array<const MetaClass*> mcs;

_associators(ns, className, assocClass, resultClass, role, resultRole, mcs);

// Convert meta-classes to object names:

Array<CIMObjectPath> result;

for (Uint32 i = 0; i < mcs.size(); i++)

result.append(CIMObjectPath(_getHostName(), nameSpace, mcs[i]->name));

return result;

}

Array<CIMObject> MetaRepository::associatorClasses(

const CIMNamespaceName& nameSpace,

const CIMName& className,

const CIMName& assocClass,

const CIMName& resultClass,

const String& role,

const String& resultRole,

Boolean includeQualifiers,

Boolean includeClassOrigin,

const CIMPropertyList& propertyList)

{

// Lookup namespace:

const MetaNameSpace* ns = _findNameSpace(*Str(nameSpace));

if (!ns)

_throw(CIM_ERR_INVALID_NAMESPACE, "%s", *Str(nameSpace));

// Get associator meta-classes:

Array<const MetaClass*> mcs;

_associators(ns, className, assocClass, resultClass, role, resultRole, mcs);

// Convert meta-classes to classes.

Array<CIMObject> result;

char** pl = _makePropertyList(propertyList);

for (Uint32 i = 0; i < mcs.size(); i++)

{

const MetaClass* mc = mcs[i];

CIMClass cc;

if (MakeClass(_getHostName(), ns, mc, false, includeQualifiers,

includeClassOrigin, pl, cc) != 0)

{

_freePropertyList(pl);

_throw(CIM_ERR_FAILED, "conversion failed: %s", mc->name);

}

result.append(cc);

}

_freePropertyList(pl);

return result;

}

Array<CIMObject> MetaRepository::referenceClasses(

const CIMNamespaceName& nameSpace,

const CIMName& className,

const CIMName& resultClass,

const String& role,

Boolean includeQualifiers,

Boolean includeClassOrigin,

const CIMPropertyList& propertyList)

{

// Lookup namespace:

const MetaNameSpace* ns = _findNameSpace(*Str(nameSpace));

if (!ns)

_throw(CIM_ERR_INVALID_NAMESPACE, "%s", *Str(nameSpace));

// Get reference meta-classes:

Array<const MetaClass*> mcs;

_references(ns, className, resultClass, role, mcs);

// Convert meta-classes to classes.

Array<CIMObject> result;

char** pl = _makePropertyList(propertyList);

for (Uint32 i = 0; i < mcs.size(); i++)

{

const MetaClass* mc = mcs[i];

CIMClass cc;

if (MakeClass(_getHostName(), ns, mc, false, includeQualifiers,

includeClassOrigin, pl, cc) != 0)

{

_freePropertyList(pl);

_throw(CIM_ERR_FAILED, "conversion failed: %s", mc->name);

}

result.append(cc);

}

_freePropertyList(pl);

return result;

}

Array<CIMObjectPath> MetaRepository::referenceClassPaths(

const CIMNamespaceName& nameSpace,

const CIMName& className,

const CIMName& resultClass,

const String& role)

{

// Lookup namespace:

const MetaNameSpace* ns = _findNameSpace(*Str(nameSpace));

if (!ns)

_throw(CIM_ERR_INVALID_NAMESPACE, "%s", *Str(nameSpace));

// Get reference meta-classes:

Array<const MetaClass*> mcs;

_references(ns, className, resultClass, role, mcs);

// Convert meta-classes to object paths.

Array<CIMObjectPath> result;

for (Uint32 i = 0; i < mcs.size(); i++)

result.append(CIMObjectPath(_getHostName(), nameSpace, mcs[i]->name));

return result;

}

const MetaClass* MetaRepository::findMetaClass(

const char* nameSpace,

const char* className)

{

// Lookup namespace:

const MetaNameSpace* ns = _findNameSpace(nameSpace);

if (!ns)

return 0;

return FindClass(ns, className);

}

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.1.2.6
changed lines
	Added in v.1.1.2.9

No CVS admin address has been configured