cache_affinity.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_AFFINITY
#define _IGNITE_CACHE_AFFINITY
 
#include <ignite/cluster/cluster_group.h>
 
#include <ignite/impl/cache/cache_affinity_impl.h>
 
namespace ignite
{
    namespace cache
    {
        template<typename K>
        class IGNITE_IMPORT_EXPORT CacheAffinity
        {
        public:
            CacheAffinity(impl::cache::SP_CacheAffinityImpl impl) :
                impl(impl)
            {
                // No-op.
            }
 
            int32_t GetPartitions()
            {
                return impl.Get()->GetPartitions();
            }
 
            int32_t GetPartition(const K& key)
            {
                return impl.Get()->GetPartition(key);
            }
 
            bool IsPrimary(cluster::ClusterNode node, const K& key)
            {
                return impl.Get()->IsPrimary(node, key);
            }
 
            bool IsBackup(cluster::ClusterNode node, const K& key)
            {
                return impl.Get()->IsBackup(node, key);
            }
 
            bool IsPrimaryOrBackup(cluster::ClusterNode node, const K& key)
            {
                return impl.Get()->IsPrimaryOrBackup(node, key);
            }
 
            std::vector<int32_t> GetPrimaryPartitions(cluster::ClusterNode node)
            {
                return impl.Get()->GetPrimaryPartitions(node);
            }
 
            std::vector<int32_t> GetBackupPartitions(cluster::ClusterNode node)
            {
                return impl.Get()->GetBackupPartitions(node);
            }
 
            std::vector<int32_t> GetAllPartitions(cluster::ClusterNode node)
            {
                return impl.Get()->GetAllPartitions(node);
            }
 
            template <typename TR>
            TR GetAffinityKey(const K& key)
            {
                return impl.Get()->template GetAffinityKey<K, TR>(key);
            }
 
            std::map<cluster::ClusterNode, std::vector<K> > MapKeysToNodes(const std::vector<K>& keys)
            {
                return impl.Get()->MapKeysToNodes(keys);
            }
 
            cluster::ClusterNode MapKeyToNode(const K& key)
            {
                return impl.Get()->MapKeyToNode(key);
            }
 
            std::vector<cluster::ClusterNode> MapKeyToPrimaryAndBackups(const K& key)
            {
                return impl.Get()->MapKeyToPrimaryAndBackups(key);
            }
 
            cluster::ClusterNode MapPartitionToNode(int32_t part)
            {
                return impl.Get()->MapPartitionToNode(part);
            }
 
            std::map<int32_t, cluster::ClusterNode> MapPartitionsToNodes(const std::vector<int32_t>& parts)
            {
                return impl.Get()->MapPartitionsToNodes(parts);
            }
 
            std::vector<cluster::ClusterNode> MapPartitionToPrimaryAndBackups(int32_t part)
            {
                return impl.Get()->MapPartitionToPrimaryAndBackups(part);
            }
 
        private:
            impl::cache::SP_CacheAffinityImpl impl;
        };
    }
}
 
#endif //_IGNITE_CACHE_AFFINITY