cache_client.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_THIN_CACHE_CACHE_CLIENT
#define _IGNITE_THIN_CACHE_CACHE_CLIENT

#include <ignite/common/concurrent.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>

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;

                CacheClient(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());
                }

                void Get(const KeyType& key, ValueType& value)
                {
                    impl::thin::WritableKeyImpl<KeyType> wrKey(key);
                    impl::thin::ReadableImpl<ValueType> rdValue(value);

                    proxy.Get(wrKey, rdValue);
                }

                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::ReadableMapImpl<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 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);
                }

                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 RefreshAffinityMapping()
                {
                    proxy.RefreshAffinityMapping();
                }

            private:
                impl::thin::cache::CacheClientProxy proxy;
            };
        }
    }
}

#endif // _IGNITE_THIN_CACHE_CACHE_CLIENT