Return to WQLOperand.h CVS log

Up to [Pegasus] / pegasus / src / Pegasus / WQL

BUG#: 6339
TITLE: chksrc Pegasus/WQL directory and subdirectories

DESCRIPTION: All files in these directories except Lex and Yacc generated
files pass chrsrc.

//%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.
//
//==============================================================================
//
//%/////////////////////////////////////////////////////////////////////////////

#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 */