coherence/lang/Primitive.hpp

/*
* Primitive.hpp
*
* Copyright (c) 2000, 2009, Oracle and/or its affiliates. All rights reserved.
*
* Oracle is a registered trademarks of Oracle Corporation and/or its
* affiliates.
*
* This software is the confidential and proprietary information of Oracle
* Corporation. You shall not disclose such confidential and proprietary
* information and shall use it only in accordance with the terms of the
* license agreement you entered into with Oracle.
*
* This notice may not be removed or altered.
*/
#ifndef COH_PRIMITIVE_HPP
#define COH_PRIMITIVE_HPP

#include "coherence/lang/compatibility.hpp"

#include "coherence/lang/abstract_spec.hpp"
#include "coherence/lang/Comparable.hpp"
#include "coherence/lang/Object.hpp"
#include "coherence/lang/String.hpp"

#include <ostream>

COH_OPEN_NAMESPACE2(coherence,lang)


/**
* Template class which converts primitive data types into immutable managed
* objects.
*
* @author jh/mf  2007.07.05
*/
template<class T>
class COH_EXPORT Primitive
    : public abstract_spec<Primitive<T>,
        extends<Object>,
        implements<Comparable> >
    {
    // ----- typedefs -------------------------------------------------------

    public:
        /**
        * The boxed primitive type.
        */
        typedef T BoxedType;


    // ----- constructors ---------------------------------------------------

    protected:
        /**
        * @internal
        */
        Primitive(const T& value = 0);

        /**
        * Copy constructor.
        */
        Primitive(const Primitive<T>& that);


    // ----- Primitive interface --------------------------------------------

    public:
        /**
        * Return the primitive value.
        *
        * @return the primitive value
        */
        virtual T getValue() const;

        /**
        * Return the primitive value
        *
        * @return The primitive value
        */
        operator T() const;

        /**
        * Return the primitive representation of a String.
        *
        * @param vs  the String to covert to a primitive type
        *
        * @return the primitive representation of the string
        *
        * @throws IllegalArgumentException if the supplied String is not
        *         convertible to the primitive type. NULL is considered an
        *         illegal argument except for the bool type, where it
        *         results in a bool(false).
        */
        static T parse(String::View vs);


    // ----- Comparable interface -------------------------------------------

    public:
        /**
        * {@inheritDoc}
        */
        virtual int32_t compareTo(Object::View v) const;


    // ----- Object interface -----------------------------------------------

    public:
        /**
        * {@inheritDoc}
        */
        virtual bool equals(Object::View v) const;

        /**
        * {@inheritDoc}
        */
        virtual size32_t hashCode() const;

        /**
        * @return true
        */
        virtual bool isImmutable() const;

        /**
        * @return true
        */
        virtual void toStream(std::ostream& out) const;


    // ----- data members ---------------------------------------------------

    protected:
        /**
        * The wrapped primitive value.
        */
        T m_value;
    };

COH_CLOSE_NAMESPACE2

#endif // COH_PRIMITIVE_HPP

Copyright (c) 2000, 2009, Oracle and/or its affiliates. All rights reserved.