Oracle Coherence for C++ API
Release 3.7.1.0
E22845-01

coherence/util/aggregator/AbstractComparableAggregator.hpp

/*
* AbstractComparableAggregator.hpp
*
* Copyright (c) 2000, 2011, 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_ABSTRACT_COMPARABLE_AGGREGATOR_HPP
#define COH_ABSTRACT_COMPARABLE_AGGREGATOR_HPP

#include "coherence/lang.ns"

#include "coherence/util/aggregator/AbstractAggregator.hpp"
#include "coherence/util/Comparator.hpp"
#include "coherence/util/ValueExtractor.hpp"

COH_OPEN_NAMESPACE3(coherence,util,aggregator)

using coherence::io::pof::PofReader;
using coherence::io::pof::PofWriter;
using coherence::io::pof::PortableObject;

using coherence::util::Comparator;
using coherence::util::ValueExtractor;


/**
* Abstract aggregator that processes values extracted from a set of entries
* in a Map, with knowledge of how to compare those values. There are two ways
* to use the AbstractComparableAggregator:
* <ul>
* <li>All the extracted objects must implement <tt>Comparable</tt>, or</li>
* <li>The AbstractComparableAggregator has to be provided with a
* <tt>Comparator object</tt>.</li>
* </ul>
* If the set of entries passed to <tt>aggregate</tt> is empty, a
* <tt>NULL</tt> result is returned.
*
* @author djl/pp  2008.05.09
*/
class COH_EXPORT AbstractComparableAggregator
    : public abstract_spec<AbstractComparableAggregator,
        extends<AbstractAggregator> >
    {
    // ----- constructors ---------------------------------------------------

    protected:
        /**
        * @internal
        */
        AbstractComparableAggregator();

        /**
        * Construct an AbstractComparableAggregator object.
        *
        * @param vExtractor  the extractor that provides an object to be compared
        * @param vComparator the comparator used to compare the extracted
        *                    object, if NULL then the extracted object must
        *                    implement Comparable
        */
        AbstractComparableAggregator(ValueExtractor::View vExtractor,
                Comparator::View vComparator = NULL);


    // ----- AbstractAggregator Interface  ----------------------------------

    protected:
        /**
        * {@inheritDoc}
        */
        virtual void init(bool fFinal);

        /**
        * {@inheritDoc}
        */
        virtual Object::Holder finalizeResult(bool fFinal);


    // ----- PortableObject interface ---------------------------------------

    public:
        /**
        * {@inheritDoc}
        */
        virtual void readExternal(PofReader::Handle hIn);

        /**
        * {@inheritDoc}
        */
        virtual void writeExternal(PofWriter::Handle hOut) const;


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

    protected:
        /**
        * The count of processed entries.
        */
        int32_t m_count;

        /**
        * The running result value.
        */
        MemberView<Object> m_vResult;

        /**
        * The comparator to use for comparing extracted values.
        */
        MemberView<Comparator> m_vComparator;
    };

COH_CLOSE_NAMESPACE3

#endif // COH_ABSTRACT_COMPARABLE_AGGREGATOR_HPP

Copyright © 2000, 2011, Oracle and/or its affiliates. All rights reserved.