Xalan-C++ API Documentation

The Xalan C++ XSLT Processor Version 1.9

DoubleSupport.hpp

Go to the documentation of this file.

/*
 * Copyright 1999-2004 The Apache Software Foundation.
 *
 * 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.
 */
#if !defined(DOUBLESUPPORT_HEADER_GUARD_1357924680)
#define DOUBLESUPPORT_HEADER_GUARD_1357924680



// Base include file.  Must be first.
#include <xalanc/PlatformSupport/PlatformSupportDefinitions.hpp>



#include <cmath>
#include <functional>



#include <xalanc/XalanDOM/XalanDOMString.hpp>



XALAN_CPP_NAMESPACE_BEGIN



// A class to help us support IEEE 754.
class XALAN_PLATFORMSUPPORT_EXPORT DoubleSupport
{
public:

    static void
    initialize(MemoryManagerType&      theManager);
 
    static void
    terminate();


    // Use these functions to determine if a value represents one of these
    // specia values.  On some platforms, regular C/C++ operators don't work
    // as we need them too, so we have these helper functions.

    static bool
    isNaN(double    theNumber)
    {
        return s_NaN == theNumber;
    }

    static bool
    isPositiveInfinity(double   theNumber)
    {
        return s_positiveInfinity == theNumber;
    }

    static bool
    isNegativeInfinity(double   theNumber)
    {
        return s_negativeInfinity == theNumber;
    }

    static bool
    isPositiveZero(double   theNumber)
    {
        return s_positiveZero == theNumber;
    }

    static bool
    isNegativeZero(double   theNumber)
    {
        return s_negativeZero == theNumber;
    }

    // These can be used to initialize values, but should not
    // be used to do equality comparisons, as == may fail on
    // some platforms.
    //

    static double
    getNaN()
    {
        return s_NaN.d;
    }

    static double
    getPositiveInfinity()
    {
        return s_positiveInfinity.d;
    }

    static double
    getNegativeInfinity()
    {
        return s_negativeInfinity.d;
    }

    static bool
    equal(
            double  theLHS,
            double  theRHS);

    static bool
    notEqual(
            double  theLHS,
            double  theRHS)
    {
        return !equal(theLHS, theRHS);
    }

    static bool
    lessThan(
            double  theLHS,
            double  theRHS);

    static bool
    lessThanOrEqual(
            double  theLHS,
            double  theRHS);

    static bool
    greaterThan(
            double  theLHS,
            double  theRHS);

    static bool
    greaterThanOrEqual(
            double  theLHS,
            double  theRHS);

    static double
    add(
            double  theLHS,
            double  theRHS);

    static double
    subtract(
            double  theLHS,
            double  theRHS);

    static double
    multiply(
            double  theLHS,
            double  theRHS);

    static double
    divide(
            double  theLHS,
            double  theRHS);

    static double
    modulus(
            double  theLHS,
            double  theRHS);

    static double
    negative(double theDouble);

    // Some functors to do the same thing.  This is for
    // STL integration...
    #if defined(XALAN_NO_STD_NAMESPACE)
    struct equalFunction : public binary_function<const double&, const double&, bool>
    #else
    struct equalFunction : public std::binary_function<const double&, const double&, bool>
    #endif
    {
        result_type
        operator()(
            first_argument_type     theLHS,
            second_argument_type    theRHS) const
        {
            return equal(theLHS, theRHS);
        }
    };

    #if defined(XALAN_NO_STD_NAMESPACE)
    struct notEqualFunction : public binary_function<const double&, const double&, bool>
    #else
    struct notEqualFunction : public std::binary_function<const double&, const double&, bool>
    #endif
    {
        result_type
        operator()(
            first_argument_type     theLHS,
            second_argument_type    theRHS) const
        {
            return notEqual(theLHS, theRHS);
        }
    };

    #if defined(XALAN_NO_STD_NAMESPACE)
    struct lessThanFunction : public binary_function<const double&, const double&, bool>
    #else
    struct lessThanFunction : public std::binary_function<const double&, const double&, bool>
    #endif
    {
        result_type
        operator()(
            first_argument_type     theLHS,
            second_argument_type    theRHS) const
        {
            return lessThan(theLHS, theRHS);
        }
    };

    #if defined(XALAN_NO_STD_NAMESPACE)
    struct lessThanOrEqualFunction : public binary_function<const double&, const double&, bool>
    #else
    struct lessThanOrEqualFunction : public std::binary_function<const double&, const double&, bool>
    #endif
    {
        result_type
        operator()(
            first_argument_type     theLHS,
            second_argument_type    theRHS) const
        {
            return lessThanOrEqual(theLHS, theRHS);
        }
    };

    #if defined(XALAN_NO_STD_NAMESPACE)
    struct greaterThanFunction : public binary_function<const double&, const double&, bool>
    #else
    struct greaterThanFunction : public std::binary_function<const double&, const double&, bool>
    #endif
    {
        result_type
        operator()(
            first_argument_type     theLHS,
            second_argument_type    theRHS) const
        {
            return greaterThan(theLHS, theRHS);
        }
    };

    #if defined(XALAN_NO_STD_NAMESPACE)
    struct greaterThanOrEqualFunction : public binary_function<const double&, const double&, bool>
    #else
    struct greaterThanOrEqualFunction : public std::binary_function<const double&, const double&, bool>
    #endif
    {
        result_type
        operator()(
            first_argument_type     theLHS,
            second_argument_type    theRHS) const
        {
            return greaterThanOrEqual(theLHS, theRHS);
        }
    };

    #if defined(XALAN_NO_STD_NAMESPACE)
    struct addFunction : public binary_function<const double&, const double&, double>
    #else
    struct addFunction : public std::binary_function<const double&, const double&, double>
    #endif
    {
        result_type
        operator()(
            first_argument_type     theLHS,
            second_argument_type    theRHS) const
        {
            return add(theLHS, theRHS);
        }
    };

    #if defined(XALAN_NO_STD_NAMESPACE)
    struct subtractFunction : public binary_function<const double&, const double&, double>
    #else
    struct subtractFunction : public std::binary_function<const double&, const double&, double>
    #endif
    {
        result_type
        operator()(
            first_argument_type     theLHS,
            second_argument_type    theRHS) const
        {
            return subtract(theLHS, theRHS);
        }
    };

    #if defined(XALAN_NO_STD_NAMESPACE)
    struct multiplyFunction : public binary_function<const double&, const double&, double>
    #else
    struct multiplyFunction : public std::binary_function<const double&, const double&, double>
    #endif
    {
        result_type
        operator()(
            first_argument_type     theLHS,
            second_argument_type    theRHS) const
        {
            return multiply(theLHS, theRHS);
        }
    };

    #if defined(XALAN_NO_STD_NAMESPACE)
    struct divideFunction : public binary_function<const double&, const double&, double>
    #else
    struct divideFunction : public std::binary_function<const double&, const double&, double>
    #endif
    {
        result_type
        operator()(
            first_argument_type     theLHS,
            second_argument_type    theRHS) const
        {
            return divide(theLHS, theRHS);
        }
    };

    #if defined(XALAN_NO_STD_NAMESPACE)
    struct modulusFunction : public binary_function<const double&, const double&, double>
    #else
    struct modulusFunction : public std::binary_function<const double&, const double&, double>
    #endif
    {
        result_type
        operator()(
            first_argument_type     theLHS,
            second_argument_type    theRHS) const
        {
            return modulus(theLHS, theRHS);
        }
    };

    #if defined(XALAN_NO_STD_NAMESPACE)
    struct negativeFunction : public unary_function<const double&, double>
    #else
    struct negativeFunction : public std::unary_function<const double&, double>
    #endif
    {
        result_type
        operator()(argument_type    theDouble) const
        {
            return negative(theDouble);
        }
    };

    static bool
    isValid(const XalanDOMString&   theString);

    static bool
    isValid(const XalanDOMChar*     theString);

    static double
    toDouble(const XalanDOMString&  theString, MemoryManagerType&      theManager);

    static double
    toDouble(const XalanDOMChar*    theString, MemoryManagerType&      theManager);

    static double
    round(double    theValue);

    static double
    ceiling(double  theValue)
    {
#if defined(XALAN_STRICT_ANSI_HEADERS)
        return std::ceil(theValue);
#else
        return ceil(theValue);
#endif
    }

    static double
    floor(double    theValue)
    {
#if defined(XALAN_STRICT_ANSI_HEADERS)
        return std::floor(theValue);
#else
        return ::floor(theValue);
#endif
    }

    typedef union
    {
        double  d;
        struct
        {
            unsigned int    dw1;
            unsigned int    dw2;
        } dwords;

        bool
        operator==(double   theNumber) const
        {
            const NumberUnion   temp = { theNumber };

            return dwords.dw1 == temp.dwords.dw1 &&
                   dwords.dw2 == temp.dwords.dw2;
        }

    } NumberUnion;

private:

    static NumberUnion          s_NaN;
    static const NumberUnion    s_positiveInfinity;
    static const NumberUnion    s_negativeInfinity;
    static const NumberUnion    s_positiveZero;
    static const NumberUnion    s_negativeZero;
};



XALAN_CPP_NAMESPACE_END



#endif  // DOUBLESUPPORT_HEADER_GUARD_1357924680

Interpreting class diagrams

Doxygen and GraphViz are used to generate this API documentation from the Xalan-C header files.

Xalan-C++ XSLT Processor Version 1.9 Copyright © 1999-2004 The Apache Software Foundation. All Rights Reserved.