impl/memory: Implement Queries

impl/memory/taskqueue_data.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package memory
 
 import (
         "errors"
         "fmt"
         "net/http"
@@ skipping 109 matching lines @@
         queueName, err := t.getQueueNameLocked(queueName)
         if err != nil {
                 return err
         }
 
         t.named[queueName] = map[string]*tq.Task{}
         t.archived[queueName] = map[string]*tq.Task{}
         return nil
 }
 
-var tqOkMethods = map[string]struct{}{
+var tqOkMethods = stringSet{
         "GET":    {},
         "POST":   {},
         "HEAD":   {},
         "PUT":    {},
         "DELETE": {},
 }
 
 func (t *taskQueueData) prepTask(c context.Context, ns string, task *tq.Task, queueName string) (*tq.Task, error) {
         toSched := task.Duplicate()
 
         if toSched.Path == "" {
                 toSched.Path = "/_ah/queue/" + queueName
         }
 
         if toSched.ETA.IsZero() {
                 toSched.ETA = clock.Now(c).Add(toSched.Delay)
         } else if toSched.Delay != 0 {
                 panic("taskqueue: both Delay and ETA are set")
         }
         toSched.Delay = 0
 
         if toSched.Method == "" {
                 toSched.Method = "POST"
         }
-        if _, ok := tqOkMethods[toSched.Method]; !ok {
+        if !tqOkMethods.has(toSched.Method) {
                 return nil, fmt.Errorf("taskqueue: bad method %q", toSched.Method)
         }
         if toSched.Method != "POST" && toSched.Method != "PUT" {
                 toSched.Payload = nil
         }
 
         if _, ok := toSched.Header[currentNamespace]; !ok {
                 if ns != "" {
                         if toSched.Header == nil {
                                 toSched.Header = http.Header{}
@@ skipping 23 matching lines @@
         closed int32
         anony  tq.AnonymousQueueData
         parent *taskQueueData
 }
 
 var _ interface {
         memContextObj
         tq.Testable
 } = (*txnTaskQueueData)(nil)
 
-func (t *txnTaskQueueData) canApplyTxn(obj memContextObj) bool         { return false }
-func (t *txnTaskQueueData) applyTxn(context.Context, memContextObj)    { panic("impossible") }
-func (t *txnTaskQueueData) mkTxn(*ds.TransactionOptions) memContextObj { panic("impossible") }
+func (t *txnTaskQueueData) canApplyTxn(obj memContextObj) bool { return false }
+func (t *txnTaskQueueData) applyTxn(context.Context, memContextObj) {
+        impossible(fmt.Errorf("cannot apply nested transaction"))
+}
+func (t *txnTaskQueueData) mkTxn(*ds.TransactionOptions) memContextObj {
+        impossible(fmt.Errorf("cannot start nested transaction"))
+        return nil
+}
 
 func (t *txnTaskQueueData) endTxn() {
         if atomic.LoadInt32(&t.closed) == 1 {
                 panic("cannot end transaction twice")
         }
         atomic.StoreInt32(&t.closed, 1)
 }
 
 func (t *txnTaskQueueData) ResetTasks() {
         t.Lock()
@@ skipping 35 matching lines @@
         return t.parent.GetTombstonedTasks()
 }
 
 func (t *txnTaskQueueData) GetScheduledTasks() tq.QueueData {
         return t.parent.GetScheduledTasks()
 }
 
 func (t *txnTaskQueueData) CreateQueue(queueName string) {
         t.parent.CreateQueue(queueName)
 }