1 karl  1.43 //%2006////////////////////////////////////////////////////////////////////////

  2 chip  1.1  //

  3 karl  1.41 // 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 karl  1.31 // IBM Corp.; EMC Corporation, The Open Group.

  7 karl  1.41 // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
  8            // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.

  9 karl  1.42 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
 10            // EMC Corporation; VERITAS Software Corporation; The Open Group.

 11 karl  1.43 // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
 12            // EMC Corporation; Symantec Corporation; The Open Group.

 13 chip  1.1  //
 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 karl  1.31 // 

 21 chip  1.1  // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
 22            // 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 mday  1.23 

 35 chip  1.1  #ifndef Pegasus_CIMOMHandle_h
 36            #define Pegasus_CIMOMHandle_h
 37            
 38            #include <Pegasus/Common/Config.h>
 39            #include <Pegasus/Common/OperationContext.h>
 40            #include <Pegasus/Common/CIMObject.h>

 41 chip  1.6  #include <Pegasus/Common/CIMObjectPath.h>

 42 chip  1.3  #include <Pegasus/Common/CIMClass.h>
 43            #include <Pegasus/Common/CIMInstance.h>

 44 chip  1.1  #include <Pegasus/Common/CIMPropertyList.h>

 45 mday  1.23 #include <Pegasus/Common/ResponseHandler.h>

 46 chuck 1.26 #include <Pegasus/Provider/Linkage.h>

 47 chip  1.6  

 48 kumpf 1.22 PEGASUS_NAMESPACE_BEGIN

 49 chip  1.1  

 50 kumpf 1.39 class CIMOMHandleRep;

 51 mday  1.23 

 52 chip  1.6  class PEGASUS_PROVIDER_LINKAGE CIMOMHandle

 53 chip  1.1  {

 54 kumpf 1.46 public:

 55 mday  1.23 

 56 kumpf 1.46     /** */
 57                CIMOMHandle();

 58 chuck 1.35 

 59 kumpf 1.46     CIMOMHandle(const CIMOMHandle&);

 60 mday  1.23 

 61 kumpf 1.46     /** */
 62                ~CIMOMHandle();

 63 mday  1.23 

 64 kumpf 1.46     CIMOMHandle& operator=(const CIMOMHandle& handle);

 65 mday  1.23       

 66 kumpf 1.46     CIMClass getClass(
 67                    const OperationContext& context,
 68                    const CIMNamespaceName& nameSpace,
 69                    const CIMName& className,
 70                    Boolean localOnly,
 71                    Boolean includeQualifiers,
 72                    Boolean includeClassOrigin,
 73                    const CIMPropertyList& propertyList);
 74            
 75                Array<CIMClass> enumerateClasses(
 76                    const OperationContext& context,
 77                    const CIMNamespaceName& nameSpace,
 78                    const CIMName& className,
 79                    Boolean deepInheritance,
 80                    Boolean localOnly,
 81                    Boolean includeQualifiers,
 82                    Boolean includeClassOrigin);
 83            
 84                Array<CIMName> enumerateClassNames(
 85                    const OperationContext& context,
 86                    const CIMNamespaceName& nameSpace,
 87 kumpf 1.46         const CIMName& className,
 88                    Boolean deepInheritance);
 89            
 90                void createClass(
 91                    const OperationContext& context,
 92                    const CIMNamespaceName& nameSpace,
 93                    const CIMClass& newClass);
 94            
 95                void modifyClass(
 96                    const OperationContext& context,
 97                    const CIMNamespaceName& nameSpace,
 98                    const CIMClass& modifiedClass);
 99            
100                void deleteClass(
101                    const OperationContext& context,
102                    const CIMNamespaceName& nameSpace,
103                    const CIMName& className);
104            
105                CIMInstance getInstance(
106                    const OperationContext& context,
107                    const CIMNamespaceName& nameSpace,
108 kumpf 1.46         const CIMObjectPath& instanceName,
109                    Boolean localOnly,
110                    Boolean includeQualifiers,
111                    Boolean includeClassOrigin,
112                    const CIMPropertyList& propertyList);
113            
114                Array<CIMInstance> enumerateInstances(
115                    const OperationContext& context,
116                    const CIMNamespaceName& nameSpace,
117                    const CIMName& className,
118                    Boolean deepInheritance,
119                    Boolean localOnly,
120                    Boolean includeQualifiers,
121                    Boolean includeClassOrigin,
122                    const CIMPropertyList& propertyList);
123            
124                Array<CIMObjectPath> enumerateInstanceNames(
125                    const OperationContext& context,
126                    const CIMNamespaceName& nameSpace,
127                    const CIMName& className);
128            
129 kumpf 1.46     CIMObjectPath createInstance(
130                    const OperationContext& context,
131                    const CIMNamespaceName& nameSpace,
132                    const CIMInstance& newInstance);
133            
134                void modifyInstance(
135                    const OperationContext& context,
136                    const CIMNamespaceName& nameSpace,
137                    const CIMInstance& modifiedInstance,
138                    Boolean includeQualifiers,
139                    const CIMPropertyList& propertyList);
140            
141                void deleteInstance(
142                    const OperationContext& context,
143                    const CIMNamespaceName& nameSpace,
144                    const CIMObjectPath& instanceName);
145            
146                Array<CIMObject> execQuery(
147                    const OperationContext& context,
148                    const CIMNamespaceName& nameSpace,
149                    const String& queryLanguage,
150 kumpf 1.46         const String& query);
151            
152                Array<CIMObject> associators(
153                    const OperationContext& context,
154                    const CIMNamespaceName& nameSpace,
155                    const CIMObjectPath& objectName,
156                    const CIMName& assocClass,
157                    const CIMName& resultClass,
158                    const String& role,
159                    const String& resultRole,
160                    Boolean includeQualifiers,
161                    Boolean includeClassOrigin,
162                    const CIMPropertyList& propertyList);
163            
164                Array<CIMObjectPath> associatorNames(
165                    const OperationContext& context,
166                    const CIMNamespaceName& nameSpace,
167                    const CIMObjectPath& objectName,
168                    const CIMName& assocClass,
169                    const CIMName& resultClass,
170                    const String& role,
171 kumpf 1.46         const String& resultRole);
172            
173                Array<CIMObject> references(
174                    const OperationContext& context,
175                    const CIMNamespaceName& nameSpace,
176                    const CIMObjectPath& objectName,
177                    const CIMName& resultClass,
178                    const String& role,
179                    Boolean includeQualifiers,
180                    Boolean includeClassOrigin,
181                    const CIMPropertyList& propertyList);
182            
183                Array<CIMObjectPath> referenceNames(
184                    const OperationContext& context,
185                    const CIMNamespaceName& nameSpace,
186                    const CIMObjectPath& objectName,
187                    const CIMName& resultClass,
188                    const String& role);
189            
190                // property operations
191                CIMValue getProperty(
192 kumpf 1.46         const OperationContext& context,
193                    const CIMNamespaceName& nameSpace,
194                    const CIMObjectPath& instanceName,
195                    const CIMName& propertyName);
196            
197                void setProperty(
198                    const OperationContext& context,
199                    const CIMNamespaceName& nameSpace,
200                    const CIMObjectPath& instanceName,
201                    const CIMName& propertyName,
202                    const CIMValue& newValue);
203            
204                CIMValue invokeMethod(
205                    const OperationContext& context,
206                    const CIMNamespaceName& nameSpace,
207                    const CIMObjectPath& instanceName,
208                    const CIMName& methodName,
209                    const Array<CIMParamValue>& inParameters,
210                    Array<CIMParamValue>& outParameters);
211            
212                /**
213 kumpf 1.46         Provides a hint to the CIM Server that the provider calling this
214                    method prefers not to be unloaded.  This hint applies in
215                    situations where a provider unload is not necessary, such as
216                    when the CIM Server unloads idle providers for efficiency reasons.
217                    A provider may rescind this hint by using the allowProviderUnload
218                    method.  Note that disallowProviderUnload is cumulative, such that
219                    each call to disallowProviderUnload must be matched with a call to
220                    allowProviderUnload.
221                 */
222                void disallowProviderUnload();
223            
224                /**
225                    Provides a hint to the CIM Server that the provider calling this
226                    method no longer prefers not to be unloaded.  This hint applies in
227                    situations where a provider unload is not necessary, such as
228                    when the CIM Server unloads idle providers for efficiency reasons.
229                    This method is used to rescind a hint that was given using the
230                    disallowProviderUnload method.  Note that each allowProviderUnload
231                    call should be preceded by a disallowProviderUnload call.
232                 */
233                void allowProviderUnload();

234 kumpf 1.27 

235 chuck 1.38 #ifdef PEGASUS_USE_EXPERIMENTAL_INTERFACES

236 kumpf 1.46     /**
237                   Returns the context of the response to the last request.
238                   Currently, the context only contains the ContentLanguageListContainer
239                   from the response.
240                   Note: this method should be called directly after the call to the
241                   CIM request method (getClass, etc), and can only be called once
242                   per request.
243                 */
244                OperationContext getResponseContext();

245 chuck 1.38 #endif
246            

247 kumpf 1.46 private:      
248                CIMOMHandleRep* _rep;

249 mday  1.24 

250 kumpf 1.46     friend class ProviderStatus;
251                friend class CMPIProvider;

252 ouyang.jian 1.47     

253 kumpf       1.46     Boolean unload_ok();

254 chip        1.1  };
255                  
256                  PEGASUS_NAMESPACE_END
257                  
258                  #endif