repeatedPtrFieldToVector(const Protobuf::RepeatedPtrField<std::string>& xs) {

  std::vector<std::string> ys;

  std::copy(xs.begin(), xs.end(), std::back_inserter(ys));

  return ys;

}

               const std::string& version) {

    if (resource.Is<envoy::service::discovery::v3::Resource>()) {

      envoy::service::discovery::v3::Resource r;

      RETURN_IF_NOT_OK(MessageUtil::unpackTo(resource, r));

      r.set_version(version);

      return std::make_unique<DecodedResourceImpl>(resource_decoder, r);

    }

    return std::unique_ptr<DecodedResourceImpl>(new DecodedResourceImpl(

        resource_decoder, absl::nullopt, Protobuf::RepeatedPtrField<std::string>(), resource, true,

        version, absl::nullopt, absl::nullopt));

  }

               const envoy::service::discovery::v3::Resource& resource) {

    return std::make_unique<DecodedResourceImpl>(resource_decoder, resource);

  }

      : DecodedResourceImpl(

            resource_decoder, resource.name(), resource.aliases(), resource.resource(),

            resource.has_resource(), resource.version(),

            resource.has_ttl() ? absl::make_optional(std::chrono::milliseconds(

                                     DurationUtil::durationToMilliseconds(resource.ttl())))

                               : absl::nullopt,

            resource.has_metadata() ? absl::make_optional(resource.metadata()) : absl::nullopt) {}

      : DecodedResourceImpl(resource_decoder, inline_entry.name(),

                            Protobuf::RepeatedPtrField<std::string>(), inline_entry.resource(),

                            true, inline_entry.version(), absl::nullopt, absl::nullopt) {}

      : resource_(std::move(resource)), has_resource_(true), name_(name), aliases_(aliases),

        version_(version), ttl_(absl::nullopt), metadata_(absl::nullopt) {}

  const std::string& name() const override { return name_; }

  const std::vector<std::string>& aliases() const override { return aliases_; }

  const std::string& version() const override { return version_; };

  const Protobuf::Message& resource() const override { return *resource_; };

  bool hasResource() const override { return has_resource_; }

  absl::optional<std::chrono::milliseconds> ttl() const override { return ttl_; }

  const OptRef<const envoy::config::core::v3::Metadata> metadata() const override {

    return metadata_.has_value() ? makeOptRef(metadata_.value()) : absl::nullopt;

  }

      : resource_(resource_decoder.decodeResource(resource)), has_resource_(has_resource),

        name_(name ? *name : resource_decoder.resourceName(*resource_)),

        aliases_(repeatedPtrFieldToVector(aliases)), version_(version), ttl_(ttl),

        metadata_(metadata) {}

  DecodedResourcesWrapper() = default;

         const Protobuf::RepeatedPtrField<Protobuf::Any>& resources, const std::string& version) {

    std::unique_ptr<DecodedResourcesWrapper> ret = std::make_unique<DecodedResourcesWrapper>();

    for (const auto& resource : resources) {

      absl::StatusOr<DecodedResourceImplPtr> resource_or_error =

          DecodedResourceImpl::fromResource(resource_decoder, resource, version);

      RETURN_IF_NOT_OK_REF(resource_or_error.status());

      ret->pushBack(std::move(resource_or_error.value()));

    }

    return ret;

  }

  void pushBack(Config::DecodedResourcePtr&& resource) {

    owned_resources_.push_back(std::move(resource));

    refvec_.emplace_back(*owned_resources_.back());

  }