: key_(metadata_key.key()) {

  for (const auto& seg : metadata_key.path()) {

    path_.push_back(seg.key());

  }

}

                                               const MetadataKey& metadata_key) {

  return metadataValue(metadata, metadata_key.key_, metadata_key.path_);

}

                                               const std::vector<std::string>& path) {

  if (!metadata) {

    return Protobuf::Value::default_instance();

  }

  const auto filter_it = metadata->filter_metadata().find(filter);

  if (filter_it == metadata->filter_metadata().end()) {

    return Protobuf::Value::default_instance();

  }

  return structValue(filter_it->second, path);

}

                                             const std::vector<std::string>& path) {

  const Protobuf::Struct* data_struct = &struct_value;

  const Protobuf::Value* val = nullptr;

  for (const auto& p : path) {

    if (nullptr == data_struct) { // sub entry not found

      return Protobuf::Value::default_instance();

    }

    const auto entry_it = data_struct->fields().find(p);

    if (entry_it == data_struct->fields().end()) {

      return Protobuf::Value::default_instance();

    }

    val = &(entry_it->second);

    if (val->has_struct_value()) {

      data_struct = &(val->struct_value());

    } else {

      data_struct = nullptr;

    }

  }

  if (nullptr == val) {

    return Protobuf::Value::default_instance();

  }

  return *val;

}

                                               const std::string& filter, const std::string& key) {

  const std::vector<std::string> path{key};

  return metadataValue(metadata, filter, path);

}

                                                const std::string& filter, const std::string& key) {

  return (*(*metadata.mutable_filter_metadata())[filter].mutable_fields())[key];

}

                                  const std::string& filter_key, bool list_as_any) {

  if (!host_metadata) {

    return label_set.empty();

  }

  const auto filter_it = host_metadata->filter_metadata().find(filter_key);

  if (filter_it == host_metadata->filter_metadata().end()) {

    return label_set.empty();

  }

  const Protobuf::Struct& data_struct = filter_it->second;

  const auto& fields = data_struct.fields();

  for (const auto& kv : label_set) {

    const auto entry_it = fields.find(kv.first);

    if (entry_it == fields.end()) {

      return false;

    }

    if (list_as_any && entry_it->second.kind_case() == Protobuf::Value::kListValue) {

      bool any_match = false;

      for (const auto& v : entry_it->second.list_value().values()) {

        if (ValueUtil::equal(v, kv.second)) {

          any_match = true;

          break;

        }

      }

      if (!any_match) {

        return false;

      }

    } else if (!ValueUtil::equal(entry_it->second, kv.second)) {

      return false;

    }

  }

  return true;

}

Metadata::getConstMetadataSharedPool(Singleton::Manager& manager, Event::Dispatcher& dispatcher) {

  return manager.getTyped<SharedPool::ObjectSharedPool<const envoy::config::core::v3::Metadata,

                                                       MessageUtil, MessageUtil>>(

      SINGLETON_MANAGER_REGISTERED_NAME(const_metadata_shared_pool), [&dispatcher] {

        return std::make_shared<SharedPool::ObjectSharedPool<

            const envoy::config::core::v3::Metadata, MessageUtil, MessageUtil>>(dispatcher);

      });

}