add flyweight pattern

Author: sensorario

README.md

@@ -16,4 +16,5 @@
  * [Bridge](structural/bridge) [:notebook:](https://en.wikipedia.org/wiki/Bridge_pattern)
  * [Composite](structural/composite) [:notebook:](http://en.wikipedia.org/wiki/Composite_pattern)
  * [Decorator](structural/decorator) [:notebook:](https://en.wikipedia.org/wiki/Decorator_pattern)
+ * [Flyweight](structural/flyweight) [:notebook:](https://en.wikipedia.org/wiki/Flyweight)
  * [Proxy](structural/proxy) [:notebook:](https://en.wikipedia.org/wiki/Proxy_pattern)

creational/README.md

@@ -1,3 +1,14 @@
 # Creational patterns
 
-Some patterns can overlap a bit. Use them with care and in the right context. Remember that these patterns's purpose is to abstract the creation of objects for complexity and maintenance purpose.
+Some patterns can overlap a bit. Use them with care and in the right context.
+Remember that these patterns's purpose is to abstract the creation of objects
+for complexity and maintenance purpose.
+
+## [Creational](creational)
+
+ * [Abstract Factory method](creational/abstract_factory) [:notebook:](http://en.wikipedia.org/wiki/Abstract_Factory_pattern)
+ * [Builder](creational/builder) [:notebook:](http://en.wikipedia.org/wiki/Builder_pattern)
+ * [Factory method](creational/factory) [:notebook:](http://en.wikipedia.org/wiki/Factory_pattern)
+ * [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:)

runtests.sh

@@ -1,2 +1,3 @@
 #!/bin/bash
 go test ./creational/...
+go test ./structural/...

structural/README.md

@@ -1,3 +1,14 @@
 # Structural Patterns
 
-Structural patterns help us to shape application with common used structures and relationships.
+Structural patterns help us to shape application with common used structures and
+relationships.
+
+## [Structural](structural)
+
+ * [Adapter](structural/adapter) [:notebook:](https://en.wikipedia.org/wiki/Adapter_pattern)
+ * [Binary Tree compositions](structural/binary-tree-compositions) [:notebook:](https://en.wikipedia.org/wiki/Binary_tree)
+ * [Bridge](structural/bridge) [:notebook:](https://en.wikipedia.org/wiki/Bridge_pattern)
+ * [Composite](structural/composite) [:notebook:](http://en.wikipedia.org/wiki/Composite_pattern)
+ * [Decorator](structural/decorator) [:notebook:](https://en.wikipedia.org/wiki/Decorator_pattern)
+ * [Flyweight](structural/flyweight) [:notebook:](https://en.wikipedia.org/wiki/Flyweight)
+ * [Proxy](structural/proxy) [:notebook:](https://en.wikipedia.org/wiki/Proxy_pattern)

structural/flyweight/README.md

@@ -0,0 +1,87 @@
+# Flyweight
+
+This pattern it's very commonly used in computer graphics and the video game
+industry. It allow sharing the state of a heavy object between many instances of
+some type.
+
+This example uses a creational pattern to create objects instance.
+
+```go
+func TestFactoryCreatesObjects(t *testing.T) {
+	f := NewObjectFactory()
+	firstObject := f.GetObject(TYPE_ONE)
+	if firstObject == nil {
+		t.Error("The pointer to the TYPE_ONE was nil")
+	}
+}
+
+```
+
+According to the flyweight pattern, each object requested is returned. Well,
+what is really returned is not an object but a pointer to that object.
+
+```go
+func TestFactoryCreatesTwoObjects(t *testing.T) {
+	f := NewObjectFactory()
+	_ = f.GetObject(TYPE_ONE)
+	secondObject := f.GetObject(TYPE_ONE)
+	if secondObject == nil {
+		t.Error("The pointer to the TYPE_ONE was nil")
+	}
+}
+
+```
+
+Each pointer created is a different pointer.
+
+```go
+func TestFactoryCreatesJustObjectOfTypes(t *testing.T) {
+	f := NewObjectFactory()
+	firstObject := f.GetObject(TYPE_ONE)
+	secondObject := f.GetObject(TYPE_ONE)
+	if firstObject != secondObject {
+		t.Error("TYPE_ONE pointers weren't the same")
+	}
+}
+
+```
+
+Even if object of TYPE_ONE is requested more times, the number of created
+objects is equals to the number of type requested.
+
+```go
+func TestNumberOfObjectsIsAlwaysNumberOfTypeOfObjectCreated(t *testing.T) {
+	f := NewObjectFactory()
+	_ = f.GetObject(TYPE_ONE)
+	_ = f.GetObject(TYPE_ONE)
+	if f.GetNumberOfObjects() != 1 {
+		t.Errorf(
+			"The number of objects created was not 1: %d\n",
+			f.GetNumberOfObjects(),
+		)
+	}
+}
+
+```
+
+Finally, and for completeness, if two objects are requested a huge amount of
+time, the number of object created is still two.
+
+```go
+func TestHighVolume(t *testing.T) {
+	f := NewObjectFactory()
+	objects := make([]*Object, 500000*2)
+	for i := 0; i < 500000; i++ {
+		objects[i] = f.GetObject(TYPE_ONE)
+	}
+	for i := 500000; i < 2*500000; i++ {
+		objects[i] = f.GetObject(TYPE_TWO)
+	}
+	if f.GetNumberOfObjects() != 2 {
+		t.Errorf(
+			"The number of objects created was not 2: %d\n",
+			f.GetNumberOfObjects(),
+		)
+	}
+}
+```

structural/flyweight/flyweight.go

@@ -0,0 +1,49 @@
+package flyweight
+
+const (
+	TYPE_ONE = iota
+	TYPE_TWO
+)
+
+type Object struct {
+	ID   uint64
+	Name int
+}
+
+type objectFactory struct {
+	createdObjects map[int]*Object
+}
+
+func (f *objectFactory) GetObject(objectID int) *Object {
+	if f.createdObjects[objectID] != nil {
+		return f.createdObjects[objectID]
+	}
+	object := getObjectFactory(objectID)
+	f.createdObjects[objectID] = &object
+	return f.createdObjects[objectID]
+}
+
+func (f *objectFactory) GetNumberOfObjects() int {
+	return len(f.createdObjects)
+}
+
+func getObjectFactory(object int) Object {
+	switch object {
+	case TYPE_TWO:
+		return Object{
+			ID:   2,
+			Name: TYPE_TWO,
+		}
+	default:
+		return Object{
+			ID:   1,
+			Name: TYPE_ONE,
+		}
+	}
+}
+
+func NewObjectFactory() objectFactory {
+	return objectFactory{
+		createdObjects: make(map[int]*Object),
+	}
+}

structural/flyweight/flyweight_test.go

@@ -0,0 +1,60 @@
+package flyweight
+
+import (
+	"testing"
+)
+
+func TestFactoryCreatesObjects(t *testing.T) {
+	f := NewObjectFactory()
+	firstObject := f.GetObject(TYPE_ONE)
+	if firstObject == nil {
+		t.Error("The pointer to the TYPE_ONE was nil")
+	}
+}
+
+func TestFactoryCreatesTwoObjects(t *testing.T) {
+	f := NewObjectFactory()
+	_ = f.GetObject(TYPE_ONE)
+	secondObject := f.GetObject(TYPE_ONE)
+	if secondObject == nil {
+		t.Error("The pointer to the TYPE_ONE was nil")
+	}
+}
+
+func TestFactoryCreatesJustObjectOfTypes(t *testing.T) {
+	f := NewObjectFactory()
+	firstObject := f.GetObject(TYPE_ONE)
+	secondObject := f.GetObject(TYPE_ONE)
+	if firstObject != secondObject {
+		t.Error("TYPE_ONE pointers weren't the same")
+	}
+}
+
+func TestNumberOfObjectsIsAlwaysNumberOfTypeOfObjectCreated(t *testing.T) {
+	f := NewObjectFactory()
+	_ = f.GetObject(TYPE_ONE)
+	_ = f.GetObject(TYPE_ONE)
+	if f.GetNumberOfObjects() != 1 {
+		t.Errorf(
+			"The number of objects created was not 1: %d\n",
+			f.GetNumberOfObjects(),
+		)
+	}
+}
+
+func TestHighVolume(t *testing.T) {
+	f := NewObjectFactory()
+	objects := make([]*Object, 500000*2)
+	for i := 0; i < 500000; i++ {
+		objects[i] = f.GetObject(TYPE_ONE)
+	}
+	for i := 500000; i < 2*500000; i++ {
+		objects[i] = f.GetObject(TYPE_TWO)
+	}
+	if f.GetNumberOfObjects() != 2 {
+		t.Errorf(
+			"The number of objects created was not 2: %d\n",
+			f.GetNumberOfObjects(),
+		)
+	}
+}