implement setters and change to call it from constructor

aliasdomain.go

@@ -22,26 +22,46 @@ func (p AliasDomainSlice) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
 
 // NewAliasDomain creates a new AliasDomain instance.
 func NewAliasDomain(name, target string) (*AliasDomain, error) {
-	if !validAliasDomainName(name) {
+	ad := &AliasDomain{}
-		return nil, ErrInvalidAliasDomainName
+
-	}
+	if err := ad.setName(name); err != nil {
-	if !validAliasDomainTarget(target) {
+		return nil, err
-		return nil, ErrInvalidAliasDomainTarget
 	}
 
-	ad := &AliasDomain{
+	if err := ad.SetTarget(target); err != nil {
-		name:   name,
+		return nil, err
-		target: target,
 	}
 
 	return ad, nil
 }
 
+// setName sets the name.
+func (ad *AliasDomain) setName(name string) error {
+	if !validAliasDomainName(name) {
+		return ErrInvalidAliasDomainName
+	}
+
+	ad.name = name
+
+	return nil
+}
+
 // Name returns name.
 func (ad *AliasDomain) Name() string {
 	return ad.name
 }
 
+// SetTarget sets the target.
+func (ad *AliasDomain) SetTarget(target string) error {
+	if !validAliasDomainTarget(target) {
+		return ErrInvalidAliasDomainTarget
+	}
+
+	ad.target = target
+
+	return nil
+}
+
 // Target returns target.
 func (ad *AliasDomain) Target() string {
 	return ad.target

aliasuser.go

@@ -28,33 +28,52 @@ func (p AliasUserSlice) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
 
 // NewAliasUser creates a new AliasUser instance.
 func NewAliasUser(name string, targets []string) (*AliasUser, error) {
-	if !validAliasUserName(name) {
+	au := &AliasUser{}
-		return nil, ErrInvalidAliasUserName
+
+	if err := au.setName(name); err != nil {
+		return nil, err
 	}
 
-	if len(targets) < 1 {
+	if err := au.SetTargets(targets); err != nil {
-		return nil, ErrNotEnoughAliasUserTargets
+		return nil, err
-	}
-
-	for _, target := range targets {
-		if !validAliasUserTarget(target) {
-			return nil, ErrInvalidAliasUserTarget
-		}
-	}
-
-	au := &AliasUser{
-		name:    name,
-		targets: targets,
 	}
 
 	return au, nil
 }
 
+// setName sets the name.
+func (au *AliasUser) setName(name string) error {
+	if !validAliasUserName(name) {
+		return ErrInvalidAliasUserName
+	}
+
+	au.name = name
+
+	return nil
+}
+
 // Name returns name.
 func (au *AliasUser) Name() string {
 	return au.name
 }
 
+// SetTargets sets targets.
+func (au *AliasUser) SetTargets(targets []string) error {
+	if len(targets) < 1 {
+		return ErrNotEnoughAliasUserTargets
+	}
+
+	for _, target := range targets {
+		if !validAliasUserTarget(target) {
+			return ErrInvalidAliasUserTarget
+		}
+	}
+
+	au.targets = targets
+
+	return nil
+}
+
 // Targets returns targets.
 func (au *AliasUser) Targets() []string {
 	return au.targets

user.go

@@ -25,29 +25,49 @@ func (p UserSlice) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
 
 // NewUser creates a new User instance.
 func NewUser(name, hashedPassword string, forwards []string) (*User, error) {
-	if !validUserName(name) {
+	u := &User{}
-		return nil, ErrInvalidUserName
+
+	if err := u.setName(name); err != nil {
+		return nil, err
 	}
 
-	u := &User{
+	u.SetHashedPassword(hashedPassword)
-		name:           name,
+	u.SetForwards(forwards)
-		hashedPassword: hashedPassword,
-		forwards:       forwards,
-	}
 
 	return u, nil
 }
 
+// setName sets the name.
+func (u *User) setName(name string) error {
+	if !validUserName(name) {
+		return ErrInvalidUserName
+	}
+
+	u.name = name
+
+	return nil
+}
+
 // Name returns name.
 func (u *User) Name() string {
 	return u.name
 }
 
+// SetHashedPassword sets the hashed password.
+func (u *User) SetHashedPassword(hashedPassword string) {
+	u.hashedPassword = hashedPassword
+}
+
 // HashedPassword returns hashedPassword.
 func (u *User) HashedPassword() string {
 	return u.hashedPassword
 }
 
+// SetForwards sets forwards.
+func (u *User) SetForwards(forwards []string) {
+	u.forwards = forwards
+}
+
 // Forwards returns forwards.
 func (u *User) Forwards() []string {
 	return u.forwards