value.h

/*********************************************************************
 *
 * Condor ClassAd library
 * Copyright (C) 1990-2003, Condor Team, Computer Sciences Department,
 * University of Wisconsin-Madison, WI and Rajesh Raman.
 *
 * This source code is covered by the Condor Public License, which can
 * be found in the accompanying LICENSE file, or online at
 * www.condorproject.org.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * AND THE UNIVERSITY OF WISCONSIN-MADISON "AS IS" AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY, OF SATISFACTORY QUALITY, AND FITNESS
 * FOR A PARTICULAR PURPOSE OR USE ARE DISCLAIMED. THE COPYRIGHT
 * HOLDERS AND CONTRIBUTORS AND THE UNIVERSITY OF WISCONSIN-MADISON
 * MAKE NO MAKE NO REPRESENTATION THAT THE SOFTWARE, MODIFICATIONS,
 * ENHANCEMENTS OR DERIVATIVE WORKS THEREOF, WILL NOT INFRINGE ANY
 * PATENT, COPYRIGHT, TRADEMARK, TRADE SECRET OR OTHER PROPRIETARY
 * RIGHT.
 *
 *********************************************************************/

#ifndef __VALUES_H__
#define __VALUES_H__

#include "common.h"
#include "util.h"

BEGIN_NAMESPACE( classad )

class Literal;
class ExprList;
class ClassAd;

class Value 
{
        public:
                enum ValueType {
                                                                                                NULL_VALUE          = 0,                                        ERROR_VALUE         = 1<<0,                             UNDEFINED_VALUE     = 1<<1,     BOOLEAN_VALUE           = 1<<2,                                 INTEGER_VALUE       = 1<<3,                                     REAL_VALUE          = 1<<4,                     RELATIVE_TIME_VALUE = 1<<5,                     ABSOLUTE_TIME_VALUE = 1<<6,                                     STRING_VALUE        = 1<<7,                                     CLASSAD_VALUE       = 1<<8,             LIST_VALUE                      = 1<<9
                };

                enum NumberFactor {  NO_FACTOR= 0,          B_FACTOR = 1,          K_FACTOR = 2,          M_FACTOR = 3,          G_FACTOR = 4,          T_FACTOR = 5
                };

 
                static const double ScaleFactor[];

                Value();

        Value(const Value &value);

                ~Value();

        Value& operator=(const Value &value);

                void Clear (void);

                void CopyFrom( const Value &v );

                void SetBooleanValue(bool b);

                void SetRealValue(double r);

                void SetIntegerValue(int i);

                void SetUndefinedValue(void);

                void SetErrorValue(void);

                void SetListValue(ExprList* l);

                void SetClassAdValue(ClassAd* c);       

                void SetStringValue( const std::string &str );

                void SetStringValue( const char *str );

                void SetAbsoluteTimeValue( abstime_t secs );

                void SetRelativeTimeValue( time_t secs );
                void SetRelativeTimeValue( double secs );

                inline ValueType GetType() const { return valueType; }

                inline bool IsBooleanValue(bool& b) const;
                inline bool IsBooleanValue() const;
                inline bool IsIntegerValue(int &i) const;       
                inline bool IsIntegerValue() const;
                inline bool IsRealValue(double &r) const;       
                inline bool IsRealValue() const;
                bool IsStringValue( std::string &str ) const;   
                bool IsStringValue( const char *&str ) const;   
                bool IsStringValue( char *str, int len ) const;         
                inline bool IsStringValue() const;
                inline bool IsListValue(const ExprList*& l) const;
                inline bool IsListValue(ExprList*& l);
                inline bool IsListValue() const;
                inline bool IsClassAdValue(const ClassAd *&c) const; 
                inline bool IsClassAdValue(ClassAd *&c); 
                inline bool IsClassAdValue() const;
                inline bool IsUndefinedValue() const;
                inline bool IsErrorValue() const;
                inline bool IsExceptional() const;
                bool IsNumber () const;
                bool IsNumber (int &i) const;
                bool IsNumber (double &r) const;
                bool IsAbsoluteTimeValue( ) const;
                bool IsAbsoluteTimeValue( abstime_t& secs ) const;
                bool IsRelativeTimeValue( ) const;
                bool IsRelativeTimeValue( double& secs ) const;
                bool IsRelativeTimeValue( time_t& secs ) const;

        bool SameAs(const Value &otherValue) const;

        friend bool operator==(const Value &value1, const Value &value2);

                friend std::ostream& operator<<(std::ostream &stream, Value &value);

        private:
                friend class Literal;
                friend class ClassAd;
                friend class ExprTree;

                ValueType               valueType;              // the type of the value


                union {
                        bool                    booleanValue;
                        int                             integerValue;
                        double                  realValue;
                        ExprList        *listValue;
                        ClassAd                 *classadValue;
                        double                  relTimeValueSecs;
                        abstime_t absTimeValueSecs;
                  
                };
                std::string                     strValue;               // has ctor/dtor cannot be in the union
};

bool convertValueToRealValue(const Value value, Value &realValue);
bool convertValueToIntegerValue(const Value value, Value &integerValue);
bool convertValueToStringValue(const Value value, Value &stringValue);

// implementations of the inlined functions
inline bool Value::
IsBooleanValue( bool& b ) const
{
        b = booleanValue;
        return( valueType == BOOLEAN_VALUE );
}

inline bool Value::
IsBooleanValue() const
{
        return( valueType == BOOLEAN_VALUE );
}

inline bool Value::
IsIntegerValue (int &i) const
{
    i = integerValue;
    return (valueType == INTEGER_VALUE);
}  

inline bool Value::
IsIntegerValue () const
{
    return (valueType == INTEGER_VALUE);
}  

inline bool Value::
IsRealValue (double &r) const
{
    r = realValue;
    return (valueType == REAL_VALUE);
}  

inline bool Value::
IsRealValue () const
{
    return (valueType == REAL_VALUE);
}  

inline bool Value::
IsListValue( const ExprList *&l) const
{
    if (valueType == LIST_VALUE) {
        l = listValue;
        return true;
    } else {
        return false;
    }
}

inline bool Value::
IsListValue( ExprList *&l)
{
    if (valueType == LIST_VALUE) {
        l = listValue;
        return true;
    } else {
        return false;
    }
}

inline bool Value::
IsListValue () const
{
        return (valueType == LIST_VALUE);
}


inline bool Value::
IsStringValue() const
{
    return (valueType == STRING_VALUE);
}


inline bool Value::
IsStringValue( const char *&s ) const
{
        // We want to be careful not to copy it in here. 
        // People may accumulate in the "s" after this call,
        // So it best to only touch it if it exists.
        // (Example: the strcat classad function)
        if (valueType == STRING_VALUE) {
                s = strValue.c_str( );
                return true;
        } else {
                return false;
        }
}

inline bool Value::
IsStringValue( char *s, int len ) const
{
        if( valueType == STRING_VALUE ) {
                strncpy( s, strValue.c_str( ), len );
                return( true );
        }
        return( false );
}

inline bool Value::
IsStringValue( std::string &s ) const
{
        if ( valueType == STRING_VALUE ) {
                s = strValue;
                return true;
        } else {
                return false;
        }
}

inline bool Value::
IsClassAdValue(const ClassAd *&ad) const
{
        if ( valueType == CLASSAD_VALUE ) {
                ad = classadValue;
                return true;
        } else {
                return false;
        }
}

inline bool Value::
IsClassAdValue(ClassAd *&ad)
{
        if ( valueType == CLASSAD_VALUE ) {
                ad = classadValue;
                return true;
        } else {
                return false;
        }
}

inline bool Value:: 
IsClassAdValue() const
{
        return( valueType == CLASSAD_VALUE );   
}

inline bool Value::
IsUndefinedValue (void) const
{ 
        return (valueType == UNDEFINED_VALUE);
}

inline bool Value::
IsErrorValue(void) const
{ 
        return (valueType == ERROR_VALUE); 
}

inline bool Value::
IsExceptional(void) const
{
        return( valueType == UNDEFINED_VALUE || valueType == ERROR_VALUE );
}

inline bool Value::
IsAbsoluteTimeValue( ) const
{
        return( valueType == ABSOLUTE_TIME_VALUE );
}

inline bool Value::
IsAbsoluteTimeValue( abstime_t &secs ) const
{
        secs = absTimeValueSecs;
        return( valueType == ABSOLUTE_TIME_VALUE );
}

inline bool Value::
IsRelativeTimeValue( ) const
{
        return( valueType == RELATIVE_TIME_VALUE );
}

inline bool Value::
IsRelativeTimeValue( double &secs ) const
{
        secs = relTimeValueSecs;
        return( valueType == RELATIVE_TIME_VALUE );
}
inline bool Value::
IsRelativeTimeValue( time_t &secs ) const
{
        secs = (int) relTimeValueSecs;
        return( valueType == RELATIVE_TIME_VALUE );
}
inline bool Value::
IsNumber( ) const
{
        return( valueType==INTEGER_VALUE || valueType==REAL_VALUE );
}
END_NAMESPACE // classad

#endif//__VALUES_H__