1 mike 1.1.2.1 //%2006////////////////////////////////////////////////////////////////////////
2 //
3 // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
4 // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
5 // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
6 // IBM Corp.; EMC Corporation, The Open Group.
7 // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
8 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
9 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
10 // EMC Corporation; VERITAS Software Corporation; The Open Group.
11 // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
12 // EMC Corporation; Symantec Corporation; The Open Group.
13 //
14 // Permission is hereby granted, free of charge, to any person obtaining a copy
15 // of this software and associated documentation files (the "Software"), to
16 // deal in the Software without restriction, including without limitation the
17 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
18 // sell copies of the Software, and to permit persons to whom the Software is
19 // furnished to do so, subject to the following conditions:
20 //
21 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
22 mike 1.1.2.1 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
23 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
24 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
25 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
26 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
27 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
29 //
30 //==============================================================================
31 //
32 //%/////////////////////////////////////////////////////////////////////////////
33
34 #include <cstdarg>
35 #include <Pegasus/Common/Resolver.h>
|
36 mike 1.1.2.6 #include <Pegasus/Common/Once.h>
37 #include <Pegasus/Common/System.h>
|
38 mike 1.1.2.1 #include "MemoryResidentRepository.h"
39 #include "RepositoryDeclContext.h"
40 #include "Filtering.h"
|
41 mike 1.1.2.3 #include "Serialization.h"
|
42 mike 1.1.2.7 #include "SchemaTypes.h"
|
43 mike 1.1.2.1
44 PEGASUS_NAMESPACE_BEGIN
45
|
46 mike 1.1.2.7 typedef const SchemaClass* ConstSchemaClassPtr;
47 #define PEGASUS_ARRAY_T ConstSchemaClassPtr
|
48 mike 1.1.2.6 # include <Pegasus/Common/ArrayInter.h>
49 # include <Pegasus/Common/ArrayImpl.h>
50 #undef PEGASUS_ARRAY_T
51
|
52 mike 1.1.2.2 #define PEGASUS_ARRAY_T NamespaceInstancePair
53 # include <Pegasus/Common/ArrayImpl.h>
54 #undef PEGASUS_ARRAY_T
55
|
56 mike 1.1.2.1 //==============================================================================
57 //
|
58 mike 1.1.2.6 // Local definitions:
|
59 mike 1.1.2.1 //
60 //==============================================================================
61
|
62 mike 1.1.2.6 static size_t const _MAX_NAMESPACE_TABLE_SIZE = 64;
|
63 mike 1.1.2.7 static const SchemaNameSpace* _nameSpaceTable[_MAX_NAMESPACE_TABLE_SIZE];
|
64 mike 1.1.2.6 static size_t _nameSpaceTableSize = 0;
65
66 static const size_t _MAX_FEATURES = 128;
67 static const size_t _MAX_QUALIFIERS = 128;
68
|
69 mike 1.1.2.5 class ThrowContext
|
70 mike 1.1.2.1 {
|
71 mike 1.1.2.5 public:
|
72 mike 1.1.2.1
|
73 mike 1.1.2.5 PEGASUS_FORMAT(3, 4)
74 ThrowContext(CIMStatusCode code_, const char* format, ...) : code(code_)
75 {
76 char buffer[1024];
77 va_list ap;
78 va_start(ap, format);
79 vsprintf(buffer, format, ap);
80 va_end(ap);
81 msg = buffer;
82 }
83 CIMStatusCode code;
84 String msg;
85 };
86
87 #define Throw(ARGS) \
88 do \
89 { \
90 ThrowContext c ARGS; \
91 throw CIMException(c.code, c.msg); \
92 } \
93 while (0)
|
94 mike 1.1.2.1
95 class Str
96 {
97 public:
98 Str(const String& s) : _cstr(s.getCString()) { }
99 Str(const CIMName& n) : _cstr(n.getString().getCString()) { }
100 Str(const CIMNamespaceName& n) : _cstr(n.getString().getCString()) { }
101 Str(const Exception& e) : _cstr(e.getMessage().getCString()) { }
102 Str(const CIMDateTime& x) : _cstr(x.toString().getCString()) { }
103 Str(const CIMObjectPath& x) : _cstr(x.toString().getCString()) { }
104 const char* operator*() const { return (const char*)_cstr; }
105 operator const char*() const { return (const char*)_cstr; }
106 private:
107 CString _cstr;
108 };
109
110 static bool _contains(const CIMPropertyList& propertyList, const CIMName& name)
111 {
112 for (Uint32 i = 0; i < propertyList.size(); i++)
113 {
114 if (propertyList[i] == name)
115 mike 1.1.2.1 return true;
116 }
117
118 return false;
119 }
120
121 static void _applyModifiedInstance(
|
122 mike 1.1.2.7 const SchemaClass* mc,
|
123 mike 1.1.2.1 const CIMInstance& modifiedInstance_,
124 const CIMPropertyList& propertyList,
125 CIMInstance& resultInstance)
126 {
127 CIMInstance& modifiedInstance = *((CIMInstance*)&modifiedInstance_);
128
129 for (Uint32 i = 0; i < modifiedInstance.getPropertyCount(); i++)
130 {
131 CIMProperty cp = modifiedInstance.getProperty(i);
132 Uint32 pos = resultInstance.findProperty(cp.getName());
133
134 if (propertyList.isNull() || _contains(propertyList, cp.getName()))
135 {
136 // Reject attempts to add properties not in class:
137
|
138 mike 1.1.2.7 const SchemaFeature* mf = FindFeature(mc,
139 *Str(cp.getName()), SCHEMA_FLAG_PROPERTY|SCHEMA_FLAG_REFERENCE);
|
140 mike 1.1.2.1
141 if (!mf)
142 {
|
143 mike 1.1.2.5 Throw((CIM_ERR_NOT_FOUND,
|
144 mike 1.1.2.1 "modifyInstance() failed: unknown property: %s",
|
145 mike 1.1.2.5 *Str(cp.getName())));
|
146 mike 1.1.2.1 }
147
148 // Reject attempts to modify key properties:
149
|
150 mike 1.1.2.7 if (mf->flags & SCHEMA_FLAG_KEY)
|
151 mike 1.1.2.1 {
|
152 mike 1.1.2.5 Throw((CIM_ERR_FAILED,
|
153 mike 1.1.2.1 "modifyInstance() failed to modify key property: %s",
|
154 mike 1.1.2.5 *Str(cp.getName())));
|
155 mike 1.1.2.1 }
156
157 // Add or replace property in result instance:
158
159 if (pos != PEG_NOT_FOUND)
160 resultInstance.removeProperty(pos);
161
162 resultInstance.addProperty(cp);
163 }
164 }
165 }
166
167 static void _print(const CIMInstance& ci)
168 {
169 CIMObject co(ci);
170
171 std::cout << co.toString() << std::endl;
172 }
173
|
174 mike 1.1.2.6 static Once _once = PEGASUS_ONCE_INITIALIZER;
175 static const char* _hostName = 0;
176
177 static void _initHostName()
178 {
179 String hn = System::getHostName();
180 _hostName = strdup(*Str(hn));
181 }
182
183 static inline const char* _getHostName()
184 {
185 once(&_once, _initHostName);
186 return _hostName;
187 }
188
189 static bool _eqi(const char* s1, const char* s2)
190 {
191 return System::strcasecmp(s1, s2) == 0;
192 }
193
|
194 mike 1.1.2.7 static const SchemaNameSpace* _findNameSpace(const char* name)
|
195 mike 1.1.2.6 {
196 for (size_t i = 0; i < _nameSpaceTableSize; i++)
197 {
|
198 mike 1.1.2.7 const SchemaNameSpace* ns = _nameSpaceTable[i];
|
199 mike 1.1.2.6
200 if (_eqi(ns->name, name))
201 return ns;
202 }
203
204 // Not found!
205 return 0;
206 }
207
|
208 mike 1.1.2.7 static bool _isSubClass(const SchemaClass* super, const SchemaClass* sub)
|
209 mike 1.1.2.6 {
210 if (!super)
211 return true;
212
|
213 mike 1.1.2.7 for (SchemaClass* p = sub->super; p; p = p->super)
|
214 mike 1.1.2.6 {
215 if (p == super)
216 return true;
217 }
218
219 return false;
220 }
221
222 static inline bool _isDirectSubClass(
|
223 mike 1.1.2.7 const SchemaClass* super,
224 const SchemaClass* sub)
|
225 mike 1.1.2.6 {
226 return sub->super == super;
227 }
228
229 static char** _makePropertyList(const CIMPropertyList& propertyList)
230 {
231 if (propertyList.isNull())
232 return 0;
233
234 size_t size = propertyList.size();
235 char** pl = (char**)malloc(sizeof(char*) * (size + 1));
236
237 for (size_t i = 0; i < size; i++)
238 pl[i] = strdup(*Str(propertyList[i]));
239
240 pl[size] = 0;
241
242 return pl;
243 }
244
245 static void _freePropertyList(char** pl)
246 mike 1.1.2.6 {
247 if (!pl)
248 return;
249
250 for (size_t i = 0; pl[i]; i++)
251 {
252 free(pl[i]);
253 }
254
255 free(pl);
256 }
257
258 static void _printPropertyList(const char* const* pl)
259 {
260 if (!pl)
261 return;
262
263 for (size_t i = 0; pl[i]; i++)
264 printf("pl[%s]\n", pl[i]);
265 }
266
|
267 mike 1.1.2.7 static bool _contains(const Array<const SchemaClass*>& x, const SchemaClass* mc)
|
268 mike 1.1.2.6 {
269 Uint32 n = x.size();
|
270 mike 1.1.2.7 const SchemaClass* const* p = x.getData();
|
271 mike 1.1.2.6
272 while (n--)
273 {
274 if (*p++ == mc)
275 return true;
276 }
277
278 return false;
279 }
280
281 static void _associators(
|
282 mike 1.1.2.7 const SchemaNameSpace* ns,
|
283 mike 1.1.2.6 const CIMName& className,
284 const CIMName& assocClass,
285 const CIMName& resultClass,
286 const String& role,
287 const String& resultRole,
|
288 mike 1.1.2.7 Array<const SchemaClass*>& result)
|
289 mike 1.1.2.6 {
290 // Lookup source class:
291
|
292 mike 1.1.2.7 const SchemaClass* mc = FindClass(ns, *Str(className));
|
293 mike 1.1.2.6
294 if (!mc)
295 Throw((CIM_ERR_NOT_FOUND, "unknown class: %s", *Str(className)));
296
297
298 // Lookup result class (if any).
299
|
300 mike 1.1.2.7 const SchemaClass* rmc = 0;
|
301 mike 1.1.2.6
302 if (!resultClass.isNull())
303 {
304 rmc = FindClass(ns, *Str(resultClass));
305
306 if (!rmc)
307 Throw((CIM_ERR_NOT_FOUND, "unknown class: %s", *Str(resultClass)));
308 }
309
310 // Convert these to UTF8 now to avoid doing so in loop below.
311
312 Str ac(assocClass);
313 Str r(role);
314 Str rr(resultRole);
315
316 // Process association classes:
317
318 for (size_t i = 0; ns->classes[i]; i++)
319 {
|
320 mike 1.1.2.7 SchemaClass* amc = ns->classes[i];
|
321 mike 1.1.2.6
322 // Skip non-association classes:
323
|
324 mike 1.1.2.7 if (!(amc->flags & SCHEMA_FLAG_ASSOCIATION))
|
325 mike 1.1.2.6 continue;
326
327 // Filter by assocClass parameter:
328
329 if (!assocClass.isNull() && !_eqi(ac, amc->name))
330 continue;
331
332 // Process reference properties:
333
|
334 mike 1.1.2.7 SchemaFeatureInfo features[SCHEMA_MAX_FEATURES];
|
335 mike 1.1.2.6 size_t size = 0;
|
336 mike 1.1.2.7 MergeFeatures(amc, false, SCHEMA_FLAG_REFERENCE, features, size);
|
337 mike 1.1.2.6
338 for (size_t j = 0; j < size; j++)
339 {
|
340 mike 1.1.2.7 const SchemaFeature* mf = features[j].mf;
|
341 mike 1.1.2.6
342 // Skip non references:
343
|
344 mike 1.1.2.7 if (!(mf->flags & SCHEMA_FLAG_REFERENCE))
|
345 mike 1.1.2.6 continue;
346
|
347 mike 1.1.2.7 const SchemaReference* mr = (const SchemaReference*)mf;
|
348 mike 1.1.2.6
349 // Filter by role parameter.
350
351 if (role.size() && !_eqi(r, mf->name))
352 continue;
353
354 // Filter by source class:
355
356 if (!IsA(mr->ref, mc))
357 continue;
358
359 // Process result reference:
360
361 for (size_t k = 0; k < size; k++)
362 {
|
363 mike 1.1.2.7 const SchemaFeature* rmf = features[k].mf;
|
364 mike 1.1.2.6
365 // Skip the feature under consideration:
366
367 if (rmf == mf)
368 continue;
369
370 // Skip non references:
371
|
372 mike 1.1.2.7 if (!(rmf->flags & SCHEMA_FLAG_REFERENCE))
|
373 mike 1.1.2.6 continue;
374
|
375 mike 1.1.2.7 const SchemaReference* rmr = (const SchemaReference*)rmf;
|
376 mike 1.1.2.6
377 // Filter by resultRole parameter.
378
379 if (resultRole.size() && !_eqi(rr, rmf->name))
380 continue;
381
382 // Skip references not of the result class kind:
383
384 if (rmc && !IsA(rmr->ref, rmc))
385 continue;
386
387 // ATTN: should we include entire class hierarchy under
388 // result class?
389
390 // If reached, then save this one.
391
392 if (!_contains(result, rmr->ref))
393 result.append(rmr->ref);
394 }
395 }
396 }
397 mike 1.1.2.6 }
398
399 static void _references(
|
400 mike 1.1.2.7 const SchemaNameSpace* ns,
|
401 mike 1.1.2.6 const CIMName& className,
402 const CIMName& resultClass,
403 const String& role,
|
404 mike 1.1.2.7 Array<const SchemaClass*>& result)
|
405 mike 1.1.2.6 {
406 // Lookup source class:
407
|
408 mike 1.1.2.7 const SchemaClass* mc = FindClass(ns, *Str(className));
|
409 mike 1.1.2.6
410 if (!mc)
411 Throw((CIM_ERR_NOT_FOUND, "unknown class: %s", *Str(className)));
412
413 // Lookup result class (if any).
414
|
415 mike 1.1.2.7 const SchemaClass* rmc = 0;
|
416 mike 1.1.2.6
417 if (!resultClass.isNull())
418 {
419 rmc = FindClass(ns, *Str(resultClass));
420
421 if (!rmc)
422 Throw((CIM_ERR_NOT_FOUND, "unknown class: %s", *Str(resultClass)));
423 }
424
425 // Convert these to UTF8 now to avoid doing so in loop below.
426
427 Str r(role);
428
429 // Process association classes:
430
431 for (size_t i = 0; ns->classes[i]; i++)
432 {
|
433 mike 1.1.2.7 SchemaClass* amc = ns->classes[i];
|
434 mike 1.1.2.6
435 // Skip non-association classes:
436
|
437 mike 1.1.2.7 if (!(amc->flags & SCHEMA_FLAG_ASSOCIATION))
|
438 mike 1.1.2.6 continue;
439
440 // Filter by result class:
441
442 if (rmc && !IsA(rmc, amc))
443 continue;
444
445 // Process reference properties:
446
|
447 mike 1.1.2.7 SchemaFeatureInfo features[SCHEMA_MAX_FEATURES];
|
448 mike 1.1.2.6 size_t size = 0;
|
449 mike 1.1.2.7 MergeFeatures(amc, false, SCHEMA_FLAG_REFERENCE, features, size);
|
450 mike 1.1.2.6
451 for (size_t j = 0; j < size; j++)
452 {
|
453 mike 1.1.2.7 const SchemaFeature* mf = features[j].mf;
|
454 mike 1.1.2.6
455 // Skip non references:
456
|
457 mike 1.1.2.7 if (!(mf->flags & SCHEMA_FLAG_REFERENCE))
|
458 mike 1.1.2.6 continue;
459
|
460 mike 1.1.2.7 const SchemaReference* mr = (const SchemaReference*)mf;
|
461 mike 1.1.2.6
462 // Filter by role parameter.
463
464 if (role.size() && !_eqi(r, mf->name))
465 continue;
466
467 // Filter by source class:
468
469 if (!IsA(mr->ref, mc))
470 continue;
471
472 // Add this one to the output:
473
474 if (!_contains(result, amc))
|
475 mike 1.1.2.7 result.append((SchemaClass*)amc);
|
476 mike 1.1.2.6 }
477 }
478 }
479
|
480 mike 1.1.2.7 static const SchemaClass* _findSchemaClass(
|
481 mike 1.1.2.6 const char* nameSpace,
482 const char* className)
483 {
484 // Lookup namespace:
485
|
486 mike 1.1.2.7 const SchemaNameSpace* ns = _findNameSpace(nameSpace);
|
487 mike 1.1.2.6
488 if (!ns)
489 return 0;
490
491 return FindClass(ns, className);
492 }
493
494 static Array<CIMName> _enumerateClassNames(
495 const CIMNamespaceName& nameSpace,
496 const CIMName& className,
497 Boolean deepInheritance)
498 {
499 // Lookup namespace:
500
|
501 mike 1.1.2.7 const SchemaNameSpace* ns = _findNameSpace(*Str(nameSpace));
|
502 mike 1.1.2.6
503 if (!ns)
504 Throw((CIM_ERR_INVALID_NAMESPACE, "%s", *Str(nameSpace)));
505
506 // Lookup class:
507
|
508 mike 1.1.2.7 const SchemaClass* super = 0;
|
509 mike 1.1.2.6
510 if (!className.isNull())
511 {
512 super = FindClass(ns, *Str(className));
513
514 if (!super)
515 Throw((CIM_ERR_NOT_FOUND, "unknown class: %s", *Str(className)));
516 }
517
518 // Iterate all classes looking for matches:
519
520 Array<CIMName> result;
521
522 for (size_t i = 0; ns->classes[i]; i++)
523 {
|
524 mike 1.1.2.7 SchemaClass* mc = ns->classes[i];
|
525 mike 1.1.2.6
526 if (deepInheritance)
527 {
528 if (_isSubClass(super, mc))
529 result.append(mc->name);
530 }
531 else
532 {
533 if (_isDirectSubClass(super, mc))
534 result.append(mc->name);
535 }
536 }
537
538 return result;
539 }
540
541 static void _getSubClassNames(
542 const CIMNamespaceName& nameSpace,
543 const CIMName& className,
544 Boolean deepInheritance,
545 Array<CIMName>& subClassNames)
546 mike 1.1.2.6 {
547 subClassNames = _enumerateClassNames(
548 nameSpace, className, deepInheritance);
549 }
550
551 static Array<CIMObject> _associatorClasses(
552 const CIMNamespaceName& nameSpace,
553 const CIMName& className,
554 const CIMName& assocClass,
555 const CIMName& resultClass,
556 const String& role,
557 const String& resultRole,
558 Boolean includeQualifiers,
559 Boolean includeClassOrigin,
560 const CIMPropertyList& propertyList)
561 {
562 // Lookup namespace:
563
|
564 mike 1.1.2.7 const SchemaNameSpace* ns = _findNameSpace(*Str(nameSpace));
|
565 mike 1.1.2.6
566 if (!ns)
567 Throw((CIM_ERR_INVALID_NAMESPACE, "%s", *Str(nameSpace)));
568
|
569 mike 1.1.2.7 // Get associator schema-classes:
|
570 mike 1.1.2.6
|
571 mike 1.1.2.7 Array<const SchemaClass*> mcs;
|
572 mike 1.1.2.6 _associators(ns, className, assocClass, resultClass, role, resultRole, mcs);
573
|
574 mike 1.1.2.7 // Convert schema-classes to classes.
|
575 mike 1.1.2.6
576 Array<CIMObject> result;
577
578 char** pl = _makePropertyList(propertyList);
579
580 for (Uint32 i = 0; i < mcs.size(); i++)
581 {
|
582 mike 1.1.2.7 const SchemaClass* mc = mcs[i];
|
583 mike 1.1.2.6 CIMClass cc;
584
585 if (MakeClass(_getHostName(), ns, mc, false, includeQualifiers,
586 includeClassOrigin, pl, cc) != 0)
587 {
588 _freePropertyList(pl);
589 Throw((CIM_ERR_FAILED, "conversion failed: %s", mc->name));
590 }
591
592 result.append(cc);
593 }
594
595 _freePropertyList(pl);
596 return result;
597 }
598
599 static Array<CIMObjectPath> _associatorClassPaths(
600 const CIMNamespaceName& nameSpace,
601 const CIMName& className,
602 const CIMName& assocClass,
603 const CIMName& resultClass,
604 mike 1.1.2.6 const String& role,
605 const String& resultRole)
606 {
607 // Lookup namespace:
608
|
609 mike 1.1.2.7 const SchemaNameSpace* ns = _findNameSpace(*Str(nameSpace));
|
610 mike 1.1.2.6
611 if (!ns)
612 Throw((CIM_ERR_INVALID_NAMESPACE, "%s", *Str(nameSpace)));
613
|
614 mike 1.1.2.7 // Get associator schema-classes:
|
615 mike 1.1.2.6
|
616 mike 1.1.2.7 Array<const SchemaClass*> mcs;
|
617 mike 1.1.2.6 _associators(ns, className, assocClass, resultClass, role, resultRole, mcs);
618
|
619 mike 1.1.2.7 // Convert schema-classes to object names:
|
620 mike 1.1.2.6
621 Array<CIMObjectPath> result;
622
623 for (Uint32 i = 0; i < mcs.size(); i++)
624 result.append(CIMObjectPath(_getHostName(), nameSpace, mcs[i]->name));
625
626 return result;
627 }
628
629 static Array<CIMObject> _referenceClasses(
630 const CIMNamespaceName& nameSpace,
631 const CIMName& className,
632 const CIMName& resultClass,
633 const String& role,
634 Boolean includeQualifiers,
635 Boolean includeClassOrigin,
636 const CIMPropertyList& propertyList)
637 {
638 // Lookup namespace:
639
|
640 mike 1.1.2.7 const SchemaNameSpace* ns = _findNameSpace(*Str(nameSpace));
|
641 mike 1.1.2.6
642 if (!ns)
643 Throw((CIM_ERR_INVALID_NAMESPACE, "%s", *Str(nameSpace)));
644
|
645 mike 1.1.2.7 // Get reference schema-classes:
|
646 mike 1.1.2.6
|
647 mike 1.1.2.7 Array<const SchemaClass*> mcs;
|
648 mike 1.1.2.6 _references(ns, className, resultClass, role, mcs);
649
|
650 mike 1.1.2.7 // Convert schema-classes to classes.
|
651 mike 1.1.2.6
652 Array<CIMObject> result;
653
654 char** pl = _makePropertyList(propertyList);
655
656 for (Uint32 i = 0; i < mcs.size(); i++)
657 {
|
658 mike 1.1.2.7 const SchemaClass* mc = mcs[i];
|
659 mike 1.1.2.6 CIMClass cc;
660
661 if (MakeClass(_getHostName(), ns, mc, false, includeQualifiers,
662 includeClassOrigin, pl, cc) != 0)
663 {
664 _freePropertyList(pl);
665 Throw((CIM_ERR_FAILED, "conversion failed: %s", mc->name));
666 }
667
668 result.append(cc);
669 }
670
671 _freePropertyList(pl);
672 return result;
673 }
674
675 static Array<CIMObjectPath> _referenceClassPaths(
676 const CIMNamespaceName& nameSpace,
677 const CIMName& className,
678 const CIMName& resultClass,
679 const String& role)
680 mike 1.1.2.6 {
681 // Lookup namespace:
682
|
683 mike 1.1.2.7 const SchemaNameSpace* ns = _findNameSpace(*Str(nameSpace));
|
684 mike 1.1.2.6
685 if (!ns)
686 Throw((CIM_ERR_INVALID_NAMESPACE, "%s", *Str(nameSpace)));
687
|
688 mike 1.1.2.7 // Get reference schema-classes:
|
689 mike 1.1.2.6
|
690 mike 1.1.2.7 Array<const SchemaClass*> mcs;
|
691 mike 1.1.2.6 _references(ns, className, resultClass, role, mcs);
692
|
693 mike 1.1.2.7 // Convert schema-classes to object paths.
|
694 mike 1.1.2.6
695 Array<CIMObjectPath> result;
696
697 for (Uint32 i = 0; i < mcs.size(); i++)
698 result.append(CIMObjectPath(_getHostName(), nameSpace, mcs[i]->name));
699
700 return result;
701 }
702
703 static CIMQualifierDecl _getQualifier(
704 const CIMNamespaceName& nameSpace,
705 const CIMName& qualifierName)
706 {
707 // Lookup namespace:
708
|
709 mike 1.1.2.7 const SchemaNameSpace* ns = _findNameSpace(*Str(nameSpace));
|
710 mike 1.1.2.6
711 if (!ns)
712 Throw((CIM_ERR_INVALID_NAMESPACE, "%s", *Str(nameSpace)));
713
714 // Lookup qualifier:
715
|
716 mike 1.1.2.7 const SchemaQualifierDecl* mqd = FindQualifierDecl(ns, *Str(qualifierName));
|
717 mike 1.1.2.6
718 if (!mqd)
719 Throw((CIM_ERR_NOT_FOUND,
720 "unknown qualifier: %s", *Str(qualifierName)));
721
722 // Make the qualifier declaration:
723
724 CIMQualifierDecl cqd;
725
726 if (MakeQualifierDecl(ns, mqd, cqd) != 0)
727 {
728 Throw((CIM_ERR_FAILED, "conversion failed: %s", mqd->name));
729 }
730
731 return cqd;
732 }
733
734 static Array<CIMQualifierDecl> _enumerateQualifiers(
735 const CIMNamespaceName& nameSpace)
736 {
737 // Lookup namespace:
738 mike 1.1.2.6
|
739 mike 1.1.2.7 const SchemaNameSpace* ns = _findNameSpace(*Str(nameSpace));
|
740 mike 1.1.2.6
741 if (!ns)
742 Throw((CIM_ERR_INVALID_NAMESPACE, "%s", *Str(nameSpace)));
743
744 // Build the array of qualifier declarations:
745
746 Array<CIMQualifierDecl> result;
747
748 for (size_t i = 0; ns->qualifiers[i]; i++)
749 {
|
750 mike 1.1.2.7 const SchemaQualifierDecl* mqd = ns->qualifiers[i];
|
751 mike 1.1.2.6 CIMQualifierDecl cqd;
752
753 if (MakeQualifierDecl(ns, mqd, cqd) != 0)
754 {
755 Throw((CIM_ERR_FAILED, "conversion failed: %s", mqd->name));
756 }
757
758 result.append(cqd);
759 }
760
761 return result;
762
763 }
764
765 static Array<CIMNamespaceName> _enumerateNameSpaces()
766 {
767 Array<CIMNamespaceName> result;
768
769 for (size_t i = 0; i < _nameSpaceTableSize; i++)
770 {
|
771 mike 1.1.2.7 const SchemaNameSpace* ns = _nameSpaceTable[i];
|
772 mike 1.1.2.6 result.append(ns->name);
773 }
774
775 return result;
776 }
777
778 static void _getSuperClassNames(
779 const CIMNamespaceName& nameSpace,
780 const CIMName& className,
781 Array<CIMName>& superClassNames)
782 {
783 superClassNames.clear();
784
785 // Lookup namespace:
786
|
787 mike 1.1.2.7 const SchemaNameSpace* ns = _findNameSpace(*Str(nameSpace));
|
788 mike 1.1.2.6
789 if (!ns)
790 Throw((CIM_ERR_INVALID_NAMESPACE, "%s", *Str(nameSpace)));
791
792 // Lookup class:
793
|
794 mike 1.1.2.7 const SchemaClass* mc = FindClass(ns, *Str(className));
|
795 mike 1.1.2.6
796 if (!mc)
797 Throw((CIM_ERR_NOT_FOUND, "unknown class: %s", *Str(className)));
798
799 // Append superclass names:
800
|
801 mike 1.1.2.7 for (const SchemaClass* p = mc->super; p; p = p->super)
|
802 mike 1.1.2.6 superClassNames.append(p->name);
803 }
804
|
805 mike 1.1.2.1 //==============================================================================
806 //
807 // class MemoryResidentRepository:
808 //
809 //==============================================================================
810
|
811 mike 1.1.2.4 static void (*_saveCallback)(const Buffer& buffer, void* data);
812 static void* _saveData;
813 static void (*_loadCallback)(Buffer& buffer, void* data);
814 static void* _loadData;
|
815 mike 1.1.2.3
|
816 mike 1.1.2.7 MemoryResidentRepository::MemoryResidentRepository()
|
817 mike 1.1.2.1 {
|
818 mike 1.1.2.3 // Load users data if any:
819 _processLoadHandler();
|
820 mike 1.1.2.1 }
821
822 MemoryResidentRepository::~MemoryResidentRepository()
823 {
824 }
825
826 CIMClass MemoryResidentRepository::getClass(
827 bool lock,
828 const CIMNamespaceName& nameSpace,
829 const CIMName& className,
830 Boolean localOnly,
831 Boolean includeQualifiers,
832 Boolean includeClassOrigin,
833 const CIMPropertyList& propertyList)
834 {
|
835 mike 1.1.2.6 // Lookup namespace:
836
|
837 mike 1.1.2.7 const SchemaNameSpace* ns = _findNameSpace(*Str(nameSpace));
|
838 mike 1.1.2.6
839 if (!ns)
840 Throw((CIM_ERR_INVALID_NAMESPACE, "%s", *Str(nameSpace)));
841
842 // Lookup class:
843
|
844 mike 1.1.2.7 const SchemaClass* mc = FindClass(ns, *Str(className));
|
845 mike 1.1.2.6
846 if (!mc)
847 {
848 Throw((CIM_ERR_NOT_FOUND, "unknown class: %s", *Str(className)));
849 }
850
851 // Build property list:
852
853 char** pl = _makePropertyList(propertyList);
854
855 // Make class:
856
857 CIMClass cc;
858
859 if (MakeClass(_getHostName(), ns, mc, localOnly, includeQualifiers,
860 includeClassOrigin, pl, cc) != 0)
861 {
862 _freePropertyList(pl);
863 Throw((CIM_ERR_FAILED, "conversion failed: %s", mc->name));
864 }
865
866 mike 1.1.2.6 _freePropertyList(pl);
867 return cc;
|
868 mike 1.1.2.1 }
869
870 CIMInstance MemoryResidentRepository::getInstance(
871 bool lock,
872 const CIMNamespaceName& nameSpace,
873 const CIMObjectPath& instanceName,
874 Boolean localOnly,
875 Boolean includeQualifiers,
876 Boolean includeClassOrigin,
877 const CIMPropertyList& propertyList)
878 {
879 Uint32 pos = _findInstance(nameSpace, instanceName);
880
881 if (pos == PEG_NOT_FOUND)
|
882 mike 1.1.2.5 Throw((CIM_ERR_NOT_FOUND, "%s", *Str(instanceName)));
|
883 mike 1.1.2.1
884 CIMInstance cimInstance = _rep[pos].second.clone();
885
886 Filtering::filterInstance(
887 cimInstance,
888 localOnly,
889 includeQualifiers,
890 includeClassOrigin,
891 propertyList);
892
893 return cimInstance;
894 }
895
896 void MemoryResidentRepository::deleteClass(
897 bool lock,
898 const CIMNamespaceName& nameSpace,
899 const CIMName& className)
900 {
|
901 mike 1.1.2.6 Throw((CIM_ERR_NOT_SUPPORTED, "deleteClass()"));
|
902 mike 1.1.2.1 }
903
904 void MemoryResidentRepository::deleteInstance(
905 bool lock,
906 const CIMNamespaceName& nameSpace,
907 const CIMObjectPath& instanceName)
908 {
909 Uint32 pos = _findInstance(nameSpace, instanceName);
910
911 if (pos == PEG_NOT_FOUND)
|
912 mike 1.1.2.5 Throw((CIM_ERR_NOT_FOUND, "%s", *Str(instanceName)));
|
913 mike 1.1.2.1
914 _rep.remove(pos);
|
915 mike 1.1.2.3 _processSaveHandler();
|
916 mike 1.1.2.1 }
917
918 void MemoryResidentRepository::createClass(
919 bool lock,
920 const CIMNamespaceName& nameSpace,
921 const CIMClass& newClass,
922 const ContentLanguageList& contentLangs)
923 {
|
924 mike 1.1.2.6 Throw((CIM_ERR_NOT_SUPPORTED, "createClass()"));
|
925 mike 1.1.2.1 }
926
927 CIMObjectPath MemoryResidentRepository::createInstance(
928 bool lock,
929 const CIMNamespaceName& nameSpace,
930 const CIMInstance& newInstance,
931 const ContentLanguageList& contentLangs)
932 {
933 // Resolve the instance first:
934
935 CIMInstance ci(newInstance.clone());
936 CIMConstClass cc;
937 RepositoryDeclContext context(this);
938 Resolver::resolveInstance(ci, &context, nameSpace, cc, false);
939 CIMObjectPath cop = ci.buildPath(cc);
940
941 ci.setPath(cop);
942
943 // Reject if an instance with this name already exists:
944
945 if (_findInstance(nameSpace, cop) != PEG_NOT_FOUND)
|
946 mike 1.1.2.5 Throw((CIM_ERR_ALREADY_EXISTS, "%s", *Str(cop)));
|
947 mike 1.1.2.1
948 // Add instance to array:
949
950 _rep.append(NamespaceInstancePair(nameSpace, ci));
|
951 mike 1.1.2.3 _processSaveHandler();
|
952 mike 1.1.2.1
953 return cop;
954 }
955
956 void MemoryResidentRepository::modifyClass(
957 bool lock,
958 const CIMNamespaceName& nameSpace,
959 const CIMClass& modifiedClass,
960 const ContentLanguageList& contentLangs)
961 {
|
962 mike 1.1.2.6 Throw((CIM_ERR_NOT_SUPPORTED, "modifyClass()"));
|
963 mike 1.1.2.1 }
964
965 void MemoryResidentRepository::modifyInstance(
966 bool lock,
967 const CIMNamespaceName& nameSpace,
968 const CIMInstance& modifiedInstance,
969 Boolean includeQualifiers,
970 const CIMPropertyList& propertyList,
971 const ContentLanguageList& contentLangs)
972 {
973 const CIMObjectPath& cop = modifiedInstance.getPath();
974 CIMName className = cop.getClassName();
975
|
976 mike 1.1.2.7 // Get the schema-class for this instance.
|
977 mike 1.1.2.1
|
978 mike 1.1.2.7 const SchemaClass* mc = _findSchemaClass(*Str(nameSpace), *Str(className));
|
979 mike 1.1.2.1
980 if (!mc)
981 {
|
982 mike 1.1.2.5 Throw((CIM_ERR_FAILED,
|
983 mike 1.1.2.1 "modifyInstance() failed: unknown class: %s:%s",
|
984 mike 1.1.2.5 *Str(nameSpace), *Str(className)));
|
985 mike 1.1.2.1 }
986
987 // Get original instance to be modified:
988
989 Uint32 pos = _findInstance(nameSpace, cop);
990
991 if (pos == PEG_NOT_FOUND)
992 {
|
993 mike 1.1.2.5 Throw((CIM_ERR_NOT_FOUND,
994 "modifyInstance() failed: unknown instance: %s",
995 *Str(cop.toString())));
|
996 mike 1.1.2.1 }
997
998 CIMInstance resultInstance = _rep[pos].second.clone();
999
1000 // Apply features of modifiedInstance to result instance.
1001
1002 _applyModifiedInstance(mc, modifiedInstance, propertyList, resultInstance);
1003
1004 // Resolve the instance.
1005
1006 CIMConstClass cc;
1007 RepositoryDeclContext context(this);
1008 Resolver::resolveInstance(resultInstance, &context, nameSpace, cc, false);
1009
1010 // Replace original instance.
1011
1012 _rep[pos].second = resultInstance;
|
1013 mike 1.1.2.3 _processSaveHandler();
|
1014 mike 1.1.2.1 }
1015
1016 Array<CIMClass> MemoryResidentRepository::enumerateClasses(
1017 bool lock,
1018 const CIMNamespaceName& nameSpace,
1019 const CIMName& className,
1020 Boolean deepInheritance,
1021 Boolean localOnly,
1022 Boolean includeQualifiers,
1023 Boolean includeClassOrigin)
1024 {
|
1025 mike 1.1.2.6 // Lookup namespace:
1026
|
1027 mike 1.1.2.7 const SchemaNameSpace* ns = _findNameSpace(*Str(nameSpace));
|
1028 mike 1.1.2.6
1029 if (!ns)
1030 Throw((CIM_ERR_INVALID_NAMESPACE, "%s", *Str(nameSpace)));
1031
1032 // Lookup class:
1033
|
1034 mike 1.1.2.7 const SchemaClass* super = 0;
|
1035 mike 1.1.2.6
1036 if (!className.isNull())
1037 {
1038 super = FindClass(ns, *Str(className));
1039
1040 if (!super)
1041 Throw((CIM_ERR_NOT_FOUND, "unknown class: %s", *Str(className)));
1042 }
1043
1044 // Iterate all classes looking for matches:
1045
1046 Array<CIMClass> result;
1047
1048 for (size_t i = 0; ns->classes[i]; i++)
1049 {
|
1050 mike 1.1.2.7 SchemaClass* mc = ns->classes[i];
|
1051 mike 1.1.2.6
1052 bool flag = false;
1053
1054 if (deepInheritance)
1055 {
1056 if (_isSubClass(super, mc))
1057 flag = true;
1058 }
1059 else
1060 {
1061 if (_isDirectSubClass(super, mc))
1062 flag = true;
1063 }
1064
1065 if (flag)
1066 {
1067 CIMClass cc;
1068
1069 if (MakeClass(_getHostName(), ns, mc, localOnly, includeQualifiers,
1070 includeClassOrigin, 0, cc) != 0)
1071 {
1072 mike 1.1.2.6 Throw((CIM_ERR_FAILED, "conversion failed: %s", mc->name));
1073 }
1074
1075 result.append(cc);
1076 }
1077 }
1078
1079 return result;
|
1080 mike 1.1.2.1 }
1081
1082 Array<CIMName> MemoryResidentRepository::enumerateClassNames(
1083 bool lock,
1084 const CIMNamespaceName& nameSpace,
1085 const CIMName& className,
1086 Boolean deepInheritance)
1087 {
|
1088 mike 1.1.2.6 return _enumerateClassNames(nameSpace, className, deepInheritance);
|
1089 mike 1.1.2.1 }
1090
1091 Array<CIMInstance> MemoryResidentRepository::enumerateInstancesForSubtree(
1092 bool lock,
1093 const CIMNamespaceName& nameSpace,
1094 const CIMName& className,
1095 Boolean deepInheritance,
1096 Boolean localOnly,
1097 Boolean includeQualifiers,
1098 Boolean includeClassOrigin,
1099 const CIMPropertyList& propertyList)
1100 {
1101 // Form array of classnames for this class and descendent classes:
1102
1103 Array<CIMName> classNames;
1104 classNames.append(className);
|
1105 mike 1.1.2.6 _getSubClassNames(nameSpace, className, true, classNames);
|
1106 mike 1.1.2.1
1107 // Get all instances for this class and all descendent classes
1108
1109 Array<CIMInstance> result;
1110
1111 for (Uint32 i = 0; i < classNames.size(); i++)
1112 {
1113 Array<CIMInstance> instances = enumerateInstancesForClass(false,
1114 nameSpace, classNames[i], false, includeQualifiers,
1115 includeClassOrigin, propertyList);
1116
1117 for (Uint32 i = 0 ; i < instances.size(); i++)
1118 {
1119 Filtering::filterInstance(
1120 instances[i],
1121 localOnly,
1122 includeQualifiers,
1123 includeClassOrigin,
1124 propertyList);
1125 }
1126
1127 mike 1.1.2.1 result.appendArray(instances);
1128 }
1129
1130 return result;
1131 }
1132
1133 Array<CIMInstance> MemoryResidentRepository::enumerateInstancesForClass(
1134 bool lock,
1135 const CIMNamespaceName& nameSpace,
1136 const CIMName& className,
1137 Boolean localOnly,
1138 Boolean includeQualifiers,
1139 Boolean includeClassOrigin,
1140 const CIMPropertyList& propertyList)
1141 {
1142 Array<CIMInstance> result;
1143
1144 for (Uint32 i = 0; i < _rep.size(); i++)
1145 {
1146 if (_rep[i].first != nameSpace)
1147 continue;
1148 mike 1.1.2.1
1149 CIMInstance& ci = _rep[i].second;
1150
1151 if (ci.getPath().getClassName() == className)
1152 {
1153 CIMInstance tmp = ci.clone();
1154
1155 Filtering::filterInstance(
1156 tmp,
1157 localOnly,
1158 includeQualifiers,
1159 includeClassOrigin,
1160 propertyList);
1161
1162 result.append(tmp);
1163 }
1164 }
1165
1166 return result;
1167 }
1168
1169 mike 1.1.2.1 Array<CIMObjectPath> MemoryResidentRepository::enumerateInstanceNamesForSubtree(
1170 bool lock,
1171 const CIMNamespaceName& nameSpace,
1172 const CIMName& className)
1173 {
1174 // Form array of classnames for this class and descendent classes:
1175
1176 Array<CIMName> classNames;
1177 classNames.append(className);
|
1178 mike 1.1.2.6 _getSubClassNames(nameSpace, className, true, classNames);
|
1179 mike 1.1.2.1
1180 // Get all instances for this class and all descendent classes
1181
1182 Array<CIMObjectPath> result;
1183
1184 for (Uint32 i = 0; i < classNames.size(); i++)
1185 {
1186 Array<CIMObjectPath> paths = enumerateInstanceNamesForClass(
1187 false, nameSpace, classNames[i]);
1188
1189 result.appendArray(paths);
1190 }
1191
1192 return result;
1193 }
1194
1195 Array<CIMObjectPath> MemoryResidentRepository::enumerateInstanceNamesForClass(
1196 bool lock,
1197 const CIMNamespaceName& nameSpace,
1198 const CIMName& className)
1199 {
1200 mike 1.1.2.1 Array<CIMObjectPath> result;
1201
1202 for (Uint32 i = 0; i < _rep.size(); i++)
1203 {
1204 if (_rep[i].first != nameSpace)
1205 continue;
1206
1207 CIMInstance& ci = _rep[i].second;
1208
1209 if (ci.getPath().getClassName() == className)
1210 result.append(ci.getPath());
1211 }
1212
1213 return result;
1214 }
1215
1216 Array<CIMInstance> MemoryResidentRepository::execQuery(
1217 bool lock,
1218 const String& queryLanguage,
1219 const String& query)
1220 {
|
1221 mike 1.1.2.5 Throw((CIM_ERR_NOT_SUPPORTED, "execQuery()"));
|
1222 mike 1.1.2.1 return Array<CIMInstance>();
1223 }
1224
1225 Array<CIMObject> MemoryResidentRepository::associators(
1226 bool lock,
1227 const CIMNamespaceName& nameSpace,
1228 const CIMObjectPath& objectName,
1229 const CIMName& assocClass,
1230 const CIMName& resultClass,
1231 const String& role,
1232 const String& resultRole,
1233 Boolean includeQualifiers,
1234 Boolean includeClassOrigin,
1235 const CIMPropertyList& propertyList)
1236 {
1237 if (objectName.getKeyBindings().size() == 0)
1238 {
|
1239 mike 1.1.2.6 return _associatorClasses(
|
1240 mike 1.1.2.1 nameSpace,
1241 objectName.getClassName(),
1242 assocClass,
1243 resultClass,
1244 role,
1245 resultRole,
1246 includeQualifiers,
1247 includeClassOrigin,
1248 propertyList);
1249 }
1250 else
1251 {
|
1252 mike 1.1.2.5 Throw((CIM_ERR_NOT_SUPPORTED, "associators()"));
|
1253 mike 1.1.2.1 return Array<CIMObject>();
1254 }
1255 }
1256
1257 Array<CIMObjectPath> MemoryResidentRepository::associatorNames(
1258 bool lock,
1259 const CIMNamespaceName& nameSpace,
1260 const CIMObjectPath& objectName,
1261 const CIMName& assocClass,
1262 const CIMName& resultClass,
1263 const String& role,
1264 const String& resultRole)
1265 {
1266 if (objectName.getKeyBindings().size() == 0)
1267 {
|
1268 mike 1.1.2.6 return _associatorClassPaths(
|
1269 mike 1.1.2.1 nameSpace,
1270 objectName.getClassName(),
1271 assocClass,
1272 resultClass,
1273 role,
1274 resultRole);
1275 }
1276 else
1277 {
|
1278 mike 1.1.2.5 Throw((CIM_ERR_NOT_SUPPORTED, "associatorNames()"));
|
1279 mike 1.1.2.1 return Array<CIMObjectPath>();
1280 }
1281 }
1282
1283 Array<CIMObject> MemoryResidentRepository::references(
1284 bool lock,
1285 const CIMNamespaceName& nameSpace,
1286 const CIMObjectPath& objectName,
1287 const CIMName& resultClass,
1288 const String& role,
1289 Boolean includeQualifiers,
1290 Boolean includeClassOrigin,
1291 const CIMPropertyList& propertyList)
1292 {
1293 if (objectName.getKeyBindings().size() == 0)
1294 {
|
1295 mike 1.1.2.6 return _referenceClasses(
|
1296 mike 1.1.2.1 nameSpace,
1297 objectName.getClassName(),
1298 resultClass,
1299 role,
1300 includeQualifiers,
1301 includeClassOrigin,
1302 propertyList);
1303 }
1304 else
1305 {
|
1306 mike 1.1.2.5 Throw((CIM_ERR_NOT_SUPPORTED, "references()"));
|
1307 mike 1.1.2.1 return Array<CIMObject>();
1308 }
1309 }
1310
1311 Array<CIMObjectPath> MemoryResidentRepository::referenceNames(
1312 bool lock,
1313 const CIMNamespaceName& nameSpace,
1314 const CIMObjectPath& objectName,
1315 const CIMName& resultClass,
1316 const String& role)
1317 {
1318 if (objectName.getKeyBindings().size() == 0)
1319 {
|
1320 mike 1.1.2.6 return _referenceClassPaths(
|
1321 mike 1.1.2.1 nameSpace,
1322 objectName.getClassName(),
1323 resultClass,
1324 role);
1325 }
1326 else
1327 {
|
1328 mike 1.1.2.5 Throw((CIM_ERR_NOT_SUPPORTED, "referenceNames()"));
|
1329 mike 1.1.2.1 return Array<CIMObjectPath>();
1330 }
1331 }
1332
1333 CIMValue MemoryResidentRepository::getProperty(
1334 bool lock,
1335 const CIMNamespaceName& nameSpace,
1336 const CIMObjectPath& instanceName,
1337 const CIMName& propertyName)
1338 {
|
1339 mike 1.1.2.5 Throw((CIM_ERR_NOT_SUPPORTED, "getProperty()"));
|
1340 mike 1.1.2.1 return CIMValue();
1341 }
1342
1343 void MemoryResidentRepository::setProperty(
1344 bool lock,
1345 const CIMNamespaceName& nameSpace,
1346 const CIMObjectPath& instanceName,
1347 const CIMName& propertyName,
1348 const CIMValue& newValue,
1349 const ContentLanguageList& contentLangs)
1350 {
|
1351 mike 1.1.2.5 Throw((CIM_ERR_NOT_SUPPORTED, "setProperty()"));
|
1352 mike 1.1.2.1 }
1353
1354 CIMQualifierDecl MemoryResidentRepository::getQualifier(
1355 bool lock,
1356 const CIMNamespaceName& nameSpace,
1357 const CIMName& qualifierName)
1358 {
|
1359 mike 1.1.2.6 return _getQualifier(nameSpace, qualifierName);
|
1360 mike 1.1.2.1 }
1361
1362 void MemoryResidentRepository::setQualifier(
1363 bool lock,
1364 const CIMNamespaceName& nameSpace,
1365 const CIMQualifierDecl& qualifierDecl,
1366 const ContentLanguageList& contentLangs)
1367 {
|
1368 mike 1.1.2.6 Throw((CIM_ERR_NOT_SUPPORTED, "setQualifier()"));
|
1369 mike 1.1.2.1 }
1370
1371 void MemoryResidentRepository::deleteQualifier(
1372 bool lock,
1373 const CIMNamespaceName& nameSpace,
1374 const CIMName& qualifierName)
1375 {
|
1376 mike 1.1.2.6 Throw((CIM_ERR_NOT_SUPPORTED, "deleteQualifier()"));
|
1377 mike 1.1.2.1 }
1378
1379 Array<CIMQualifierDecl> MemoryResidentRepository::enumerateQualifiers(
1380 bool lock,
1381 const CIMNamespaceName& nameSpace)
1382 {
|
1383 mike 1.1.2.6 return _enumerateQualifiers(nameSpace);
|
1384 mike 1.1.2.1 }
1385
1386 void MemoryResidentRepository::createNameSpace(
1387 bool lock,
1388 const CIMNamespaceName& nameSpace,
1389 const NameSpaceAttributes& attributes)
1390 {
|
1391 mike 1.1.2.6 Throw((CIM_ERR_NOT_SUPPORTED, "createNameSpace()"));
|
1392 mike 1.1.2.1 }
1393
1394 void MemoryResidentRepository::modifyNameSpace(
1395 bool lock,
1396 const CIMNamespaceName& nameSpace,
1397 const NameSpaceAttributes& attributes)
1398 {
|
1399 mike 1.1.2.6 Throw((CIM_ERR_NOT_SUPPORTED, "modifyNameSpace()"));
|
1400 mike 1.1.2.1 }
1401
1402 Array<CIMNamespaceName> MemoryResidentRepository::enumerateNameSpaces(
1403 bool lock) const
1404 {
|
1405 mike 1.1.2.6 return _enumerateNameSpaces();
|
1406 mike 1.1.2.1 }
1407
1408 void MemoryResidentRepository::deleteNameSpace(
1409 bool lock,
1410 const CIMNamespaceName& nameSpace)
1411 {
|
1412 mike 1.1.2.6 Throw((CIM_ERR_NOT_SUPPORTED, "deleteNameSpace()"));
|
1413 mike 1.1.2.1 }
1414
1415 Boolean MemoryResidentRepository::getNameSpaceAttributes(
1416 bool lock,
1417 const CIMNamespaceName& nameSpace,
1418 NameSpaceAttributes& attributes)
1419 {
1420 attributes.clear();
1421 return false;
1422 }
1423
1424 void MemoryResidentRepository::setDeclContext(
1425 bool lock,
1426 RepositoryDeclContext* context)
1427 {
|
1428 mike 1.1.2.5 Throw((CIM_ERR_NOT_SUPPORTED, "setDeclContext()"));
|
1429 mike 1.1.2.1 }
1430
1431 Boolean MemoryResidentRepository::isDefaultInstanceProvider(
1432 bool lock)
1433 {
1434 return true;
1435 }
1436
1437 void MemoryResidentRepository::getSubClassNames(
1438 bool lock,
1439 const CIMNamespaceName& nameSpace,
1440 const CIMName& className,
1441 Boolean deepInheritance,
1442 Array<CIMName>& subClassNames) const
1443 {
|
1444 mike 1.1.2.6 _getSubClassNames(nameSpace, className, deepInheritance, subClassNames);
|
1445 mike 1.1.2.1 }
1446
1447 void MemoryResidentRepository::getSuperClassNames(
1448 bool lock,
1449 const CIMNamespaceName& nameSpace,
1450 const CIMName& className,
1451 Array<CIMName>& superClassNames) const
1452 {
|
1453 mike 1.1.2.6 _getSuperClassNames(nameSpace, className, superClassNames);
|
1454 mike 1.1.2.1 }
1455
1456 Boolean MemoryResidentRepository::isRemoteNameSpace(
1457 bool lock,
1458 const CIMNamespaceName& nameSpace,
1459 String& remoteInfo)
1460 {
1461 return false;
1462 }
1463
1464 #ifdef PEGASUS_DEBUG
1465 void MemoryResidentRepository::DisplayCacheStatistics(
1466 bool lock)
1467 {
1468 }
1469 #endif
1470
1471 Uint32 MemoryResidentRepository::_findInstance(
1472 const CIMNamespaceName& nameSpace,
1473 const CIMObjectPath& instanceName)
1474 {
1475 mike 1.1.2.1 for (Uint32 i = 0; i < _rep.size(); i++)
1476 {
1477 if (_rep[i].first == nameSpace &&
1478 _rep[i].second.getPath() == instanceName)
1479 {
1480 return i;
1481 }
1482 }
1483
1484 return PEG_NOT_FOUND;
1485 }
1486
|
1487 mike 1.1.2.4 void MemoryResidentRepository::installSaveCallback(
1488 void (*handler)(const Buffer& buffer, void* data),
1489 void * data)
|
1490 mike 1.1.2.3 {
|
1491 mike 1.1.2.4 _saveCallback = handler;
1492 _saveData = data;
|
1493 mike 1.1.2.3 }
1494
|
1495 mike 1.1.2.4 void MemoryResidentRepository::installLoadCallback(
1496 void (*handler)(Buffer& buffer, void* data),
1497 void * data)
|
1498 mike 1.1.2.3 {
|
1499 mike 1.1.2.4 _loadCallback = handler;
1500 _loadData = data;
|
1501 mike 1.1.2.3 }
1502
1503 void MemoryResidentRepository::_processSaveHandler()
1504 {
|
1505 mike 1.1.2.4 if (!_saveCallback)
|
1506 mike 1.1.2.3 return;
1507
1508 Buffer out;
1509
1510 for (Uint32 i = 0; i < _rep.size(); i++)
1511 {
1512 SerializeNameSpace(out, _rep[i].first);
1513 SerializeInstance(out, _rep[i].second);
1514 }
1515
|
1516 mike 1.1.2.4 (*_saveCallback)(out, _saveData);
|
1517 mike 1.1.2.3 }
1518
1519 void MemoryResidentRepository::_processLoadHandler()
1520 {
|
1521 mike 1.1.2.4 if (!_loadCallback)
|
1522 mike 1.1.2.3 return;
1523
1524 Buffer in;
|
1525 mike 1.1.2.4 (*_loadCallback)(in, _loadData);
|
1526 mike 1.1.2.3 size_t pos = 0;
1527
1528 while (pos != in.size())
1529 {
1530 CIMNamespaceName nameSpace;
1531
1532 if (DeserializeNameSpace(in, pos, nameSpace) != 0)
1533 return;
1534
1535 CIMInstance cimInstance;
1536
1537 if (DeserializeInstance(in, pos, cimInstance) != 0)
1538 return;
1539
1540 _rep.append(NamespaceInstancePair(nameSpace, cimInstance));
1541 }
1542 }
1543
|
1544 mike 1.1.2.7 Boolean MemoryResidentRepository::addNameSpace(const SchemaNameSpace* nameSpace)
|
1545 mike 1.1.2.6 {
1546 if (!nameSpace)
1547 return false;
1548
1549 if (_nameSpaceTableSize == _MAX_NAMESPACE_TABLE_SIZE)
1550 return false;
1551
1552 if (_findNameSpace(nameSpace->name))
1553 return false;
1554
1555 _nameSpaceTable[_nameSpaceTableSize++] = nameSpace;
1556
1557 return true;
1558 }
1559
|
1560 mike 1.1.2.1 PEGASUS_NAMESPACE_END
|
Return to
MemoryResidentRepository.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Repository