continuous_query.h

Go to the documentation of this file.

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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.
 */

#ifndef _IGNITE_CACHE_QUERY_CONTINUOUS_CONTINUOUS_QUERY
#define _IGNITE_CACHE_QUERY_CONTINUOUS_CONTINUOUS_QUERY

#include <ignite/impl/cache/query/continuous/continuous_query_impl.h>

#include <ignite/cache/event/cache_entry_event_listener.h>
#include <ignite/cache/event/cache_entry_event_filter.h>

namespace ignite
{
    namespace cache
    {
        // Forward-declaration.
        template<typename K, typename V>
        class IGNITE_IMPORT_EXPORT Cache;

        namespace query
        {
            namespace continuous
            {
                template<typename K, typename V>
                class ContinuousQuery
                {
                    friend class Cache<K, V>;
                public:

                    enum { DEFAULT_BUFFER_SIZE = 1 };

                    enum { DEFAULT_TIME_INTERVAL = 0 };

                    ~ContinuousQuery()
                    {
                        // No-op.
                    }

                    ContinuousQuery(Reference<event::CacheEntryEventListener<K, V> > lsnr) :
                        impl(new impl::cache::query::continuous::ContinuousQueryImpl<K, V>(lsnr, false))
                    {
                        // No-op.
                    }

                    ContinuousQuery(Reference<event::CacheEntryEventListener<K, V> > lsnr, bool loc) :
                        impl(new impl::cache::query::continuous::ContinuousQueryImpl<K, V>(lsnr, loc))
                    {
                        // No-op.
                    }

                    template<typename F>
                    ContinuousQuery(Reference<event::CacheEntryEventListener<K, V> > lsnr,
                        const Reference<F>& remoteFilter) :
                        impl(new impl::cache::query::continuous::ContinuousQueryImpl<K, V>(lsnr, false, remoteFilter))
                    {
                        // No-op.
                    }

                    template<typename F>
                    ContinuousQuery(Reference<event::CacheEntryEventListener<K, V> > lsnr,
                        const Reference<F>& remoteFilter, bool loc) :
                        impl(new impl::cache::query::continuous::ContinuousQueryImpl<K, V>(lsnr, loc, remoteFilter))
                    {
                        // No-op.
                    }

                    void SetLocal(bool val)
                    {
                        impl.Get()->SetLocal(val);
                    }

                    bool GetLocal() const
                    {
                        return impl.Get()->GetLocal();
                    }

                    void SetBufferSize(int32_t val)
                    {
                        impl.Get()->SetBufferSize(val);
                    }

                    int32_t GetBufferSize() const
                    {
                        return impl.Get()->GetBufferSize();
                    }

                    void SetTimeInterval(int64_t val)
                    {
                        impl.Get()->SetTimeInterval(val);
                    }

                    int64_t GetTimeInterval() const
                    {
                        return impl.Get()->GetTimeInterval();
                    }

                    void SetListener(Reference<event::CacheEntryEventListener<K, V> > lsnr)
                    {
                        impl.Get()->SetListener(lsnr);
                    }

                    const event::CacheEntryEventListener<K, V>& GetListener() const
                    {
                        return impl.Get()->GetListener();
                    }

                    event::CacheEntryEventListener<K, V>& GetListener()
                    {
                        return impl.Get()->GetListener();
                    }

                private:
                    common::concurrent::SharedPointer<impl::cache::query::continuous::ContinuousQueryImpl<K, V> > impl;
                };
            }
        }
    }
}

#endif //_IGNITE_CACHE_QUERY_CONTINUOUS_CONTINUOUS_QUERY