Attributes in Swift @available

-

Attributes in Swift


In Swift Attributes are used to provide some kind of additional information to a declaration or a type. For example if I want a function to be just available for iOS 12 version onwards. The Swift compiler will give warnings in such cases and provides suggestion to fix it as shown below.



You can download the example for it from GitHub

How do we declare an attribute?

Attribute declaration starts with "@" symbol and can also arguments which is enclosed in parentheses. Arguments specify some more information on how it applies to the existing attribute declaration.

@ attributename(attributearguments)

Example:  Here we have used attribute available and also gave more information on how it applies to the declaration , in this case it's only for iOS platform and available from12.5 version onwards.

    @available(iOS,introduced: 12.5)
    func methodForiOS12_5_only() {
    

    }

Types of Attributes in Swift


There are two kinds of attributes in swift - Declaration Attributes and Type Attributes.

Declaration Attributes

As the name suggests , these can only be applied to declarations.

 available
discardableResult
dynamicMemberLookup
GKInspectable
inlinable
nonobjc
NSApplicationMain
NSCopying
NSCopying
objc
objcMembers
requires_stored_property_inits
testable
UIApplicationMain
usableFromInline
warn_unqualified_access

Declaration Attributes used by InterfaceBuilder

IBAction
IBOutlet
IBDesignable
IBInspectable


Type Attributes

As the name suggests it can be applied to types only.

autoclosure
convention
escaping


Details on Declaration Attribute available

Below are the list of arguments and the details to help understand the available attribute.

You can also find it's implementation once you download the project from GitHub  .

@Available Attribute

This declaration attribute always appears in a list of two or more arguments. It always beings with a platform or argument.

Class : AvailableAttributeExample.swift
Implemented in Class : ViewController . availableAttributeExample

Attribute Name Argument Argument Details
available



Platform or langauge This is the required argument and rest of the arguments can appear after that. Possible values are listed below.
iOS , iOSApplicationExtension , macOS , macOSApplicationExtension , watchOS , watchOSApplicationExtension , tvOS , tvOSApplicationExtension , swift 

unavailable It specifies the platform cannot be used on the specified platform.
For first argument as swift this is not applicable

introduced The first version of language or platform in which the declaration was introduced.

format: introduced: <version>
<version> is three positive integers separated by a dot.

deprecated The first version of language or platform from which the declaration was deprecated.

format: deprecated: <version>
<version> is optional , if we wan’t to specify the declaration is deprecated for all version , skip the “version” as well as “:”

obsoleted The first version of language or platform from which it has became obsolete and cannot be used.

format: obsoleted: <version>

message Provides textual message to be displayed by the compiler when emitting an error or warning.

format: message: <message>
<message> is a string

renamed It is usually used in conjunction with unavailable argument to specify the name of the declaration is change between releases of framework and library.

@Available Argument - Introduced


    @available(iOS,introduced: 13.5)
    func methodAvailableFrom13_5()  {
        
    }

The above method is available for iOS platform and is introduced from version 13.5. As the current target version is 13.2 it will throw error.




@Available Argument -  Deprecated

    @available(iOS,deprecated,message: "This method has been deprecated , avoid using this method")
    func deprecatedMehod()  {
        

    }

The above method is available for iOS platform but is deprecate . A custom message can be shown by Xcode while emitting it as Warning




@Available Argument -  Obsoleted


    @available(iOS,obsoleted:13.2,message: "Cannot allow using this old method.")

    func obseleteMethod() {

        

    }

The above method is available for iOS platform but it obsolete and hence no longer available. Xcode will emit an error.




@Available Argument -  Renamed


    @available(iOS,unavailable,renamed: "formatNameWithSeperator" )
    func formatName(firstName:String , lastName:String)  -> String{
        return "\(firstName) , \(lastName)"
    }

    func formatNameWithSeperator( firstName:String ,  lastName:String , seperator:String) -> String {
        return "\(firstName) \(seperator) \(lastName)"

    }
"formName" function is now unavailable as well we have mentioned that it has been renamed to a new method "formatNameWithSeperator". As we see from the above implementation renamed argument is used in conjunction with unavailable argument.




@Discardable Attribute

This attribute is used to suppress function or method warning when it returns a value and the returned value is not used.

In below example "incrementCounterValue" returns a Int value and is not used. If @discardable is not used compiler would give warning.

    @discardableResult
    func incrementCounterValue(inputCountValue:inout Int) -> Int {
        return inputCountValue + 1
    }

Implementation does not show warning even thought the returned value is not used.

   func discardableAttributeExample() {
        let attr = DiscardableAttributeExample()
        
        /*
         * Method retunrs a Int Value , but since it is marked with discardableResult
         * The warning of the unused variable returned by the function will be suppressed
         */
        var counter = 1
        attr.incrementCounterValue(inputCountValue: &counter)

    }

Comments

  1. Blogger6 March 2020 at 00:04

    This comment has been removed by a blog administrator.

    ReplyDelete

Post a Comment

Popular posts from this blog

hitTest on iOS to identify the view being hit

-
Image
HitTest on iOS Use hitTest, to identify the view being tapped. The below method allows us to identify the view being selected. We can use it, to identify the view from which we would like to hide the touch events or identify the view we are interested into. Example: In the below case when we tap on Black View we can show an alert like "Black View tapped!" , if we tap on Red View , we can show an alert  "You are not allowed to tap on Red View" .  override func hitTest ( _ point: CGPoint , with event: UIEvent ?) -> UIView ? { } Here is a simple implementation of the method, to identify the view being hit. View hierarchy being used is listed below:- Blue(parent) - Red(child) - Green(child) - Yellow (child) - Orange (child) - Black (child) - White (child) So lets' start with override of hitTest method.      override func hitTest ( _ point: CGPoint , with event: UIEvent ?) -> UIView ? {         //1         if let viewAvailable = findPoin
Read more

CMTimeMakeWithSeconds explained

-
Image
CMTime  is structure which has two main components,  timeScale  and  value. CMTIME = VALUE  / TIMESCALE where, TimeScale =  fraction of a second each unit in numerator occupies. CMTIME = Value / TimeScale 1)  public   func  CMTimeMake( _  value:  Int64 ,  _  timescale:  Int32 ) ->  CMTime CMTimeMake ( 6000 ,  10 ) Means, there are 6000 units , each unit occupies 1/10 of a second 2)  public   func  CMTimeMakeWithSeconds( _  seconds:  Float64 ,  _  preferredTimescale:  Int32 ) ->  CMTime CMTimeMakeWithSeconds(10.0,500) 10.0 = VALUE /500 Therefore VALUE = 5000 So, there are 5000 units, each occupy 1/500 of a second
Read more

Custom Editing Control for UITableViewCell , like iPhone Mail Appliation

-
Image
Dear Friends, Today, while I was developing a application, I found that I am in need to a custom Editing control. Custom Editing Control are displayed on the left side of the screen. IOS sdk provides two of such kind which we use most of the time UITableViewCellEditingStyleDelete & UITableViewCellEditingStyleInsert  . I will be now discussing the third one, UITableViewCellEditingStyleNone. This can be used to design our own Editing control. How this is going to look like can be fond from below screen shot. Steps to achieve this can be found below: STEP 1: Create A subclass of UITabelViewCell First create a subclass of UITableViewCell, where when the cell object is initialised we will have to add a UIButton to its view. You will also need a offset variable, whose value will be 32.0 in all iPhones. -( id ) initWithCoder:( NSCoder *)aDecoder{          self =[ super initWithCoder :aDecoder];          if ( self ){         offset =32.0;        
Read more