Generated.
@throws ApiException if an error occurs during querying of the API.
@return List<Term> *
559217
public List<Term> getTerm (String term, Boolean get_fingerprint, String retina_name, Integer start_index, Integer max_results) throws ApiException {
        // verify required params are set
        if(retina_name == null ) {
             throw new ApiException(400, "missing required params");
        }
        // create path and map variables
        String path = "/terms".replaceAll("\\{format\\}","json");

        // query params
        Map<String, String> queryParams = new HashMap<String, String>();
        Map<String, String> headerParams = new HashMap<String, String>();

        if(!"null".equals(String.valueOf(retina_name)))
            queryParams.put("retina_name", String.valueOf(retina_name));
        if(!"null".equals(String.valueOf(term)))
            queryParams.put("term", String.valueOf(term));
        if(!"null".equals(String.valueOf(start_index)))
            queryParams.put("start_index", String.valueOf(start_index));
        if(!"null".equals(String.valueOf(max_results)))
            queryParams.put("max_results", String.valueOf(max_results));
        if(!"null".equals(String.valueOf(get_fingerprint)))
            queryParams.put("get_fingerprint", String.valueOf(get_fingerprint));
        String contentType = "application/json";

        try {
            Object response = apiInvoker.invokeAPI(basePath, path, "GET", queryParams
                , null, headerParams, contentType);
            if(response != null) {
                if (response instanceof String) {
                        @SuppressWarnings("unchecked")
                        List<Term> result = (List<Term>) ApiInvoker.deserialize( (String) response, "Array"
                                , Term.class, null);return result;
                }
                else if (response instanceof java.io.ByteArrayInputStream) {
                        @SuppressWarnings("unchecked")
                        List<Term> result =    (List<Term>) response;return result;
                }
                
            }
            else {
                return null;
            }
        } catch (ApiException ex) {
            if(ex.getCode() == 404) {
            	return null;
            }
            else {
                throw ex;
            }
        }
        return null;}
1206552
public Set<ApiFlowDoc> getApiFlowDocs(Set<Class<?>> classes, List<ApiMethodDoc> apiMethodDocs) {
		Set<ApiFlowDoc> apiFlowDocs = new TreeSet<ApiFlowDoc>();
		for (Class<?> clazz : classes) {
			log.debug("Getting JSONDoc for class: " + clazz.getName());
			Method[] methods = clazz.getMethods();
			for (Method method : methods) {
				if(method.isAnnotationPresent(ApiFlow.class)) {
					ApiFlowDoc apiFlowDoc = getApiFlowDoc(method, apiMethodDocs);
					apiFlowDocs.add(apiFlowDoc);
				}	
			}
		}
		return apiFlowDocs;
	}
424443
@Override
  public List<String> listKeys() {
    lock.lock();
    try {
      List<String> keys = new ArrayList<>(this.items.size());
      for (Map.Entry<String, ApiType> entry : this.items.entrySet()) {
        keys.add(entry.getKey());
      }
      return keys;
    } finally {
      lock.unlock();
    }
  }
1067941
public Map<String, List<String>> getQueryString() {
    if (querystring == null) {
      try {
        querystring = new QueryStringDecoder(request.getUri()).getParameters();
      } catch (IllegalArgumentException e) {
        throw new BadRequestException("Bad query string: " + e.getMessage());
      }
    }
    return querystring;
  }
1204687
public Array listToArray() throws PageException {

	if (this.query instanceof QueryImpl) return ListUtil.listToArray(((QueryImpl) this.query).getColumnlist(false), ",");

	throw new ApplicationException("Query is not of type QueryImpl. Use instead Query.columnArray() or Query.columnList().listToArray().");
    }
1114096
public List<Parameter> getAllParameters() {
        List<Parameter> ret = new ArrayList<Parameter>();

        if (parameters != null)
            ret.addAll(parameters);

        if (terms != null) {
            for (final Term t : terms) {
                ret.addAll(t.getAllParameters());
            }
        }

        return ret;
    }
1268812
public ApiResponse<TagsEnvelope> getTagCategoriesWithHttpInfo() throws ApiException {
        com.squareup.okhttp.Call call = getTagCategoriesValidateBeforeCall(null, null);
        Type localVarReturnType = new TypeToken<TagsEnvelope>(){}.getType();
        return apiClient.execute(call, localVarReturnType);
    }
389986
@Override
    public List<?> getResultList() {
        if (log.isDebugEnabled())
            log.debug("JPA Query: " + getJPAQuery());

        // get luence query
        String q = luceneQuery;
        if (null == q) {
            q = KunderaCoreUtils.getLuceneQueryFromJPAQuery(kunderaQuery, kunderaMetadata);
        }

        if (log.isDebugEnabled())
            log.debug("Lucene Query: " + q);

        EntityMetadata m = kunderaQuery.getEntityMetadata();
        Client client = persistenceDelegeator.getClient(m);

        handlePostEvent();
        Map<String, Object> searchFilter = client.getIndexManager().search(m.getEntityClazz(), q, -1, maxResult);

        if (kunderaQuery.isAliasOnly()) {
            String[] primaryKeys = searchFilter.values().toArray(new String[] {});
            return persistenceDelegeator.find(m.getEntityClazz(), primaryKeys);
        } else {
            return persistenceDelegeator.find(m.getEntityClazz(), searchFilter);

        }

    }
1188222
@Override
    public List<ApiZone> all() {
        List<ApiZone> answer = new ArrayList<>();
        for(Zone zone : SmartFoxServer.getInstance()
                .getZoneManager().getZoneList()) {
            answer.add((ApiZone) zone.getProperty(APIKey.ZONE));
        }
        return answer;
    }
327078
public ApiResponse<GetStatisticDefinitionsResponse> getStatisticDefinitionsWithHttpInfo() throws ApiException {
        com.squareup.okhttp.Call call = getStatisticDefinitionsValidateBeforeCall(null, null);
        Type localVarReturnType = new TypeToken<GetStatisticDefinitionsResponse>(){}.getType();
        return apiClient.execute(call, localVarReturnType);
    }
1083129
public ApiResponse buildParamsDescription() {
		ApiResponseList configParams = new ApiResponseList("methodConfigParams");
		for (String param : this.getMandatoryParamNames())
			configParams.addItem(buildParamMap(param, true));
		for (String param : this.getOptionalParamNames())
			configParams.addItem(buildParamMap(param, false));
		return configParams;
	}
881836
@Override
  public List<String> generateQueries() {

    ensureParentOfStagingPathExists();

    List<String> hiveQueries = Lists.newArrayList();
    /*
     * Setting partition mode to 'nonstrict' is needed to improve readability of the code.
     * If we do not set dynamic partition mode to nonstrict, we will have to write partition values also,
     * and because hive considers partition as a virtual column, we also have to write each of the column
     * name in the query (in place of *) to match source and target columns.
     */
    hiveQueries.add("SET hive.exec.dynamic.partition.mode=nonstrict");

    Preconditions.checkNotNull(this.workUnit, "Workunit must not be null");
    EventWorkunitUtils.setBeginDDLBuildTimeMetadata(this.workUnit, System.currentTimeMillis());

    HiveConverterUtils.createStagingDirectory(fs, outputTableMetadata.getDestinationDataPath(),
        conversionEntity, this.workUnitState);

    // Create DDL statement for table
    String createStagingTableDDL =
        HiveConverterUtils.generateCreateDuplicateTableDDL(
            inputDbName,
            inputTableName,
            stagingTableName,
            stagingDataLocation,
            Optional.of(outputDatabaseName));
    hiveQueries.add(createStagingTableDDL);
    log.debug("Create staging table DDL:\n" + createStagingTableDDL);


    String insertInStagingTableDML =
        HiveConverterUtils
            .generateTableCopy(
                inputTableName,
                stagingTableName,
                conversionEntity.getTable().getDbName(),
                outputDatabaseName,
                Optional.of(partitionsDMLInfo));
    hiveQueries.add(insertInStagingTableDML);
    log.debug("Conversion staging DML: " + insertInStagingTableDML);

    log.info("Conversion Queries {}\n",  hiveQueries);

    EventWorkunitUtils.setEndDDLBuildTimeMetadata(workUnit, System.currentTimeMillis());
    return hiveQueries;
  }
180186
public function getList()
    {
        if (!userHasPermission('admin:cdn:manager:object:browse')) {
            throw new ApiException(
                'You do not have permission to access this resource',
                $oHttpCodes::STATUS_UNAUTHORIZED
            );
        }

        $oInput       = Factory::service('Input');
        $oObjectModel = Factory::model('Object', 'nails/module-cdn');
        $iBucketId    = (int) $oInput->get('bucket_id') ?: null;
        $iPage        = (int) $oInput->get('page') ?: 1;

        if (empty($iBucketId)) {
            throw new ApiException(
                '`bucket_id` is a required field',
                $oHttpCodes::STATUS_BAD_REQUEST
            );
        }

        $aObjects = $oObjectModel->getAll(
            $iPage,
            static::CONFIG_OBJECTS_PER_PAGE,
            ['where' => [['bucket_id', $iBucketId]]]
        );

        return Factory::factory('ApiResponse', 'nails/module-api')
            ->setData(array_map(
                function ($oObj) {
                    $oObj->url->preview = $oObj->is_img ? cdnCrop($oObj->id, 400, 400) : null;
                    return $oObj;
                },
                $aObjects
            ))
            ->setMeta([
                'page'     => $iPage,
                'per_page' => static::CONFIG_OBJECTS_PER_PAGE,
            ]);
    }
1005131
public ApiResponse<GetArgsResponse> argsWithHttpInfo() throws ApiException {
        com.squareup.okhttp.Call call = argsValidateBeforeCall(null, null);
        Type localVarReturnType = new TypeToken<GetArgsResponse>(){}.getType();
        return apiClient.execute(call, localVarReturnType);
    }
878168
public List<String> getParamNames() {
    if (!Strings.contains(content, ":")) { return Collections.emptyList(); }
    final List<String> params = new ArrayList<String>();
    int index = 0;
    do {
      final int colonIndex = content.indexOf(':', index);
      if (-1 == colonIndex) {
        break;
      }
      index = colonIndex + 1;
      while (index < content.length()) {
        final char c = content.charAt(index);
        if (isValidIdentifierStarter(c)) {
          index++;
        } else {
          break;
        }
      }
      final String paramName = content.substring(colonIndex + 1, index);
      if (!params.contains(paramName)) {
        params.add(paramName);
      }
    } while (index < content.length());
    return params;
  }
947985
public String list()
   {
      StringBuilder sb = new StringBuilder();

      Context c = null;
      try
      {
         c = new InitialContext();
         Context context = (Context)c.lookup("java:");
         sb.append("java:").append(NEW_LINE);
         list(context, " ", sb);
      }
      catch (Throwable t)
      {
         log.debug(t.getMessage(), t);
      }
      finally
      {
         if (c != null)
         {
            try
            {
               c.close();
            }
            catch (Throwable ignore)
            {
               // Ignore
            }
         }
      }

      return sb.toString();
   }
957552
public List<String> listTypes() throws AtlasServiceException {
        final JSONObject jsonObject = callAPIWithQueryParams(API.LIST_TYPES, null);
        return extractResults(jsonObject, AtlasClient.RESULTS, new ExtractOperation<String, String>());
    }