Merge pull request #6 from luk4z7/develop

Develop

README.md

@@ -43,6 +43,7 @@ A curated collection of idiomatic design & application patterns for Go language.
 | [Facade](/structural/facade/main.go) | Uses one type as an API to a number of others | ✔ |
 | [Flyweight](/structural/flyweight/main.go) | Reuses existing instances of objects with similar/identical state to minimize resource usage | ✔ |
 | [Proxy](/structural/decorator/proxy.md) | Provides a surrogate for an object to control it's actions | ✔ |
+| [Adapter](/structural/adapter/adapter.md) | Provides a surrogate for an object to control it's actions | ✔ |
 
 ## Behavioral Patterns
 

creational/abstract_factory.md

@@ -0,0 +1,98 @@
+# Abstract Factory Pattern
+
+Provide an interface for creating families of related or dependent objects without specifying their concrete classes
+
+## Implementation
+
+```go
+const (
+    CAR  = 1
+    LuxuryCarType = 1
+    FamilyCarType = 2
+)
+
+type Car interface {
+    NumDoors() int
+}
+
+func CreateVehicleFactory(v int) (VehicleFactory, error) {
+    switch v {
+    case CAR:
+        return new(CarFactory), nil
+    default:
+        return nil, errors.New(fmt.Sprintf("Factory of type %d not exist\n", v))
+    }
+}
+
+type CarFactory struct{}
+
+func (c *CarFactory) NewVehicle(v int) (Vehicle, error) {
+    switch v {
+    case LuxuryCarType:
+        return new(LuxuryCar), nil
+    case FamilyCarType:
+        return new(FamilyCar), nil
+    default:
+        return nil, errors.New(fmt.Sprintf("Vehicle of type %d not exist\n", v))
+    }
+}
+
+type FamilyCar struct{}
+
+func (*FamilyCar) NumDoors() int {
+    return 5
+}
+
+func (*FamilyCar) NumWheels() int {
+    return 4
+}
+
+func (*FamilyCar) NumSeats() int {
+    return 5
+}
+
+type LuxuryCar struct{}
+
+func (*LuxuryCar) NumDoors() int {
+    return 4
+}
+
+func (*LuxuryCar) NumWheels() int {
+    return 4
+}
+
+func (*LuxuryCar) NumSeats() int {
+    return 5
+}
+
+type Vehicle interface {
+    NumWheels() int
+    NumSeats() int
+}
+
+type VehicleFactory interface {
+    NewVehicle(v int) (Vehicle, error)
+}
+```
+
+## Usage
+
+
+```go
+carFactory, err := CreateVehicleFactory(CAR)
+if err != nil {
+	panic(err)
+}
+
+luxuryCar, err := carFactory.NewVehicle(LuxuryCarType)
+if err != nil {
+	panic(err)
+}
+
+car, ok := luxuryCar.(Car)
+if !ok {
+	panic(err)
+}
+
+fmt.Println(luxuryCar.NumWheels(), luxuryCar.NumSeats(), car.NumDoors())
+```

creational/abstract_factory/abstract_factory.go

@@ -0,0 +1,22 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+)
+
+const (
+	CAR  = 1
+	BIKE = 2
+)
+
+func CreateVehicleFactory(v int) (VehicleFactory, error) {
+	switch v {
+	case CAR:
+		return new(CarFactory), nil
+	case BIKE:
+		return new(MotorbikeFactory), nil
+	default:
+		return nil, errors.New(fmt.Sprintf("Factory of type %d not exist\n", v))
+	}
+}

creational/abstract_factory/main_test.go

@@ -0,0 +1,25 @@
+package main
+
+import (
+	"testing"
+)
+
+func TestCarFactory(t *testing.T) {
+	carFactory, err := CreateVehicleFactory(CAR)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	luxuryCar, err := carFactory.NewVehicle(LuxuryCarType)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	car, ok := luxuryCar.(Car)
+	if !ok {
+		t.Fatal("struct assertion failed")
+	}
+
+	t.Logf("CarType: Luxury NumWheels=%d, NumSeats=%d, NumDoors=%d",
+		luxuryCar.NumWheels(), luxuryCar.NumSeats(), car.NumDoors())
+}

creational/abstract_factory/motorbike_factory.go

@@ -12,7 +12,7 @@ const (
 
 type MotorbikeFactory struct{}
 
-func (m *MotorbikeFactory) Build(v int) (Vehicle, error) {
+func (m *MotorbikeFactory) NewVehicle(v int) (Vehicle, error) {
 	switch v {
 	case SportMotorbikeType:
 		return new(SportMotorbike), nil