(file) Return to CIMValue.h CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Common

   1 karl  1.49 //%2006////////////////////////////////////////////////////////////////////////
   2 mike  1.11 //
   3 karl  1.40 // 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.35 // IBM Corp.; EMC Corporation, The Open Group.
   7 karl  1.40 // 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.49 // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
  12            // EMC Corporation; Symantec Corporation; The Open Group.
  13 mike  1.11 //
  14            // Permission is hereby granted, free of charge, to any person obtaining a copy
  15 kumpf 1.25 // 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 mike  1.11 // 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 kumpf 1.25 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
  22 mike  1.11 // 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 kumpf 1.25 // 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 mike  1.11 // 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_Value_h
  35            #define Pegasus_Value_h
  36            
  37            #include <Pegasus/Common/String.h>
  38            #include <Pegasus/Common/Config.h>
  39            #include <Pegasus/Common/CIMType.h>
  40 kumpf 1.23 #include <Pegasus/Common/CIMObjectPath.h>
  41 dave.sudlik 1.41 #include <Pegasus/Common/CIMObject.h>
  42 mike        1.11 #include <Pegasus/Common/CIMDateTime.h>
  43 kumpf       1.18 #include <Pegasus/Common/Exception.h>
  44 mike        1.11 #include <Pegasus/Common/Array.h>
  45 kumpf       1.29 #include <Pegasus/Common/Linkage.h>
  46 mike        1.11 
  47                  PEGASUS_NAMESPACE_BEGIN
  48                  
  49 kumpf       1.18 class CIMValueRep;
  50 dave.sudlik 1.41 class CIMObject;
  51 a.dunfey    1.50 #ifdef PEGASUS_USE_EXPERIMENTAL_INTERFACES
  52                  #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
  53                  class CIMInstance;
  54                  #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
  55                  #endif // PEGASUS_USE_EXPERIMENTAL_INTERFACES
  56 kumpf       1.18 
  57 mike        1.11 /**
  58 kumpf       1.53     The CIMValue class represents a value of any of the CIM data types.
  59                      This class encapsulates a union which holds value of any CIMType.
  60                      A type field indicates the type of the value.
  61 mike        1.11 */
  62                  class PEGASUS_COMMON_LINKAGE CIMValue
  63                  {
  64                  public:
  65 kumpf       1.53     /**
  66                          Constructs a null CIMValue with type Boolean and isArray=false.
  67 karl        1.15     */
  68 mike        1.11     CIMValue();
  69                  
  70 kumpf       1.53     /**
  71                          Constructs a null CIMValue object with the specified type and
  72                          array indicator.
  73                          @param type The CIMType of the value
  74                          @param isArray A Boolean indicating whether the value is of array type
  75                          @param arraySize An integer specifying the size of the array, if the
  76                              CIMValue is for an array of a fixed size.  This value is ignored
  77                              if the isArray argument is false.
  78 karl        1.15     */
  79                      CIMValue(CIMType type, Boolean isArray, Uint32 arraySize = 0);
  80                  
  81 kumpf       1.53     /**
  82                          Constructs a CIMValue with the specified value and inferred type.
  83                          @param x The Boolean value to assign
  84                      */
  85 kumpf       1.18     CIMValue(Boolean x);
  86 mike        1.11 
  87 kumpf       1.53     /**
  88                          Constructs a CIMValue with the specified value and inferred type.
  89                          @param x The Uint8 value to assign
  90                      */
  91 kumpf       1.18     CIMValue(Uint8 x);
  92 mike        1.11 
  93 kumpf       1.53     /**
  94                          Constructs a CIMValue with the specified value and inferred type.
  95                          @param x The Sint8 value to assign
  96                      */
  97 kumpf       1.18     CIMValue(Sint8 x);
  98 mike        1.11 
  99 kumpf       1.53     /**
 100                          Constructs a CIMValue with the specified value and inferred type.
 101                          @param x The Uint16 value to assign
 102                      */
 103 kumpf       1.18     CIMValue(Uint16 x);
 104 mike        1.11 
 105 kumpf       1.53     /**
 106                          Constructs a CIMValue with the specified value and inferred type.
 107                          @param x The Sint16 value to assign
 108                      */
 109 kumpf       1.18     CIMValue(Sint16 x);
 110 mike        1.11 
 111 kumpf       1.53     /**
 112                          Constructs a CIMValue with the specified value and inferred type.
 113                          @param x The Uint32 value to assign
 114                      */
 115 kumpf       1.18     CIMValue(Uint32 x);
 116 mike        1.11 
 117 kumpf       1.53     /**
 118                          Constructs a CIMValue with the specified value and inferred type.
 119                          @param x The Sint32 value to assign
 120                      */
 121 kumpf       1.18     CIMValue(Sint32 x);
 122 mike        1.11 
 123 kumpf       1.53     /**
 124                          Constructs a CIMValue with the specified value and inferred type.
 125                          @param x The Uint64 value to assign
 126                      */
 127 kumpf       1.18     CIMValue(Uint64 x);
 128 mike        1.11 
 129 kumpf       1.53     /**
 130                          Constructs a CIMValue with the specified value and inferred type.
 131                          @param x The Sint64 value to assign
 132                      */
 133 kumpf       1.18     CIMValue(Sint64 x);
 134 mike        1.11 
 135 kumpf       1.53     /**
 136                          Constructs a CIMValue with the specified value and inferred type.
 137                          @param x The Real32 value to assign
 138                      */
 139 kumpf       1.18     CIMValue(Real32 x);
 140 mike        1.11 
 141 kumpf       1.53     /**
 142                          Constructs a CIMValue with the specified value and inferred type.
 143                          @param x The Real64 value to assign
 144                      */
 145 kumpf       1.18     CIMValue(Real64 x);
 146 mike        1.11 
 147 kumpf       1.53     /**
 148                          Constructs a CIMValue with the specified value and inferred type.
 149                          @param x The Char16 value to assign
 150                      */
 151 kumpf       1.18     CIMValue(const Char16& x);
 152 mike        1.11 
 153 kumpf       1.53     /**
 154                          Constructs a CIMValue with the specified value and inferred type.
 155                          @param x The String value to assign
 156                      */
 157 kumpf       1.18     CIMValue(const String& x);
 158 mike        1.11 
 159 kumpf       1.53     /**
 160                          Constructs a CIMValue with the specified value and inferred type.
 161                          @param x The CIMDateTime value to assign
 162                      */
 163 kumpf       1.18     CIMValue(const CIMDateTime& x);
 164 mike        1.11 
 165 kumpf       1.53     /**
 166                          Constructs a CIMValue with the specified value and inferred type.
 167                          @param x The CIMObjectPath value to assign
 168                      */
 169 kumpf       1.23     CIMValue(const CIMObjectPath& x);
 170 mike        1.11 
 171 kumpf       1.53     /**
 172                          Constructs a CIMValue with the specified value and inferred type.
 173                          Note: The CIMObject argument is cloned to prevent subsequent
 174                          modification through the shared representation model.
 175                          @param x The CIMObject value to assign
 176                          @exception UninitializedObjectException If the CIMObject is
 177                              uninitialized.
 178 denise.eckstein 1.46     */
 179 dave.sudlik     1.41     CIMValue(const CIMObject& x);
 180                      
 181 a.dunfey        1.50 #ifdef PEGASUS_USE_EXPERIMENTAL_INTERFACES
 182                      #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
 183 kumpf           1.53     /**
 184                              Constructs a CIMValue with the specified value and inferred type.
 185                              Note: The CIMInstance argument is cloned to prevent subsequent
 186                              modification through the shared representation model.
 187                              @param x The CIMInstance value to assign
 188                              @exception UninitializedObjectException If the CIMInstance is
 189                                  uninitialized.
 190                          */
 191 a.dunfey        1.50     CIMValue(const CIMInstance& x);
 192                      #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
 193                      #endif // PEGASUS_USE_EXPERIMENTAL_INTERFACES
 194                      
 195 kumpf           1.53     /**
 196                              Constructs a CIMValue with the specified value and inferred type.
 197                              @param x The Boolean Array value to assign
 198                          */
 199 kumpf           1.18     CIMValue(const Array<Boolean>& x);
 200 mike            1.11 
 201 kumpf           1.53     /**
 202                              Constructs a CIMValue with the specified value and inferred type.
 203                              @param x The Uint8 Array value to assign
 204                          */
 205 kumpf           1.18     CIMValue(const Array<Uint8>& x);
 206 mike            1.11 
 207 kumpf           1.53     /**
 208                              Constructs a CIMValue with the specified value and inferred type.
 209                              @param x The Sint8 Array value to assign
 210                          */
 211 kumpf           1.18     CIMValue(const Array<Sint8>& x);
 212 mike            1.11 
 213 kumpf           1.53     /**
 214                              Constructs a CIMValue with the specified value and inferred type.
 215                              @param x The Uint16 Array value to assign
 216                          */
 217 kumpf           1.18     CIMValue(const Array<Uint16>& x);
 218 mike            1.11 
 219 kumpf           1.53     /**
 220                              Constructs a CIMValue with the specified value and inferred type.
 221                              @param x The Sint16 Array value to assign
 222                          */
 223 kumpf           1.18     CIMValue(const Array<Sint16>& x);
 224 mike            1.11 
 225 kumpf           1.53     /**
 226                              Constructs a CIMValue with the specified value and inferred type.
 227                              @param x The Uint32 Array value to assign
 228                          */
 229 kumpf           1.18     CIMValue(const Array<Uint32>& x);
 230 mike            1.11 
 231 kumpf           1.53     /**
 232                              Constructs a CIMValue with the specified value and inferred type.
 233                              @param x The Sint32 Array value to assign
 234                          */
 235 kumpf           1.18     CIMValue(const Array<Sint32>& x);
 236 mike            1.11 
 237 kumpf           1.53     /**
 238                              Constructs a CIMValue with the specified value and inferred type.
 239                              @param x The Uint64 Array value to assign
 240                          */
 241 kumpf           1.18     CIMValue(const Array<Uint64>& x);
 242 mike            1.11 
 243 kumpf           1.53     /**
 244                              Constructs a CIMValue with the specified value and inferred type.
 245                              @param x The Sint64 Array value to assign
 246                          */
 247 kumpf           1.18     CIMValue(const Array<Sint64>& x);
 248 mike            1.11 
 249 kumpf           1.53     /**
 250                              Constructs a CIMValue with the specified value and inferred type.
 251                              @param x The Real32 Array value to assign
 252                          */
 253 kumpf           1.18     CIMValue(const Array<Real32>& x);
 254 mike            1.11 
 255 kumpf           1.53     /**
 256                              Constructs a CIMValue with the specified value and inferred type.
 257                              @param x The Real64 Array value to assign
 258                          */
 259 kumpf           1.18     CIMValue(const Array<Real64>& x);
 260 mike            1.11 
 261 kumpf           1.53     /**
 262                              Constructs a CIMValue with the specified value and inferred type.
 263                              @param x The Char16 Array value to assign
 264                          */
 265 kumpf           1.18     CIMValue(const Array<Char16>& x);
 266 mike            1.11 
 267 kumpf           1.53     /**
 268                              Constructs a CIMValue with the specified value and inferred type.
 269                              @param x The String Array value to assign
 270                          */
 271 kumpf           1.18     CIMValue(const Array<String>& x);
 272 mike            1.11 
 273 kumpf           1.53     /**
 274                              Constructs a CIMValue with the specified value and inferred type.
 275                              @param x The CIMDateTime Array value to assign
 276                          */
 277 kumpf           1.18     CIMValue(const Array<CIMDateTime>& x);
 278 mike            1.11 
 279 kumpf           1.53     /**
 280                              Constructs a CIMValue with the specified value and inferred type.
 281                              @param x The CIMObjectPath Array value to assign
 282                          */
 283 kumpf           1.23     CIMValue(const Array<CIMObjectPath>& x);
 284 kumpf           1.14 
 285 kumpf           1.53     /**
 286                              Constructs a CIMValue with the specified value and inferred type.
 287                              Note: The CIMObjects in the Array argument are cloned to prevent
 288                              subsequent modification through the shared representation model.
 289                              @param x The CIMObject Array value to assign
 290                              @exception UninitializedObjectException If any of the CIMObjects in the
 291                                  Array are uninitialized.
 292 denise.eckstein 1.46     */
 293 dave.sudlik     1.41     CIMValue(const Array<CIMObject>& x);
 294                      
 295 a.dunfey        1.50 #ifdef PEGASUS_USE_EXPERIMENTAL_INTERFACES
 296 kumpf           1.51 #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
 297 kumpf           1.53     /**
 298                              Constructs a CIMValue with the specified value and inferred type.
 299                              Note: The CIMInstances in the Array argument are cloned to prevent
 300                              subsequent modification through the shared representation model.
 301                              @param x The CIMInstance Array value to assign
 302                              @exception UninitializedObjectException If any of the CIMInstances in
 303                                  the Array are uninitialized.
 304                          */
 305 a.dunfey        1.50     CIMValue(const Array<CIMInstance>& x);
 306                      #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
 307                      #endif // PEGASUS_USE_EXPERIMENTAL_INTERFACES
 308                      
 309 kumpf           1.53     /**
 310                              Constructs a CIMValue by copying another CIMValue object.
 311                              Note: If the specified CIMValue contains CIMObject or CIMInstance
 312                              objects, they are cloned to prevent subsequent modification through
 313                              the shared representation model.
 314                              @param x The CIMValue object to copy
 315 denise.eckstein 1.46     */
 316 mike            1.11     CIMValue(const CIMValue& x);
 317                      
 318 kumpf           1.53     /**
 319                              Destructs a CIMValue object.
 320                          */
 321 mike            1.11     ~CIMValue();
 322                      
 323 kumpf           1.53     /**
 324                              Assigns the value from a specified CIMValue object.
 325                              Note: If the specified CIMValue contains CIMObject or CIMInstance
 326                              objects, they are cloned to prevent subsequent modification through
 327                              the shared representation model.
 328                              @param x The CIMValue object to copy
 329                              @return A reference to this CIMValue object with the new assignment
 330 denise.eckstein 1.46     */
 331 kumpf           1.18     CIMValue& operator=(const CIMValue& x);
 332 mike            1.11 
 333 kumpf           1.53     /**
 334                              Assigns the value from a specified CIMValue object.
 335                              Note: If the specified CIMValue contains CIMObject or CIMInstance
 336                              objects, they are cloned to prevent subsequent modification through
 337                              the shared representation model.
 338                              @param x The CIMValue object to copy
 339 karl            1.13     */
 340 mike            1.11     void assign(const CIMValue& x);
 341                      
 342 kumpf           1.53     /**
 343                              Resets to a null value with type Boolean and isArray=false.
 344 karl            1.13     */
 345 mike            1.11     void clear();
 346                      
 347 kumpf           1.53     /**
 348                              Compares the type and isArray attributes with a specified CIMValue.
 349                              @param x The CIMValue object with which to compare
 350                              @return A Boolean indicating whether the CIMValue objects have the same
 351                                  type and isArray attribute value.
 352 mike            1.11     */
 353 kumpf           1.18     Boolean typeCompatible(const CIMValue& x) const;
 354 mike            1.11 
 355 kumpf           1.53     /**
 356                              Indicates whether the value is an array.
 357                              @return A Boolean indicating whether the value is an array.
 358 mike            1.11     */
 359 kumpf           1.18     Boolean isArray() const;
 360 mike            1.11 
 361 kumpf           1.53     /**
 362                              Indicates whether the value is null.  A null CIMValue has a type, but
 363                              no value can be retrieved from it.
 364                              @return A Boolean indicating whether the value is null.
 365 mike            1.12     */
 366 kumpf           1.18     Boolean isNull() const;
 367 mike            1.12 
 368 kumpf           1.53     /**
 369                              Gets the fixed array size of a CIMValue.  This value is undefined for
 370                              non-array values.  A value of 0 is given for variable size arrays.
 371                              @return An integer indicating the array size.
 372 mike            1.11     */
 373                          Uint32 getArraySize() const;
 374                      
 375 kumpf           1.53     /**
 376                              Gets the value type.
 377                              @return A CIMType indicating the type of the value.
 378 karl            1.13     */
 379 kumpf           1.18     CIMType getType() const;
 380 mike            1.11 
 381 kumpf           1.53     /**
 382                              Sets the value to null with the specified type and array indicator.
 383                              @param type The CIMType of the value
 384                              @param isArray A Boolean indicating whether the value is of array type
 385                              @param arraySize An integer specifying the size of the array, if the
 386                                  CIMValue is for an array of a fixed size.  This value is ignored
 387                                  if the isArray argument is false.
 388 karl            1.13     */
 389 mike            1.11     void setNullValue(CIMType type, Boolean isArray, Uint32 arraySize = 0);
 390                      
 391 kumpf           1.53     /**
 392                              Sets the CIMValue to the specified value and inferred type.
 393                              @param x The Boolean value to assign
 394 kumpf           1.51     */
 395 mike            1.11     void set(Boolean x);
 396                      
 397 kumpf           1.53     /**
 398                              Sets the CIMValue to the specified value and inferred type.
 399                              @param x The Uint8 value to assign
 400                          */
 401 mike            1.11     void set(Uint8 x);
 402 kumpf           1.53 
 403                          /**
 404                              Sets the CIMValue to the specified value and inferred type.
 405                              @param x The Sint8 value to assign
 406                          */
 407 mike            1.11     void set(Sint8 x);
 408 kumpf           1.53 
 409                          /**
 410                              Sets the CIMValue to the specified value and inferred type.
 411                              @param x The Uint16 value to assign
 412                          */
 413 mike            1.11     void set(Uint16 x);
 414 kumpf           1.53 
 415                          /**
 416                              Sets the CIMValue to the specified value and inferred type.
 417                              @param x The Sint16 value to assign
 418                          */
 419 mike            1.11     void set(Sint16 x);
 420 kumpf           1.53 
 421                          /**
 422                              Sets the CIMValue to the specified value and inferred type.
 423                              @param x The Uint32 value to assign
 424                          */
 425 mike            1.11     void set(Uint32 x);
 426 kumpf           1.53 
 427                          /**
 428                              Sets the CIMValue to the specified value and inferred type.
 429                              @param x The Sint32 value to assign
 430                          */
 431 mike            1.11     void set(Sint32 x);
 432 kumpf           1.53 
 433                          /**
 434                              Sets the CIMValue to the specified value and inferred type.
 435                              @param x The Uint64 value to assign
 436                          */
 437 mike            1.11     void set(Uint64 x);
 438 kumpf           1.53 
 439                          /**
 440                              Sets the CIMValue to the specified value and inferred type.
 441                              @param x The Sint64 value to assign
 442                          */
 443 mike            1.11     void set(Sint64 x);
 444 kumpf           1.53 
 445                          /**
 446                              Sets the CIMValue to the specified value and inferred type.
 447                              @param x The Real32 value to assign
 448                          */
 449 mike            1.11     void set(Real32 x);
 450 kumpf           1.53 
 451                          /**
 452                              Sets the CIMValue to the specified value and inferred type.
 453                              @param x The Real64 value to assign
 454                          */
 455 mike            1.11     void set(Real64 x);
 456 kumpf           1.53 
 457                          /**
 458                              Sets the CIMValue to the specified value and inferred type.
 459                              @param x The Char16 value to assign
 460                          */
 461 mike            1.11     void set(const Char16& x);
 462 kumpf           1.53 
 463                          /**
 464                              Sets the CIMValue to the specified value and inferred type.
 465                              @param x The String value to assign
 466                          */
 467 mike            1.11     void set(const String& x);
 468 kumpf           1.53 
 469                          /**
 470                              Sets the CIMValue to the specified value and inferred type.
 471                              @param x The CIMDateTime value to assign
 472                          */
 473 mike            1.11     void set(const CIMDateTime& x);
 474 kumpf           1.53 
 475                          /**
 476                              Sets the CIMValue to the specified value and inferred type.
 477                              @param x The CIMObjectPath value to assign
 478                          */
 479 kumpf           1.23     void set(const CIMObjectPath& x);
 480 kumpf           1.53 
 481                          /**
 482                              Sets the CIMValue to the specified value and inferred type.
 483                              Note: The CIMObject argument is cloned to prevent subsequent
 484                              modification through the shared representation model.
 485                              @param x The CIMObject value to assign
 486                              @exception UninitializedObjectException If the CIMObject is
 487                                  uninitialized.
 488                          */
 489 dave.sudlik     1.41     void set(const CIMObject& x);
 490 kumpf           1.53 
 491 a.dunfey        1.50 #ifdef PEGASUS_USE_EXPERIMENTAL_INTERFACES
 492                      #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
 493 kumpf           1.53     /**
 494                              Sets the CIMValue to the specified value and inferred type.
 495                              Note: The CIMInstance argument is cloned to prevent subsequent
 496                              modification through the shared representation model.
 497                              @param x The CIMInstance value to assign
 498                              @exception UninitializedObjectException If the CIMInstance is
 499                                  uninitialized.
 500                          */
 501 a.dunfey        1.50     void set(const CIMInstance& x);
 502                      #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
 503                      #endif // PEGASUS_USE_EXPERIMENTAL_INTERFACES
 504 kumpf           1.53 
 505                          /**
 506                              Sets the CIMValue to the specified value and inferred type.
 507                              @param x The Boolean Array value to assign
 508                          */
 509 mike            1.11     void set(const Array<Boolean>& x);
 510 kumpf           1.53 
 511                          /**
 512                              Sets the CIMValue to the specified value and inferred type.
 513                              @param x The Uint8 Array value to assign
 514                          */
 515 mike            1.11     void set(const Array<Uint8>& x);
 516 kumpf           1.53 
 517                          /**
 518                              Sets the CIMValue to the specified value and inferred type.
 519                              @param x The Sint8 Array value to assign
 520                          */
 521 mike            1.11     void set(const Array<Sint8>& x);
 522 kumpf           1.53 
 523                          /**
 524                              Sets the CIMValue to the specified value and inferred type.
 525                              @param x The Uint16 Array value to assign
 526                          */
 527 mike            1.11     void set(const Array<Uint16>& x);
 528 kumpf           1.53 
 529                          /**
 530                              Sets the CIMValue to the specified value and inferred type.
 531                              @param x The Sint16 Array value to assign
 532                          */
 533 mike            1.11     void set(const Array<Sint16>& x);
 534 kumpf           1.53 
 535                          /**
 536                              Sets the CIMValue to the specified value and inferred type.
 537                              @param x The Uint32 Array value to assign
 538                          */
 539 mike            1.11     void set(const Array<Uint32>& x);
 540 kumpf           1.53 
 541                          /**
 542                              Sets the CIMValue to the specified value and inferred type.
 543                              @param x The Sint32 Array value to assign
 544                          */
 545 mike            1.11     void set(const Array<Sint32>& x);
 546 kumpf           1.53 
 547                          /**
 548                              Sets the CIMValue to the specified value and inferred type.
 549                              @param x The Uint64 Array value to assign
 550                          */
 551 mike            1.11     void set(const Array<Uint64>& x);
 552 kumpf           1.53 
 553                          /**
 554                              Sets the CIMValue to the specified value and inferred type.
 555                              @param x The Sint64 Array value to assign
 556                          */
 557 mike            1.11     void set(const Array<Sint64>& x);
 558 kumpf           1.53 
 559                          /**
 560                              Sets the CIMValue to the specified value and inferred type.
 561                              @param x The Real32 Array value to assign
 562                          */
 563 mike            1.11     void set(const Array<Real32>& x);
 564 kumpf           1.53 
 565                          /**
 566                              Sets the CIMValue to the specified value and inferred type.
 567                              @param x The Real64 Array value to assign
 568                          */
 569 mike            1.11     void set(const Array<Real64>& x);
 570 kumpf           1.53 
 571                          /**
 572                              Sets the CIMValue to the specified value and inferred type.
 573                              @param x The Char16 Array value to assign
 574                          */
 575 mike            1.11     void set(const Array<Char16>& x);
 576 kumpf           1.53 
 577                          /**
 578                              Sets the CIMValue to the specified value and inferred type.
 579                              @param x The String Array value to assign
 580                          */
 581 mike            1.11     void set(const Array<String>& x);
 582 kumpf           1.53 
 583                          /**
 584                              Sets the CIMValue to the specified value and inferred type.
 585                              @param x The CIMDateTime Array value to assign
 586                          */
 587 mike            1.11     void set(const Array<CIMDateTime>& x);
 588 kumpf           1.53 
 589                          /**
 590                              Sets the CIMValue to the specified value and inferred type.
 591                              @param x The CIMObjectPath Array value to assign
 592                          */
 593 kumpf           1.23     void set(const Array<CIMObjectPath>& x);
 594 kumpf           1.53 
 595                          /**
 596                              Sets the CIMValue to the specified value and inferred type.
 597                              Note: The CIMObjects in the Array argument are cloned to prevent
 598                              subsequent modification through the shared representation model.
 599                              @param x The CIMObject Array value to assign
 600                              @exception UninitializedObjectException If any of the CIMObjects in the
 601                                  Array are uninitialized.
 602                          */
 603 dave.sudlik     1.41     void set(const Array<CIMObject>& x);
 604 kumpf           1.53 
 605 a.dunfey        1.50 #ifdef PEGASUS_USE_EXPERIMENTAL_INTERFACES
 606                      #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
 607 kumpf           1.53     /**
 608                              Sets the CIMValue to the specified value and inferred type.
 609                              Note: The CIMInstances in the Array argument are cloned to prevent
 610                              subsequent modification through the shared representation model.
 611                              @param x The CIMInstance Array value to assign
 612                              @exception UninitializedObjectException If any of the CIMInstances in
 613                                  the Array are uninitialized.
 614                          */
 615 a.dunfey        1.50     void set(const Array<CIMInstance>& x);
 616                      #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
 617                      #endif // PEGASUS_USE_EXPERIMENTAL_INTERFACES
 618 mike            1.11 
 619 kumpf           1.53     /**
 620                              Gets the value of the CIMValue.  The caller should first verify that
 621                              the value is of the expected type and is not null.  The behavior is
 622                              undefined for null values.
 623                              @param x Output Boolean into which the value is stored.
 624                              @exception TypeMismatchException If the value type does not match the
 625                                  output parameter.
 626                          */
 627                          void get(Boolean& x) const;
 628 kumpf           1.31 
 629 kumpf           1.53     /**
 630                              Gets the value of the CIMValue.  The caller should first verify that
 631                              the value is of the expected type and is not null.  The behavior is
 632                              undefined for null values.
 633                              @param x Output Uint8 into which the value is stored.
 634                              @exception TypeMismatchException If the value type does not match the
 635                                  output parameter.
 636 karl            1.13     */
 637 mike            1.11     void get(Uint8& x) const;
 638 kumpf           1.53 
 639                          /**
 640                              Gets the value of the CIMValue.  The caller should first verify that
 641                              the value is of the expected type and is not null.  The behavior is
 642                              undefined for null values.
 643                              @param x Output Sint8 into which the value is stored.
 644                              @exception TypeMismatchException If the value type does not match the
 645                                  output parameter.
 646                          */
 647 mike            1.11     void get(Sint8& x) const;
 648 kumpf           1.53 
 649                          /**
 650                              Gets the value of the CIMValue.  The caller should first verify that
 651                              the value is of the expected type and is not null.  The behavior is
 652                              undefined for null values.
 653                              @param x Output Uint16 into which the value is stored.
 654                              @exception TypeMismatchException If the value type does not match the
 655                                  output parameter.
 656                          */
 657 mike            1.11     void get(Uint16& x) const;
 658 kumpf           1.53 
 659                          /**
 660                              Gets the value of the CIMValue.  The caller should first verify that
 661                              the value is of the expected type and is not null.  The behavior is
 662                              undefined for null values.
 663                              @param x Output Sint16 into which the value is stored.
 664                              @exception TypeMismatchException If the value type does not match the
 665                                  output parameter.
 666                          */
 667 mike            1.11     void get(Sint16& x) const;
 668 kumpf           1.53 
 669                          /**
 670                              Gets the value of the CIMValue.  The caller should first verify that
 671                              the value is of the expected type and is not null.  The behavior is
 672                              undefined for null values.
 673                              <pre>
 674                                  Uint32 v;
 675                                  CIMValue value = property.getValue();
 676                                  if ((value.getType() == CIMTYPE_UINT32) && (!value.isNull()))
 677                                      value.get(v);
 678                              </pre>
 679                              @param x Output Uint32 into which the value is stored.
 680                              @exception TypeMismatchException If the value type does not match the
 681                                  output parameter.
 682                          */
 683 mike            1.11     void get(Uint32& x) const;
 684 kumpf           1.53 
 685                          /**
 686                              Gets the value of the CIMValue.  The caller should first verify that
 687                              the value is of the expected type and is not null.  The behavior is
 688                              undefined for null values.
 689                              @param x Output Sint32 into which the value is stored.
 690                              @exception TypeMismatchException If the value type does not match the
 691                                  output parameter.
 692                          */
 693 mike            1.11     void get(Sint32& x) const;
 694 kumpf           1.53 
 695                          /**
 696                              Gets the value of the CIMValue.  The caller should first verify that
 697                              the value is of the expected type and is not null.  The behavior is
 698                              undefined for null values.
 699                              @param x Output Uint64 into which the value is stored.
 700                              @exception TypeMismatchException If the value type does not match the
 701                                  output parameter.
 702                          */
 703 mike            1.11     void get(Uint64& x) const;
 704 kumpf           1.53 
 705                          /**
 706                              Gets the value of the CIMValue.  The caller should first verify that
 707                              the value is of the expected type and is not null.  The behavior is
 708                              undefined for null values.
 709                              @param x Output Sint64 into which the value is stored.
 710                              @exception TypeMismatchException If the value type does not match the
 711                                  output parameter.
 712                          */
 713 mike            1.11     void get(Sint64& x) const;
 714 kumpf           1.53 
 715                          /**
 716                              Gets the value of the CIMValue.  The caller should first verify that
 717                              the value is of the expected type and is not null.  The behavior is
 718                              undefined for null values.
 719                              @param x Output Real32 into which the value is stored.
 720                              @exception TypeMismatchException If the value type does not match the
 721                                  output parameter.
 722                          */
 723 mike            1.11     void get(Real32& x) const;
 724 kumpf           1.53 
 725                          /**
 726                              Gets the value of the CIMValue.  The caller should first verify that
 727                              the value is of the expected type and is not null.  The behavior is
 728                              undefined for null values.
 729                              @param x Output Real64 into which the value is stored.
 730                              @exception TypeMismatchException If the value type does not match the
 731                                  output parameter.
 732                          */
 733 mike            1.11     void get(Real64& x) const;
 734 kumpf           1.53 
 735                          /**
 736                              Gets the value of the CIMValue.  The caller should first verify that
 737                              the value is of the expected type and is not null.  The behavior is
 738                              undefined for null values.
 739                              @param x Output Char16 into which the value is stored.
 740                              @exception TypeMismatchException If the value type does not match the
 741                                  output parameter.
 742                          */
 743 mike            1.11     void get(Char16& x) const;
 744 kumpf           1.53 
 745                          /**
 746                              Gets the value of the CIMValue.  The caller should first verify that
 747                              the value is of the expected type and is not null.  The behavior is
 748                              undefined for null values.
 749                              @param x Output String into which the value is stored.
 750                              @exception TypeMismatchException If the value type does not match the
 751                                  output parameter.
 752                          */
 753 mike            1.11     void get(String& x) const;
 754 kumpf           1.53 
 755                          /**
 756                              Gets the value of the CIMValue.  The caller should first verify that
 757                              the value is of the expected type and is not null.  The behavior is
 758                              undefined for null values.
 759                              @param x Output CIMDateTime into which the value is stored.
 760                              @exception TypeMismatchException If the value type does not match the
 761                                  output parameter.
 762                          */
 763 mike            1.11     void get(CIMDateTime& x) const;
 764 kumpf           1.53 
 765                          /**
 766                              Gets the value of the CIMValue.  The caller should first verify that
 767                              the value is of the expected type and is not null.  The behavior is
 768                              undefined for null values.
 769                              @param x Output CIMObjectPath into which the value is stored.
 770                              @exception TypeMismatchException If the value type does not match the
 771                                  output parameter.
 772                          */
 773 kumpf           1.23     void get(CIMObjectPath& x) const;
 774 kumpf           1.53 
 775                          /**
 776                              Gets the value of the CIMValue.  The caller should first verify that
 777                              the value is of the expected type and is not null.  The behavior is
 778                              undefined for null values.
 779                              @param x Output CIMObject into which the value is stored.
 780                              @exception TypeMismatchException If the value type does not match the
 781                                  output parameter.
 782                          */
 783 dave.sudlik     1.41     void get(CIMObject& x) const;
 784 kumpf           1.53 
 785 a.dunfey        1.50 #ifdef PEGASUS_USE_EXPERIMENTAL_INTERFACES
 786                      #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
 787 kumpf           1.53     /**
 788                              Gets the value of the CIMValue.  The caller should first verify that
 789                              the value is of the expected type and is not null.  The behavior is
 790                              undefined for null values.
 791                              @param x Output CIMInstance into which the value is stored.
 792                              @exception TypeMismatchException If the value type does not match the
 793                                  output parameter.
 794                          */
 795 a.dunfey        1.50     void get(CIMInstance& x) const;
 796                      #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
 797                      #endif // PEGASUS_USE_EXPERIMENTAL_INTERFACES
 798 kumpf           1.53 
 799                          /**
 800                              Gets the value of the CIMValue.  The caller should first verify that
 801                              the value is of the expected type and is not null.  The behavior is
 802                              undefined for null values.
 803                              @param x Output Boolean Array into which the value is stored.
 804                              @exception TypeMismatchException If the value type does not match the
 805                                  output parameter.
 806                          */
 807 mike            1.11     void get(Array<Boolean>& x) const;
 808 kumpf           1.53 
 809                          /**
 810                              Gets the value of the CIMValue.  The caller should first verify that
 811                              the value is of the expected type and is not null.  The behavior is
 812                              undefined for null values.
 813                              @param x Output Uint8 Array into which the value is stored.
 814                              @exception TypeMismatchException If the value type does not match the
 815                                  output parameter.
 816                          */
 817 mike            1.11     void get(Array<Uint8>& x) const;
 818 kumpf           1.53 
 819                          /**
 820                              Gets the value of the CIMValue.  The caller should first verify that
 821                              the value is of the expected type and is not null.  The behavior is
 822                              undefined for null values.
 823                              @param x Output Sint8 Array into which the value is stored.
 824                              @exception TypeMismatchException If the value type does not match the
 825                                  output parameter.
 826                          */
 827 mike            1.11     void get(Array<Sint8>& x) const;
 828 kumpf           1.53 
 829                          /**
 830                              Gets the value of the CIMValue.  The caller should first verify that
 831                              the value is of the expected type and is not null.  The behavior is
 832                              undefined for null values.
 833                              @param x Output Uint16 Array into which the value is stored.
 834                              @exception TypeMismatchException If the value type does not match the
 835                                  output parameter.
 836                          */
 837 mike            1.11     void get(Array<Uint16>& x) const;
 838 kumpf           1.53 
 839                          /**
 840                              Gets the value of the CIMValue.  The caller should first verify that
 841                              the value is of the expected type and is not null.  The behavior is
 842                              undefined for null values.
 843                              @param x Output Sint16 Array into which the value is stored.
 844                              @exception TypeMismatchException If the value type does not match the
 845                                  output parameter.
 846                          */
 847 mike            1.11     void get(Array<Sint16>& x) const;
 848 kumpf           1.53 
 849                          /**
 850                              Gets the value of the CIMValue.  The caller should first verify that
 851                              the value is of the expected type and is not null.  The behavior is
 852                              undefined for null values.
 853                              @param x Output Uint32 Array into which the value is stored.
 854                              @exception TypeMismatchException If the value type does not match the
 855                                  output parameter.
 856                          */
 857 mike            1.11     void get(Array<Uint32>& x) const;
 858 kumpf           1.53 
 859                          /**
 860                              Gets the value of the CIMValue.  The caller should first verify that
 861                              the value is of the expected type and is not null.  The behavior is
 862                              undefined for null values.
 863                              @param x Output Sint32 Array into which the value is stored.
 864                              @exception TypeMismatchException If the value type does not match the
 865                                  output parameter.
 866                          */
 867 mike            1.11     void get(Array<Sint32>& x) const;
 868 kumpf           1.53 
 869                          /**
 870                              Gets the value of the CIMValue.  The caller should first verify that
 871                              the value is of the expected type and is not null.  The behavior is
 872                              undefined for null values.
 873                              @param x Output Uint64 Array into which the value is stored.
 874                              @exception TypeMismatchException If the value type does not match the
 875                                  output parameter.
 876                          */
 877 mike            1.11     void get(Array<Uint64>& x) const;
 878 kumpf           1.53 
 879                          /**
 880                              Gets the value of the CIMValue.  The caller should first verify that
 881                              the value is of the expected type and is not null.  The behavior is
 882                              undefined for null values.
 883                              @param x Output Sint64 Array into which the value is stored.
 884                              @exception TypeMismatchException If the value type does not match the
 885                                  output parameter.
 886                          */
 887 mike            1.11     void get(Array<Sint64>& x) const;
 888 kumpf           1.53 
 889                          /**
 890                              Gets the value of the CIMValue.  The caller should first verify that
 891                              the value is of the expected type and is not null.  The behavior is
 892                              undefined for null values.
 893                              @param x Output Real32 Array into which the value is stored.
 894                              @exception TypeMismatchException If the value type does not match the
 895                                  output parameter.
 896                          */
 897 mike            1.11     void get(Array<Real32>& x) const;
 898 kumpf           1.53 
 899                          /**
 900                              Gets the value of the CIMValue.  The caller should first verify that
 901                              the value is of the expected type and is not null.  The behavior is
 902                              undefined for null values.
 903                              @param x Output Real64 Array into which the value is stored.
 904                              @exception TypeMismatchException If the value type does not match the
 905                                  output parameter.
 906                          */
 907 mike            1.11     void get(Array<Real64>& x) const;
 908 kumpf           1.53 
 909                          /**
 910                              Gets the value of the CIMValue.  The caller should first verify that
 911                              the value is of the expected type and is not null.  The behavior is
 912                              undefined for null values.
 913                              @param x Output Char16 Array into which the value is stored.
 914                              @exception TypeMismatchException If the value type does not match the
 915                                  output parameter.
 916                          */
 917 mike            1.11     void get(Array<Char16>& x) const;
 918 kumpf           1.53 
 919                          /**
 920                              Gets the value of the CIMValue.  The caller should first verify that
 921                              the value is of the expected type and is not null.  The behavior is
 922                              undefined for null values.
 923                              @param x Output String Array into which the value is stored.
 924                              @exception TypeMismatchException If the value type does not match the
 925                                  output parameter.
 926                          */
 927 mike            1.11     void get(Array<String>& x) const;
 928 kumpf           1.53 
 929                          /**
 930                              Gets the value of the CIMValue.  The caller should first verify that
 931                              the value is of the expected type and is not null.  The behavior is
 932                              undefined for null values.
 933                              @param x Output CIMDateTime Array into which the value is stored.
 934                              @exception TypeMismatchException If the value type does not match the
 935                                  output parameter.
 936                          */
 937 kumpf           1.51     void get(Array<CIMDateTime>& x) const;
 938 kumpf           1.53 
 939                          /**
 940                              Gets the value of the CIMValue.  The caller should first verify that
 941                              the value is of the expected type and is not null.  The behavior is
 942                              undefined for null values.
 943                              @param x Output CIMObjectPath Array into which the value is stored.
 944                              @exception TypeMismatchException If the value type does not match the
 945                                  output parameter.
 946                          */
 947 kumpf           1.51     void get(Array<CIMObjectPath>& x) const;
 948 kumpf           1.53 
 949                          /**
 950                              Gets the value of the CIMValue.  The caller should first verify that
 951                              the value is of the expected type and is not null.  The behavior is
 952                              undefined for null values.
 953                              @param x Output CIMObject Array into which the value is stored.
 954                              @exception TypeMismatchException If the value type does not match the
 955                                  output parameter.
 956                          */
 957 kumpf           1.51     void get(Array<CIMObject>& x) const;
 958 kumpf           1.53 
 959 a.dunfey        1.50 #ifdef PEGASUS_USE_EXPERIMENTAL_INTERFACES
 960                      #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
 961 kumpf           1.53     /**
 962                              Gets the value of the CIMValue.  The caller should first verify that
 963                              the value is of the expected type and is not null.  The behavior is
 964                              undefined for null values.
 965                              @param x Output CIMInstance Array into which the value is stored.
 966                              @exception TypeMismatchException If the value type does not match the
 967                                  output parameter.
 968                          */
 969 kumpf           1.51     void get(Array<CIMInstance>& x) const;
 970 a.dunfey        1.50 #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
 971                      #endif // PEGASUS_USE_EXPERIMENTAL_INTERFACES
 972 mike            1.11 
 973 kumpf           1.53     /**
 974                              Compares with another CIMValue object for equality.
 975                              @param x The CIMValue with which to compare
 976                              @return A Boolean indicating whether they are identical in type,
 977                                  array attributes, and value.
 978 kumpf           1.27     */
 979                          Boolean equal(const CIMValue& x) const;
 980 kumpf           1.20 
 981 kumpf           1.53     /**
 982                              Converts a CIMValue to a String.  This method should only be
 983                              used for diagnostic output purposes.  To get an actual String value,
 984                              use get(String &).
 985                              @return A String representation of the value.
 986 kumpf           1.44     */
 987 mike            1.11     String toString() const;
 988                      
 989 david.dillard   1.43 #ifdef PEGASUS_USE_DEPRECATED_INTERFACES
 990 kumpf           1.44     /**
 991                              <I><B>Deprecated Interface</B></I><BR>
 992 kumpf           1.53         Constructs a CIMValue with the specified value and type Sint8.
 993                              (Note: This constructor exists solely to support binary compatibility
 994                              with a previous definition of the Sint8 type.)
 995                              @param x The Sint8 value to assign
 996 kumpf           1.44     */
 997 david.dillard   1.43     CIMValue(char x);
 998                      
 999 kumpf           1.44     /**
1000                              <I><B>Deprecated Interface</B></I><BR>
1001 kumpf           1.53         Constructs a CIMValue with the specified value and type Sint8 Array.
1002                              (Note: This constructor exists solely to support binary compatibility
1003                              with a previous definition of the Sint8 type.)
1004                              @param x The Sint8 Array value to assign
1005 kumpf           1.44     */
1006 david.dillard   1.43     CIMValue(const Array<char>& x);
1007                      
1008 kumpf           1.44     /**
1009                              <I><B>Deprecated Interface</B></I><BR>
1010 kumpf           1.53         Sets the CIMValue to the specified value and type Sint8.
1011                              (Note: This method exists solely to support binary compatibility with
1012                              a previous definition of the Sint8 type.)
1013                              @param x The value to assign
1014 kumpf           1.44     */
1015 david.dillard   1.43     void set(char x);
1016                      
1017 kumpf           1.44     /**
1018                              <I><B>Deprecated Interface</B></I><BR>
1019 kumpf           1.53         Sets the CIMValue to the specified value and type Sint8 Array.
1020                              (Note: This method exists solely to support binary compatibility with
1021                              a previous definition of the Sint8 type.)
1022                              @param x The Array value to assign
1023 kumpf           1.44     */
1024 david.dillard   1.43     void set(const Array<char>& x);
1025                      
1026 kumpf           1.44     /**
1027                              <I><B>Deprecated Interface</B></I><BR>
1028 kumpf           1.53         Gets the Sint8 value of the CIMValue.  The caller should first verify
1029                              that the value is of the expected type and is not null.  The behavior
1030                              is undefined for null values.
1031                              (Note: This method exists solely to support binary compatibility with
1032                              a previous definition of the Sint8 type.)
1033                              @param x Output variable into which the value is stored.
1034 kumpf           1.44     */
1035 david.dillard   1.43     void get(char& x) const;
1036                      
1037 kumpf           1.44     /**
1038                              <I><B>Deprecated Interface</B></I><BR>
1039 kumpf           1.53         Gets the Sint8 Array value of the CIMValue.  The caller should first
1040                              verify that the value is of the expected type and is not null.  The
1041                              behavior is undefined for null values.
1042                              (Note: This method exists solely to support binary compatibility with
1043                              a previous definition of the Sint8 type.)
1044                              @param x Output Array variable into which the value is stored.
1045 kumpf           1.44     */
1046 david.dillard   1.43     void get(Array<char>& x) const;
1047                      #endif
1048                      
1049 mike            1.11 private:
1050                      
1051 mike            1.47     void _get(const String*& data, Uint32& size) const;
1052                      
1053 a.arora         1.37     CIMValueRep* _rep;
1054 mike            1.11 
1055                          friend class CIMMethodRep;
1056                          friend class CIMParameterRep;
1057                          friend class CIMPropertyRep;
1058                          friend class CIMQualifierRep;
1059                          friend class CIMQualifierDeclRep;
1060 schuur          1.38     friend class BinaryStreamer;
1061 mike            1.47     friend class XmlWriter;
1062 mike            1.11 };
1063 kumpf           1.18 
1064 kumpf           1.53 /**
1065                          Compares two CIMValue objects for equality.
1066                          @param x First CIMValue to compare
1067                          @param y Second CIMValue to compare
1068                          @return A Boolean indicating whether they are identical in type, array
1069                              attributes, and value.
1070 karl            1.17 */
1071 mike            1.11 PEGASUS_COMMON_LINKAGE Boolean operator==(const CIMValue& x, const CIMValue& y);
1072                      
1073 kumpf           1.53 /**
1074                          Compares two CIMValue objects for inequality.
1075                          @param x First CIMValue to compare
1076                          @param y Second CIMValue to compare
1077                          @return A Boolean indicating whether they are NOT identical in type, array
1078                              attributes, and value.
1079 karl            1.17 */
1080 kumpf           1.18 PEGASUS_COMMON_LINKAGE Boolean operator!=(const CIMValue& x, const CIMValue& y);
1081 mike            1.11 
1082                      #define PEGASUS_ARRAY_T CIMValue
1083 kumpf           1.24 # include <Pegasus/Common/ArrayInter.h>
1084 mike            1.11 #undef PEGASUS_ARRAY_T
1085                      
1086                      PEGASUS_NAMESPACE_END
1087                      
1088 mike            1.48 #ifdef PEGASUS_INTERNALONLY
1089                      #include <Pegasus/Common/CIMValueInline.h>
1090                      #endif
1091                      
1092 mike            1.11 #endif /* Pegasus_Value_h */

No CVS admin address has been configured
Powered by
ViewCVS 0.9.2