From d05b5eb27aecc5a52c2d125b01d82344e79b245e Mon Sep 17 00:00:00 2001
From: Patrick Mylund Nielsen <patrick@patrickmylund.com>
Date: Sun, 15 Jan 2012 12:16:10 -0600
Subject: [PATCH] Fixed widths in top section of cache.go

---
 cache.go | 61 +++++++++++++++++++++++++++++---------------------------
 1 file changed, 32 insertions(+), 29 deletions(-)

diff --git a/cache.go b/cache.go
index a9757c2..81821ad 100644
--- a/cache.go
+++ b/cache.go
@@ -1,32 +1,26 @@
 package cache
 
-import (
-	"fmt"
-	"reflect"
-	"runtime"
-	"sync"
-	"time"
-)
-
-// go-cache is an in-memory key:value store/cache similar to memcached that is suitable for
-// applications running on a single machine. Any object can be stored, for a given duration
-// or forever, and the cache can be used safely by multiple goroutines.
+// go-cache is an in-memory key:value store/cache similar to memcached that is
+// suitable for applications running on a single machine. Any object can be stored,
+// for a given duration or forever, and the cache can be used safely by multiple
+// goroutines.
 //
-// Installation:
+// == Installation
 //     goinstall github.com/pmylund/go-cache
 //
-// Usage:
+// == Usage
 //     import "github.com/pmylund/go-cache"
 //
-//     // Create a cache with a default expiration time of 5 minutes, and which purges
-//     // expired items every 30 seconds
+//     // Create a cache with a default expiration time of 5 minutes, and which
+//     // purges expired items every 30 seconds
 //     c := cache.New(5*time.Minute, 30*time.Second)
 //
 //     // Set the value of the key "foo" to "bar", with the default expiration time
 //     c.Set("foo", "bar", 0)
 //
-//     // Set the value of the key "baz" to "yes", with no expiration time (the item
-//     // won't be removed until it is re-set, or removed using c.Delete("baz")
+//     // Set the value of the key "baz" to "yes", with no expiration time
+//     // (the item won't be removed until it is re-set, or removed using
+//     // c.Delete("baz")
 //     c.Set("baz", "yes", -1)
 //
 //     // Get the string associated with the key "foo" from the cache
@@ -35,17 +29,18 @@ import (
 //             fmt.Println(foo)
 //     }
 //
-//     // Since Go is statically typed, and cache values can be anything, type assertion
-//     // is needed when values are being passed to functions that don't take arbitrary types,
-//     // (i.e. interface{}). The simplest way to do this for values which will only be used
-//     // once--e.g. for passing to another function--is:
+//     // Since Go is statically typed, and cache values can be anything, type
+//     // assertion is needed when values are being passed to functions that don't
+//     // take arbitrary types, (i.e. interface{}). The simplest way to do this for
+//     // values which will only be used once--e.g. for passing to another
+//     // function--is:
 //     foo, found := c.Get("foo")
 //     if found {
 //             MyFunction(foo.(string))
 //     }
 //
-//     // This gets tedious if the value is used several times in the same function. You
-//     // might do either of the following instead:
+//     // This gets tedious if the value is used several times in the same function.
+//     // You might do either of the following instead:
 //     if x, found := c.Get("foo"); found {
 //             foo := x.(string)
 //             ...
@@ -65,11 +60,11 @@ import (
 //             ...
 //     }
 //
-// If you store a reference type like a pointer, slice, map or channel, you do not need to
-// run Set if you modify the underlying data. The cache does not serialize its data, so if
-// you modify a struct whose pointer you've stored in the cache, retrieving that pointer
-// with Get will point you to the same data:
-//
+//     // If you store a reference type like a pointer, slice, map or channel, you
+//     // do not need to run Set if you modify the underlying data. The cache does
+//     // not serialize its data, so if you modify a struct whose pointer you've
+//     // stored in the cache, retrieving that pointer with Get will point you to
+//     // the same data:
 //     foo := &MyStruct{Num: 1}
 //     c.Set("foo", foo, 0)
 //     ...
@@ -83,10 +78,18 @@ import (
 //     foo := x.(*MyStruct)
 //     foo.Println(foo.Num)
 //
-// will print:
+//     // will print:
 //     1
 //     2
 
+import (
+	"fmt"
+	"reflect"
+	"runtime"
+	"sync"
+	"time"
+)
+
 type Cache struct {
 	*cache
 	// If this is confusing, see the comment at the bottom of the New() function