1 karl  1.5 //%2006////////////////////////////////////////////////////////////////////////

  2 kumpf 1.1 //

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

  7 karl  1.2 // 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.3 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
 10           // EMC Corporation; VERITAS Software Corporation; The Open Group.

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

 13 kumpf 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.5 // 

 21 kumpf 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           #include <Pegasus/Common/Config.h>

 35 chip  1.4 #include <Pegasus/Common/CIMMessage.h>

 36 kumpf 1.1 #include <Pegasus/Common/OperationContext.h>

 37 mike  1.6 #include <Pegasus/Common/AsyncQueue.h>

 38 kumpf 1.1 #include <Pegasus/Common/MessageQueueService.h>
 39           
 40           #include "CIMOMHandleRep.h"
 41           
 42           PEGASUS_NAMESPACE_BEGIN
 43           

 44 chip  1.4 class InternalCIMOMHandleMessageQueue : public MessageQueue
 45           {
 46           public:
 47               InternalCIMOMHandleMessageQueue();
 48               virtual ~InternalCIMOMHandleMessageQueue();
 49           
 50               virtual void handleEnqueue();
 51           
 52               CIMResponseMessage * sendRequest(CIMRequestMessage * request);
 53           
 54           private:
 55               Uint32 _output_qid;
 56               Uint32 _return_qid;
 57           
 58               Mutex _mutex;

 59 mike  1.6     AsyncQueue<Message> _response;

 60 chip  1.4 
 61           };
 62           

 63 kumpf 1.1 /**
 64               InternalCIMOMHandleRep is the default, in-process CIMOMHandle
 65               implementation.  The code was extracted from CIMOMHandle.cpp to allow
 66               for polymorphic CIMOMHandleRep implementations.
 67            */

 68 chip  1.4 class InternalCIMOMHandleRep : public CIMOMHandleRep

 69 kumpf 1.1 {
 70           public:
 71               InternalCIMOMHandleRep();
 72               virtual ~InternalCIMOMHandleRep();
 73           
 74               virtual CIMClass getClass(
 75                   const OperationContext & context,
 76                   const CIMNamespaceName& nameSpace,
 77                   const CIMName& className,
 78                   Boolean localOnly,
 79                   Boolean includeQualifiers,
 80                   Boolean includeClassOrigin,
 81                   const CIMPropertyList& propertyList);
 82           
 83               virtual Array<CIMClass> enumerateClasses(
 84                   const OperationContext & context,
 85                   const CIMNamespaceName& nameSpace,
 86                   const CIMName& className,
 87                   Boolean deepInheritance,
 88                   Boolean localOnly,
 89                   Boolean includeQualifiers,
 90 kumpf 1.1         Boolean includeClassOrigin);
 91           
 92               virtual Array<CIMName> enumerateClassNames(
 93                   const OperationContext & context,
 94                   const CIMNamespaceName& nameSpace,
 95                   const CIMName& className,
 96                   Boolean deepInheritance);
 97           
 98               virtual void createClass(
 99                   const OperationContext & context,
100                   const CIMNamespaceName& nameSpace,
101                   const CIMClass& newClass);
102           
103               virtual void modifyClass(
104                   const OperationContext & context,
105                   const CIMNamespaceName& nameSpace,
106                   const CIMClass& modifiedClass);
107           
108               virtual void deleteClass(
109                   const OperationContext & context,
110                   const CIMNamespaceName& nameSpace,
111 kumpf 1.1         const CIMName& className);
112           
113               virtual CIMInstance getInstance(
114                   const OperationContext & context,
115                   const CIMNamespaceName& nameSpace,
116                   const CIMObjectPath& instanceName,
117                   Boolean localOnly,
118                   Boolean includeQualifiers,
119                   Boolean includeClassOrigin,
120                   const CIMPropertyList& propertyList);
121           
122               virtual Array<CIMInstance> enumerateInstances(
123                   const OperationContext & context,
124                   const CIMNamespaceName& nameSpace,
125                   const CIMName& className,
126                   Boolean deepInheritance,
127                   Boolean localOnly,
128                   Boolean includeQualifiers,
129                   Boolean includeClassOrigin,
130                   const CIMPropertyList& propertyList);
131           
132 kumpf 1.1     virtual Array<CIMObjectPath> enumerateInstanceNames(
133                   const OperationContext & context,
134                   const CIMNamespaceName& nameSpace,
135                   const CIMName& className);
136           
137               virtual CIMObjectPath createInstance(
138                   const OperationContext & context,
139                   const CIMNamespaceName& nameSpace,
140                   const CIMInstance& newInstance);
141           
142               virtual void modifyInstance(
143                   const OperationContext & context,
144                   const CIMNamespaceName& nameSpace,
145                   const CIMInstance& modifiedInstance,
146                   Boolean includeQualifiers,
147                   const CIMPropertyList& propertyList);
148           
149               virtual void deleteInstance(
150                   const OperationContext & context,
151                   const CIMNamespaceName& nameSpace,
152                   const CIMObjectPath& instanceName);
153 kumpf 1.1 
154               virtual Array<CIMObject> execQuery(
155                   const OperationContext & context,
156                   const CIMNamespaceName& nameSpace,
157                   const String& queryLanguage,
158                   const String& query);
159           
160               virtual Array<CIMObject> associators(
161                   const OperationContext & context,
162                   const CIMNamespaceName& nameSpace,
163                   const CIMObjectPath& objectName,
164                   const CIMName& assocClass,
165                   const CIMName& resultClass,
166                   const String& role,
167                   const String& resultRole,
168                   Boolean includeQualifiers,
169                   Boolean includeClassOrigin,
170                   const CIMPropertyList& propertyList);
171           
172               virtual Array<CIMObjectPath> associatorNames(
173                   const OperationContext & context,
174 kumpf 1.1         const CIMNamespaceName& nameSpace,
175                   const CIMObjectPath& objectName,
176                   const CIMName& assocClass,
177                   const CIMName& resultClass,
178                   const String& role,
179                   const String& resultRole);
180           
181               virtual Array<CIMObject> references(
182                   const OperationContext & context,
183                   const CIMNamespaceName& nameSpace,
184                   const CIMObjectPath& objectName,
185                   const CIMName& resultClass,
186                   const String& role,
187                   Boolean includeQualifiers,
188                   Boolean includeClassOrigin,
189                   const CIMPropertyList& propertyList);
190           
191               virtual Array<CIMObjectPath> referenceNames(
192                   const OperationContext & context,
193                   const CIMNamespaceName& nameSpace,
194                   const CIMObjectPath& objectName,
195 kumpf 1.1         const CIMName& resultClass,
196                   const String& role);
197           
198               // property operations
199               virtual CIMValue getProperty(
200                   const OperationContext & context,
201                   const CIMNamespaceName& nameSpace,
202                   const CIMObjectPath& instanceName,
203                   const CIMName& propertyName);
204           
205               virtual void setProperty(
206                   const OperationContext & context,
207                   const CIMNamespaceName& nameSpace,
208                   const CIMObjectPath& instanceName,
209                   const CIMName& propertyName,
210                   const CIMValue& newValue);
211           
212               virtual CIMValue invokeMethod(
213                   const OperationContext & context,
214                   const CIMNamespaceName& nameSpace,
215                   const CIMObjectPath& instanceName,
216 kumpf 1.1         const CIMName& methodName,
217                   const Array<CIMParamValue>& inParameters,
218                   Array<CIMParamValue>& outParameters);
219           
220               virtual void disallowProviderUnload();  // Overload for OS/400
221               virtual void allowProviderUnload();  // Overload for OS/400
222               virtual OperationContext getResponseContext();
223           
224           private:
225               InternalCIMOMHandleRep(const InternalCIMOMHandleRep& rep);
226               InternalCIMOMHandleRep& operator=(const InternalCIMOMHandleRep& rep);
227           

228 chip  1.4     CIMResponseMessage* do_request(CIMRequestMessage* request);

229 kumpf 1.1 

230 chip  1.4 private:
231               InternalCIMOMHandleMessageQueue _queue;
232           

233 kumpf 1.1 };
234           
235           PEGASUS_NAMESPACE_END