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               #ifndef Pegasus_Repository_MemoryResidentRepository
 35               #define Pegasus_Repository_MemoryResidentRepository
 36               
 37               #include <Pegasus/Common/Config.h>
 38               #include <Pegasus/Repository/Repository.h>
 39               #include <Pegasus/Common/Pair.h>
 40               
 41               PEGASUS_NAMESPACE_BEGIN
 42               
 43 mike  1.1.2.1 typedef Pair<CIMNamespaceName, CIMInstance> NamespaceInstancePair;
 44               
 45               #define PEGASUS_ARRAY_T NamespaceInstancePair
 46               # include <Pegasus/Common/ArrayInter.h>
 47               #undef PEGASUS_ARRAY_T
 48               
 49               class RepositoryDeclContext;
 50               class compilerDeclContext;
 51               
 52               /** Virtual base class for CIMRepository implementations.
 53               */
 54               class MemoryResidentRepository : public Repository
 55               {
 56               public:
 57               
 58                   MemoryResidentRepository(
 59                       const String& repositoryRoot, 
 60                       Uint32 repositoryMode);
 61               
 62                   virtual ~MemoryResidentRepository();
 63               
 64 mike  1.1.2.1     virtual CIMClass getClass(
 65                       bool lock,
 66                       const CIMNamespaceName& nameSpace,
 67                       const CIMName& className,
 68                       Boolean localOnly,
 69                       Boolean includeQualifiers,
 70                       Boolean includeClassOrigin,
 71                       const CIMPropertyList& propertyList);
 72               
 73                   virtual CIMInstance getInstance(
 74                       bool lock,
 75                       const CIMNamespaceName& nameSpace,
 76                       const CIMObjectPath& instanceName,
 77                       Boolean localOnly,
 78                       Boolean includeQualifiers,
 79                       Boolean includeClassOrigin,
 80                       const CIMPropertyList& propertyList);
 81               
 82                   virtual void deleteClass(
 83                       bool lock,
 84                       const CIMNamespaceName& nameSpace,
 85 mike  1.1.2.1         const CIMName& className);
 86               
 87                   virtual void deleteInstance(
 88                       bool lock,
 89                       const CIMNamespaceName& nameSpace,
 90                       const CIMObjectPath& instanceName);
 91               
 92                   virtual void createClass(
 93                       bool lock,
 94                       const CIMNamespaceName& nameSpace,
 95                       const CIMClass& newClass,
 96                       const ContentLanguageList& contentLangs);
 97               
 98                   virtual CIMObjectPath createInstance(
 99                       bool lock,
100                       const CIMNamespaceName& nameSpace,
101                       const CIMInstance& newInstance,
102                       const ContentLanguageList& contentLangs);
103               
104                   virtual void modifyClass(
105                       bool lock,
106 mike  1.1.2.1         const CIMNamespaceName& nameSpace,
107                       const CIMClass& modifiedClass,
108                       const ContentLanguageList& contentLangs);
109               
110                   virtual void modifyInstance(
111                       bool lock,
112                       const CIMNamespaceName& nameSpace,
113                       const CIMInstance& modifiedInstance,
114                       Boolean includeQualifiers,
115                       const CIMPropertyList& propertyList,
116                       const ContentLanguageList& contentLangs);
117               
118                   virtual Array<CIMClass> enumerateClasses(
119                       bool lock,
120                       const CIMNamespaceName& nameSpace,
121                       const CIMName& className,
122                       Boolean deepInheritance,
123                       Boolean localOnly,
124                       Boolean includeQualifiers,
125                       Boolean includeClassOrigin);
126               
127 mike  1.1.2.1     virtual Array<CIMName> enumerateClassNames(
128                       bool lock,
129                       const CIMNamespaceName& nameSpace,
130                       const CIMName& className,
131                       Boolean deepInheritance);
132               
133                   virtual Array<CIMInstance> enumerateInstancesForSubtree(
134                       bool lock,
135                       const CIMNamespaceName& nameSpace,
136                       const CIMName& className,
137                       Boolean deepInheritance,
138                       Boolean localOnly,
139                       Boolean includeQualifiers,
140                       Boolean includeClassOrigin,
141                       const CIMPropertyList& propertyList);
142               
143                   virtual Array<CIMInstance> enumerateInstancesForClass(
144                       bool lock,
145                       const CIMNamespaceName& nameSpace,
146                       const CIMName& className,
147                       Boolean localOnly,
148 mike  1.1.2.1         Boolean includeQualifiers,
149                       Boolean includeClassOrigin,
150                       const CIMPropertyList& propertyList);
151               
152                   virtual Array<CIMObjectPath> enumerateInstanceNamesForSubtree(
153                       bool lock,
154                       const CIMNamespaceName& nameSpace,
155                       const CIMName& className);
156               
157                   virtual Array<CIMObjectPath> enumerateInstanceNamesForClass(
158                       bool lock,
159                       const CIMNamespaceName& nameSpace,
160                       const CIMName& className);
161               
162                   virtual Array<CIMInstance> execQuery(
163                       bool lock,
164                       const String& queryLanguage,
165                       const String& query);
166               
167                   virtual Array<CIMObject> associators(
168                       bool lock,
169 mike  1.1.2.1         const CIMNamespaceName& nameSpace,
170                       const CIMObjectPath& objectName,
171                       const CIMName& assocClass,
172                       const CIMName& resultClass,
173                       const String& role,
174                       const String& resultRole,
175                       Boolean includeQualifiers,
176                       Boolean includeClassOrigin,
177                       const CIMPropertyList& propertyList);
178               
179                   virtual Array<CIMObjectPath> associatorNames(
180                       bool lock,
181                       const CIMNamespaceName& nameSpace,
182                       const CIMObjectPath& objectName,
183                       const CIMName& assocClass,
184                       const CIMName& resultClass,
185                       const String& role,
186                       const String& resultRole);
187               
188                   virtual Array<CIMObject> references(
189                       bool lock,
190 mike  1.1.2.1         const CIMNamespaceName& nameSpace,
191                       const CIMObjectPath& objectName,
192                       const CIMName& resultClass,
193                       const String& role,
194                       Boolean includeQualifiers,
195                       Boolean includeClassOrigin,
196                       const CIMPropertyList& propertyList);
197               
198                   virtual Array<CIMObjectPath> referenceNames(
199                       bool lock,
200                       const CIMNamespaceName& nameSpace,
201                       const CIMObjectPath& objectName,
202                       const CIMName& resultClass,
203                       const String& role);
204               
205                   virtual CIMValue getProperty(
206                       bool lock,
207                       const CIMNamespaceName& nameSpace,
208                       const CIMObjectPath& instanceName,
209                       const CIMName& propertyName);
210               
211 mike  1.1.2.1     virtual void setProperty(
212                       bool lock,
213                       const CIMNamespaceName& nameSpace,
214                       const CIMObjectPath& instanceName,
215                       const CIMName& propertyName,
216                       const CIMValue& newValue,
217                       const ContentLanguageList& contentLangs);
218               
219                   virtual CIMQualifierDecl getQualifier(
220                       bool lock,
221                       const CIMNamespaceName& nameSpace,
222                       const CIMName& qualifierName);
223               
224                   virtual void setQualifier(
225                       bool lock,
226                       const CIMNamespaceName& nameSpace,
227                       const CIMQualifierDecl& qualifierDecl,
228                       const ContentLanguageList& contentLangs);
229               
230                   virtual void deleteQualifier(
231                       bool lock,
232 mike  1.1.2.1         const CIMNamespaceName& nameSpace,
233                       const CIMName& qualifierName);
234               
235                   virtual Array<CIMQualifierDecl> enumerateQualifiers(
236                       bool lock,
237                       const CIMNamespaceName& nameSpace);
238               
239                   virtual void createNameSpace(
240                       bool lock,
241                       const CIMNamespaceName& nameSpace,
242                       const NameSpaceAttributes& attributes);
243               
244                   virtual void modifyNameSpace(
245                       bool lock,
246                       const CIMNamespaceName& nameSpace,
247                       const NameSpaceAttributes& attributes);
248               
249                   virtual Array<CIMNamespaceName> enumerateNameSpaces(
250                       bool lock) const;
251               
252                   virtual void deleteNameSpace(
253 mike  1.1.2.1         bool lock,
254                       const CIMNamespaceName& nameSpace);
255               
256                   virtual Boolean getNameSpaceAttributes(
257                       bool lock,
258                       const CIMNamespaceName& nameSpace,
259                       NameSpaceAttributes& attributes);
260               
261                   virtual void setDeclContext(
262                       bool lock,
263                       RepositoryDeclContext* context);
264               
265                   virtual Boolean isDefaultInstanceProvider(
266                       bool lock);
267               
268                   virtual void getSubClassNames(
269                       bool lock,
270                       const CIMNamespaceName& nameSpace,
271                       const CIMName& className,
272                       Boolean deepInheritance,
273                       Array<CIMName>& subClassNames) const;
274 mike  1.1.2.1 
275                   virtual void getSuperClassNames(
276                       bool lock,
277                       const CIMNamespaceName& nameSpace,
278                       const CIMName& className,
279                       Array<CIMName>& superClassNames) const;
280               
281                   virtual Boolean isRemoteNameSpace(
282                       bool lock,
283                       const CIMNamespaceName& nameSpace,
284                       String& remoteInfo);
285               
286               #ifdef PEGASUS_DEBUG
287                   virtual void DisplayCacheStatistics(
288                       bool lock);
289               #endif
290               
291               private:
292               
293                   Uint32 _findInstance(
294                       const CIMNamespaceName& nameSpace,
295 mike  1.1.2.1         const CIMObjectPath& instanceName);
296               
297                   Array<NamespaceInstancePair> _rep;
298               };
299               
300               PEGASUS_NAMESPACE_END
301               
302               #endif /* Pegasus_Repository_MemoryResidentRepository */