cache_client.h

Go to the documentation of this file.

/*
 * Copyright 2019 GridGain Systems, Inc. and Contributors.
 *
 * Licensed under the GridGain Community Edition License (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     https://www.gridgain.com/products/software/community-edition/gridgain-community-edition-license
 *
 * 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_THIN_CACHE_CACHE_CLIENT
#define _IGNITE_THIN_CACHE_CACHE_CLIENT
 
#include <ignite/common/concurrent.h>
 
#include <ignite/thin/cache/query/query_cursor.h>
#include <ignite/thin/cache/query/query_fields_cursor.h>
#include <ignite/thin/cache/query/query_scan.h>
#include <ignite/thin/cache/query/query_sql_fields.h>
#include <ignite/thin/cache/query/continuous/continuous_query_client.h>
#include <ignite/thin/cache/query/continuous/continuous_query_handle.h>
 
#include <ignite/impl/thin/writable.h>
#include <ignite/impl/thin/writable_key.h>
 
#include <ignite/impl/thin/readable.h>
#include <ignite/impl/thin/cache/cache_client_proxy.h>
#include <ignite/impl/thin/cache/continuous/continuous_query_client_holder.h>
 
namespace ignite
{
    namespace thin
    {
        namespace cache
        {
            template<typename K, typename V>
            class CacheClient
            {
                friend class impl::thin::cache::CacheClientProxy;
 
            public:
                typedef K KeyType;
 
                typedef V ValueType;
 
                explicit CacheClient(const common::concurrent::SharedPointer<void>& impl) :
                    proxy(impl)
                {
                    // No-op.
                }
 
                CacheClient()
                {
                    // No-op.
                }
 
                ~CacheClient()
                {
                    // No-op.
                }
 
                void Put(const KeyType& key, const ValueType& value)
                {
                    impl::thin::WritableKeyImpl<KeyType> wrKey(key);
                    impl::thin::WritableImpl<ValueType> wrValue(value);
 
                    proxy.Put(wrKey, wrValue);
                }
 
                template<typename InIter>
                void PutAll(InIter begin, InIter end)
                {
                    impl::thin::WritableMapImpl<K, V, InIter> wrSeq(begin, end);
 
                    proxy.PutAll(wrSeq);
                }
 
                template<typename Map>
                void PutAll(const Map& vals)
                {
                    PutAll(vals.begin(), vals.end());
                }
 
                bool Get(const KeyType& key, ValueType& value)
                {
                    impl::thin::WritableKeyImpl<KeyType> wrKey(key);
                    impl::thin::ReadableImpl<ValueType> rdValue(value);
 
                    proxy.Get(wrKey, rdValue);
 
                    return !rdValue.IsNull();
                }
 
                ValueType Get(const KeyType& key)
                {
                    ValueType value;
 
                    Get(key, value);
 
                    return value;
                }
 
                template<typename InIter, typename OutIter>
                void GetAll(InIter begin, InIter end, OutIter dst)
                {
                    impl::thin::WritableSetImpl<K, InIter> wrSeq(begin, end);
                    impl::thin::ReadableContainerImpl< std::pair<K, V>, OutIter> rdSeq(dst);
 
                    proxy.GetAll(wrSeq, rdSeq);
                }
 
                template<typename Set, typename Map>
                void GetAll(const Set& keys, Map& res)
                {
                    return GetAll(keys.begin(), keys.end(), std::inserter(res, res.end()));
                }
 
                bool Replace(const K& key, const V& value)
                {
                    impl::thin::WritableKeyImpl<KeyType> wrKey(key);
                    impl::thin::WritableImpl<ValueType> wrValue(value);
 
                    return proxy.Replace(wrKey, wrValue);
                }
 
                bool Replace(const KeyType& key, const ValueType& oldVal, const ValueType& newVal)
                {
                    impl::thin::WritableKeyImpl<KeyType> wrKey(key);
                    impl::thin::WritableImpl<ValueType> wrOldVal(oldVal);
                    impl::thin::WritableImpl<ValueType> wrNewVal(newVal);
 
                    return proxy.Replace(wrKey, wrOldVal, wrNewVal);
                }
 
                bool ContainsKey(const KeyType& key)
                {
                    impl::thin::WritableKeyImpl<KeyType> wrKey(key);
 
                    return proxy.ContainsKey(wrKey);
                }
 
                template<typename Set>
                bool ContainsKeys(const Set& keys)
                {
                    return ContainsKeys(keys.begin(), keys.end());
                }
 
                template<typename InIter>
                bool ContainsKeys(InIter begin, InIter end)
                {
                    impl::thin::WritableSetImpl<K, InIter> wrSeq(begin, end);
 
                    return proxy.ContainsKeys(wrSeq);
                }
 
                int64_t GetSize(int32_t peekModes)
                {
                    return proxy.GetSize(peekModes);
                }
 
                bool Remove(const KeyType& key)
                {
                    impl::thin::WritableKeyImpl<KeyType> wrKey(key);
 
                    return proxy.Remove(wrKey);
                }
 
                bool Remove(const KeyType& key, const ValueType& val)
                {
                    impl::thin::WritableKeyImpl<KeyType> wrKey(key);
                    impl::thin::WritableImpl<ValueType> wrVal(val);
 
                    return proxy.Remove(wrKey, wrVal);
                }
 
                template<typename Set>
                void RemoveAll(const Set& keys)
                {
                    RemoveAll(keys.begin(), keys.end());
                }
 
                template<typename InIter>
                void RemoveAll(InIter begin, InIter end)
                {
                    impl::thin::WritableSetImpl<K, InIter> wrSeq(begin, end);
 
                    proxy.RemoveAll(wrSeq);
                }
 
                void RemoveAll()
                {
                    proxy.RemoveAll();
                }
 
                void Clear(const KeyType& key)
                {
                    impl::thin::WritableKeyImpl<KeyType> wrKey(key);
 
                    proxy.Clear(wrKey);
                }
 
                void Clear()
                {
                    proxy.Clear();
                }
 
                template<typename Set>
                void ClearAll(const Set& keys)
                {
                    ClearAll(keys.begin(), keys.end());
                }
 
                template<typename InIter>
                void ClearAll(InIter begin, InIter end)
                {
                    impl::thin::WritableSetImpl<K, InIter> wrSeq(begin, end);
 
                    proxy.ClearAll(wrSeq);
                }
 
                void GetAndPut(const KeyType& key, const ValueType& valIn, ValueType& valOut)
                {
                    impl::thin::WritableKeyImpl<KeyType> wrKey(key);
                    impl::thin::WritableImpl<ValueType> wrValIn(valIn);
                    impl::thin::ReadableImpl<ValueType> rdValOut(valOut);
 
                    proxy.GetAndPut(wrKey, wrValIn, rdValOut);
                }
 
                ValueType GetAndPut(const KeyType& key, const ValueType& valIn)
                {
                    ValueType valOut;
 
                    GetAndPut(key, valIn, valOut);
 
                    return valOut;
                }
 
                void GetAndRemove(const KeyType& key, ValueType& valOut)
                {
                    impl::thin::WritableKeyImpl<KeyType> wrKey(key);
                    impl::thin::ReadableImpl<ValueType> rdValOut(valOut);
 
                    proxy.GetAndRemove(wrKey, rdValOut);
                }
 
                ValueType GetAndRemove(const KeyType& key)
                {
                    ValueType valOut;
 
                    GetAndRemove(key, valOut);
 
                    return valOut;
                }
 
                void GetAndReplace(const KeyType& key, const ValueType& valIn, ValueType& valOut)
                {
                    impl::thin::WritableKeyImpl<KeyType> wrKey(key);
                    impl::thin::WritableImpl<ValueType> wrValIn(valIn);
                    impl::thin::ReadableImpl<ValueType> rdValOut(valOut);
 
                    proxy.GetAndReplace(wrKey, wrValIn, rdValOut);
                }
 
                ValueType GetAndReplace(const KeyType& key, const ValueType& valIn)
                {
                    ValueType valOut;
 
                    GetAndReplace(key, valIn, valOut);
 
                    return valOut;
                }
 
                bool PutIfAbsent(const KeyType& key, const ValueType& val)
                {
                    impl::thin::WritableKeyImpl<KeyType> wrKey(key);
                    impl::thin::WritableImpl<ValueType> wrValIn(val);
 
                    return proxy.PutIfAbsent(wrKey, wrValIn);
                }
 
                void GetAndPutIfAbsent(const KeyType& key, const ValueType& valIn, ValueType& valOut)
                {
                    impl::thin::WritableKeyImpl<KeyType> wrKey(key);
                    impl::thin::WritableImpl<ValueType> wrValIn(valIn);
                    impl::thin::ReadableImpl<ValueType> rdValOut(valOut);
 
                    proxy.GetAndPutIfAbsent(wrKey, wrValIn, rdValOut);
                }
 
                ValueType GetAndPutIfAbsent(const KeyType& key, const ValueType& valIn)
                {
                    ValueType valOut;
 
                    GetAndPutIfAbsent(key, valIn, valOut);
 
                    return valOut;
                }
 
                query::QueryFieldsCursor Query(const query::SqlFieldsQuery& qry)
                {
                    return proxy.Query(qry);
                }
 
                query::QueryCursor<KeyType, ValueType> Query(const query::ScanQuery& qry)
                {
                    return query::QueryCursor<KeyType, ValueType>(proxy.Query(qry));
                }
 
                query::continuous::ContinuousQueryHandleClient QueryContinuous(
                    query::continuous::ContinuousQueryClient<K, V> continuousQuery)
                {
                    using namespace impl::thin::cache::query::continuous;
 
                    SP_ContinuousQueryClientHolderBase holder(new ContinuousQueryClientHolder<K, V>(continuousQuery));
 
                    return proxy.QueryContinuous(holder, continuousQuery.GetJavaFilter());
                }
 
                void RefreshAffinityMapping()
                {
                    // No-op.
                }
 
            private:
                impl::thin::cache::CacheClientProxy proxy;
            };
        }
    }
}
 
#endif // _IGNITE_THIN_CACHE_CACHE_CLIENT