wqloperand.h

Pegasus is an open-source implementationof the DMTF CIM and WBEM standards. It is designed to be por

//%2006////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
// Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
// IBM Corp.; EMC Corporation, The Open Group.
// Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
// Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
// EMC Corporation; VERITAS Software Corporation; The Open Group.
// Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
// EMC Corporation; Symantec Corporation; The Open Group.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
// 
// THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
// ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
// "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//==============================================================================
//
// Author: Mike Brasher ([e-mail])
//
// Modified By:
//
//%/////////////////////////////////////////////////////////////////////////////

#ifndef Pegasus_WQLOperand_h
#define Pegasus_WQLOperand_h

#include <new>
#include <Pegasus/Common/Config.h>
#include <Pegasus/Common/String.h>
#include <Pegasus/Common/InternalException.h>
#include <Pegasus/WQL/Linkage.h>

PEGASUS_NAMESPACE_BEGIN

/** Tag used to force invocation of the integer value form of the WQLOperand
    Constructor.
*/
enum WQLIntegerValueTag 
{ 
    WQL_INTEGER_VALUE_TAG 
};

/** Tag used to force invocation of the double value form of the WQLOperand
    Constructor.
*/
enum WQLDoubleValueTag 
{ 
    WQL_DOUBLE_VALUE_TAG 
};

/** Tag used to force invocation of the boolean value form of the WQLOperand
    Constructor.
*/
enum WQLBooleanValueTag 
{ 
    WQL_BOOLEAN_VALUE_TAG 
};

/** Tag used to force invocation of the string value form of the WQLOperand
    Constructor.
*/
enum WQLStringValueTag 
{ 
    WQL_STRING_VALUE_TAG 
};

/** Tag used to force invocation of the property name form of the WQLOperand
    Constructor.
*/
enum WQLPropertyNameTag 
{ 
    WQL_PROPERTY_NAME_TAG 
};

/** Used to represent SQL where clause operands.

    Instances of WQLOperand are used to represent the operands of the
    SQL where clause. Instances of this class are created while parsing
    a SQL where clause and added to the WQLSelectStatement by calling the
    WQLSelectStatement::appendOperand() method. Consider the following
    example:

    <pre>
	SELECT ratio, size, name, str
	FROM MyClass
	WHERE ratio &gt; 1.4 AND size = 3 AND name = "Hello" AND str IS NULL
    </pre>

    In this example, the following are operands:

    <pre>
	ratio
	1.4
	size
	3
	name
	"Hello"
	str
    </pre>

    Operands are of one of the following types:

    <ul>
	<li>NULL_VALUE - contains a null value of any type</li>
	<li>INTEGER_VALUE - an integer literal (e.g., 10, -22)</li>
	<li>DOUBLE_VALUE - a double literal (e.g., 1.4, 1.375e-5)</li>
	<li>BOOLEAN_VALUE - a boolean literal (e.g., TRUE or FALSE)</li>
	<li>STRING_VALUE - a string literal (e.g., "Hello World")</li>
	<li>PROPERTY_NAME- the name of a property (e.g., count, size)</li>
    </ul>
*/
class PEGASUS_WQL_LINKAGE WQLOperand
{
public:

    /** Defines allowed types of WQL operands (NULL_VALUE, INTEGER_VALUE,
	DOUBLE_VALUE, BOOLEAN_VALUE, STRING_VALUE, PROPERTY_NAME).
    */
    enum Type
    {
	NULL_VALUE,
	INTEGER_VALUE,
	DOUBLE_VALUE,
	BOOLEAN_VALUE,
	STRING_VALUE,
	PROPERTY_NAME
    };

    /** Desfault constructor. Initializes to null value.
    */
    WQLOperand();

    /** Copy constructor.
    */
    WQLOperand(const WQLOperand& x);

    /** Initializes object as INTEGER_VALUE.
    */
    WQLOperand(Sint64 x, WQLIntegerValueTag)
    {
	_integerValue = x;
	_type = INTEGER_VALUE;
    }

    /** Initializes object as DOUBLE_VALUE.
    */
    WQLOperand(Real64 x, WQLDoubleValueTag)
    {
	_doubleValue = x;
	_type = DOUBLE_VALUE;
    }

    /** Initializes object as BOOLEAN_VALUE.
    */
    WQLOperand(Boolean x, WQLBooleanValueTag)
    {
	_booleanValue = x;
	_type = BOOLEAN_VALUE;
    }

    /** Initializes object as STRING_VALUE.
    */
    WQLOperand(const String& x, WQLStringValueTag)
    {
	new(_stringValue) String(x);
	_type = STRING_VALUE;
    }

    /** Initializes object as PROPERTY_NAME.
    */
    WQLOperand(const String& x, WQLPropertyNameTag)
    {
	new(_propertyName) String(x);
	_type = PROPERTY_NAME;
    }

    /** Destructor. 
    */
    ~WQLOperand();

    /** Assignment operator.
    */
    WQLOperand& operator=(const WQLOperand& x);

    /** Clears this object and sets its type to NULL_VALUE.
    */
    void clear();

    /** Assigns object from the given operand.
    */
    void assign(const WQLOperand& x);

    /** Accessor for getting the type of the operand.
    */
    Type getType() const { return _type; }

    /** Sets this object to an INTEGER_VALUE.
    */
    void setIntegerValue(Sint64 x)
    {
	clear();
	_integerValue = x;
	_type = INTEGER_VALUE;
    }

    /** Sets this object to an DOUBLE_VALUE.
    */
    void setDoubleValue(Real64 x)
    {
	clear();
	_doubleValue = x;
	_type = DOUBLE_VALUE;
    }

    /** Sets this object to a BOOLEAN_VALUE.
    */
    void setBooleanValue(Boolean x)
    {
	clear();
	_booleanValue = x;
	_type = BOOLEAN_VALUE;
    }

    /** Sets this object to a STRING_VALUE.
    */
    void setStringValue(const String& x)
    {
	clear();
	new(_stringValue) String(x);
	_type = STRING_VALUE;
    }

    /** Sets this object to a PROPERTY_NAME.
    */
    void setPropertyName(const String& x)
    {
	clear();
	new(_propertyName) String(x);
	_type = PROPERTY_NAME;
    }

    /** Gets this object as an INTEGER_VALUE.
    */
    Sint64 getIntegerValue() const
    {
	if (_type != INTEGER_VALUE)
	    throw TypeMismatchException();

	return _integerValue;
    }

    /** Gets this object as an DOUBLE_VALUE.
	@exception TypeMismatchException is not the expected type.
    */
    Real64 getDoubleValue() const
    {
	if (_type != DOUBLE_VALUE)
	    throw TypeMismatchException();

	return _doubleValue;
    }

    /** Gets this object as an BOOLEAN_VALUE.
	@exception TypeMismatchException is not the expected type.
    */
    Boolean getBooleanValue() const
    {
	if (_type != BOOLEAN_VALUE)
	    throw TypeMismatchException();

	return _booleanValue;
    }

    /** Gets this object as a STRING_VALUE.
	@exception TypeMismatchException is not the expected type.
    */
    const String& getStringValue() const
    {
	if (_type != STRING_VALUE)
	    throw TypeMismatchException();

	return *((String*)_stringValue);
    }

    /** Gets this object as a PROPERTY_NAME.
	@exception TypeMismatchException is not the expected type.
    */
    const String& getPropertyName() const
    {
	if (_type != PROPERTY_NAME)
	    throw TypeMismatchException();

	return *((String*)_propertyName);
    }

    /** Converts this object to a string for output purposes.
    */
    String toString() const;

private:

    union
    {
#ifdef PEGASUS_OS_OS400
        // add void* to force the proper alignment
        void* _alignos400;
#endif
	Sint64 _integerValue;
	Real64 _doubleValue;
	Boolean _booleanValue;
	char _stringValue[sizeof(String)];
	char _propertyName[sizeof(String)];
    };

    Type _type;
};

PEGASUS_NAMESPACE_END

#endif /* Pegasus_WQLOperand_h */