format: add checks for type alias

include/envoy/buffer/buffer.h

@@ -381,6 +381,7 @@ class Instance {
 };
 
 using InstancePtr = std::unique_ptr<Instance>;
+using InstanceSharedPtr = std::shared_ptr<Instance>;
 
 /**
  * A factory for creating buffers which call callbacks when reaching high and low watermarks.

include/envoy/config/grpc_mux.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <memory>
+
 #include "envoy/common/exception.h"
 #include "envoy/common/pure.h"
 #include "envoy/config/subscription.h"
@@ -119,6 +121,7 @@ class GrpcMux {
 using GrpcMuxPtr = std::unique_ptr<GrpcMux>;
 using GrpcMuxSharedPtr = std::shared_ptr<GrpcMux>;
 
+template <class ResponseProto> using ResponseProtoPtr = std::unique_ptr<ResponseProto>;
 /**
  * A grouping of callbacks that a GrpcMux should provide to its GrpcStream.
  */
@@ -141,7 +144,7 @@ template <class ResponseProto> class GrpcStreamCallbacks {
   /**
    * For the GrpcStream to pass received protos to the context.
    */
-  virtual void onDiscoveryResponse(std::unique_ptr<ResponseProto>&& message,
+  virtual void onDiscoveryResponse(ResponseProtoPtr<ResponseProto>&& message,
                                    ControlPlaneStats& control_plane_stats) PURE;
 
   /**

include/envoy/config/typed_metadata.h

@@ -21,6 +21,8 @@ class TypedMetadata {
     virtual ~Object() = default;
   };
 
+  using ObjectConstPtr = std::unique_ptr<const Object>;
+
   virtual ~TypedMetadata() = default;
 
   /**
@@ -47,6 +49,8 @@ class TypedMetadata {
   virtual const Object* getData(const std::string& key) const PURE;
 };
 
+using TypedMetadataPtr = std::unique_ptr<TypedMetadata>;
+
 /**
  * Typed metadata should implement this factory and register via Registry::registerFactory or the
  * convenience class RegisterFactory.
@@ -62,8 +66,7 @@ class TypedMetadataFactory : public UntypedFactory {
    * @return a derived class object pointer of TypedMetadata.
    * @throw EnvoyException if the parsing can't be done.
    */
-  virtual std::unique_ptr<const TypedMetadata::Object>
-  parse(const ProtobufWkt::Struct& data) const PURE;
+  virtual TypedMetadata::ObjectConstPtr parse(const ProtobufWkt::Struct& data) const PURE;
 
   std::string category() const override { return "envoy.typed_metadata"; }
 };

include/envoy/event/dispatcher.h

@@ -41,11 +41,15 @@ struct DispatcherStats {
   ALL_DISPATCHER_STATS(GENERATE_HISTOGRAM_STRUCT)
 };
 
+using DispatcherStatsPtr = std::unique_ptr<DispatcherStats>;
+
 /**
  * Callback invoked when a dispatcher post() runs.
  */
 using PostCb = std::function<void()>;
 
+using PostCbSharedPtr = std::shared_ptr<PostCb>;
+
 /**
  * Abstract event dispatching loop.
  */

include/envoy/filesystem/filesystem.h

@@ -130,6 +130,8 @@ class Instance {
   virtual bool illegalPath(const std::string& path) PURE;
 };
 
+using InstancePtr = std::unique_ptr<Instance>;
+
 enum class FileType { Regular, Directory, Other };
 
 struct DirectoryEntry {

include/envoy/http/header_map.h

@@ -70,6 +70,8 @@ class LowerCaseString {
   std::string string_;
 };
 
+using LowerCaseStringPtr = std::unique_ptr<LowerCaseString>;
+
 /**
  * Convenient type for a vector of lower case string and string pair.
  */
@@ -717,6 +719,8 @@ class RequestOrResponseHeaderMap : public HeaderMap {
   INLINE_REQ_RESP_HEADERS(DEFINE_INLINE_HEADER)
 };
 
+using RequestOrResponseHeaderMapPtr = std::unique_ptr<RequestOrResponseHeaderMap>;
+
 // Request headers.
 class RequestHeaderMap
     : public RequestOrResponseHeaderMap,
@@ -748,14 +752,18 @@ class ResponseHeaderMap
 public:
   INLINE_RESP_HEADERS(DEFINE_INLINE_HEADER)
 };
+
 using ResponseHeaderMapPtr = std::unique_ptr<ResponseHeaderMap>;
+using ResponseHeaderMapSharedPtr = std::shared_ptr<ResponseHeaderMap>;
 
 // Response trailers.
 class ResponseTrailerMap
     : public ResponseHeaderOrTrailerMap,
       public HeaderMap,
       public CustomInlineHeaderBase<CustomInlineHeaderRegistry::Type::ResponseTrailers> {};
+
 using ResponseTrailerMapPtr = std::unique_ptr<ResponseTrailerMap>;
+using ResponseTrailerMapSharedPtr = std::shared_ptr<ResponseTrailerMap>;
 
 /**
  * Convenient container type for storing Http::LowerCaseString and std::string key/value pairs.

include/envoy/http/message.h

@@ -9,6 +9,8 @@
 namespace Envoy {
 namespace Http {
 
+template <class TrailerType> using TrailerTypePtr = std::unique_ptr<TrailerType>;
+
 /**
  * Wraps an HTTP message including its headers, body, and any trailers.
  */
@@ -36,7 +38,7 @@ template <class HeaderType, class TrailerType> class Message {
    * Set the trailers.
    * @param trailers supplies the new trailers.
    */
-  virtual void trailers(std::unique_ptr<TrailerType>&& trailers) PURE;
+  virtual void trailers(TrailerTypePtr<TrailerType>&& trailers) PURE;
 
   /**
    * @return std::string the message body as a std::string.

include/envoy/http/metadata_interface.h

@@ -52,6 +52,8 @@ class MetadataMapVector : public VectorMetadataMapPtr {
   }
 };
 
+using MetadataMapVectorPtr = std::unique_ptr<MetadataMapVector>;
+
 using MetadataCallback = std::function<void(MetadataMapPtr&&)>;
 
 } // namespace Http

include/envoy/init/manager.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <memory>
+
 #include "envoy/common/pure.h"
 #include "envoy/init/target.h"
 #include "envoy/init/watcher.h"
@@ -75,5 +77,7 @@ struct Manager {
   virtual void initialize(const Watcher& watcher) PURE;
 };
 
+using ManagerPtr = std::unique_ptr<Manager>;
+
 } // namespace Init
 } // namespace Envoy

include/envoy/network/connection.h

@@ -93,6 +93,8 @@ class Connection : public Event::DeferredDeletable, public FilterManager {
     Stats::Counter* delayed_close_timeouts_;
   };
 
+  using ConnectionStatsPtr = std::unique_ptr<ConnectionStats>;
+
   ~Connection() override = default;
 
   /**

include/envoy/network/filter.h

@@ -364,6 +364,7 @@ class FilterChain {
 };
 
 using FilterChainSharedPtr = std::shared_ptr<FilterChain>;
+using FilterChainOptConstRef = absl::optional<std::reference_wrapper<const FilterChain>>;
 
 /**
  * A filter chain that can be drained.

include/envoy/network/socket.h

@@ -192,6 +192,7 @@ class Socket {
 
   using OptionConstSharedPtr = std::shared_ptr<const Option>;
   using Options = std::vector<OptionConstSharedPtr>;
+  using OptionsPtr = std::unique_ptr<Options>;
   using OptionsSharedPtr = std::shared_ptr<Options>;
 
   static OptionsSharedPtr& appendOptions(OptionsSharedPtr& to, const OptionsSharedPtr& from) {

include/envoy/registry/registry.h

@@ -3,6 +3,7 @@
 #include <algorithm>
 #include <functional>
 #include <map>
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -70,6 +71,9 @@ template <class Base> class FactoryRegistryProxyImpl : public FactoryRegistryPro
   }
 };
 
+template <class Base>
+using FactoryRegistryProxyImplPtr = std::unique_ptr<FactoryRegistryProxyImpl<Base>>;
+
 /**
  * BaseFactoryCategoryRegistry holds the static factory map for
  * FactoryCategoryRegistry, ensuring that friends of that class

include/envoy/router/route_config_provider_manager.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <memory>
 #include <string>
 
 #include "envoy/config/route/v3/route.pb.h"
@@ -55,5 +56,8 @@ class RouteConfigProviderManager {
                                   ProtobufMessage::ValidationVisitor& validator) PURE;
 };
 
+using RouteConfigProviderManagerPtr = std::unique_ptr<RouteConfigProviderManager>;
+using RouteConfigProviderManagerSharedPtr = std::shared_ptr<RouteConfigProviderManager>;
+
 } // namespace Router
 } // namespace Envoy

include/envoy/router/router.h

@@ -574,6 +574,7 @@ using MetadataMatchCriterionConstSharedPtr = std::shared_ptr<const MetadataMatch
 
 class MetadataMatchCriteria;
 using MetadataMatchCriteriaConstPtr = std::unique_ptr<const MetadataMatchCriteria>;
+using MetadataMatchCriteriaSharedPtr = std::shared_ptr<MetadataMatchCriteria>;
 
 class MetadataMatchCriteria {
 public:
@@ -1098,6 +1099,8 @@ using ConfigConstSharedPtr = std::shared_ptr<const Config>;
 class GenericConnectionPoolCallbacks;
 class GenericUpstream;
 
+using GenericUpstreamPtr = std::unique_ptr<GenericUpstream>;
+
 /**
  * An API for wrapping either an HTTP or a TCP connection pool.
  *
@@ -1184,7 +1187,7 @@ class GenericConnectionPoolCallbacks {
    * @param upstream_local_address supplies the local address of the upstream connection.
    * @param info supplies the stream info object associated with the upstream connection.
    */
-  virtual void onPoolReady(std::unique_ptr<GenericUpstream>&& upstream,
+  virtual void onPoolReady(GenericUpstreamPtr&& upstream,
                            Upstream::HostDescriptionConstSharedPtr host,
                            const Network::Address::InstanceConstSharedPtr& upstream_local_address,
                            const StreamInfo::StreamInfo& info) PURE;

include/envoy/router/router_ratelimit.h

@@ -91,6 +91,8 @@ class RateLimitPolicyEntry {
                       const envoy::config::core::v3::Metadata* dynamic_metadata) const PURE;
 };
 
+using RateLimitPolicyEntryPtr = std::unique_ptr<RateLimitPolicyEntry>;
+
 /**
  * Rate limiting policy.
  */

include/envoy/runtime/runtime.h

@@ -278,6 +278,7 @@ using LoaderPtr = std::unique_ptr<Loader>;
 // protos being enabled or disabled by default.
 using LoaderSingleton = InjectableSingleton<Loader>;
 using ScopedLoaderSingleton = ScopedInjectableLoader<Loader>;
+using ScopedLoaderSingletonPtr = std::unique_ptr<ScopedLoaderSingleton>;
 
 } // namespace Runtime
 } // namespace Envoy

include/envoy/secret/secret_manager.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <memory>
 #include <string>
 
 #include "envoy/config/core/v3/config_source.pb.h"
@@ -156,5 +157,7 @@ class SecretManager {
       Server::Configuration::TransportSocketFactoryContext& secret_provider_context) PURE;
 };
 
+using SecretManagerPtr = std::unique_ptr<SecretManager>;
+
 } // namespace Secret
 } // namespace Envoy

include/envoy/server/config_tracker.h

@@ -23,6 +23,7 @@ class ConfigTracker {
 public:
   using Cb = std::function<ProtobufTypes::MessagePtr()>;
   using CbsMap = std::map<std::string, Cb>;
+  using CbsMapSharedPtr = std::shared_ptr<CbsMap>;
 
   /**
    * EntryOwner supplies RAII semantics for entries in the map.
@@ -55,5 +56,7 @@ class ConfigTracker {
   virtual EntryOwnerPtr add(const std::string& key, Cb cb) PURE;
 };
 
+using ConfigTrackerSharedPtr = std::shared_ptr<ConfigTracker>;
+
 } // namespace Server
 } // namespace Envoy

include/envoy/server/factory_context.h

@@ -105,6 +105,8 @@ class CommonFactoryContext {
   virtual Api::Api& api() PURE;
 };
 
+using CommonFactoryContextPtr = std::unique_ptr<CommonFactoryContext>;
+
 /**
  * ServerFactoryContext is an specialization of common interface for downstream and upstream network
  * filters. The implementation guarantees the lifetime is no shorter than server. It could be used
@@ -249,6 +251,7 @@ class FilterChainFactoryContext : public virtual FactoryContext {
 };
 
 using FilterChainFactoryContextPtr = std::unique_ptr<FilterChainFactoryContext>;
+using FilterChainFactoryContextSharedPtr = std::shared_ptr<FilterChainFactoryContext>;
 
 /**
  * An implementation of FactoryContext. The life time should cover the lifetime of the filter chains

include/envoy/server/guarddog.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <memory>
+
 #include "envoy/common/pure.h"
 #include "envoy/server/watchdog.h"
 
@@ -42,5 +44,7 @@ class GuardDog {
   virtual void stopWatching(WatchDogSharedPtr wd) PURE;
 };
 
+using GuardDogPtr = std::unique_ptr<GuardDog>;
+
 } // namespace Server
 } // namespace Envoy

include/envoy/server/health_checker_config.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <memory>
+
 #include "envoy/common/random_generator.h"
 #include "envoy/config/core/v3/health_check.pb.h"
 #include "envoy/config/typed_config.h"
@@ -53,6 +55,8 @@ class HealthCheckerFactoryContext {
   virtual Api::Api& api() PURE;
 };
 
+using HealthCheckerFactoryContextPtr = std::unique_ptr<HealthCheckerFactoryContext>;
+
 /**
  * Implemented by each custom health checker and registered via Registry::registerFactory()
  * or the convenience class RegisterFactory.

include/envoy/server/hot_restart.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <cstdint>
+#include <memory>
 #include <string>
 
 #include "envoy/common/pure.h"
@@ -101,6 +102,8 @@ class HotRestart {
   virtual Thread::BasicLockable& accessLogLock() PURE;
 };
 
+using HotRestartPtr = std::unique_ptr<HotRestart>;
+
 /**
  * HotRestartDomainSocketInUseException is thrown during HotRestart construction only when the
  * underlying domain socket is in use.

include/envoy/server/listener_manager.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <memory>
 #include <vector>
 
 #include "envoy/admin/v3/config_dump.pb.h"
@@ -223,5 +224,7 @@ class ListenerManager {
   virtual ApiListenerOptRef apiListener() PURE;
 };
 
+using ListenerManagerPtr = std::unique_ptr<ListenerManager>;
+
 } // namespace Server
 } // namespace Envoy

include/envoy/server/overload_manager.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <memory>
 #include <string>
 #include <unordered_map>
 
@@ -91,5 +92,7 @@ class OverloadManager {
   virtual ThreadLocalOverloadState& getThreadLocalOverloadState() PURE;
 };
 
+using OverloadManagerPtr = std::unique_ptr<OverloadManager>;
+
 } // namespace Server
 } // namespace Envoy