Swift - Access Control

To restrict access to code blocks, modules and abstraction is done through access control. Classes, structures and enumerations can be accessed according to their properties, methods, initializers and subscripts by access control mechanisms. Constants, variables and functions in a protocol are restricted and allowed access as global and local through access control. Access control applied to properties, types and functions can be referred as 'entities'.

Access control model is based on modules and source files.

Module is defined as a single unit of code distribution and can be imported using the keyword 'import'. A source file is defined as a single source code file with in a module to access multiple types and functions.

Three different access levels are provided by Swift 4 language. They are Public, Internal and Private access.

S.No	Access Levels & Definition
1	Public Enables entities to be processed with in any source file from their defining module, a source file from another module that imports the defining module.
2	Internal Enables entities to be used within any source file from their defining module, but not in any source file outside of that module.
3	Private Restricts the use of an entity to its own defining source file. Private access plays role to hide the implementation details of a specific code functionality.

Syntax

public class SomePublicClass {} 
 internal class SomeInternalClass {} 
 private class SomePrivateClass {} 
   public var somePublicVariable = 0  
internal let someInternalConstant = 0 
 private func somePrivateFunction() {}  

Access Control for Function types

Some functions may have arguments declared inside the function without any return values. The following program declares a and b as arguments to the sum() function. Inside the function itself the values for arguments a and b are passed by invoking the function call sum() and its values are printed thereby eliminating return values. To make the function's return type as private, declare the function's overall access level with the private modifier.

private func sum(a: Int, b: Int) { 
    let a = a + b  
   let b = a - b  
   print(a, b)  } 
   sum(a: 20, b: 10)  sum(a: 40, b: 10)
  sum(a: 24, b: 6)

When we run the above program using playground, we get the following result −

30 
20 
 50
 40 
 30
 24  

Access Control for Enumeration types

public enum Student { 
    case Name(String)  
   case Mark(Int,Int,Int)  } 
 var studDetails = Student.Name("Swift 4")
  var studMarks = Student.Mark(98,97,95)  
  switch studMarks {   
  case .Name(let studName):    
    print("Student name is: \(studName).")  
   case .Mark(let Mark1, let Mark2, let Mark3): 
       print("Student Marks are: \(Mark1),\(Mark2),\(Mark3).")  
     }

When we run the above program using playground, we get the following result −

Student Marks are: 98,97,95  

Enumeration in Swift 4 language automatically receive the same access level for individual cases of an enumeration. Consider for example to access the students name and marks secured in three subjects enumeration name is declared as student and the members present in enum class are name which belongs to string datatype, marks are represented as mark1, mark2 and mark3 of datatype Integer. To access either the student name or marks they have scored. Now, the switch case will print student name if that case block is executed otherwise it will print the marks secured by the student. If both condition fails the default block will be executed.

Access Control for SubClasses

Swift 4 allows the user to subclass any class that can be accessed in the current access context. A subclass cannot have a higher access level than its superclass. The user is restricted from writing a public subclass of an internal superclass.

public class cricket { 
    internal func printIt() {   
     print("Welcome to Swift 4 Super Class") 
    } 
 }  
  internal class tennis: cricket { 
    override internal func printIt() {  
      print("Welcome to Swift 4 Sub Class") 
    } 
 }
    let cricinstance = cricket()  cricinstance.printIt()  
  let tennisinstance = tennis() 
 tennisinstance.printIt()

When we run the above program using playground, we get the following result −

Welcome to Swift Super Class  Welcome to Swift Sub Class  

Access Control for Constants, variables, properties and subscripts

Swift 4 constant, variable, or property cannot be defined as public than its type. It is not valid to write a public property with a private type. Similarly, a subscript cannot be more public than its index or return type.

When a constant, variable, property, or subscript makes use of a private type, the constant, variable, property, or subscript must also be marked as private −

private var privateInstance = SomePrivateClass()  

Getters and Setters

Getters and setters for constants, variables, properties, and subscripts automatically receive the same access level as the constant, variable, property, or subscript they belong to.

class Samplepgm {  
   var counter: Int = 0{  
      willSet(newTotal) { 
          print("Total Counter is: \(newTotal)")  
      }  
      didSet {
           if counter > oldValue { 
             print("Newly Added Counter \(counter - oldValue)")
           } 
       }  
   } 
 } 
   let NewCounter = Samplepgm()  NewCounter.counter = 100 
 NewCounter.counter = 800

When we run the above program using playground, we get the following result −

Total Counter is: 100
  Newly Added Counter 100  
Total Counter is: 800 
 Newly Added Counter 700  

Access Control for Initializers and Default Initializers

Custom initializers can be assigned an access level less than or equal to the type that they initialize. A required initializer must have the same access level as the class it belongs to. The types of an initializer's parameters cannot be more private than the initializer's own access level.

To declare each and every subclass of the initialize 'required' keyword needs to be defined before the init() function.

class classA {  
   required init() { 
       let a = 10     
   print(a)  
   }  
}  class classB: classA { 
    required init() {  
      let b = 30 
       print(b)     
}  }  let res = classA() 
 let print = classB()

When we run the above program using playground, we get the following result −

10 
 30 
 10  

A default initializer has the same access level as the type it initializes, unless that type is defined as public. When default initialize is defined as public it is considered internal. When the user needs a public type to be initializable with a no-argument initializer in another module, provide explicitly a public no-argument initializer as part of the type's definition.

Access Control for Protocols

When we define a new protocol to inherit functionalities from an existing protocol, both has to be declared the same access levels to inherit the properties of each other. Swift 4 access control won’t allow the users to define a 'public' protocol that inherits from an 'internal' protocol.

public protocol tcpprotocol { 
    init(no1: Int)  } 
 public class mainClass {     var no1: Int     
 // local storage     init(no1: Int) {   
     self.no1 = no1 // initialization     
}  
}  class subClass: mainClass, tcpprotocol { 
    var no2: Int     init(no1: Int, no2 : Int) 
{        self.no2 = no2 
       super.init(no1:no1)     } 
         // Requires only one parameter for convenient method 
    required override convenience init(no1: Int) { 
       self.init(no1:no1, no2:0) 
    } 
 }   
 let res = mainClass(no1: 20)  let print = subClass(no1: 30, no2: 50)  
  print("res is: \(res.no1)") 
 print("res is: \(print.no1)")  
print("res is: \(print.no2)")

When we run the above program using playground, we get the following result −

res is: 20  res is: 30  res is: 50  

Access Control for Extensions

Swift 4 does not allow the users to provide an explicit access level modifier for an extension when the user uses that extension to add protocol conformance. The default access level for each protocol requirement implementation within the extension is provided with its own protocol access level.

Access Control for Generics

Generics allow the user to specify minimum access levels to access the type constraints on its type parameters.

public struct TOS<T> {
     var items = [T]()     mutating func push(item: T) {
        items.append(item)     }  
   mutating func pop() -> T {     
   return items.removeLast()  
   } 
 }  
  var tos = TOS<String>() 
 tos.push(item: "Swift 4") 
 print(tos.items)    tos.push(item: "Generics") 
 print(tos.items)    tos.push(item: "Type Parameters") 
 print(tos.items)    tos.push(item: "Naming Type Parameters")
  print(tos.items)  let deletetos = tos.pop()

When we run the above program using playground, we get the following result −

[Swift 4]  [Swift 4, Generics] 
 [Swift 4, Generics, Type Parameters]  
[Swift 4, Generics, Type Parameters, Naming Type Parameters]  

Access Control for Type Aliases

The user can define type aliases to treat distinct access control types. Same access level or different access levels can be defined by the user. When type alias is 'private' its associated members can be declared as 'private, internal of public type'. When type alias is public the members cannot be alias as an 'internal' or 'private' name

Any type aliases you define are treated as distinct types for the purposes of access control. A type alias can have an access level less than or equal to the access level of the type it aliases. For example, a private type alias can alias a private, internal, or public type, but a public type alias cannot alias an internal or private type.

public protocol Container { 
    associatedtype ItemType     mutating func append(item: ItemType) 
    var count: Int { get } 
    subscript(i: Int) -> ItemType { get }
  }  
struct Stack<T>: Container { 
    // original Stack<T> implementation     var items = [T]() 
    mutating func push(item: T) { 
       items.append(item)     }  
   mutating func pop() -> T { 
       return items.removeLast()     } 
// conformance to the Container protocol  
   mutating func append(item: T) {        self.push(item
: item)     }     var count: Int {
        return items.count     }     subscript(i: Int) -> T {  
      return items[i]    
 }
  } 
 func allItemsMatch<     C1: Container, C2: Container   
  where C1.ItemType == C2.ItemType, C1.ItemType: Equatable> 
    (someContainer: C1, anotherContainer: C2) -> Bool { 
 // check that both containers contain the same number of items  
   if someContainer.count != anotherContainer.count { 
       return false     }
          // check each pair of items to see if they are equivalent 
    for i in 0..<someContainer.count {
        if someContainer[i] != anotherContainer[i] {  
         return false        
} 
    } 
    // all items match, so return true   
  return true  } 
 var tos = Stack<String>()
  tos.push(item: "Swift 4") 
 print(tos.items)  
  tos.push(item: "Generics")
  print(tos.items)   
 tos.push(item: "Where Clause") 
 print(tos.items)   
 var eos = ["Swift 4",
 "Generics", "Where Clause"] 
 print(eos)

When we run the above program using playground, we get the following result −

[Swift 4] 
 [Swift 4, Generics] 
 [Swift 4, Generics, Where Clause]
  [Swift 4, Generics, Where Clause]  

Swift Encoding and Decoding

Swift 4 introduces a new Codable Protocol, that let’s you serialize and De-serialize custom data types without writing any special code – and without having to worry about losing your value types.

struct Language: Codable { 
    var name: String  
   var version: Int  } 
 let swift = Language(name: "Swift", version: 4)
  let java = Language(name: "java", version: 8)
  let R = Language(name: "R", version: 3

Notice that Langauage is conforming to Codable Protocol. Now we’ll convert it to a Json Data Representation using one simple line.

let encoder = JSONEncoder() 
 if let encoded = try? encoder.encode(java) {
     //Perform some operations on this value.
  }

Swift will automatically encode all the values inside your data type.

You can decode the data using Decoder function like

let decoder = JSONDecoder()
  if let decoded = try? decoder.decode(Language.self, from: encoded)
 { 
    //Perform some operations on this value.
  }

Both JSONEncoder and its property list counterpart PropertyListEncoder have lots of options for customizing how they work.