java/src/main/com/google/appengine/api/search/checkers/GetIndexesRequestChecker.java

   1 // Copyright 2011 Google Inc. All Rights Reserved.
   2
   3 package com.google.appengine.api.search.checkers;
   4
   5 import com.google.appengine.api.NamespaceManager;
   6 import com.google.appengine.api.search.SearchServicePb.ListIndexesParams;
   7 import com.google.apphosting.api.AppEngineInternal;
   8 import com.google.common.base.Strings;
   9
  10 /**
  11  * Checks values of {@link com.google.appengine.api.search.GetIndexesRequest}.
  12  *
  13  */
  14 @AppEngineInternal
  15 public class GetIndexesRequestChecker {
  16
  17   /**
  18    * Checks whether the number of indexes to return is between 1 and the
  19    * maximum.
  20    *
  21    * @param limit the maximum number of indexes to return in list results
  22    * @return the checked number of indexes to return
  23    * @throws IllegalArgumentException if the number of indexes to return
  24    * is out of range
  25    */
  26   public static int checkLimit(int limit) {
  27     Preconditions.checkArgument(limit >= 1 && limit <= SearchApiLimits.GET_INDEXES_MAXIMUM_LIMIT,
  28         String.format("The limit %d must be between 1 and %d",
  29             limit, SearchApiLimits.GET_INDEXES_MAXIMUM_LIMIT));
  30     return limit;
  31   }
  32
  33   /**
  34    * Checks whether the offset of the first indexes to return is between 0 and the
  35    * maximum.
  36    *
  37    * @param offset the offset of the first index to return in list results
  38    * @return the checked offset of the first index to return
  39    * @throws IllegalArgumentException if the offset of the first index to return
  40    * is out of range
  41    */
  42   public static int checkOffset(int offset) {
  43     Preconditions.checkArgument(offset >= 0 && offset <= SearchApiLimits.GET_INDEXES_MAXIMUM_OFFSET,
  44         String.format("The limit %d must be between 1 and %d",
  45             offset, SearchApiLimits.GET_INDEXES_MAXIMUM_OFFSET));
  46     return offset;
  47   }
  48
  49   /**
  50    * Checks whether the given index name prefix is legal. This method uses the same
  51    * checks as {@link IndexChecker#checkName(String)}.
  52    *
  53    * @param indexNamePrefix the index name prefix to be checked
  54    * @return the checked index name prefix
  55    * @throws IllegalArgumentException if the index name prefix is illegal.
  56    */
  57   public static String checkIndexNamePrefix(String indexNamePrefix) {
  58     if (Strings.isNullOrEmpty(indexNamePrefix)) {
  59       return indexNamePrefix;
  60     }
  61     return IndexChecker.checkName(indexNamePrefix);
  62   }
  63
  64   /**
  65    * Checks whether the given start index name is legal. This method uses the same
  66    * checks as {@link IndexChecker#checkName(String)}.
  67    *
  68    * @param startIndexName the name of the first index to be returned
  69    * @return the checked start index name
  70    * @throws IllegalArgumentException if the start index name is illegal.
  71    */
  72   public static String checkStartIndexName(String startIndexName) {
  73     if (Strings.isNullOrEmpty(startIndexName)) {
  74       return startIndexName;
  75     }
  76     return IndexChecker.checkName(startIndexName);
  77   }
  78
  79   /**
  80    * Ensures the given protocol buffer parameters are valid. If any of the parameters
  81    * fail to pass the checks, this method throws {@link IllegalArgumentException}. If
  82    * everything is valid the original parameters are returned.
  83    *
  84    * @param params the parameters to be checked for validity
  85    * @return the checked parameters for listing indexes
  86    * @throws IllegalArgumentException if any of the values are incorrect
  87    */
  88   public static ListIndexesParams checkListIndexesParams(ListIndexesParams params) {
  89     if (params.hasLimit()) {
  90       checkLimit(params.getLimit());
  91     }
  92     if (params.hasNamespace()) {
  93       NamespaceManager.validateNamespace(params.getNamespace());
  94     }
  95     if (params.hasStartIndexName()) {
  96       checkStartIndexName(params.getStartIndexName());
  97     }
  98     if (params.hasIndexNamePrefix()) {
  99       checkIndexNamePrefix(params.getIndexNamePrefix());
 100     }
 101     if (params.hasOffset()) {
 102       checkOffset(params.getOffset());
 103     }
 104     return params;
 105   }
 106 }