Overriding NSLayoutConstraint in an inherited class - ios

Question

There are two classes in my code, one is NameCell, which contains a simple UILabel with text. The second one is NameValueCell, which inherits from that class, but adds also the property UIView *valueView.
One layout constraint needs to be altered. I'm looking for a way to override:
H:|[nameView]| - nameView should occupy full width in NameCell
with
H:|[nameView][valueView(==nameView)]| - nameView to valueView width ratio should be 1:1 in NameValueCell
What is the best practice out there for overriding NSLayoutConstraint? I have to stick to inheritance in my code because my application requires many different UITableViewCell specializations.
NameCell.h:
#interface NameCell : UITableViewCell
#property (nonatomic, retain) IBOutlet UIView *nameView;
#property (nonatomic, retain) IBOutlet UILabel *nameLabel;
#end
NameValueCell.h:
#interface NameValueCell : NameCell
#property (nonatomic, retain) IBOutlet UIView *valueView;
#end
NameCell.m:
#implementation NameCell
- (id)initWithStyle:(UITableViewCellStyle)style reuseIdentifier:(NSString *)reuseIdentifier {
self = [super initWithStyle:style reuseIdentifier:reuseIdentifier];
if (self) {
UIView *nameView = [[UIView alloc] init];
self.nameView = nameView;
[self.contentView addSubview:self.nameView];
UILabel *nameLabel = [[UILabel alloc] init];
self.nameLabel = nameLabel;
[self.nameView addSubview:self.nameLabel];
NSDictionary *views = NSDictionaryOfVariableBindings(nameView, nameLabel);
NSArray *constraints;
// The constraint that should be overridden
constraints = [NSLayoutConstraint constraintsWithVisualFormat:#"H:|[nameView]|"
options: 0
metrics:nil
views:views];
[self.contentView addConstraints:constraints];
}
return self;
}
#end
NameValueCell.m:
#implementation NameValueCell
- (id)initWithStyle:(UITableViewCellStyle)style reuseIdentifier:(NSString *)reuseIdentifier {
self = [super initWithStyle:style reuseIdentifier:reuseIdentifier];
if (self) {
NSString *reuseID = reuseIdentifier;
UIView *valueView = [[UIView alloc] init];
self.valueView = valueView;
[self.contentView addSubview:self.valueView];
NSDictionary *views = #{
#"nameView": self.nameView,
#"nameLabel": self.nameLabel,
#"valueView": self.valueView
};
NSArray *constraints;
// The overriding constraint
constraints = [NSLayoutConstraint constraintsWithVisualFormat:#"H:|[nameView][valueView(==nameView)]|"
options: 0
metrics:nil
views:views];
[self.contentView addConstraints:constraints];
}
return self;
}
#end

Answer 1

The subclass wants to augment the superclass behavior, for example, by adding additional subviews; but it also wants to override the superclass when it comes to creating constraints. To do both, the best approach is to factor out the view creating and the constraint creating code, then in the subclass, control whether we're augmenting or overriding by calling super selectively.
First, factor out...
// in NameCell.m initWithStyle
// super initWithStyle..., if (self) { ...
[self addCustomSubviews];
[self addCustomConstraints];
In NameCell, these new methods should be implemented exactly as you have them inline in the question, but in the subclass: (1) don't implement init at all, allowing the superclass init to call the factored code, and (2) override the factored code as follows...
// NameValueCell.m
- (void)addCustomSubviews {
// augmenting super here, so call super...
[super addCustomSubviews];
// add the value view
UIView *valueView = [[UIView alloc] init];
// and so on
}
- (void)addCustomConstraints {
// overriding super here, so don't call super, just add constraints
NSDictionary *views = #{
// and so in
}
In a less fussy but less clear alternative, you could just leave your inits as they are, but in the subclass init, remove the constraints that were just created in the super...
// in NameValueCell.m, in the initWithStyle method, before creating constraints
[self removeConstraints:self.constraints]; // then ...
NSDictionary *views = #{ // and so on...
I wouldn't call this alternative a best (or even good) practice, but I think it should work.

Answer 2

First: don't add constraints; activate them. It's far simpler and less error-prone.
Okay, then. Just keep a reference to the constraints that might need replacing in an NSArray instance variable:
constraints = [NSLayoutConstraint constraintsWithVisualFormat:#"H:|[nameView]|"
options: 0
metrics:nil
views:views];
self.removeableConstraints = constraints; // an instance property
[NSLayoutConstraint activateConstraints: constraints];
Now all the subclass has to do is deactivate self.removeableConstraints and activate its substitute constraints.
[NSLayoutConstraint deactivateConstraints: self.removeableConstraints];
constraints = [NSLayoutConstraint constraintsWithVisualFormat:#"H:|[nameView][valueView(==nameView)]|"
options: 0
metrics:nil
views:views];
[NSLayoutConstraint activateConstraints: constraints];
That is the general pattern for swapping out constraints, and there is no reason that the class/subclass relationship here shouldn't use it.