Oracle Fusion Middleware C++ API Reference for Oracle Coherence
12c (12.1.2)
E26041-01

coherence/util/aggregator/CompositeAggregator.hpp

/*
* CompositeAggregator.hpp
*
* Copyright (c) 2000, 2013, 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_COMPOSITE_AGGREGATOR_HPP
#define COH_COMPOSITE_AGGREGATOR_HPP

#include "coherence/lang.ns"

#include "coherence/io/pof/PofReader.hpp"
#include "coherence/io/pof/PofWriter.hpp"
#include "coherence/io/pof/PortableObject.hpp"
#include "coherence/util/InvocableMap.hpp"

COH_OPEN_NAMESPACE3(coherence,util,aggregator)

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


/**
* CompositeAggregator provides an ability to execute a collection of
* aggregators against the same subset of the entries in an InvocableMap,
* resulting in a list of corresponding aggregation results. The size of the
* returned list will always be equal to the length of the aggregators' array.
*
* @author djl  2008.05.16
*/
class COH_EXPORT CompositeAggregator
    : public class_spec<CompositeAggregator,
        extends<Object>,
        implements<PortableObject, InvocableMap::EntryAggregator> >
    {
    friend class factory<CompositeAggregator>;

    // ----- factory methods ------------------------------------------------

    public:
         /**
         * Default constructor (necessary for the PortableObject interface).
         */
         static CompositeAggregator::Handle create();

         /**
         * Create an instance of CompositeAggregator based on a specified
         * array of coherence::util::InvocableMap::EntryAggregator.
         * If all the aggregators in the specified array are instances of
         * coherence::util::InvocableMap::ParallelAwareAggregator
         * then a parallel-aware instance of the CompositeAggregator will be
         * created.
         * <br>
         * If at least one of the specified aggregator is not parallel-aware,
         * then the resulting CompositeAggregator will not be parallel-aware
         * and could be ill-suited for aggregations run against large
         * partitioned caches.
         *
         * @param vaAggregator  an array of EntryAggregator objects; must
         *                      contain not less than two aggregators
         */
         static CompositeAggregator::Handle create(
                 ObjectArray::View vaAggregator);


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

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

        /**
        * @internal
        */
        CompositeAggregator(ObjectArray::View vaAggregator);

    private:
        /**
        * Blocked copy constructor.
        */
        CompositeAggregator(const CompositeAggregator&);


    // ----- InvocableMap::EntryAggregator interface ------------------------

    public:
        /**
        * {@inheritDoc}
        */
        virtual Object::Holder aggregate(Set::View vSetEntries);


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

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

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


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

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

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

        /**
        * {@inheritDoc}
        */
        virtual void toStream(std::ostream& out) const;


    // ----- data member accessors ------------------------------------------

    public:
        /**
        * Determine the ValueExtractor whose values this aggregator is
        * aggregating.
        *
        * @return the ValueExtractor used by this aggregator
        */
        virtual ObjectArray::View getAggregators() const;


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

    protected:
        /**
        * The underlying EntryAggregator array.
        */
        FinalView<ObjectArray> f_vaAggregator;
    };

COH_CLOSE_NAMESPACE3

#endif // COH_COMPOSITE_AGGREGATOR_HPP

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