0001    //
0002    //  SnapKit
0003    //
0004    //  Copyright (c) 2011-Present SnapKit Team - https://github.com/SnapKit
0005    //
0006    //  Permission is hereby granted, free of charge, to any person obtaining a copy
0007    //  of this software and associated documentation files (the "Software"), to deal
0008    //  in the Software without restriction, including without limitation the rights
0009    //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
0010    //  copies of the Software, and to permit persons to whom the Software is
0011    //  furnished to do so, subject to the following conditions:
0012    //
0013    //  The above copyright notice and this permission notice shall be included in
0014    //  all copies or substantial portions of the Software.
0015    //
0016    //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
0017    //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
0018    //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
0019    //  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
0020    //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
0021    //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
0022    //  THE SOFTWARE.
0023    
0024    #if os(iOS) || os(tvOS)
0025    import UIKit
0026    #else
0027    import AppKit
0028    #endif
0029    
0030    /**
0031        Used to expose API's for a Constraint
0032    */
0033    public class ConstraintConstraint.swift:69 internal class ConcreteConstraint: Constraint {
ConstraintDescription.swift:35     var constraint: Constraint { get }
ConstraintDescription.swift:479     internal var constraint: Constraint {
ConstraintMaker.swift:139     internal class func prepareConstraints(view view: View, file: String = "Unknown", line: UInt = 0, @noescape closure: (make: ConstraintMaker) -> Void) -> [Constraint] {
LayoutConstraint.swift:35     internal var snp_constraint: Constraint? = nil
View+SnapKit.swift:130     public func snp_prepareConstraints(file: String = __FILE__, line: UInt = __LINE__, @noescape closure: (make: ConstraintMaker) -> Void) -> [Constraint] { {
0034        
0035        public func install() -> [LayoutConstraint] { fatalError("Must be implemented by Concrete subclass.") }
0036        public func uninstallConstraintMaker.swift:193             existingLayoutConstraint.snp_constraint?.uninstall()() -> Void { fatalError("Must be implemented by Concrete subclass.") }
0037        public func activate() -> Void { fatalError("Must be implemented by Concrete subclass.") }
0038        public func deactivate() -> Void { fatalError("Must be implemented by Concrete subclass.") }
0039        
0040        public func updateOffset(amount: Float) -> Void { fatalError("Must be implemented by Concrete subclass.") }
0041        public func updateOffset(amount: Double) -> Void { fatalError("Must be implemented by Concrete subclass.") }
0042        public func updateOffset(amount: CGFloat) -> Void { fatalError("Must be implemented by Concrete subclass.") }
0043        public func updateOffset(amount: Int) -> Void { fatalError("Must be implemented by Concrete subclass.") }
0044        public func updateOffset(amount: UInt) -> Void { fatalError("Must be implemented by Concrete subclass.") }
0045        public func updateOffset(amount: CGPoint) -> Void { fatalError("Must be implemented by Concrete subclass.") }
0046        public func updateOffset(amount: CGSize) -> Void { fatalError("Must be implemented by Concrete subclass.") }
0047        public func updateOffset(amount: EdgeInsets) -> Void { fatalError("Must be implemented by Concrete subclass.") }
0048        
0049        public func updateInsets(amount: EdgeInsets) -> Void { fatalError("Must be implemented by Concrete subclass.") }
0050        
0051        public func updatePriority(priority: Float) -> Void { fatalError("Must be implemented by Concrete subclass.") }
0052        public func updatePriority(priority: Double) -> Void { fatalError("Must be implemented by Concrete subclass.") }
0053        public func updatePriority(priority: CGFloat) -> Void { fatalError("Must be implemented by Concrete subclass.") }
0054        public func updatePriority(priority: UInt) -> Void { fatalError("Must be implemented by Concrete subclass.") }
0055        public func updatePriority(priority: Int) -> Void { fatalError("Must be implemented by Concrete subclass.") }
0056        public func updatePriorityRequired() -> Void { fatalError("Must be implemented by Concrete subclass.") }
0057        public func updatePriorityHigh() -> Void { fatalError("Must be implemented by Concrete subclass.") }
0058        public func updatePriorityMedium() -> Void { fatalError("Must be implemented by Concrete subclass.") }
0059        public func updatePriorityLow() -> Void { fatalError("Must be implemented by Concrete subclass.") }
0060        
0061        internal var makerFileConstraint.swift:133         return self.installOnView(updateExisting: false, file: self.makerFile, line: self.makerLine)
Constraint.swift:212                 NSException(name: "Cannot Install Constraint", reason: "No common superview between views (@\(self.makerFile)#\(self.makerLine))", userInfo: nil).raise()
Constraint.swift:222                     NSException(name: "Cannot Install Constraint", reason: "Missing superview (@\(self.makerFile)#\(self.makerLine))", userInfo: nil).raise()
Constraint.swift:230                 NSException(name: "Cannot Install Constraint", reason: "Already installed on different view. (@\(self.makerFile)#\(self.makerLine))", userInfo: nil).raise()
ConstraintMaker.swift:145             constraint.makerFile = maker.file
ConstraintMaker.swift:158             constraint.makerFile = maker.file
ConstraintMaker.swift:172             constraint.makerFile = maker.file
ConstraintMaker.swift:185             constraint.makerFile = maker.file
Debugging.swift:104         return self.snp_constraint?.makerFile: String = "Unknown"
0062        internal var makerLineConstraint.swift:133         return self.installOnView(updateExisting: false, file: self.makerFile, line: self.makerLine)
Constraint.swift:212                 NSException(name: "Cannot Install Constraint", reason: "No common superview between views (@\(self.makerFile)#\(self.makerLine))", userInfo: nil).raise()
Constraint.swift:222                     NSException(name: "Cannot Install Constraint", reason: "Missing superview (@\(self.makerFile)#\(self.makerLine))", userInfo: nil).raise()
Constraint.swift:230                 NSException(name: "Cannot Install Constraint", reason: "Already installed on different view. (@\(self.makerFile)#\(self.makerLine))", userInfo: nil).raise()
ConstraintMaker.swift:146             constraint.makerLine = maker.line
ConstraintMaker.swift:159             constraint.makerLine = maker.line
ConstraintMaker.swift:173             constraint.makerLine = maker.line
ConstraintMaker.swift:186             constraint.makerLine = maker.line
Debugging.swift:108         return self.snp_constraint?.makerLine: UInt = 0
0063        
0064    }
0065    
0066    /**
0067        Used internally to implement a ConcreteConstraint
0068    */
0069    internal class ConcreteConstraintConstraint.swift:494 private func ==(left: ConcreteConstraint, right: ConcreteConstraint) -> Bool {
Constraint.swift:494 private func ==(left: ConcreteConstraint, right: ConcreteConstraint) -> Bool {
ConstraintDescription.swift:484             self.concreteConstraint = ConcreteConstraint(
ConstraintDescription.swift:533     private var concreteConstraint: ConcreteConstraint? = nil
ConstraintMaker.swift:156         let constraints = maker.constraintDescriptions.map { $0.constraint as! ConcreteConstraint }
ConstraintMaker.swift:170         let constraints = maker.constraintDescriptions.map { $0.constraint as! ConcreteConstraint }
ConstraintMaker.swift:183         let constraints = maker.constraintDescriptions.map { $0.constraint as! ConcreteConstraint}: Constraint {
0070        
0071        internal override func updateOffsetConstraint.swift:75         self.updateOffset(Float(amount))
Constraint.swift:78         self.updateOffset(Float(amount))
Constraint.swift:81         self.updateOffset(Float(amount))
Constraint.swift:84         self.updateOffset(Float(amount))(amount: Float) -> Void {
0072            self.constant = amount
0073        }
0074        internal override func updateOffset(amount: Double) -> Void {
0075            self.updateOffset(Float(amount))
0076        }
0077        internal override func updateOffset(amount: CGFloat) -> Void {
0078            self.updateOffset(Float(amount))
0079        }
0080        internal override func updateOffset(amount: Int) -> Void {
0081            self.updateOffset(Float(amount))
0082        }
0083        internal override func updateOffset(amount: UInt) -> Void {
0084            self.updateOffset(Float(amount))
0085        }
0086        internal override func updateOffset(amount: CGPoint) -> Void {
0087            self.constant = amount
0088        }
0089        internal override func updateOffset(amount: CGSize) -> Void {
0090            self.constant = amount
0091        }
0092        internal override func updateOffset(amount: EdgeInsets) -> Void {
0093            self.constant = amount
0094        }
0095        
0096        internal override func updateInsets(amount: EdgeInsets) -> Void {
0097            self.constant = EdgeInsets(top: amount.top, left: amount.left, bottom: -amount.bottom, right: -amount.right)
0098        }
0099        
0100        internal override func updatePriorityConstraint.swift:104         self.updatePriority(Float(priority))
Constraint.swift:107         self.updatePriority(Float(priority))
Constraint.swift:110         self.updatePriority(Float(priority))
Constraint.swift:113         self.updatePriority(Float(priority))
Constraint.swift:116         self.updatePriority(Float(1000.0))
Constraint.swift:119         self.updatePriority(Float(750.0))
Constraint.swift:125         self.updatePriority(Float(501.0))
Constraint.swift:129         self.updatePriority(Float(250.0))(priority: Float) -> Void {
0101            self.priority = priority
0102        }
0103        internal override func updatePriority(priority: Double) -> Void {
0104            self.updatePriority(Float(priority))
0105        }
0106        internal override func updatePriority(priority: CGFloat) -> Void {
0107            self.updatePriority(Float(priority))
0108        }
0109        internal override func updatePriority(priority: UInt) -> Void {
0110            self.updatePriority(Float(priority))
0111        }
0112        internal override func updatePriority(priority: Int) -> Void {
0113            self.updatePriority(Float(priority))
0114        }
0115        internal override func updatePriorityRequired() -> Void {
0116            self.updatePriority(Float(1000.0))
0117        }
0118        internal override func updatePriorityHigh() -> Void {
0119            self.updatePriority(Float(750.0))
0120        }
0121        internal override func updatePriorityMedium() -> Void {
0122            #if os(iOS) || os(tvOS)
0123            self.updatePriority(Float(500.0))
0124            #else
0125            self.updatePriority(Float(501.0))
0126            #endif
0127        }
0128        internal override func updatePriorityLow() -> Void {
0129            self.updatePriority(Float(250.0))
0130        }
0131        
0132        internal override func installConstraint.swift:142             self.install()() -> [LayoutConstraint] {
0133            return self.installOnView(updateExisting: false, file: self.makerFile, line: self.makerLine)
0134        }
0135        
0136        internal override func uninstall() -> Void {
0137            self.uninstallFromView()
0138        }
0139        
0140        internal override func activate() -> Void {
0141            guard self.installInfo != nil else {
0142                self.install()
0143                return
0144            }
0145            #if SNAPKIT_DEPLOYMENT_LEGACY
0146            guard #available(iOS 8.0, OSX 10.10, *) else {
0147                self.install()
0148                return
0149            }
0150            #endif
0151            let layoutConstraints = self.installInfo!.layoutConstraints.allObjects as! [LayoutConstraint]
0152            if layoutConstraints.count > 0 {
0153                NSLayoutConstraint.activateConstraints(layoutConstraints)
0154            }
0155        }
0156        
0157        internal override func deactivate() -> Void {
0158            guard self.installInfo != nil else {
0159                return
0160            }
0161            #if SNAPKIT_DEPLOYMENT_LEGACY
0162            guard #available(iOS 8.0, OSX 10.10, *) else {
0163                return
0164            }
0165            #endif
0166            let layoutConstraints = self.installInfo!.layoutConstraints.allObjects as! [LayoutConstraint]
0167            if layoutConstraints.count > 0 {
0168                NSLayoutConstraint.deactivateConstraints(layoutConstraints)
0169            }
0170        }
0171        
0172        private let fromItemConstraint.swift:199         self.fromItem = fromItem
Constraint.swift:210             installOnView = closestCommonSuperviewFromView(self.fromItem.view, toView: self.toItem.view)
Constraint.swift:217             if self.fromItem.attributes.isSubsetOf(ConstraintAttributes.Width.union(.Height)) {
Constraint.swift:218                 installOnView = self.fromItem.view
Constraint.swift:220                 installOnView = self.fromItem.view?.superview
Constraint.swift:237         let layoutFromAttributes = self.fromItem.attributes.layoutAttributes
Constraint.swift:241         let layoutFrom: View? = self.fromItem.view
Constraint.swift:360                     if let fromView = self.fromItem.view {
Constraint.swift:495     return (left.fromItem == right.fromItem &&
Constraint.swift:495     return (left.fromItem == right.fromItem &&: ConstraintItem
0173        private let toItemConstraint.swift:200         self.toItem = toItem
Constraint.swift:209         if self.toItem.view != nil {
Constraint.swift:210             installOnView = closestCommonSuperviewFromView(self.fromItem.view, toView: self.toItem.view)
Constraint.swift:238         let layoutToAttributes = self.toItem.attributes.layoutAttributes
Constraint.swift:257             var layoutTo: AnyObject? = self.toItem.view
Constraint.swift:496             left.toItem == right.toItem &&
Constraint.swift:496             left.toItem == right.toItem &&: ConstraintItem
0174        private let relationConstraint.swift:201         self.relation = relation
Constraint.swift:244         let layoutRelation: NSLayoutRelation = self.relation.layoutRelation
Constraint.swift:497             left.relation == right.relation &&
Constraint.swift:497             left.relation == right.relation &&: ConstraintRelation
0175        private let multiplierConstraint.swift:203         self.multiplier = multiplier
Constraint.swift:270                 multiplier: CGFloat(self.multiplier),
Constraint.swift:498             left.multiplier == right.multiplier &&
Constraint.swift:498             left.multiplier == right.multiplier &&: Float
0176        private var constantConstraint.swift:72         self.constant = amount
Constraint.swift:87         self.constant = amount
Constraint.swift:90         self.constant = amount
Constraint.swift:93         self.constant = amount
Constraint.swift:97         self.constant = EdgeInsets(top: amount.top, left: amount.left, bottom: -amount.bottom, right: -amount.right)
Constraint.swift:181                     layoutConstraint.constant = attribute.snp_constantForValue(self.constant)
Constraint.swift:202         self.constant = constant
Constraint.swift:251             let layoutConstant: CGFloat = layoutToAttribute.snp_constantForValue(self.constant): Any {
0177            didSet {
0178                if let installInfo = self.installInfo {
0179                    for layoutConstraint in installInfo.layoutConstraints.allObjects as! [LayoutConstraint] {
0180                        let attribute = (layoutConstraint.secondAttribute == .NotAnAttribute) ? layoutConstraint.firstAttribute : layoutConstraint.secondAttribute
0181                        layoutConstraint.constant = attribute.snp_constantForValue(self.constant)
0182                    }
0183                }
0184            }
0185        }
0186        private var priorityConstraint.swift:101         self.priority = priority
Constraint.swift:190                     layoutConstraint.priority = self.priority
Constraint.swift:204         self.priority = priority
Constraint.swift:274             layoutConstraint.priority = self.priority
Constraint.swift:499             left.priority == right.priority)
Constraint.swift:499             left.priority == right.priority): Float {
0187            didSet {
0188                if let installInfo = self.installInfo {
0189                    for layoutConstraint in installInfo.layoutConstraints.allObjects as! [LayoutConstraint] {
0190                        layoutConstraint.priority = self.priority
0191                    }
0192                }
0193            }
0194        }
0195        
0196        private var installInfoConstraint.swift:141         guard self.installInfo != nil else {
Constraint.swift:151         let layoutConstraints = self.installInfo!.layoutConstraints.allObjects as! [LayoutConstraint]
Constraint.swift:158         guard self.installInfo != nil else {
Constraint.swift:166         let layoutConstraints = self.installInfo!.layoutConstraints.allObjects as! [LayoutConstraint]
Constraint.swift:178             if let installInfo = self.installInfo {
Constraint.swift:188             if let installInfo = self.installInfo {
Constraint.swift:228         if let installedOnView = self.installInfo?.view {
Constraint.swift:233             return self.installInfo?.layoutConstraints.allObjects as? [LayoutConstraint] ?? []
Constraint.swift:329         self.installInfo = ConcreteConstraintInstallInfo(view: installOnView, layoutConstraints: NSHashTable.weakObjectsHashTable())
Constraint.swift:333             self.installInfo!.layoutConstraints.addObject(layoutConstraint)
Constraint.swift:344         if let installInfo = self.installInfo,
Constraint.swift:368         self.installInfo = nil: ConcreteConstraintInstallInfo? = nil
0197        
0198        internal initConstraintDescription.swift:484             self.concreteConstraint = ConcreteConstraint((fromItem: ConstraintItem, toItem: ConstraintItem, relation: ConstraintRelation, constant: Any, multiplier: Float, priority: Float) {
0199            self.fromItem = fromItem
0200            self.toItem = toItem
0201            self.relation = relation
0202            self.constant = constant
0203            self.multiplier = multiplier
0204            self.priority = priority
0205        }
0206        
0207        internal func installOnViewConstraint.swift:133         return self.installOnView(updateExisting: false, file: self.makerFile, line: self.makerLine)
ConstraintMaker.swift:160             constraint.installOnView(updateExisting: false)
ConstraintMaker.swift:174             constraint.installOnView(updateExisting: false)
ConstraintMaker.swift:187             constraint.installOnView(updateExisting: true)(updateExisting updateExisting: Bool = false, file: String? = nil, line: UInt? = nil) -> [LayoutConstraint] {
0208            var installOnView: View? = nil
0209            if self.toItem.view != nil {
0210                installOnView = closestCommonSuperviewFromView(self.fromItem.view, toView: self.toItem.view)
0211                if installOnView == nil {
0212                    NSException(name: "Cannot Install Constraint", reason: "No common superview between views (@\(self.makerFile)#\(self.makerLine))", userInfo: nil).raise()
0213                    return []
0214                }
0215            } else {
0216                
0217                if self.fromItem.attributes.isSubsetOf(ConstraintAttributes.Width.union(.Height)) {
0218                    installOnView = self.fromItem.view
0219                } else {
0220                    installOnView = self.fromItem.view?.superview
0221                    if installOnView == nil {
0222                        NSException(name: "Cannot Install Constraint", reason: "Missing superview (@\(self.makerFile)#\(self.makerLine))", userInfo: nil).raise()
0223                        return []
0224                    }
0225                }
0226            }
0227            
0228            if let installedOnView = self.installInfo?.view {
0229                if installedOnView != installOnView {
0230                    NSException(name: "Cannot Install Constraint", reason: "Already installed on different view. (@\(self.makerFile)#\(self.makerLine))", userInfo: nil).raise()
0231                    return []
0232                }
0233                return self.installInfo?.layoutConstraints.allObjects as? [LayoutConstraint] ?? []
0234            }
0235            
0236            var newLayoutConstraints = [LayoutConstraint]()
0237            let layoutFromAttributes = self.fromItem.attributes.layoutAttributes
0238            let layoutToAttributes = self.toItem.attributes.layoutAttributes
0239            
0240            // get layout from
0241            let layoutFrom: View? = self.fromItem.view
0242            
0243            // get layout relation
0244            let layoutRelation: NSLayoutRelation = self.relation.layoutRelation
0245            
0246            for layoutFromAttribute in layoutFromAttributes {
0247                // get layout to attribute
0248                let layoutToAttribute = (layoutToAttributes.count > 0) ? layoutToAttributes[0] : layoutFromAttribute
0249                
0250                // get layout constant
0251                let layoutConstant: CGFloat = layoutToAttribute.snp_constantForValue(self.constant)
0252                
0253                // get layout to
0254                #if os(iOS) || os(tvOS)
0255                var layoutTo: AnyObject? = self.toItem.view ?? self.toItem.layoutSupport
0256                #else
0257                var layoutTo: AnyObject? = self.toItem.view
0258                #endif
0259                if layoutTo == nil && layoutToAttribute != .Width && layoutToAttribute != .Height {
0260                    layoutTo = installOnView
0261                }
0262                
0263                // create layout constraint
0264                let layoutConstraint = LayoutConstraint(
0265                    item: layoutFrom!,
0266                    attribute: layoutFromAttribute,
0267                    relatedBy: layoutRelation,
0268                    toItem: layoutTo,
0269                    attribute: layoutToAttribute,
0270                    multiplier: CGFloat(self.multiplier),
0271                    constant: layoutConstant)
0272                
0273                // set priority
0274                layoutConstraint.priority = self.priority
0275                
0276                // set constraint
0277                layoutConstraint.snp_constraint = self
0278                
0279                newLayoutConstraints.append(layoutConstraint)
0280            }
0281            
0282            // special logic for updating
0283            if updateExisting {
0284                // get existing constraints for this view
0285                let existingLayoutConstraints = layoutFrom!.snp_installedLayoutConstraints.reverse()
0286                
0287                // array that will contain only new layout constraints to keep
0288                var newLayoutConstraintsToKeep = [LayoutConstraint]()
0289                
0290                // begin looping
0291                for layoutConstraint in newLayoutConstraints {
0292                    // layout constraint that should be updated
0293                    var updateLayoutConstraint: LayoutConstraint? = nil
0294                    
0295                    // loop through existing and check for match
0296                    for existingLayoutConstraint in existingLayoutConstraints {
0297                        if existingLayoutConstraint == layoutConstraint {
0298                            updateLayoutConstraint = existingLayoutConstraint
0299                            break
0300                        }
0301                    }
0302                    
0303                    // if we have existing one lets just update the constant
0304                    if updateLayoutConstraint != nil {
0305                        updateLayoutConstraint!.constant = layoutConstraint.constant
0306                    }
0307                        // otherwise add this layout constraint to new keep list
0308                    else {
0309                        newLayoutConstraintsToKeep.append(layoutConstraint)
0310                    }
0311                }
0312                
0313                // set constraints to only new ones
0314                newLayoutConstraints = newLayoutConstraintsToKeep
0315            }
0316            
0317            // add constraints
0318            #if SNAPKIT_DEPLOYMENT_LEGACY && !os(OSX)
0319            if #available(iOS 8.0, *) {
0320                NSLayoutConstraint.activateConstraints(newLayoutConstraints)
0321            } else {
0322                installOnView!.addConstraints(newLayoutConstraints)
0323            }
0324            #else
0325                NSLayoutConstraint.activateConstraints(newLayoutConstraints)
0326            #endif
0327            
0328            // set install info
0329            self.installInfo = ConcreteConstraintInstallInfo(view: installOnView, layoutConstraints: NSHashTable.weakObjectsHashTable())
0330            
0331            // store which layout constraints are installed for this constraint
0332            for layoutConstraint in newLayoutConstraints {
0333                self.installInfo!.layoutConstraints.addObject(layoutConstraint)
0334            }
0335            
0336            // store the layout constraints against the layout from view
0337            layoutFrom!.snp_installedLayoutConstraints += newLayoutConstraints
0338            
0339            // return the new constraints
0340            return newLayoutConstraints
0341        }
0342        
0343        internal func uninstallFromViewConstraint.swift:137         self.uninstallFromView()() {
0344            if let installInfo = self.installInfo,
0345                let installedLayoutConstraints = installInfo.layoutConstraints.allObjects as? [LayoutConstraint] {
0346                    
0347                    if installedLayoutConstraints.count > 0 {
0348                        // remove the constraints from the UIView's storage
0349                        #if SNAPKIT_DEPLOYMENT_LEGACY && !os(OSX)
0350                        if #available(iOS 8.0, *) {
0351                            NSLayoutConstraint.deactivateConstraints(installedLayoutConstraints)
0352                        } else if let installedOnView = installInfo.view {
0353                            installedOnView.removeConstraints(installedLayoutConstraints)
0354                        }
0355                        #else
0356                            NSLayoutConstraint.deactivateConstraints(installedLayoutConstraints)
0357                        #endif
0358                        
0359                        // remove the constraints from the from item view
0360                        if let fromView = self.fromItem.view {
0361                            fromView.snp_installedLayoutConstraints = fromView.snp_installedLayoutConstraints.filter {
0362                                return !installedLayoutConstraints.contains($0)
0363                            }
0364                        }
0365                    }
0366                    
0367            }
0368            self.installInfo = nil
0369        }
0370        
0371    }
0372    
0373    private struct ConcreteConstraintInstallInfoConstraint.swift:196     private var installInfo: ConcreteConstraintInstallInfo? = nil
Constraint.swift:329         self.installInfo = ConcreteConstraintInstallInfo(view: installOnView, layoutConstraints: NSHashTable.weakObjectsHashTable()) {
0374        
0375        weak var viewConstraint.swift:228         if let installedOnView = self.installInfo?.view {: View? = nil
0376        let layoutConstraintsConstraint.swift:151         let layoutConstraints = self.installInfo!.layoutConstraints.allObjects as! [LayoutConstraint]
Constraint.swift:166         let layoutConstraints = self.installInfo!.layoutConstraints.allObjects as! [LayoutConstraint]
Constraint.swift:179                 for layoutConstraint in installInfo.layoutConstraints.allObjects as! [LayoutConstraint] {
Constraint.swift:189                 for layoutConstraint in installInfo.layoutConstraints.allObjects as! [LayoutConstraint] {
Constraint.swift:233             return self.installInfo?.layoutConstraints.allObjects as? [LayoutConstraint] ?? []
Constraint.swift:333             self.installInfo!.layoutConstraints.addObject(layoutConstraint)
Constraint.swift:345             let installedLayoutConstraints = installInfo.layoutConstraints.allObjects as? [LayoutConstraint] {: NSHashTable
0377        
0378    }
0379    
0380    private extension NSLayoutAttribute {
0381        
0382        private func snp_constantForValueConstraint.swift:181                     layoutConstraint.constant = attribute.snp_constantForValue(self.constant)
Constraint.swift:251             let layoutConstant: CGFloat = layoutToAttribute.snp_constantForValue(self.constant)(value: Any?) -> CGFloat {
0383            // Float
0384            if let float = value as? Float {
0385                return CGFloat(float)
0386            }
0387                // Double
0388            else if let double = value as? Double {
0389                return CGFloat(double)
0390            }
0391                // UInt
0392            else if let int = value as? Int {
0393                return CGFloat(int)
0394            }
0395                // Int
0396            else if let uint = value as? UInt {
0397                return CGFloat(uint)
0398            }
0399                // CGFloat
0400            else if let float = value as? CGFloat {
0401                return float
0402            }
0403                // CGSize
0404            else if let size = value as? CGSize {
0405                if self == .Width {
0406                    return size.width
0407                } else if self == .Height {
0408                    return size.height
0409                }
0410            }
0411                // CGPoint
0412            else if let point = value as? CGPoint {
0413                #if os(iOS) || os(tvOS)
0414                    switch self {
0415                    case .Left, .CenterX, .LeftMargin, .CenterXWithinMargins: return point.x
0416                    case .Top, .CenterY, .TopMargin, .CenterYWithinMargins, .Baseline, .FirstBaseline: return point.y
0417                    case .Right, .RightMargin: return point.x
0418                    case .Bottom, .BottomMargin: return point.y
0419                    case .Leading, .LeadingMargin: return point.x
0420                    case .Trailing, .TrailingMargin: return point.x
0421                    case .Width, .Height, .NotAnAttribute: return CGFloat(0)
0422                    }
0423                #else
0424                    switch self {
0425                    case .Left, .CenterX: return point.x
0426                    case .Top, .CenterY, .Baseline: return point.y
0427                    case .Right: return point.x
0428                    case .Bottom: return point.y
0429                    case .Leading: return point.x
0430                    case .Trailing: return point.x
0431                    case .Width, .Height, .NotAnAttribute: return CGFloat(0)
0432                    case .FirstBaseline: return point.y
0433                    }
0434                #endif
0435            }
0436                // EdgeInsets
0437            else if let insets = value as? EdgeInsets {
0438                #if os(iOS) || os(tvOS)
0439                    switch self {
0440                    case .Left, .CenterX, .LeftMargin, .CenterXWithinMargins: return insets.left
0441                    case .Top, .CenterY, .TopMargin, .CenterYWithinMargins, .Baseline, .FirstBaseline: return insets.top
0442                    case .Right, .RightMargin: return insets.right
0443                    case .Bottom, .BottomMargin: return insets.bottom
0444                    case .Leading, .LeadingMargin: return  (Config.interfaceLayoutDirection == .LeftToRight) ? insets.left : -insets.right
0445                    case .Trailing, .TrailingMargin: return  (Config.interfaceLayoutDirection == .LeftToRight) ? insets.right : -insets.left
0446                    case .Width: return -insets.left + insets.right
0447                    case .Height: return -insets.top + insets.bottom
0448                    case .NotAnAttribute: return CGFloat(0)
0449                    }
0450                #else
0451                    switch self {
0452                    case .Left, .CenterX: return insets.left
0453                    case .Top, .CenterY, .Baseline: return insets.top
0454                    case .Right: return insets.right
0455                    case .Bottom: return insets.bottom
0456                    case .Leading: return  (Config.interfaceLayoutDirection == .LeftToRight) ? insets.left : -insets.right
0457                    case .Trailing: return  (Config.interfaceLayoutDirection == .LeftToRight) ? insets.right : -insets.left
0458                    case .Width: return -insets.left + insets.right
0459                    case .Height: return -insets.top + insets.bottom
0460                    case .NotAnAttribute: return CGFloat(0)
0461                    case .FirstBaseline: return insets.bottom
0462                    }
0463                #endif
0464            }
0465            
0466            return CGFloat(0);
0467        }
0468    }
0469    
0470    private func closestCommonSuperviewFromViewConstraint.swift:210             installOnView = closestCommonSuperviewFromView(self.fromItem.view, toView: self.toItem.view)(fromView: View?, toView: View?) -> View? {
0471        var views = Set<View>()
0472        var fromView = fromView
0473        var toView = toView
0474        repeat {
0475            if let view = toView {
0476                if views.contains(view) {
0477                    return view
0478                }
0479                views.insert(view)
0480                toView = view.superview
0481            }
0482            if let view = fromView {
0483                if views.contains(view) {
0484                    return view
0485                }
0486                views.insert(view)
0487                fromView = view.superview
0488            }
0489        } while (fromView != nil || toView != nil)
0490        
0491        return nil
0492    }
0493    
0494    private func ==(left: ConcreteConstraint, right: ConcreteConstraint) -> Bool {
0495        return (left.fromItem == right.fromItem &&
0496                left.toItem == right.toItem &&
0497                left.relation == right.relation &&
0498                left.multiplier == right.multiplier &&
0499                left.priority == right.priority)
0500    }
0501

Constraint.swift:69	internal class ConcreteConstraint: Constraint {
ConstraintDescription.swift:35	var constraint: Constraint { get }
ConstraintDescription.swift:479	internal var constraint: Constraint {
ConstraintMaker.swift:139	internal class func prepareConstraints(view view: View, file: String = "Unknown", line: UInt = 0, @noescape closure: (make: ConstraintMaker) -> Void) -> [Constraint] {
LayoutConstraint.swift:35	internal var snp_constraint: Constraint? = nil
View+SnapKit.swift:130	public func snp_prepareConstraints(file: String = __FILE__, line: UInt = __LINE__, @noescape closure: (make: ConstraintMaker) -> Void) -> [Constraint] {

Constraint.swift:133	return self.installOnView(updateExisting: false, file: self.makerFile, line: self.makerLine)
Constraint.swift:212	NSException(name: "Cannot Install Constraint", reason: "No common superview between views (@\(self.makerFile)#\(self.makerLine))", userInfo: nil).raise()
Constraint.swift:222	NSException(name: "Cannot Install Constraint", reason: "Missing superview (@\(self.makerFile)#\(self.makerLine))", userInfo: nil).raise()
Constraint.swift:230	NSException(name: "Cannot Install Constraint", reason: "Already installed on different view. (@\(self.makerFile)#\(self.makerLine))", userInfo: nil).raise()
ConstraintMaker.swift:145	constraint.makerFile = maker.file
ConstraintMaker.swift:158	constraint.makerFile = maker.file
ConstraintMaker.swift:172	constraint.makerFile = maker.file
ConstraintMaker.swift:185	constraint.makerFile = maker.file
Debugging.swift:104	return self.snp_constraint?.makerFile

Constraint.swift:494	private func ==(left: ConcreteConstraint, right: ConcreteConstraint) -> Bool {
Constraint.swift:494	private func ==(left: ConcreteConstraint, right: ConcreteConstraint) -> Bool {
ConstraintDescription.swift:484	self.concreteConstraint = ConcreteConstraint(
ConstraintDescription.swift:533	private var concreteConstraint: ConcreteConstraint? = nil
ConstraintMaker.swift:156	let constraints = maker.constraintDescriptions.map { $0.constraint as! ConcreteConstraint }
ConstraintMaker.swift:170	let constraints = maker.constraintDescriptions.map { $0.constraint as! ConcreteConstraint }
ConstraintMaker.swift:183	let constraints = maker.constraintDescriptions.map { $0.constraint as! ConcreteConstraint}

Constraint.swift:75	self.updateOffset(Float(amount))
Constraint.swift:78	self.updateOffset(Float(amount))
Constraint.swift:81	self.updateOffset(Float(amount))
Constraint.swift:84	self.updateOffset(Float(amount))

Constraint.swift:104	self.updatePriority(Float(priority))
Constraint.swift:107	self.updatePriority(Float(priority))
Constraint.swift:110	self.updatePriority(Float(priority))
Constraint.swift:113	self.updatePriority(Float(priority))
Constraint.swift:116	self.updatePriority(Float(1000.0))
Constraint.swift:119	self.updatePriority(Float(750.0))
Constraint.swift:125	self.updatePriority(Float(501.0))
Constraint.swift:129	self.updatePriority(Float(250.0))

Constraint.swift:199	self.fromItem = fromItem
Constraint.swift:210	installOnView = closestCommonSuperviewFromView(self.fromItem.view, toView: self.toItem.view)
Constraint.swift:217	if self.fromItem.attributes.isSubsetOf(ConstraintAttributes.Width.union(.Height)) {
Constraint.swift:218	installOnView = self.fromItem.view
Constraint.swift:220	installOnView = self.fromItem.view?.superview
Constraint.swift:237	let layoutFromAttributes = self.fromItem.attributes.layoutAttributes
Constraint.swift:241	let layoutFrom: View? = self.fromItem.view
Constraint.swift:360	if let fromView = self.fromItem.view {
Constraint.swift:495	return (left.fromItem == right.fromItem &&
Constraint.swift:495	return (left.fromItem == right.fromItem &&

Constraint.swift:200	self.toItem = toItem
Constraint.swift:209	if self.toItem.view != nil {
Constraint.swift:210	installOnView = closestCommonSuperviewFromView(self.fromItem.view, toView: self.toItem.view)
Constraint.swift:238	let layoutToAttributes = self.toItem.attributes.layoutAttributes
Constraint.swift:257	var layoutTo: AnyObject? = self.toItem.view
Constraint.swift:496	left.toItem == right.toItem &&
Constraint.swift:496	left.toItem == right.toItem &&

Constraint.swift:201	self.relation = relation
Constraint.swift:244	let layoutRelation: NSLayoutRelation = self.relation.layoutRelation
Constraint.swift:497	left.relation == right.relation &&
Constraint.swift:497	left.relation == right.relation &&

Constraint.swift:203	self.multiplier = multiplier
Constraint.swift:270	multiplier: CGFloat(self.multiplier),
Constraint.swift:498	left.multiplier == right.multiplier &&
Constraint.swift:498	left.multiplier == right.multiplier &&

Constraint.swift:72	self.constant = amount
Constraint.swift:87	self.constant = amount
Constraint.swift:90	self.constant = amount
Constraint.swift:93	self.constant = amount
Constraint.swift:97	self.constant = EdgeInsets(top: amount.top, left: amount.left, bottom: -amount.bottom, right: -amount.right)
Constraint.swift:181	layoutConstraint.constant = attribute.snp_constantForValue(self.constant)
Constraint.swift:202	self.constant = constant
Constraint.swift:251	let layoutConstant: CGFloat = layoutToAttribute.snp_constantForValue(self.constant)

Constraint.swift:101	self.priority = priority
Constraint.swift:190	layoutConstraint.priority = self.priority
Constraint.swift:204	self.priority = priority
Constraint.swift:274	layoutConstraint.priority = self.priority
Constraint.swift:499	left.priority == right.priority)
Constraint.swift:499	left.priority == right.priority)

Constraint.swift:141	guard self.installInfo != nil else {
Constraint.swift:151	let layoutConstraints = self.installInfo!.layoutConstraints.allObjects as! [LayoutConstraint]
Constraint.swift:158	guard self.installInfo != nil else {
Constraint.swift:166	let layoutConstraints = self.installInfo!.layoutConstraints.allObjects as! [LayoutConstraint]
Constraint.swift:178	if let installInfo = self.installInfo {
Constraint.swift:188	if let installInfo = self.installInfo {
Constraint.swift:228	if let installedOnView = self.installInfo?.view {
Constraint.swift:233	return self.installInfo?.layoutConstraints.allObjects as? [LayoutConstraint] ?? []
Constraint.swift:329	self.installInfo = ConcreteConstraintInstallInfo(view: installOnView, layoutConstraints: NSHashTable.weakObjectsHashTable())
Constraint.swift:333	self.installInfo!.layoutConstraints.addObject(layoutConstraint)
Constraint.swift:344	if let installInfo = self.installInfo,
Constraint.swift:368	self.installInfo = nil

Constraint.swift:133	return self.installOnView(updateExisting: false, file: self.makerFile, line: self.makerLine)
ConstraintMaker.swift:160	constraint.installOnView(updateExisting: false)
ConstraintMaker.swift:174	constraint.installOnView(updateExisting: false)
ConstraintMaker.swift:187	constraint.installOnView(updateExisting: true)

Constraint.swift:196	private var installInfo: ConcreteConstraintInstallInfo? = nil
Constraint.swift:329	self.installInfo = ConcreteConstraintInstallInfo(view: installOnView, layoutConstraints: NSHashTable.weakObjectsHashTable())