value.h

/***************************************************************
 *
 * Copyright (C) 1990-2007, Condor Team, Computer Sciences Department,
 * University of Wisconsin-Madison, WI.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); you
 * may not use this file except in compliance with the License.  You may
 * obtain a copy of the License at
 * 
 *    http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 ***************************************************************/


#ifndef __CLASSAD_VALUE_H__
#define __CLASSAD_VALUE_H__

#include "classad/common.h"
#include "classad/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;

        bool IsBooleanValueEquiv(bool &b) 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( int &size ) 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::
IsStringValue( int &size ) const
{
    if (valueType == STRING_VALUE) {
        size = strValue.size();
        return true;
    } else {
        size = -1;
        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//__CLASSAD_VALUE_H__