case model.Vector:
		if v.Len() < 1 {
			log.Debugf("no values for query: %s", query)
			return 0, nil
		}

		return float64(v[0].Value), nil
	default:
		return 0, errors.New("bad metric value type returned for query")
	}
}

func convertLatencyToDuration(val float64) time.Duration {
	return time.Duration(val) * time.Millisecond
}

func printHeader(writer io.Writer) {

            saveError(messages -> messages.addErrorsDocidNotFound(GLOBAL, form.docId));
            return redirect(ErrorAction.class);
        }

        final String content = viewHelper.createCacheContent(doc, form.hq);
        if (content == null) {
            saveError(messages -> messages.addErrorsDocidNotFound(GLOBAL, form.docId));
            return redirect(ErrorAction.class);
        }

    }
    return dummy;
  }

  @Benchmark
  int copyPreSizedArrayList(int reps) {
    int size = this.size;
    int tmp = 0;
    for (int rep = 0; rep < reps; rep++) {
      List<Object> builder = Lists.newArrayListWithCapacity(size);
      for (int i = 0; i < size; i++) {
        builder.add(OBJECT);
      }
      tmp += ImmutableList.copyOf(builder).size();
    }
    return tmp;
  }

  @Override
  protected Collection<E> actualContents() {
    return collection;
  }

  // TODO: dispose of this once collection is encapsulated.
  @Override
  @CanIgnoreReturnValue
  protected Collection<E> resetContainer(Collection<E> newContents) {
    collection = super.resetContainer(newContents);
    return collection;
  }

  /** @see AbstractContainerTester#resetContainer() */

     *
     * @param <E>
     *            要素の型
     * @param value
     *            反復子が返す唯一の値
     * @return {@link SingleValueIterator}をラップした{@link Iterable}
     */
    public static <E> Iterable<E> iterable(final E value) {
        return () -> new SingleValueIterator<>(value);
    }

    /**
     * インスタンスを構築します。
     *
     * @param value
     *            反復子が返す唯一の値
     */

    }
    return dummy;
  }

  @Benchmark
  int copyPreSizedArrayList(int reps) {
    int size = this.size;
    int tmp = 0;
    for (int rep = 0; rep < reps; rep++) {
      List<Object> builder = Lists.newArrayListWithCapacity(size);
      for (int i = 0; i < size; i++) {
        builder.add(OBJECT);
      }
      tmp += ImmutableList.copyOf(builder).size();
    }
    return tmp;
  }

    /**
     * Not exactly sure what that is all about, certainly legacy stuff
     * 
     * @return resolveHashes
     */
    boolean isResolveHashes ();


    /**
     * @return whether this refrral needs to be resolved further
     */
    boolean isIntermediate ();


    /**
     * @param next
     * @return new referral, combining a chain of referrals
     */

    } // -- void addGoal( String )

    /**
     * Get configuration to pass to the goals.
     *
     * @return Object
     */
    public Object getConfiguration() {
        return this.configuration;
    } // -- Object getConfiguration()

    /**
     * Method getGoals.
     *
     * @return List
     */
    public java.util.List<String> getGoals() {
        if (this.goals == null) {

		case <-ctx2.Done():
		// The lock acquirer decides to cancel, exit this goroutine
		case <-ctx.Done():
		}

		cancel()
	}()
	return ctx, cancel
}

func (ld sharedLock) GetLock(ctx context.Context) (context.Context, context.CancelFunc) {
	l := <-ld.lockContext
	return mergeContext(l.Context(), ctx)
}

func newSharedLock(ctx context.Context, objAPI ObjectLayer, lockName string) *sharedLock {
	l := &sharedLock{

			j += 3
		default:
			t[j] = s[i]
			j++
		}
	}
	return string(t)
}

// s3EncodeName encodes string in response when encodingType is specified in AWS S3 requests.
func s3EncodeName(name, encodingType string) string {
	if strings.ToLower(encodingType) == "url" {
		return s3URLEncode(name)
	}
	return name
}

// getHandlerName returns the name of the handler function. It takes the type