cache.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
#define _IGNITE_CACHE

#include <map>
#include <set>

#include <ignite/common/common.h>
#include <ignite/common/concurrent.h>

#include "ignite/cache/cache_peek_mode.h"
#include "ignite/cache/query/query_cursor.h"
#include "ignite/cache/query/query_fields_cursor.h"
#include "ignite/cache/query/query_scan.h"
#include "ignite/cache/query/query_sql.h"
#include "ignite/cache/query/query_text.h"
#include "ignite/cache/query/query_sql_fields.h"
#include "ignite/impl/cache/cache_impl.h"
#include "ignite/impl/operations.h"
#include "ignite/ignite_error.h"

namespace ignite
{
    namespace cache
    {
        template<typename K, typename V>
        class IGNITE_IMPORT_EXPORT Cache
        {
        public:
            Cache(impl::cache::CacheImpl* impl) : impl(ignite::common::concurrent::SharedPointer<impl::cache::CacheImpl>(impl))
            {
                // No-op.
            }

            const char* GetName() const
            {
                return impl.Get()->GetName();
            }

            bool IsEmpty()
            {
                IgniteError err;

                bool res = IsEmpty(err);

                IgniteError::ThrowIfNeeded(err);

                return res;
            }

            bool IsEmpty(IgniteError& err)
            {
                return impl.Get()->IsEmpty(&err);
            }

            bool ContainsKey(const K& key)
            {
                IgniteError err;

                bool res = ContainsKey(key, err);

                IgniteError::ThrowIfNeeded(err);

                return res;
            }

            bool ContainsKey(const K& key, IgniteError& err)
            {
                impl::In1Operation<K> op(&key);

                return impl.Get()->ContainsKey(op, &err);
            }

            bool ContainsKeys(const std::set<K>& keys)
            {
                IgniteError err;

                bool res = ContainsKeys(keys, err);

                IgniteError::ThrowIfNeeded(err);

                return res;
            }

            bool ContainsKeys(const std::set<K>& keys, IgniteError& err)
            {
                impl::InSetOperation<K> op(&keys);

                return impl.Get()->ContainsKeys(op, &err);
            }

            V LocalPeek(const K& key, int32_t peekModes)
            {
                IgniteError err;

                V res = LocalPeek(key, peekModes, err);

                IgniteError::ThrowIfNeeded(err);

                return res;
            }

            V LocalPeek(const K& key, int32_t peekModes, IgniteError& err)
            {
                impl::InCacheLocalPeekOperation<K> inOp(&key, peekModes);
                impl::Out1Operation<V> outOp;

                impl.Get()->LocalPeek(inOp, outOp, peekModes, &err);

                return outOp.GetResult();
            }

            V Get(const K& key)
            {
                IgniteError err;

                V res = Get(key, err);

                IgniteError::ThrowIfNeeded(err);

                return res;
            }

            V Get(const K& key, IgniteError& err)
            {
                impl::In1Operation<K> inOp(&key);
                impl::Out1Operation<V> outOp;

                impl.Get()->Get(inOp, outOp, &err);

                return outOp.GetResult();
            }

            std::map<K, V> GetAll(const std::set<K>& keys)
            {
                IgniteError err;

                std::map<K, V> res = GetAll(keys, err);

                IgniteError::ThrowIfNeeded(err);

                return res;
            }

            std::map<K, V> GetAll(const std::set<K>& keys, IgniteError& err)
            {
                impl::InSetOperation<K> inOp(&keys);
                impl::OutMapOperation<K, V> outOp;

                impl.Get()->GetAll(inOp, outOp, &err);

                return outOp.GetResult();
            }

            void Put(const K& key, const V& val)
            {
                IgniteError err;

                Put(key, val, err);

                IgniteError::ThrowIfNeeded(err);
            }

            void Put(const K& key, const V& val, IgniteError& err)
            {
                impl::In2Operation<K, V> op(&key, &val);

                impl.Get()->Put(op, &err);
            }

            void PutAll(const std::map<K, V>& vals)
            {
                IgniteError err;

                PutAll(vals, err);

                IgniteError::ThrowIfNeeded(err);
            }

            void PutAll(const std::map<K, V>& vals, IgniteError& err)
            {
                impl::InMapOperation<K, V> op(&vals);

                impl.Get()->PutAll(op, &err);
            }

            V GetAndPut(const K& key, const V& val)
            {
                IgniteError err;

                V res = GetAndPut(key, val, err);

                IgniteError::ThrowIfNeeded(err);

                return res;
            }

            V GetAndPut(const K& key, const V& val, IgniteError& err)
            {
                impl::In2Operation<K, V> inOp(&key, &val);
                impl::Out1Operation<V> outOp;

                impl.Get()->GetAndPut(inOp, outOp, &err);

                return outOp.GetResult();
            }

            V GetAndReplace(const K& key, const V& val)
            {
                IgniteError err;

                V res = GetAndReplace(key, val, err);

                IgniteError::ThrowIfNeeded(err);

                return res;
            }

            V GetAndReplace(const K& key, const V& val, IgniteError& err)
            {
                impl::In2Operation<K, V> inOp(&key, &val);
                impl::Out1Operation<V> outOp;

                impl.Get()->GetAndReplace(inOp, outOp, &err);

                return outOp.GetResult();
            }

            V GetAndRemove(const K& key)
            {
                IgniteError err;

                V res = GetAndRemove(key, err);

                IgniteError::ThrowIfNeeded(err);

                return res;
            }

            V GetAndRemove(const K& key, IgniteError& err)
            {
                impl::In1Operation<K> inOp(&key);
                impl::Out1Operation<V> outOp;

                impl.Get()->GetAndRemove(inOp, outOp, &err);

                return outOp.GetResult();
            }

            bool PutIfAbsent(const K& key, const V& val)
            {
                IgniteError err;

                bool res = PutIfAbsent(key, val, err);

                IgniteError::ThrowIfNeeded(err);

                return res;
            }

            bool PutIfAbsent(const K& key, const V& val, IgniteError& err)
            {
                impl::In2Operation<K, V> op(&key, &val);

                return impl.Get()->PutIfAbsent(op, &err);
            }

            V GetAndPutIfAbsent(const K& key, const V& val)
            {
                IgniteError err;

                V res = GetAndPutIfAbsent(key, val, err);

                IgniteError::ThrowIfNeeded(err);

                return res;
            }

            V GetAndPutIfAbsent(const K& key, const V& val, IgniteError& err)
            {
                impl::In2Operation<K, V> inOp(&key, &val);
                impl::Out1Operation<V> outOp;

                impl.Get()->GetAndPutIfAbsent(inOp, outOp, &err);

                return outOp.GetResult();
            }

            bool Replace(const K& key, const V& val)
            {
                IgniteError err;

                bool res = Replace(key, val, err);

                IgniteError::ThrowIfNeeded(err);

                return res;
            }

            bool Replace(const K& key, const V& val, IgniteError& err)
            {
                impl::In2Operation<K, V> op(&key, &val);

                return impl.Get()->Replace(op, &err);
            }

            bool Replace(const K& key, const V& oldVal, const V& newVal)
            {
                IgniteError err;

                bool res = Replace(key, oldVal, newVal, err);

                IgniteError::ThrowIfNeeded(err);

                return res;
            }

            bool Replace(const K& key, const V& oldVal, const V& newVal, IgniteError& err)
            {
                impl::In3Operation<K, V, V> op(&key, &oldVal, &newVal);

                return impl.Get()->ReplaceIfEqual(op, &err);
            }

            void LocalEvict(const std::set<K>& keys)
            {
                IgniteError err;

                LocalEvict(keys, err);

                IgniteError::ThrowIfNeeded(err);
            }

            void LocalEvict(const std::set<K>& keys, IgniteError& err)
            {
                impl::InSetOperation<K> op(&keys);

                impl.Get()->LocalEvict(op, &err);
            }

            void Clear()
            {
                IgniteError err;

                Clear(err);

                IgniteError::ThrowIfNeeded(err);
            }

            void Clear(IgniteError& err)
            {
                impl.Get()->Clear(&err);
            }

            void Clear(const K& key)
            {
                IgniteError err;

                Clear(key, err);

                IgniteError::ThrowIfNeeded(err);
            }

            void Clear(const K& key, IgniteError& err)
            {
                impl::In1Operation<K> op(&key);

                impl.Get()->Clear(op, &err);
            }

            void ClearAll(const std::set<K>& keys)
            {
                IgniteError err;

                ClearAll(keys, err);

                IgniteError::ThrowIfNeeded(err);
            }

            void ClearAll(const std::set<K>& keys, IgniteError& err)
            {
                impl::InSetOperation<K> op(&keys);

                impl.Get()->ClearAll(op, &err);
            }

            void LocalClear(const K& key)
            {
                IgniteError err;

                LocalClear(key, err);

                IgniteError::ThrowIfNeeded(err);
            }

            void LocalClear(const K& key, IgniteError& err)
            {
                impl::In1Operation<K> op(&key);

                impl.Get()->LocalClear(op, &err);
            }

            void LocalClearAll(const std::set<K>& keys)
            {
                IgniteError err;

                LocalClearAll(keys, err);

                IgniteError::ThrowIfNeeded(err);
            }

            void LocalClearAll(const std::set<K>& keys, IgniteError& err)
            {
                impl::InSetOperation<K> op(&keys);

                impl.Get()->LocalClearAll(op, &err);
            }

            bool Remove(const K& key)
            {
                IgniteError err;

                bool res = Remove(key, err);

                IgniteError::ThrowIfNeeded(err);

                return res;
            }

            bool Remove(const K& key, IgniteError& err)
            {
                impl::In1Operation<K> op(&key);

                return impl.Get()->Remove(op, &err);
            }

            bool Remove(const K& key, const V& val)
            {
                IgniteError err;

                bool res = Remove(key, val, err);

                IgniteError::ThrowIfNeeded(err);

                return res;
            }

            bool Remove(const K& key, const V& val, IgniteError& err)
            {
                impl::In2Operation<K, V> op(&key, &val);

                return impl.Get()->RemoveIfEqual(op, &err);
            }

            void RemoveAll(const std::set<K>& keys)
            {
                IgniteError err;

                RemoveAll(keys, err);

                IgniteError::ThrowIfNeeded(err);
            }

            void RemoveAll(const std::set<K>& keys, IgniteError& err)
            {
                impl::InSetOperation<K> op(&keys);

                impl.Get()->RemoveAll(op, &err);
            }

            void RemoveAll()
            {
                IgniteError err;

                RemoveAll(err);

                IgniteError::ThrowIfNeeded(err);
            }

            void RemoveAll(IgniteError& err)
            {
                return impl.Get()->RemoveAll(&err);
            }

            int32_t LocalSize()
            {
                return LocalSize(IGNITE_PEEK_MODE_ALL);
            }

            int32_t LocalSize(IgniteError& err)
            {
                return LocalSize(IGNITE_PEEK_MODE_ALL, err);
            }

            int32_t LocalSize(int32_t peekModes)
            {
                IgniteError err;

                int32_t res = LocalSize(peekModes, err);

                IgniteError::ThrowIfNeeded(err);

                return res;
            }

            int32_t LocalSize(int32_t peekModes, IgniteError& err)
            {
                return impl.Get()->LocalSize(peekModes, &err);
            }

            int32_t Size()
            {
                return Size(ignite::cache::IGNITE_PEEK_MODE_ALL);
            }

            int32_t Size(IgniteError& err)
            {
                return Size(ignite::cache::IGNITE_PEEK_MODE_ALL, err);
            }

            int32_t Size(int32_t peekModes)
            {
                IgniteError err;

                int32_t res = Size(peekModes, err);

                IgniteError::ThrowIfNeeded(err);

                return res;
            }

            int32_t Size(int32_t peekModes, IgniteError& err)
            {
                return impl.Get()->Size(peekModes, &err);
            }

            query::QueryCursor<K, V> Query(const query::SqlQuery& qry)
            {
                IgniteError err;

                query::QueryCursor<K, V> res = Query(qry, err);

                IgniteError::ThrowIfNeeded(err);

                return res;
            }

            query::QueryCursor<K, V> Query(const query::SqlQuery& qry, IgniteError& err)
            {
                impl::cache::query::QueryCursorImpl* cursorImpl = impl.Get()->QuerySql(qry, &err);

                return query::QueryCursor<K, V>(cursorImpl);
            }

            query::QueryCursor<K, V> Query(const query::TextQuery& qry)
            {
                IgniteError err;

                query::QueryCursor<K, V> res = Query(qry, err);

                IgniteError::ThrowIfNeeded(err);

                return res;
            }

            query::QueryCursor<K, V> Query(const query::TextQuery& qry, IgniteError& err)
            {
                impl::cache::query::QueryCursorImpl* cursorImpl = impl.Get()->QueryText(qry, &err);

                return query::QueryCursor<K, V>(cursorImpl);
            }

            query::QueryCursor<K, V> Query(const query::ScanQuery& qry)
            {
                IgniteError err;

                query::QueryCursor<K, V> res = Query(qry, err);

                IgniteError::ThrowIfNeeded(err);

                return res;
            }

            query::QueryCursor<K, V> Query(const query::ScanQuery& qry, IgniteError& err)
            {
                impl::cache::query::QueryCursorImpl* cursorImpl = impl.Get()->QueryScan(qry, &err);

                return query::QueryCursor<K, V>(cursorImpl);
            }

            query::QueryFieldsCursor Query(const query::SqlFieldsQuery& qry)
            {
                IgniteError err;

                query::QueryFieldsCursor res = Query(qry, err);

                IgniteError::ThrowIfNeeded(err);

                return res;
            }

            query::QueryFieldsCursor Query(const query::SqlFieldsQuery& qry, IgniteError& err)
            {
                impl::cache::query::QueryCursorImpl* cursorImpl = impl.Get()->QuerySqlFields(qry, &err);

                return query::QueryFieldsCursor(cursorImpl);
            }

            bool IsValid()
            {
                return impl.IsValid();
            }

        private:
            ignite::common::concurrent::SharedPointer<impl::cache::CacheImpl> impl;
        };
    }
}

#endif