const HostConstSharedPtr& host) {

  for (size_t pool_map_index = 0; pool_map_index < NumResourcePriorities; ++pool_map_index) {

    auto priority = static_cast<ResourcePriority>(pool_map_index);

    conn_pool_maps_[pool_map_index].reset(new ConnPoolMapType(dispatcher, host, priority));

  }

}

PriorityConnPoolMap<KEY_TYPE, POOL_TYPE>::~PriorityConnPoolMap() = default;

                                                  const PoolFactory& factory) {

  return conn_pool_maps_[getPriorityIndex(priority)]->getPool(key, factory);

}

                                                         const KEY_TYPE& key) {

  return conn_pool_maps_[getPriorityIndex(priority)]->erasePool(key);

}

size_t PriorityConnPoolMap<KEY_TYPE, POOL_TYPE>::size() const {

  size_t size = 0;

  for (const auto& pool_map : conn_pool_maps_) {

    size += pool_map->size();

  }

  return size;

}

bool PriorityConnPoolMap<KEY_TYPE, POOL_TYPE>::empty() const {

  for (const auto& pool_map : conn_pool_maps_) {

    if (!pool_map->empty()) {

      return false;

    }

  }

  return true;

}

void PriorityConnPoolMap<KEY_TYPE, POOL_TYPE>::clear() {

  for (auto& pool_map : conn_pool_maps_) {

    pool_map->clear();

  }

}

void PriorityConnPoolMap<KEY_TYPE, POOL_TYPE>::addIdleCallback(const IdleCb& cb) {

  for (auto& pool_map : conn_pool_maps_) {

    pool_map->addIdleCallback(cb);

  }

}

    ConnectionPool::DrainBehavior drain_behavior) {

  for (auto& pool_map : conn_pool_maps_) {

    pool_map->drainConnections(drain_behavior);

  }

}

size_t PriorityConnPoolMap<KEY_TYPE, POOL_TYPE>::getPriorityIndex(ResourcePriority priority) const {

  size_t index = static_cast<size_t>(priority);

  ASSERT(index < conn_pool_maps_.size());

  return index;

}