From b6509a3ad71eea83dcdb74ef1cb32dd1c7f6dd56 Mon Sep 17 00:00:00 2001
From: Charlie Andrews <charlieandrews.cwa@gmail.com>
Date: Wed, 11 Oct 2017 09:36:32 -0500
Subject: [PATCH] Add RecalculateCaches to every level in hierarchy

This to decouple the implementation of recalculating caches from the
structure of the hierarchy: holder > index > frame > view > fragment.
See [Law of Demeter](https://en.wikipedia.org/wiki/Law_of_Demeter).
---
 frame.go  |  7 +++++++
 holder.go | 22 +++++-----------------
 index.go  |  7 +++++++
 view.go   |  7 +++++++
 4 files changed, 26 insertions(+), 17 deletions(-)

diff --git a/frame.go b/frame.go
index 141772a93..21f160a64 100644
--- a/frame.go
+++ b/frame.go
@@ -543,6 +543,13 @@ func (f *Frame) Views() []*View {
 	return other
 }
 
+// RecalculateCaches recalculates caches on every view in the frame.
+func (f *Frame) RecalculateCaches() {
+	for _, view := range f.Views() {
+		view.RecalculateCaches()
+	}
+}
+
 // CreateViewIfNotExists returns the named view, creating it if necessary.
 func (f *Frame) CreateViewIfNotExists(name string) (*View, error) {
 	// Don't create inverse views if they are not enabled.
diff --git a/holder.go b/holder.go
index 31aee1c21..0b091045f 100644
--- a/holder.go
+++ b/holder.go
@@ -361,25 +361,13 @@ func (h *Holder) flushCaches() {
 	}
 }
 
-// RecalculateCaches calls RecalculateCache on every fragment of every frame of
-// every index. This is probably not practical to call in real-world workloads,
-// but makes writing integration tests much eaiser, since one doesn't have to
-// wait 10 seconds after setting bits to get expected response.
+// RecalculateCaches recalculates caches on every index in the holder. This is
+// probably not practical to call in real-world workloads, but makes writing
+// integration tests much eaiser, since one doesn't have to wait 10 seconds
+// after setting bits to get expected response.
 func (h *Holder) RecalculateCaches() {
 	for _, index := range h.Indexes() {
-		for _, frame := range index.Frames() {
-			for _, view := range frame.Views() {
-				for _, fragment := range view.Fragments() {
-					select {
-					case <-h.closing:
-						return
-					default:
-					}
-
-					fragment.RecalculateCache()
-				}
-			}
-		}
+		index.RecalculateCaches()
 	}
 }
 
diff --git a/index.go b/index.go
index 6e38b19aa..3e6cb2518 100644
--- a/index.go
+++ b/index.go
@@ -392,6 +392,13 @@ func (i *Index) Frames() []*Frame {
 	return a
 }
 
+// RecalculateCaches recalculates caches on every frame in the index.
+func (i *Index) RecalculateCaches() {
+	for _, frame := range i.Frames() {
+		frame.RecalculateCaches()
+	}
+}
+
 // CreateFrame creates a frame.
 func (i *Index) CreateFrame(name string, opt FrameOptions) (*Frame, error) {
 	i.mu.Lock()
diff --git a/view.go b/view.go
index 4ee863c8b..5da97d644 100644
--- a/view.go
+++ b/view.go
@@ -213,6 +213,13 @@ func (v *View) Fragments() []*Fragment {
 	return other
 }
 
+// RecalculateCaches recalculates the cache on every fragment in the view.
+func (v *View) RecalculateCaches() {
+	for _, fragment := range v.Fragments() {
+		fragment.RecalculateCache()
+	}
+}
+
 // CreateFragmentIfNotExists returns a fragment in the view by slice.
 func (v *View) CreateFragmentIfNotExists(slice uint64) (*Fragment, error) {
 	v.mu.Lock()