OW_CIMValue.hpp

Go to the documentation of this file.

/*******************************************************************************
* Copyright (C) 2001-2004 Vintela, Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
*  - Redistributions of source code must retain the above copyright notice,
*    this list of conditions and the following disclaimer.
*
*  - Redistributions in binary form must reproduce the above copyright notice,
*    this list of conditions and the following disclaimer in the documentation
*    and/or other materials provided with the distribution.
*
*  - Neither the name of Vintela, Inc. nor the names of its
*    contributors may be used to endorse or promote products derived from this
*    software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL Vintela, Inc. OR THE CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*******************************************************************************/

#ifndef OW_CIMVALUE_HPP_INCLUDE_GUARD_
#define OW_CIMVALUE_HPP_INCLUDE_GUARD_
#include "OW_config.h"
#include "OW_CIMBase.hpp"
#include "OW_COWIntrusiveReference.hpp"
#include "OW_CIMFwd.hpp"
#include "OW_Array.hpp"
#include "OW_CIMDataType.hpp"
#include "OW_CIMNULL.hpp"

namespace OW_NAMESPACE
{

class OW_COMMON_API CIMValue : public CIMBase
{
   class CIMValueImpl;
public:
   static CIMValue createSimpleValue(const String& cimtype,
      const String& value);
   explicit CIMValue(CIMNULL_t);
   CIMValue(const CIMValue& x);
   explicit CIMValue(Bool x);
   explicit CIMValue(bool x);
   explicit CIMValue(UInt8 x);
   explicit CIMValue(Int8 x);
   explicit CIMValue(UInt16 x);
   explicit CIMValue(Int16 x);
   explicit CIMValue(UInt32 x);
   explicit CIMValue(Int32 x);
   explicit CIMValue(UInt64 x);
   explicit CIMValue(Int64 x);
   explicit CIMValue(Real32 x);
   explicit CIMValue(Real64 x);
   explicit CIMValue(const Char16& x);
   explicit CIMValue(const String& x);
   explicit CIMValue(const char* x);
   explicit CIMValue(const CIMDateTime& x);
   explicit CIMValue(const CIMObjectPath& x);
   explicit CIMValue(const CIMClass& x);
   explicit CIMValue(const CIMInstance& x);
   explicit CIMValue(const BoolArray& x);
   explicit CIMValue(const Char16Array& x);
   explicit CIMValue(const UInt8Array& x);
   explicit CIMValue(const Int8Array& x);
   explicit CIMValue(const UInt16Array& x);
   explicit CIMValue(const Int16Array& x);
   explicit CIMValue(const UInt32Array& x);
   explicit CIMValue(const Int32Array& x);
   explicit CIMValue(const UInt64Array& x);
   explicit CIMValue(const Int64Array& x);
   explicit CIMValue(const Real64Array& x);
   explicit CIMValue(const Real32Array& x);
   explicit CIMValue(const StringArray& x);
   explicit CIMValue(const CIMDateTimeArray& x);
   explicit CIMValue(const CIMObjectPathArray& x);
   explicit CIMValue(const CIMClassArray& x);
   explicit CIMValue(const CIMInstanceArray& x);
private:
   // These are private/unimplemented to help prevent unintended errors of
   // passing a pointer to the constructor.
   explicit CIMValue(const void*);
   explicit CIMValue(void*);
   explicit CIMValue(volatile const void*);
   explicit CIMValue(volatile void*);
public:
   ~CIMValue();
   UInt32 getArraySize() const;
   void get(Bool& x) const;
   void get(Char16& x) const;
   void get(UInt8& x) const;
   void get(Int8& x) const;
   void get(UInt16& x) const;
   void get(Int16& x) const;
   void get(UInt32& x) const;
   void get(Int32& x) const;
   void get(UInt64& x) const;
   void get(Int64& x) const;
   void get(Real32& x) const;
   void get(Real64& x) const;
   void get(String& x) const;
   void get(CIMDateTime& x) const;
   void get(CIMObjectPath& x) const;
   void get(CIMClass& x) const;
   void get(CIMInstance& x) const;
   void get(CIMObjectPathArray& x) const;
   void get(Char16Array& x) const;
   void get(UInt8Array& x) const;
   void get(Int8Array& x) const;
   void get(UInt16Array& x) const;
   void get(Int16Array& x) const;
   void get(UInt32Array& x) const;
   void get(Int32Array& x) const;
   void get(UInt64Array& x) const;
   void get(Int64Array& x) const;
   void get(Real64Array& x) const;
   void get(Real32Array& x) const;
   void get(StringArray& x) const;
   void get(BoolArray& x) const;
   void get(CIMDateTimeArray& x) const;
   void get(CIMClassArray& x) const;
   void get(CIMInstanceArray& x) const;
   Bool toBool() const;
   Char16 toChar16() const;
   UInt8 toUInt8() const;
   Int8 toInt8() const;
   UInt16 toUInt16() const;
   Int16 toInt16() const;
   UInt32 toUInt32() const;
   Int32 toInt32() const;
   UInt64 toUInt64() const;
   Int64 toInt64() const;
   Real32 toReal32() const;
   Real64 toReal64() const;
   CIMDateTime toCIMDateTime() const;
   CIMObjectPath toCIMObjectPath() const;
   CIMClass toCIMClass() const;
   CIMInstance toCIMInstance() const;
   CIMObjectPathArray toCIMObjectPathArray() const;
   Char16Array toChar16Array() const;
   UInt8Array toUInt8Array() const;
   Int8Array toInt8Array() const;
   UInt16Array toUInt16Array() const;
   Int16Array toInt16Array() const;
   UInt32Array toUInt32Array() const;
   Int32Array toInt32Array() const;
   UInt64Array toUInt64Array() const;
   Int64Array toInt64Array() const;
   Real64Array toReal64Array() const;
   Real32Array toReal32Array() const;
   StringArray toStringArray() const;
   BoolArray toBoolArray() const;
   CIMDateTimeArray toCIMDateTimeArray() const;
   CIMClassArray toCIMClassArray() const;
   CIMInstanceArray toCIMInstanceArray() const;
   
   virtual void setNull();

   typedef COWIntrusiveReference<CIMValueImpl> CIMValue::*safe_bool;
   operator safe_bool () const
      {  return (m_impl) ? &CIMValue::m_impl : 0; }
   bool operator!() const
      {  return !m_impl; }
   CIMValue& set(const CIMValue& x);
   CIMValue& operator= (const CIMValue& x);
   bool equal(const CIMValue& x) const;
   bool operator== (const CIMValue& x) const;
   bool operator!= (const CIMValue& x) const;
   bool operator<= (const CIMValue& x) const;
   bool operator>= (const CIMValue& x) const;
   bool operator< (const CIMValue& x) const;
   bool operator> (const CIMValue& x) const;
   CIMDataType::Type getType() const;
   CIMDataType getCIMDataType() const;
   bool sameType(const CIMValue& x) const;
   bool isArray() const;
   virtual void readObject(std::istream &istrm);
   virtual void writeObject(std::ostream &ostrm) const;
   virtual String toString() const;
   virtual String toMOF() const;
   bool isNumericType() const;
private:

#ifdef OW_WIN32
#pragma warning (push)
#pragma warning (disable: 4251)
#endif

   COWIntrusiveReference<CIMValueImpl> m_impl;

#ifdef OW_WIN32
#pragma warning (pop)
#endif

};

} // end namespace OW_NAMESPACE

#endif

---