 /**
     Used to expose API's for a Constraint
 */
-public protocol Constraint: class {
-    
-    func install() -> [LayoutConstraint]
-    func uninstall()
-    func activate()
-    func deactivate()
-    
-    func updateOffset(amount: Float) -> Void
-    func updateOffset(amount: Double) -> Void
-    func updateOffset(amount: CGFloat) -> Void
-    func updateOffset(amount: Int) -> Void
-    func updateOffset(amount: UInt) -> Void
-    func updateOffset(amount: CGPoint) -> Void
-    func updateOffset(amount: CGSize) -> Void
-    func updateOffset(amount: EdgeInsets) -> Void
-    
-    func updateInsets(amount: EdgeInsets) -> Void
-    
-    func updatePriority(priority: Float) -> Void
-    func updatePriority(priority: Double) -> Void
-    func updatePriority(priority: CGFloat) -> Void
-    func updatePriority(priority: UInt) -> Void
-    func updatePriority(priority: Int) -> Void
-    func updatePriorityRequired() -> Void
-    func updatePriorityHigh() -> Void
-    func updatePriorityMedium() -> Void
-    func updatePriorityLow() -> Void
+public class Constraint {
+    
+    public func install() -> [LayoutConstraint] { fatalError("Must be implemented by Concrete subclass.") }
+    public func uninstall() -> Void { fatalError("Must be implemented by Concrete subclass.") }
+    public func activate() -> Void { fatalError("Must be implemented by Concrete subclass.") }
+    public func deactivate() -> Void { fatalError("Must be implemented by Concrete subclass.") }
+    
+    public func updateOffset(amount: Float) -> Void { fatalError("Must be implemented by Concrete subclass.") }
+    public func updateOffset(amount: Double) -> Void { fatalError("Must be implemented by Concrete subclass.") }
+    public func updateOffset(amount: CGFloat) -> Void { fatalError("Must be implemented by Concrete subclass.") }
+    public func updateOffset(amount: Int) -> Void { fatalError("Must be implemented by Concrete subclass.") }
+    public func updateOffset(amount: UInt) -> Void { fatalError("Must be implemented by Concrete subclass.") }
+    public func updateOffset(amount: CGPoint) -> Void { fatalError("Must be implemented by Concrete subclass.") }
+    public func updateOffset(amount: CGSize) -> Void { fatalError("Must be implemented by Concrete subclass.") }
+    public func updateOffset(amount: EdgeInsets) -> Void { fatalError("Must be implemented by Concrete subclass.") }
+    
+    public func updateInsets(amount: EdgeInsets) -> Void { fatalError("Must be implemented by Concrete subclass.") }
+    
+    public func updatePriority(priority: Float) -> Void { fatalError("Must be implemented by Concrete subclass.") }
+    public func updatePriority(priority: Double) -> Void { fatalError("Must be implemented by Concrete subclass.") }
+    public func updatePriority(priority: CGFloat) -> Void { fatalError("Must be implemented by Concrete subclass.") }
+    public func updatePriority(priority: UInt) -> Void { fatalError("Must be implemented by Concrete subclass.") }
+    public func updatePriority(priority: Int) -> Void { fatalError("Must be implemented by Concrete subclass.") }
+    public func updatePriorityRequired() -> Void { fatalError("Must be implemented by Concrete subclass.") }
+    public func updatePriorityHigh() -> Void { fatalError("Must be implemented by Concrete subclass.") }
+    public func updatePriorityMedium() -> Void { fatalError("Must be implemented by Concrete subclass.") }
+    public func updatePriorityLow() -> Void { fatalError("Must be implemented by Concrete subclass.") }
     
 }
 

        }
    }
    
    internal func deactivate() {
        if NSLayoutConstraint.respondsToSelector("deactivateConstraints:") && self.installInfo != nil {
            let layoutConstraints = self.installInfo!.layoutConstraints.allObjects as! [LayoutConstraint]
            if layoutConstraints.count > 0 {

*/
internal class ConcreteConstraint: Constraint {
    
    internal override func updateOffset(amount: Float) -> Void {
        self.constant = amount
    }
    internal override func updateOffset(amount: Double) -> Void {
        self.updateOffset(Float(amount))
    }
    internal override func updateOffset(amount: CGFloat) -> Void {
        self.updateOffset(Float(amount))
    }
    internal override func updateOffset(amount: Int) -> Void {
        self.updateOffset(Float(amount))
    }
    internal override func updateOffset(amount: UInt) -> Void {
        self.updateOffset(Float(amount))
    }
    internal override func updateOffset(amount: CGPoint) -> Void {
        self.constant = amount
    }
    internal override func updateOffset(amount: CGSize) -> Void {
        self.constant = amount
    }
    internal override func updateOffset(amount: EdgeInsets) -> Void {
        self.constant = amount
    }
    
    internal override func updateInsets(amount: EdgeInsets) -> Void {
        self.constant = EdgeInsets(top: amount.top, left: amount.left, bottom: -amount.bottom, right: -amount.right)
    }
    
    internal override func updatePriority(priority: Float) -> Void {
        self.priority = priority
    }
    internal override func updatePriority(priority: Double) -> Void {
        self.updatePriority(Float(priority))
    }
    internal override func updatePriority(priority: CGFloat) -> Void {
        self.updatePriority(Float(priority))
    }
    internal override func updatePriority(priority: UInt) -> Void {
        self.updatePriority(Float(priority))
    }
    internal override func updatePriority(priority: Int) -> Void {
        self.updatePriority(Float(priority))
    }
    internal override func updatePriorityRequired() -> Void {
        self.updatePriority(Float(1000.0))
    }
    internal override func updatePriorityHigh() -> Void {
        self.updatePriority(Float(750.0))
    }
    internal override func updatePriorityMedium() -> Void {
        #if os(iOS)
        self.updatePriority(Float(500.0))
        #else
        self.updatePriority(Float(501.0))
        #endif
    }
    internal override func updatePriorityLow() -> Void {
        self.updatePriority(Float(250.0))
    }
    
    internal override func install() -> [LayoutConstraint] {
        return self.installOnView(updateExisting: false)
    }
    
    internal override func uninstall() -> Void {
        self.uninstallFromView()
    }
    
    internal override func activate() -> Void {
        if NSLayoutConstraint.respondsToSelector("activateConstraints:") && self.installInfo != nil {
            let layoutConstraints = self.installInfo!.layoutConstraints.allObjects as! [LayoutConstraint]
            if layoutConstraints.count > 0 {
