Hi, I’m using Network Framework to implement a UDP client via NWConnection, and I’m looking for clarification about the correct and fully safe shutdown procedure, especially regarding resource release. I have initiated some pending receive calls on the NWConnection (using receive). After calling connection.cancel(), do we need to wait for the cancellation of these pending receives? As mentioned in this thread, NWConnection retains references to the receive closures and releases them once they are called. If a receive closure holds a reference to the NWConnection itself, do we need to wait for these closures to be called to avoid memory leaks? Or, if there are no such retained references, we don't need to wait for the cancellation of the pending I/O and cancelled state for NWConnection?

Hi, I’m using Network Framework to implement a UDP listener via NWListener. I am looking for clarification about the correct and fully safe shutdown procedure, especially regarding resource release. After calling listener.cancel(), do we need to wait for the .cancelled state before exiting the application? Or can we just exit once the cancellation is initiated, assuming the OS will close the NWListener and there will be no resource leak? Is it recommended (or required) to set newConnectionHandler = nil when shutting down a UDP listener? My understanding is that if there is no NWListener attached, then whenever a connection is accepted by the OS, it will not be delivered to the application and the OS will simply drop it.

Hi Everyone, I have a query regarding capturing an NWConnection instance inside the receive closure, which gets invoked whenever some raw bytes are received. I want to know whether this will create a strong retain cycle or not. My understanding is that NWConnection holds a reference to the closure, and if I capture the NWConnection instance inside the closure, the closure will have a reference back to the connection, which, according to my understanding, creates a strong reference cycle. Is my understanding correct? If so, how can we break the strong reference cycle — using a capture list, or is there any other way as well? Thanks

I was exploring the scenarios where an NWListener or NWConnection can be invalidated or reclaimed by the OS itself. I came across the document TN2277: Networking and Multitasking, which discusses situations where iOS can reclaim the underlying socket descriptor. The document states: while the app is suspended the system may choose to reclaim resources out from underneath a network socket used by the app, thereby closing the network connection represented by that socket. From this, I understand that when the app is in a suspended state, the OS may reclaim the socket descriptor. My questions are: In what scenarios does the OS not reclaim the socket descriptor while the app is suspended, and in which cases does it reclaim it? When reclamation occurs, does the OS reclaim 'a' single NWListener/NWConnection, or does it reclaim 'all' NWListener/NWConnections opened by the application? Thanks.

Hi, I am exploring Closures and trying to understand how they works. Closure have a special key feature that they can capture the context of the variables/constants from surroundings, once captured we can still use them inside the closure even if the scope in which they are defined does not exist. I want to understand the lifecycle of captured variable/constant i.e., where are these captured variables stored and when these get created and destroyed. How is memory managed for captured variables or constants in a closure, depending on whether they are value types or reference types?

I have a Class defined in C++, I want to pass the instance of class from C++ to Swift as a reference type. By default swift maps C++ classes as value types but we can change this behavior by using SWIFT_IMMORTAL_REFERENCE annotation mentioned here. The example mentioned here is of Singelton class but I have a usecase where i require more than one instance. Cpp Class Skeleton. class Cpp { public: void Print () noexcept; void SetValue (int pValue) noexcept; // Method which is Invoked by Swift. static Cpp& ReturnObj () noexcept; private: int vValue; } SWIFT_IMMORTAL_REFERENCE; Definition of Return Obj Cpp& Cpp::ReturnObj () noexcept { static Cpp obj; return obj; } Swift Co var obj : Cpp = Cpp.ReturnObj() withUnsafeBytes(of: &obj) {(pointer : UnsafeRawBufferPointer) in print (pointer) print (pointer.baseAddress!) } Output Address Printed by C++ 0x100008000 Address Printed by Swift 0x00007ff7bfeff108 So from the above observation copy is passed. How to do pass by reference then?

I have a Usecase where I want to pass user-defined swift structure instance from Swift to C++ as argument to the C++ Function. In the documentation it's mentioned that swift exposes these structures to c++. Swift Structure. public struct MyStruct { public init (_ pValue : Int) { uValue = pValue } public var uValue : Int } I am able to Create Instance in C++ . Code void CppClass::CreateSwiftStruct () { Interop::MyStruct my_struct = Interop::MyStruct::init (20); } But when I define a C++ Function which takes Interop::MyStruct as argument then that function doesn't get exposed to swift, so i am not able to call it. Skeleton For CppClass class CppClass { static void PassStruct (Interop::MyStruct pStruct); static void Test (); } Here PassStruct Method doesn't get exposed to C++ but Test does. How can I pass Struct Instance in swift to C++ Function as In Param?

I have a struct defined in Swift, i want to pass it's instance pointer from swift to C++. When I am trying to directly return Typed Pointer from Swift Function to C++, the function doesn't get expose to C++. Code which i have tried. // Defined Structure public struct MyStruct { public init (_ pValue : Int) { uValue = pValue } public var uValue : Int } var my_struct = MyStruct(20) // Function which returns Struct Pointer to C++ // When I return typed pointer this function doesn't get exposed to C++ public func PassStructPointer () -> UnsafeMutablePointer<MyStruct> { withUnsafeMutablePointer(to: &my_struct) { pointer in return pointer } } But when I pass UnsafeRawMutablePointer instead of type pointer then the function does get expose to C++ var my_struct = MyStruct(20) // This get expose to C++. public func PassStructPointer () -> UnsafeMutableRawPointer { return withUnsafeMutableBytes(of: &my_struct) { pointer in return pointer.baseAddress! } } Can we not pass typed pointer of the types defined by us?

I am trying to use the swift type UnsafeMutablePointer directly in C++. According to the documentation mentioned, swift expose this type to C++. But I am not able to use it . void GetPointerFromSwift () { // Calls a swift function to get a pointer. swift::UnsafeMutablePointer<swit::Int> x = Interop::GetPointer () }

I have a use case where I want to return reference from Swift Function just like we can do in C++. This is How we do it in C++: int & ReturnIntRef () noexcept { static int a = 4; return a; } Do we have equivalent of this in Swift ?

When i instantiate a structure defined in swift in C++ and then i pass it to swift function as a IN param, it is passed as a constant value to the function. Here the same structure instance is passed or a copy is created?

When we pass a input to swift function it is passed as a constant, so does copy gets created or not here? public func Test (_ pValue : Int) { print (pValue) } let x : Int = 2 Test (x)

I have a usecase, where I have Data instance as Data is Value type copy will be created on assignment. I want to prevent copying for which I was using this Initializer of Data. Will it prevent copying?.

I have a use-case where I want to pass the user defined swift structure instantiated in swift and then pass it to a C++ Function as a Input Param. Is there a way to do that?

Hi, I was trying to understand how swift manages it memory just wanted to verify my understanding on it. For Value Types i.e. Struct ARC (Automatic Reference Counting) is not there, Memory is Managed/Confined on the basis of scope of that Variable. And For Struct whenver we do assignment a Copy is been created. For Classes, Swift Manages Memroy with the help of ARC i.e. whenever I create a instance of class its reference count get increased and when we assign same instance to new variable then it also result in increment of Reference Count. The Memory will get deallocated when all the variables pointing to that object are no longer in use.