| /******************************************************************************* |
| * Copyright (c) 2016 CEA LIST. |
| * |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Created on: 26 mars 2013 |
| * |
| * Contributors: |
| * Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr |
| * - Initial API and implementation |
| ******************************************************************************/ |
| |
| #ifndef FML_EXPRESSION_NUMBER_H_ |
| #define FML_EXPRESSION_NUMBER_H_ |
| |
| #include <fml/builtin/BuiltinForm.h> |
| |
| |
| namespace sep |
| { |
| |
| class Number : public BuiltinForm , |
| AVM_INJECT_INSTANCE_COUNTER_CLASS( Number ) |
| { |
| |
| public: |
| /** |
| * CONSTRUCTOR |
| * Default |
| */ |
| Number(class_kind_t aClassKind) |
| : BuiltinForm( aClassKind ) |
| { |
| //!! NOTHING |
| } |
| |
| /** |
| * CONSTRUCTOR |
| * Copy |
| */ |
| Number(const Number & aNumber) |
| : BuiltinForm( aNumber ) |
| { |
| //!! NOTHING |
| } |
| |
| |
| /** |
| * DESTRUCTOR |
| */ |
| virtual ~Number() |
| { |
| //!! NOTHING |
| } |
| |
| |
| /** |
| * SIGN TESTS |
| */ |
| virtual int sign() const = 0; |
| |
| |
| inline virtual bool isPositive() const |
| { |
| return( sign() >= 0 ); |
| } |
| |
| inline virtual bool strictlyPositive() const |
| { |
| return( sign() > 0 ); |
| } |
| |
| |
| inline virtual bool isNegative() const |
| { |
| return( sign() <= 0 ); |
| } |
| |
| inline virtual bool strictlyNegative() const |
| { |
| return( sign() < 0 ); |
| } |
| |
| |
| /** |
| * BASICS TESTS |
| */ |
| virtual bool isZero() const = 0; |
| |
| virtual bool isOne() const = 0; |
| |
| virtual bool isNegativeOne() const = 0; |
| |
| |
| /** |
| * CONVERSION |
| */ |
| virtual bool isInt32() const = 0; |
| virtual avm_int32_t toInt32() const = 0; |
| |
| virtual bool isInt64() const = 0; |
| virtual avm_int64_t toInt64() const = 0; |
| |
| |
| virtual bool isInteger() const = 0; |
| virtual avm_integer_t toInteger() const = 0; |
| |
| virtual bool isUInteger() const = 0; |
| virtual avm_uinteger_t toUInteger() const = 0; |
| |
| |
| virtual bool isRational() const = 0; |
| virtual avm_integer_t toDenominator() const = 0; |
| virtual avm_integer_t toNumerator() const = 0; |
| |
| |
| virtual bool isFloat() const = 0; |
| virtual avm_float_t toFloat() const = 0; |
| |
| virtual bool isReal() const = 0; |
| virtual avm_real_t toReal() const = 0; |
| |
| |
| // /** |
| // * INCREMENT |
| // * DECREMENT |
| // */ |
| // virtual void addExpr(avm_integer_t aValue = 1) = 0; |
| // virtual void minExpr(avm_integer_t aValue = 1) = 0; |
| // |
| // /** |
| // * uminus |
| // */ |
| // virtual void uminus() = 0; |
| |
| }; |
| |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| //////////////////////////////////////////////////////////////////////////////// |
| // GENERIC BUILTIN FORM |
| //////////////////////////////////////////////////////////////////////////////// |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| template< typename Value_T , class Class_T > |
| class GenericNumberClass |
| { |
| |
| protected: |
| /** |
| * ATTRIBUTES |
| */ |
| Value_T mValue; |
| |
| |
| public: |
| |
| /** |
| * CONSTRUCTOR |
| * Default |
| */ |
| GenericNumberClass(const Value_T & aValue) |
| : mValue( aValue ) |
| { |
| //!! NOTHING |
| } |
| |
| /** |
| * CONSTRUCTOR |
| * Copy |
| */ |
| GenericNumberClass(const GenericNumberClass & aNumber) |
| : mValue( aNumber.mValue ) |
| { |
| //!! NOTHING |
| } |
| |
| |
| /** |
| * DESTRUCTOR |
| */ |
| virtual ~GenericNumberClass() |
| { |
| //!! NOTHING |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mValue |
| */ |
| inline Value_T & getValue() |
| { |
| return( mValue ); |
| } |
| |
| inline const Value_T & getValue() const |
| { |
| return( mValue ); |
| } |
| |
| inline void setValue(Value_T aValue) |
| { |
| mValue = aValue; |
| } |
| |
| |
| /** |
| * INCREMENT |
| * DECREMENT |
| */ |
| #ifdef _AVM_NEED_INT64_T_OVERLOADS_ |
| |
| void addExpr(avm_integer_t aValue = 1) |
| { |
| mValue = (mValue + static_cast< long >( aValue )); |
| } |
| |
| void minExpr(avm_integer_t aValue = 1) |
| { |
| mValue = (mValue - static_cast< long >( aValue )); |
| } |
| |
| #else |
| |
| void addExpr(avm_integer_t aValue = 1) |
| { |
| mValue = (mValue + aValue); |
| } |
| |
| void minExpr(avm_integer_t aValue = 1) |
| { |
| mValue = (mValue - aValue); |
| } |
| |
| #endif /* _AVM_NEED_INT64_T_OVERLOADS_ */ |
| |
| |
| /** |
| * uminus |
| */ |
| void uminus() |
| { |
| mValue = (- mValue); |
| } |
| |
| |
| /** |
| * ASSIGN |
| * OPERATOR |
| */ |
| template< class Number_T > |
| Class_T & operator=(const Number_T & x) |
| { |
| if( this == &x ) |
| { |
| return *this; |
| } |
| |
| mValue = x.mValue; |
| |
| return( *this ); |
| } |
| |
| |
| template< class Number_T > |
| Class_T & operator+=(const Number_T & other) |
| { |
| mValue += other.mValue; |
| |
| return( *this ); |
| } |
| |
| template< class Number_T > |
| Class_T & operator-=(const Number_T & other) |
| { |
| mValue -= other.mValue; |
| |
| return( *this ); |
| } |
| |
| |
| template< class Number_T > |
| Class_T & operator*=(const Number_T & other) |
| { |
| mValue *= other.mValue; |
| |
| return( *this ); |
| } |
| |
| template< class Number_T > |
| Class_T & operator/=(const Number_T & other) |
| { |
| mValue /= other.mValue; |
| |
| return( *this ); |
| } |
| |
| |
| /** |
| * ARITHMETIC |
| * OPERATOR |
| */ |
| Class_T operator-() const |
| { |
| return( Class_T( - mValue ) ); |
| } |
| |
| template< class Number_T > |
| Class_T operator+(const Number_T & other) const |
| { |
| return( Class_T( mValue + other.mValue ) ); |
| } |
| |
| template< class Number_T > |
| Class_T operator-(const Number_T & other) const |
| { |
| return( Class_T( mValue - other.mValue ) ); |
| } |
| |
| |
| template< class Number_T > |
| Class_T operator*(const Number_T & other) const |
| { |
| return( Class_T( mValue * other.mValue ) ); |
| } |
| |
| template< class Number_T > |
| Class_T operator/(const Number_T & other) const |
| { |
| return( Class_T( mValue / other.mValue ) ); |
| } |
| |
| |
| /** |
| * COMPARISON |
| * OPERATOR |
| */ |
| // EQUAL |
| template< class Number_T > |
| inline bool operator==(const Number_T & other) const |
| { |
| return( mValue == other.mValue ); |
| } |
| |
| template< class Number_T > |
| inline bool isEQ(const Number_T & other) const |
| { |
| return( mValue == other.mValue ); |
| } |
| |
| |
| // NOT EQUAL |
| template< class Number_T > |
| inline bool operator!=(const Number_T & other) const |
| { |
| return( mValue != other.mValue ); |
| } |
| |
| template< class Number_T > |
| inline bool isNEQ(const Number_T & other) const |
| { |
| return( mValue != other.mValue ); |
| } |
| |
| |
| // COMPARE |
| template< class Number_T > |
| inline int compare(const Number_T & other) const |
| { |
| return( (mValue < other.getValue()) ? -1 : |
| (mValue == other.getValue()) ? 0 : 1 ); |
| } |
| |
| |
| // < <= > >= |
| template< class Number_T > |
| bool operator< (const Number_T & other) const |
| { |
| return( mValue < other.mValue ); |
| } |
| |
| template< class Number_T > |
| bool operator<=(const Number_T & other) const |
| { |
| return( mValue <= other.mValue ); |
| } |
| |
| template< class Number_T > |
| bool operator> (const Number_T & other) const |
| { |
| return( mValue > other.mValue ); |
| } |
| |
| template< class Number_T > |
| bool operator>=(const Number_T & other) const |
| { |
| return( mValue >= other.mValue ); |
| } |
| |
| }; |
| |
| |
| } /* namespace sep */ |
| #endif /* FML_EXPRESSION_NUMBER_H_ */ |
