1 karl  1.1 //BEGIN_LICENSE
  2           //
  3           // Copyright (c) 2000 The Open Group, BMC Software, Tivoli Systems, IBM
  4           //
  5           // Permission is hereby granted, free of charge, to any person obtaining a
  6           // copy of this software and associated documentation files (the "Software"),
  7           // to deal in the Software without restriction, including without limitation
  8           // the rights to use, copy, modify, merge, publish, distribute, sublicense,
  9           // and/or sell copies of the Software, and to permit persons to whom the
 10           // Software is furnished to do so, subject to the following conditions:
 11           //
 12           // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 13           // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 14           // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 15           // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 16           // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 17           // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 18           // DEALINGS IN THE SOFTWARE.
 19           //
 20           //END_LICENSE
 21           //BEGIN_HISTORY
 22 karl  1.1 //
 23           // Author:
 24           //

 25 mike  1.2 // $Log: Provider.cpp,v $

 26 mike  1.3 // Revision 1.2  2001/01/29 02:24:15  mike
 27           // Added support for GetInstance.
 28           //

 29 mike  1.2 // Revision 1.1  2001/01/20 22:29:24  karl
 30           // new provider interface class
 31           //

 32 karl  1.1 //
 33           //END_HISTORY
 34           
 35           #include "Provider.h"
 36           
 37           PEGASUS_NAMESPACE_BEGIN
 38           
 39           Provider::Provider()
 40           {
 41           
 42           }
 43           
 44           Provider::~Provider()
 45           {
 46           
 47           }
 48           
 49           ClassDecl Provider::getClass(
 50               const String& nameSpace,
 51               const String& className,
 52               Boolean localOnly,
 53 karl  1.1     Boolean includeQualifiers,
 54               Boolean includeClassOrigin,
 55               const Array<String>& propertyList)
 56           {
 57               throw CimException(CimException::NOT_SUPPORTED);
 58               return ClassDecl();
 59           }
 60           
 61           InstanceDecl Provider::getInstance(
 62               const String& nameSpace,
 63               const Reference& instanceName,
 64               Boolean localOnly,
 65               Boolean includeQualifiers,
 66               Boolean includeClassOrigin,
 67               const Array<String>& propertyList)
 68           {
 69               throw CimException(CimException::NOT_SUPPORTED);
 70               return InstanceDecl();
 71           }
 72           
 73           void Provider::deleteClass(
 74 karl  1.1     const String& nameSpace,
 75               const String& className)
 76           {
 77               throw CimException(CimException::NOT_SUPPORTED);
 78           }
 79           
 80           void Provider::deleteInstance(
 81               const String& nameSpace,
 82               const Reference& instanceName) 
 83           { 
 84               throw CimException(CimException::NOT_SUPPORTED);
 85           }
 86           
 87           void Provider::createClass(
 88               const String& nameSpace,
 89               ClassDecl& newClass) 
 90           {
 91               throw CimException(CimException::NOT_SUPPORTED);
 92           }
 93           
 94           void Provider::createInstance(
 95 karl  1.1     const String& nameSpace,
 96               const InstanceDecl& newInstance) 
 97           { 
 98               throw CimException(CimException::NOT_SUPPORTED);
 99           }
100           
101           void Provider::modifyClass(
102               const String& nameSpace,
103               ClassDecl& modifiedClass) 
104           {
105               throw CimException(CimException::NOT_SUPPORTED);
106           }
107           
108           void Provider::modifyInstance(
109               const String& nameSpace,
110               const InstanceDecl& modifiedInstance) 
111           {
112               throw CimException(CimException::NOT_SUPPORTED);
113           }
114           
115           Array<ClassDecl> Provider::enumerateClasses(
116 karl  1.1     const String& nameSpace,
117               const String& className,
118               Boolean deepInheritance,
119               Boolean localOnly,
120               Boolean includeQualifiers,
121               Boolean includeClassOrigin)
122           {
123               throw CimException(CimException::NOT_SUPPORTED);
124               return Array<ClassDecl>();
125           }
126           
127           Array<String> Provider::enumerateClassNames(
128               const String& nameSpace,
129               const String& className,
130               Boolean deepInheritance)
131           {
132               throw CimException(CimException::NOT_SUPPORTED);
133               return Array<String>();
134           }
135           
136           Array<InstanceDecl> Provider::enumerateInstances(
137 karl  1.1     const String& nameSpace,
138               const String& className,
139               Boolean deepInheritance,
140               Boolean localOnly,
141               Boolean includeQualifiers,
142               Boolean includeClassOrigin,
143               const Array<String>& propertyList)
144           {
145               throw CimException(CimException::NOT_SUPPORTED);
146               return Array<InstanceDecl>();
147           }
148           

149 mike  1.3 Array<Reference> Provider::enumerateInstanceNames(

150 karl  1.1     const String& nameSpace,
151               const String& className) 
152           { 
153               throw CimException(CimException::NOT_SUPPORTED);

154 mike  1.3     return Array<Reference>();

155 karl  1.1 }
156           
157           Array<InstanceDecl> Provider::execQuery(
158               const String& queryLanguage,
159               const String& query) 
160           { 
161               throw CimException(CimException::NOT_SUPPORTED);
162               return Array<InstanceDecl>();
163           }
164           
165           Array<InstanceDecl> Provider::associators(
166               const String& nameSpace,
167               const Reference& objectName,
168               const String& assocClass,
169               const String& resultClass,
170               const String& role,
171               const String& resultRole,
172               Boolean includeQualifiers,
173               Boolean includeClassOrigin,
174               const Array<String>& propertyList)
175           {
176 karl  1.1     throw CimException(CimException::NOT_SUPPORTED);
177               return Array<InstanceDecl>();
178           }
179           
180           Array<Reference> Provider::associatorNames(
181               const String& nameSpace,
182               const Reference& objectName,
183               const String& assocClass,
184               const String& resultClass,
185               const String& role,
186               const String& resultRole)
187           { 
188               throw CimException(CimException::NOT_SUPPORTED);
189               return Array<Reference>();
190           }
191           
192           Array<InstanceDecl> Provider::references(
193               const String& nameSpace,
194               const Reference& objectName,
195               const String& resultClass,
196               const String& role,
197 karl  1.1     Boolean includeQualifiers,
198               Boolean includeClassOrigin,
199               const Array<String>& propertyList)
200           {
201               throw CimException(CimException::NOT_SUPPORTED);
202               return Array<InstanceDecl>();
203           }
204           
205           Array<Reference> Provider::referenceNames(
206               const String& nameSpace,
207               const Reference& objectName,
208               const String& resultClass,
209               const String& role)
210           { 
211               throw CimException(CimException::NOT_SUPPORTED);
212               return Array<Reference>();
213           }
214           
215           Value Provider::getProperty(
216               const String& nameSpace,
217               const Reference& instanceName,
218 karl  1.1     const String& propertyName) 
219           { 
220               throw CimException(CimException::NOT_SUPPORTED);
221               return Value();
222           }
223           
224           void Provider::setProperty(
225               const String& nameSpace,
226               const Reference& instanceName,
227               const String& propertyName,
228               const Value& newValue)
229           { 
230               throw CimException(CimException::NOT_SUPPORTED);
231           }
232           
233           QualifierDecl Provider::getQualifier(
234               const String& nameSpace,
235               const String& qualifierName) 
236           {
237               throw CimException(CimException::NOT_SUPPORTED);
238               return QualifierDecl();
239 karl  1.1 }
240           
241           void Provider::setQualifier(
242               const String& nameSpace,
243               const QualifierDecl& qualifierDecl) 
244           {
245               throw CimException(CimException::NOT_SUPPORTED);
246           }
247           
248           void Provider::deleteQualifier(
249               const String& nameSpace,
250               const String& qualifierName) 
251           {
252               throw CimException(CimException::NOT_SUPPORTED);
253           }
254           
255           Array<QualifierDecl> Provider::enumerateQualifiers(
256               const String& nameSpace)
257           {
258               throw CimException(CimException::NOT_SUPPORTED);
259               return Array<QualifierDecl>();
260 karl  1.1 }
261           
262           Value Provider::invokeMethod(
263               const String& nameSpace,
264               const Reference& instanceName,
265               const String& methodName,
266               const Array<Value>& inParameters,
267               Array<Value>& outParameters) 
268           {
269               throw CimException(CimException::NOT_SUPPORTED);
270               return Value();

271 mike  1.2 }
272           
273           void Provider::initialize(Repository& repository)
274           {
275           

276 karl  1.1 }
277           
278           PEGASUS_NAMESPACE_END