limit the number of objects available

Author: sensorario

README.md

@@ -8,3 +8,7 @@
  * [Object Pool](creational/pool) [:notebook:](http://en.wikipedia.org/wiki/Object_Pool_pattern)
  * [Prototype](creational/prototype) [:notebook:](http://en.wikipedia.org/wiki/Prototype_pattern)
  * [Singleton](creational/singleton) [:notebook:](http://en.wikipedia.org/wiki/Singleton_pattern) (is considered an anti-pattern! :no_entry:)
+
+## [Structural](structural)
+
+ * [Composite](structural/composite) [:notebook:](http://en.wikipedia.org/wiki/Composite_pattern)

creational/pool/pool.go

@@ -2,6 +2,9 @@ package pool
 
 import (
 	"container/list"
+	"errors"
+	"log"
+	"strconv"
 )
 
 type PoolObject struct {
@@ -21,19 +24,24 @@ func InitPool() Pool {
 	return *pool
 }
 
-func (p *Pool) Loan() PoolObject {
+func (p *Pool) Loan() (*PoolObject, error) {
 	if p.idle.Len() > 0 {
 		for e, i := p.idle.Front(), 0; e != nil; e, i = e.Next(), i+1 {
 			if i == 0 {
 				object := e.Value.(PoolObject)
-				return object
+				return &object, nil
 			}
 		}
 	}
 
+	log.Println(strconv.Itoa(p.active.Len()))
+	if p.NumberOfObjectsInPool() >= 3 {
+		return nil, errors.New("...")
+	}
+
 	object := PoolObject{p.NumberOfObjectsInPool() + 1}
 	p.active.PushBack(object)
-	return object
+	return &object, nil
 }
 
 func (p *Pool) Receive(object PoolObject) {

creational/pool/pool_test.go

@@ -18,7 +18,7 @@ func TestWhenObjectIsNeededItIsRequestedFromThePool(t *testing.T) {
 		t.Fatal("There shouldnt be more than zero object in pool")
 	}
 
-	objectOne := pool.Loan()
+	objectOne, _ := pool.Loan()
 	if pool.NumberOfActiveObjects() != 1 {
 		t.Fatal("Something went wrong")
 	}
@@ -31,15 +31,15 @@ func TestWhenObjectIsNeededItIsRequestedFromThePool(t *testing.T) {
 		t.Fatal("object id should be 1")
 	}
 
-	pool.Receive(objectOne)
+	pool.Receive(*objectOne)
 	if pool.NumberOfActiveObjects() != 0 {
 		t.Fatal("There should not be active object")
 	}
 	if pool.NumberOfIdleObjects() != 1 {
 		t.Fatal("Actually there should be zero idle objects in pool")
 	}
 
-	secondCall := pool.Loan()
+	secondCall, _ := pool.Loan()
 	if secondCall.id != createdId {
 		t.Fatal(strings.Join([]string{
 			"Pool should return same object: we now have ",
@@ -56,16 +56,31 @@ func TestWhenObjectIsNeededItIsRequestedFromThePool(t *testing.T) {
 func TestPool(t *testing.T) {
 	pool := InitPool()
 
-	_ = pool.Loan()
-	foo := pool.Loan()
-	_ = pool.Loan()
+	_, _ = pool.Loan()
+	foo, _ := pool.Loan()
+	_, _ = pool.Loan()
 
 	if pool.NumberOfActiveObjects() != 3 {
 		t.Fatal("Actually there should be zero idle objects in pool")
 	}
 
-	pool.Receive(foo)
+	pool.Receive(*foo)
 	if pool.NumberOfActiveObjects() != 2 {
 		t.Fatal("Actually there should be zero idle objects in pool")
 	}
 }
+
+func TestPoolLimitNumberOfAvailableObject(t *testing.T) {
+	pool := InitPool()
+	_, _ = pool.Loan()
+	_, _ = pool.Loan()
+	_, err := pool.Loan()
+	if err != nil {
+		t.Fatal("There should be one more available object in pool")
+	}
+
+	_, err = pool.Loan()
+	if err == nil {
+		t.Fatal("Current pool should manage only four object")
+	}
+}

structural/composite/composite.go

@@ -0,0 +1,35 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+)
+
+type Person struct{ name string }
+
+type Swimmer struct{}
+
+func (s *Swimmer) Swim(name string) {
+	fmt.Println(strings.Join([]string{
+		name,
+		" is swimming",
+	}, ""))
+}
+
+type IronMan struct {
+	person  Person
+	swimmer Swimmer
+}
+
+func (i *IronMan) Swim() {
+	i.swimmer.Swim(i.person.name)
+}
+
+func main() {
+	ironMan := IronMan{
+		person:  Person{"Mariottide"},
+		swimmer: Swimmer{},
+	}
+
+	ironMan.Swim()
+}