Merge pull request #23 from bvwells/memento

Implement memento design pattern #14

Author: bvwells

README.md

@@ -66,7 +66,7 @@ Name       | Description                               | Status
 [`Interpreter`](./behavioral/interpreter.go) | Given a language, define a representation for its grammar along with an interpreter that uses the representation to interpret sentences in the language. |
 [`Iterator`](./behavioral/iterator.go) | Provide a way to access the elements of an aggregate object sequentially without exposing its underlying representation. | Implemented
 [`Mediator`](./behavioral/mediator.go) | Define an object that encapsulates how a set of objects interact. Mediator promotes loose coupling by keeping objects from referring to each other explicitly, and it allows their interaction to vary independently. | Implemented
-[`Memento`](./behavioral/memento.go) | Without violating encapsulation, capture and externalize an object's internal state allowing the object to be restored to this state later. |
+[`Memento`](./behavioral/memento.go) | Without violating encapsulation, capture and externalize an object's internal state allowing the object to be restored to this state later. | Implemented
 [`Observer`](./behavioral/observer.go) | Define a one-to-many dependency between objects where a state change in one object results in all its dependents being notified and updated automatically. | Implemented
 [`State`](./behavioral/state.go) | Allow an object to alter its behavior when its internal state changes. The object will appear to change its class. | Implemented
 [`Strategy`](./behavioral/strategy.go) | Define a family of algorithms, encapsulate each one, and make them interchangeable. Strategy lets the algorithm vary independently from clients that use it. | Implemented

behavioral/memento.go

@@ -1 +1,46 @@
 package behavioral
+
+// Memento stores the state of the Number.
+type Memento struct {
+	state int
+}
+
+// NewMemento creates a new memento.
+func NewMemento(value int) *Memento {
+	return &Memento{value}
+}
+
+// Number represents an integer which can be operated on.
+type Number struct {
+	value int
+}
+
+// NewNumber creates a new Number.
+func NewNumber(value int) *Number {
+	return &Number{value}
+}
+
+// Dubble doubles the value of the number.
+func (n *Number) Dubble() {
+	n.value = 2 * n.value
+}
+
+// Half halves the value of the number.
+func (n *Number) Half() {
+	n.value = n.value / 2
+}
+
+// Value returns the value of the number.
+func (n *Number) Value() int {
+	return n.value
+}
+
+// CreateMemento creates a Memento with the current state of the number.
+func (n *Number) CreateMemento() *Memento {
+	return NewMemento(n.value)
+}
+
+// ReinstateMemento reinstates the value of the Number to the value of the memento.
+func (n *Number) ReinstateMemento(memento *Memento) {
+	n.value = memento.state
+}

behavioral/memento_test.go

@@ -0,0 +1,22 @@
+package behavioral
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestMemento(t *testing.T) {
+
+	n := NewNumber(10)
+	n.Dubble()
+	assert.Equal(t, 20, n.Value())
+
+	memento := n.CreateMemento()
+
+	n.Half()
+	assert.Equal(t, 10, n.Value())
+
+	n.ReinstateMemento(memento)
+	assert.Equal(t, 20, n.Value())
+}