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.appengine.api.search.Util;
   8 import com.google.apphosting.api.AppEngineInternal;
   9
  10 /**
  11  * Checks values of {@link com.google.appengine.api.search.GetIndexesRequest}.
  12  *
  13  */
  14 @AppEngineInternal
  15 public class GetIndexesRequestChecker {
  16
  17   /**
  18    * The maximum offset of the first index returned in list indexes results.
  19    * @deprecated From 1.7.4, use {@link SearchApiLimits#GET_INDEXES_MAXIMUM_OFFSET}
  20    */
  21   @Deprecated public static final int MAXIMUM_OFFSET = 1000;
  22
  23   /**
  24    * The maximum number of indexes that can be requested to be returned in
  25    * list indexes results.
  26    * @deprecated From 1.7.4, use {@link SearchApiLimits#GET_INDEXES_MAXIMUM_LIMIT}
  27    */
  28   @Deprecated public static final int MAXIMUM_LIMIT = 1000;
  29
  30   /**
  31    * The default number of indexes we will try to return.
  32    * @deprecated From 1.7.4, use {@link SearchApiLimits#GET_INDEXES_DEFAULT_LIMIT}
  33    */
  34   @Deprecated public static final int DEFAULT_LIMIT = 20;
  35
  36   /**
  37    * Checks whether the number of indexes to return is between 1 and the
  38    * maximum.
  39    *
  40    * @param limit the maximum number of indexes to return in list results
  41    * @return the checked number of indexes to return
  42    * @throws IllegalArgumentException if the number of indexes to return
  43    * is out of range
  44    */
  45   public static int checkLimit(int limit) {
  46     Preconditions.checkArgument(limit >= 1 && limit <= SearchApiLimits.GET_INDEXES_MAXIMUM_LIMIT,
  47         String.format("The limit %d must be between 1 and %d",
  48             limit, SearchApiLimits.GET_INDEXES_MAXIMUM_LIMIT));
  49     return limit;
  50   }
  51
  52   /**
  53    * Checks whether the offset of the first indexes to return is between 0 and the
  54    * maximum.
  55    *
  56    * @param offset the offset of the first index to return in list results
  57    * @return the checked offset of the first index to return
  58    * @throws IllegalArgumentException if the offset of the first index to return
  59    * is out of range
  60    */
  61   public static int checkOffset(int offset) {
  62     Preconditions.checkArgument(offset >= 0 && offset <= SearchApiLimits.GET_INDEXES_MAXIMUM_OFFSET,
  63         String.format("The limit %d must be between 1 and %d",
  64             offset, SearchApiLimits.GET_INDEXES_MAXIMUM_OFFSET));
  65     return offset;
  66   }
  67
  68   /**
  69    * Checks whether the given index name prefix is legal. This method uses the same
  70    * checks as {@link IndexChecker#checkName(String)}.
  71    *
  72    * @param indexNamePrefix the index name prefix to be checked
  73    * @return the checked index name prefix
  74    * @throws IllegalArgumentException if the index name prefix is illegal.
  75    */
  76   public static String checkIndexNamePrefix(String indexNamePrefix) {
  77     if (Util.isNullOrEmpty(indexNamePrefix)) {
  78       return indexNamePrefix;
  79     }
  80     return IndexChecker.checkName(indexNamePrefix);
  81   }
  82
  83   /**
  84    * Checks whether the given start index name is legal. This method uses the same
  85    * checks as {@link IndexChecker#checkName(String)}.
  86    *
  87    * @param startIndexName the name of the first index to be returned
  88    * @return the checked start index name
  89    * @throws IllegalArgumentException if the start index name is illegal.
  90    */
  91   public static String checkStartIndexName(String startIndexName) {
  92     if (Util.isNullOrEmpty(startIndexName)) {
  93       return startIndexName;
  94     }
  95     return IndexChecker.checkName(startIndexName);
  96   }
  97
  98   /**
  99    * Ensures the given protocol buffer parameters are valid. If any of the parameters
 100    * fail to pass the checks, this method throws {@link IllegalArgumentException}. If
 101    * everything is valid the original parameters are returned.
 102    *
 103    * @param params the parameters to be checked for validity
 104    * @return the checked parameters for listing indexes
 105    * @throws IllegalArgumentException if any of the values are incorrect
 106    */
 107   public static ListIndexesParams checkListIndexesParams(ListIndexesParams params) {
 108     if (params.hasLimit()) {
 109       checkLimit(params.getLimit());
 110     }
 111     if (params.hasNamespace()) {
 112       NamespaceManager.validateNamespace(params.getNamespace());
 113     }
 114     if (params.hasStartIndexName()) {
 115       checkStartIndexName(params.getStartIndexName());
 116     }
 117     if (params.hasIndexNamePrefix()) {
 118       checkIndexNamePrefix(params.getIndexNamePrefix());
 119     }
 120     if (params.hasOffset()) {
 121       checkOffset(params.getOffset());
 122     }
 123     return params;
 124   }
 125 }