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