[HTTPConnectionPool] Move Connections down in the file

Author: fabianfett

Sources/AsyncHTTPClient/ConnectionPool/HTTPConnectionPool.swift

@@ -22,113 +22,6 @@ protocol HTTPConnectionPoolDelegate{
 }
 
 finalclassHTTPConnectionPool{
-structConnection:Hashable{
-typealiasID=Int
-
-privateenumReference{
-case http1_1(HTTP1Connection)
-case http2(HTTP2Connection)
-case __testOnly_connection(ID,EventLoop)
-}
-
-privatelet_ref:Reference
-
-fileprivatestaticfunc http1_1(_ conn:HTTP1Connection)->Self{
-Connection(_ref:.http1_1(conn))
-}
-
-fileprivatestaticfunc http2(_ conn:HTTP2Connection)->Self{
-Connection(_ref:.http2(conn))
-}
-
-staticfunc __testOnly_connection(id:ID, eventLoop:EventLoop)->Self{
-Connection(_ref:.__testOnly_connection(id, eventLoop))
-}
-
-varid:ID{
-switchself._ref {
-case.http1_1(let connection):
-return connection.id
-case.http2(let connection):
-return connection.id
-case.__testOnly_connection(let id, _):
-return id
-}
-}
-
-vareventLoop:EventLoop{
-switchself._ref {
-case.http1_1(let connection):
-return connection.channel.eventLoop
-case.http2(let connection):
-return connection.channel.eventLoop
-case.__testOnly_connection(_,let eventLoop):
-return eventLoop
-}
-}
-
-fileprivatefunc executeRequest(_ request:HTTPExecutableRequest){
-switchself._ref {
-case.http1_1(let connection):
-return connection.executeRequest(request)
-case.http2(let connection):
-return connection.executeRequest(request)
-case.__testOnly_connection:
-break
-}
-}
-
- /// Shutdown cancels any running requests on the connection and then closes the connection
-fileprivatefunc shutdown(){
-switchself._ref {
-case.http1_1(let connection):
-return connection.shutdown()
-case.http2(let connection):
-return connection.shutdown()
-case.__testOnly_connection:
-break
-}
-}
-
- /// Closes the connection without cancelling running requests. Use this when you are sure, that the
- /// connection is currently idle.
-fileprivatefunc close(promise:EventLoopPromise<Void>?){
-switchself._ref {
-case.http1_1(let connection):
-return connection.close(promise: promise)
-case.http2(let connection):
-return connection.close(promise: promise)
-case.__testOnly_connection:
- promise?.succeed(())
-}
-}
-
-staticfunc==(lhs:HTTPConnectionPool.Connection, rhs:HTTPConnectionPool.Connection)->Bool{
-switch(lhs._ref, rhs._ref){
-case(.http1_1(let lhsConn),.http1_1(let rhsConn)):
-return lhsConn.id == rhsConn.id
-case(.http2(let lhsConn),.http2(let rhsConn)):
-return lhsConn.id == rhsConn.id
-case(.__testOnly_connection(let lhsID,let lhsEventLoop),.__testOnly_connection(let rhsID,let rhsEventLoop)):
-return lhsID == rhsID && lhsEventLoop === rhsEventLoop
-default:
-returnfalse
-}
-}
-
-func hash(into hasher:inoutHasher){
-switchself._ref {
-case.http1_1(let conn):
- hasher.combine(conn.id)
-case.http2(let conn):
- hasher.combine(conn.id)
-case.__testOnly_connection(let id,let eventLoop):
- hasher.combine(id)
- hasher.combine(eventLoop.id)
-}
-}
-}
-
 privateletstateLock=Lock()
 privatevar_state:StateMachine
 
@@ -530,6 +423,115 @@ extension HTTPConnectionPool: HTTPRequestScheduler{
 }
 }
 
+extensionHTTPConnectionPool{
+structConnection:Hashable{
+typealiasID=Int
+
+privateenumReference{
+case http1_1(HTTP1Connection)
+case http2(HTTP2Connection)
+case __testOnly_connection(ID,EventLoop)
+}
+
+privatelet_ref:Reference
+
+fileprivatestaticfunc http1_1(_ conn:HTTP1Connection)->Self{
+Connection(_ref:.http1_1(conn))
+}
+
+fileprivatestaticfunc http2(_ conn:HTTP2Connection)->Self{
+Connection(_ref:.http2(conn))
+}
+
+staticfunc __testOnly_connection(id:ID, eventLoop:EventLoop)->Self{
+Connection(_ref:.__testOnly_connection(id, eventLoop))
+}
+
+varid:ID{
+switchself._ref {
+case.http1_1(let connection):
+return connection.id
+case.http2(let connection):
+return connection.id
+case.__testOnly_connection(let id, _):
+return id
+}
+}
+
+vareventLoop:EventLoop{
+switchself._ref {
+case.http1_1(let connection):
+return connection.channel.eventLoop
+case.http2(let connection):
+return connection.channel.eventLoop
+case.__testOnly_connection(_,let eventLoop):
+return eventLoop
+}
+}
+
+fileprivatefunc executeRequest(_ request:HTTPExecutableRequest){
+switchself._ref {
+case.http1_1(let connection):
+return connection.executeRequest(request)
+case.http2(let connection):
+return connection.executeRequest(request)
+case.__testOnly_connection:
+break
+}
+}
+
+ /// Shutdown cancels any running requests on the connection and then closes the connection
+fileprivatefunc shutdown(){
+switchself._ref {
+case.http1_1(let connection):
+return connection.shutdown()
+case.http2(let connection):
+return connection.shutdown()
+case.__testOnly_connection:
+break
+}
+}
+
+ /// Closes the connection without cancelling running requests. Use this when you are sure, that the
+ /// connection is currently idle.
+fileprivatefunc close(promise:EventLoopPromise<Void>?){
+switchself._ref {
+case.http1_1(let connection):
+return connection.close(promise: promise)
+case.http2(let connection):
+return connection.close(promise: promise)
+case.__testOnly_connection:
+ promise?.succeed(())
+}
+}
+
+staticfunc==(lhs:HTTPConnectionPool.Connection, rhs:HTTPConnectionPool.Connection)->Bool{
+switch(lhs._ref, rhs._ref){
+case(.http1_1(let lhsConn),.http1_1(let rhsConn)):
+return lhsConn.id == rhsConn.id
+case(.http2(let lhsConn),.http2(let rhsConn)):
+return lhsConn.id == rhsConn.id
+case(.__testOnly_connection(let lhsID,let lhsEventLoop),.__testOnly_connection(let rhsID,let rhsEventLoop)):
+return lhsID == rhsID && lhsEventLoop === rhsEventLoop
+default:
+returnfalse
+}
+}
+
+func hash(into hasher:inoutHasher){
+switchself._ref {
+case.http1_1(let conn):
+ hasher.combine(conn.id)
+case.http2(let conn):
+ hasher.combine(conn.id)
+case.__testOnly_connection(let id,let eventLoop):
+ hasher.combine(id)
+ hasher.combine(eventLoop.id)
+}
+}
+}
+}
+
 extensionHTTPConnectionPool{
  /// This is a wrapper that we use inside the connection pool state machine to ensure that
  /// the actual request can not be accessed at any time. Further it exposes all that is needed within