looks at {@Link String} to see if queue name already is stored, if not,
adds it
@param {@link JobDetails}
@param {@link Result}
@return queue list
163238
String createQueueListValue(JobDetails jobDetails, String existingQueues) {
    /*
     * check if queue already exists append separator at the end to avoid
     * "false" queue match via substring match
     */
    String queue = jobDetails.getQueue();
    queue = queue.concat(Constants.SEP);

    if (existingQueues == null) {
      return queue;
    }

    if (!existingQueues.contains(queue)) {
      existingQueues = existingQueues.concat(queue);
    }
    return existingQueues;
  }
685929
public String[] getJobList() {
        String[] strings = new String[jobMap.keySet().size()];
        int i = 0;
        for (String s : jobMap.keySet()) {
            strings[i++] = s;
        }
        return strings;
    }
895538
@Override
  public Value<List<BigQueryLoadJobReference>> run(
      BigQueryStoreResult<GoogleCloudStorageFileSet> bigQueryStoreResult) throws Exception {
    BigQueryStoreResult<GoogleCloudStorageFileSet> outputResult = bigQueryStoreResult;
    List<GcsFilename> files = outputResult.getResult().getFiles();
    List<List<GcsFilename>> bundles =
        bundleFiles(files, BigQueryConstants.BIGQUERY_LOAD_DATA_SIZE_LIMIT);
    List<FutureValue<BigQueryLoadJobReference>> jobReferenceList = new ArrayList<>();
    for (List<GcsFilename> bundle : bundles) {
      jobReferenceList.add(futureCall(new BigQueryLoadFileSetJob(dataset, tableName, projectId,
          bundle, SerializableValue.of(Marshallers.getGenericJsonMarshaller(TableSchema.class),
              outputResult.getSchema())), immediate(Integer.valueOf(0))));
    }
    return futureList(jobReferenceList);
  }
536312
void addResult(String valueData, String detailData) {
    if (value) {
      if (valueData == null) throw new IllegalArgumentException(CLASS + ": valueData may not be null");
      values.add(valueData);
      if (detail) {
        if (detailData == null) throw new IllegalArgumentException(CLASS + ": detailData may not be null");
        details.add(detailData);
      }
    } 
    counter++;
  }
383270
public ListenableFuture<Map<JobId, Job>> jobs(@Nullable final String jobQuery,
                                                @Nullable final String hostNamePattern) {
    final Map<String, String> params = new HashMap<>();
    if (!Strings.isNullOrEmpty(jobQuery)) {
      params.put("q", jobQuery);
    }
    if (!Strings.isNullOrEmpty(hostNamePattern)) {
      params.put("hostPattern", hostNamePattern);
    }
    return get(uri("/jobs", params), jobIdMap);
  }
491288
public void populate(Result result) {
    // process job-level stats and properties
    NavigableMap<byte[], byte[]> infoValues = result.getFamilyMap(Constants.INFO_FAM_BYTES);

    this.jobId = ByteUtil.getValueAsString(JobHistoryKeys.KEYS_TO_BYTES
          .get(JobHistoryKeys.JOBID), infoValues);
    this.user = ByteUtil.getValueAsString(JobHistoryKeys.KEYS_TO_BYTES
          .get(JobHistoryKeys.USER), infoValues);
    this.jobName = ByteUtil.getValueAsString(JobHistoryKeys.KEYS_TO_BYTES
          .get(JobHistoryKeys.JOBNAME),infoValues);
    this.priority = ByteUtil.getValueAsString(JobHistoryKeys.KEYS_TO_BYTES
          .get(JobHistoryKeys.JOB_PRIORITY), infoValues);
    this.status = ByteUtil.getValueAsString(JobHistoryKeys.KEYS_TO_BYTES
          .get(JobHistoryKeys.JOB_STATUS), infoValues);
    this.hadoopVersion = getHadoopVersionFromResult(JobHistoryKeys.hadoopversion, infoValues);
    this.version = ByteUtil.getValueAsString(Constants.VERSION_COLUMN_BYTES, infoValues);
    this.cost = ByteUtil.getValueAsDouble(Constants.JOBCOST_BYTES, infoValues);

    // times
    this.submitTime = ByteUtil.getValueAsLong(JobHistoryKeys.KEYS_TO_BYTES
          .get(JobHistoryKeys.SUBMIT_TIME), infoValues);
    this.launchTime = ByteUtil.getValueAsLong(JobHistoryKeys.KEYS_TO_BYTES
          .get(JobHistoryKeys.LAUNCH_TIME), infoValues);
    this.finishTime = ByteUtil.getValueAsLong(JobHistoryKeys.KEYS_TO_BYTES
          .get(JobHistoryKeys.FINISH_TIME), infoValues);
    this.megabyteMillis = ByteUtil.getValueAsLong(Constants.MEGABYTEMILLIS_BYTES, infoValues);
    this.cost = ByteUtil.getValueAsDouble(Constants.JOBCOST_BYTES, infoValues);

    // task counts
    this.totalMaps =
        ByteUtil.getValueAsLong(JobHistoryKeys.KEYS_TO_BYTES.get(JobHistoryKeys.TOTAL_MAPS),
          infoValues);
    this.totalReduces =
        ByteUtil.getValueAsLong(JobHistoryKeys.KEYS_TO_BYTES.get(JobHistoryKeys.TOTAL_REDUCES),
          infoValues);
    this.finishedMaps =
        ByteUtil.getValueAsLong(JobHistoryKeys.KEYS_TO_BYTES.get(JobHistoryKeys.FINISHED_MAPS),
          infoValues);
    this.finishedReduces =
        ByteUtil.getValueAsLong(JobHistoryKeys.KEYS_TO_BYTES.get(JobHistoryKeys.FINISHED_REDUCES),
          infoValues);
    this.failedMaps =
        ByteUtil.getValueAsLong(JobHistoryKeys.KEYS_TO_BYTES.get(JobHistoryKeys.FAILED_MAPS),
          infoValues);
    this.failedReduces =
        ByteUtil.getValueAsLong(JobHistoryKeys.KEYS_TO_BYTES.get(JobHistoryKeys.FAILED_REDUCES),
          infoValues);

    this.config = JobHistoryService.parseConfiguration(infoValues);
    this.queue = this.config.get(Constants.HRAVEN_QUEUE);
    this.counters = JobHistoryService.parseCounters(Constants.COUNTER_COLUMN_PREFIX_BYTES,
        infoValues);
    this.mapCounters = JobHistoryService.parseCounters(Constants.MAP_COUNTER_COLUMN_PREFIX_BYTES,
        infoValues);
    this.reduceCounters = JobHistoryService.parseCounters(Constants.REDUCE_COUNTER_COLUMN_PREFIX_BYTES,
        infoValues);

    // populate stats from counters for this job based on
    // hadoop version
    if (this.hadoopVersion == HadoopVersion.TWO) {
      // map file bytes read
      this.mapFileBytesRead = getCounterValueAsLong(this.mapCounters, 
            Constants.FILESYSTEM_COUNTER_HADOOP2, Constants.FILES_BYTES_READ);

      // map file bytes written
      this.mapFileBytesWritten = getCounterValueAsLong(this.mapCounters,
            Constants.FILESYSTEM_COUNTER_HADOOP2, Constants.FILES_BYTES_WRITTEN);

      // reduce file bytes read
      this.reduceFileBytesRead = getCounterValueAsLong(this.reduceCounters,
            Constants.FILESYSTEM_COUNTER_HADOOP2, Constants.FILES_BYTES_READ);

      // hdfs bytes read
      this.hdfsBytesRead = getCounterValueAsLong(this.counters, Constants.FILESYSTEM_COUNTER_HADOOP2,
            Constants.HDFS_BYTES_READ);

      // hdfs bytes written
      this.hdfsBytesWritten = getCounterValueAsLong(this.counters, Constants.FILESYSTEM_COUNTER_HADOOP2,
            Constants.HDFS_BYTES_WRITTEN);

      // map slot millis
      this.mapSlotMillis = getCounterValueAsLong(this.counters, Constants.JOB_COUNTER_HADOOP2,
            Constants.SLOTS_MILLIS_MAPS);

      // reduce slot millis
      this.reduceSlotMillis = getCounterValueAsLong(this.counters, Constants.JOB_COUNTER_HADOOP2,
            Constants.SLOTS_MILLIS_REDUCES);

      // reduce shuffle bytes
      this.reduceShuffleBytes = getCounterValueAsLong(this.reduceCounters, Constants.TASK_COUNTER_HADOOP2,
            Constants.REDUCE_SHUFFLE_BYTES);
    } else { // presume it's hadoop1
      // map file bytes read
      this.mapFileBytesRead = getCounterValueAsLong(this.mapCounters, Constants.FILESYSTEM_COUNTERS,
            Constants.FILES_BYTES_READ);

      // map file bytes written
      this.mapFileBytesWritten = getCounterValueAsLong(this.mapCounters, Constants.FILESYSTEM_COUNTERS,
            Constants.FILES_BYTES_WRITTEN);

      // reduce file bytes read
      this.reduceFileBytesRead = getCounterValueAsLong(this.reduceCounters, Constants.FILESYSTEM_COUNTERS,
            Constants.FILES_BYTES_READ);

      // hdfs bytes read
      this.hdfsBytesRead = getCounterValueAsLong(this.counters, Constants.FILESYSTEM_COUNTERS,
            Constants.HDFS_BYTES_READ);

      // hdfs bytes written
      this.hdfsBytesWritten = getCounterValueAsLong(this.counters, Constants.FILESYSTEM_COUNTERS,
            Constants.HDFS_BYTES_WRITTEN);

      // map slot millis
      this.mapSlotMillis = getCounterValueAsLong(this.counters, Constants.JOBINPROGRESS_COUNTER,
            Constants.SLOTS_MILLIS_MAPS);

      // reduce slot millis
      this.reduceSlotMillis = getCounterValueAsLong(this.counters, Constants.JOBINPROGRESS_COUNTER,
            Constants.SLOTS_MILLIS_REDUCES);

      // reduce shuffle bytes
      this.reduceShuffleBytes = getCounterValueAsLong(this.reduceCounters, Constants.TASK_COUNTER,
            Constants.REDUCE_SHUFFLE_BYTES);
    }
    // populate the task-level data
    // TODO: make sure to properly implement setTasks(...) before adding TaskDetails
    //populateTasks(result.getFamilyMap(Constants.TASK_FAM_BYTES));
  }
12563
public Map<ComponentJob, AnalyzerResult> getUnsafeResultElements() {
        if (_unsafeResultElements == null) {
            _unsafeResultElements = new LinkedHashMap<>();
            final Map<ComponentJob, AnalyzerResult> resultMap = _analysisResult.getResultMap();
            for (final Entry<ComponentJob, AnalyzerResult> entry : resultMap.entrySet()) {
                final AnalyzerResult analyzerResult = entry.getValue();
                try {
                    SerializationUtils.serialize(analyzerResult, new NullOutputStream());
                } catch (final SerializationException e) {
                    _unsafeResultElements.put(entry.getKey(), analyzerResult);
                }
            }
        }
        return _unsafeResultElements;
    }
763167
@Override
    public java.util.concurrent.Future<ListQueueTagsResult> listQueueTagsAsync(String queueUrl) {

        return listQueueTagsAsync(new ListQueueTagsRequest().withQueueUrl(queueUrl));
    }
1350969
@Nonnull
  public TriggerBuilder <T> forJob (@Nonnull final IJobDetail jobDetail)
  {
    final JobKey k = jobDetail.getKey ();
    if (k.getName () == null)
      throw new IllegalArgumentException ("The given job has not yet had a name assigned to it.");
    m_aJobKey = k;
    return this;
  }
470225
@SuppressWarnings("unchecked")
	public <P extends ParaObject> List<P> getItemsFromList(List<?> result) {
		if (result != null && !result.isEmpty()) {
			// this isn't very efficient but there's no way to know what type of objects we're reading
			ArrayList<P> objects = new ArrayList<>(result.size());
			for (Object map : result) {
				P p = ParaObjectUtils.setAnnotatedFields((Map<String, Object>) map);
				if (p != null) {
					objects.add(p);
				}
			}
			return objects;
		}
		return Collections.emptyList();
	}
1305192
@Override
  public FutureResultImpl<T> setResult(T result) {
    this.result = result;
    succeeded = true;
    checkCallHandler();
    return this;
  }
1357721
@Override
  public JobDetail retrieveJob(String jobKey) {

    synchronized (lock) {
      JobWrapper jw = jobsByKey.get(jobKey);
      return (jw != null) ? (JobDetail) jw.jobDetail.clone() : null;
    }
  }
325656
public JobExecutionStatusDetails withDetailsMap(java.util.Map<String, String> detailsMap) {
        setDetailsMap(detailsMap);
        return this;
    }
1113401
public JobWithDetails getJob(String jobName) throws IOException {
        return getJob(null, UrlUtils.toFullJobPath(jobName));
    }
1258529
@Override
  public Set<String> getJobKeys() {

    Set<String> outList = new HashSet<String>();

    synchronized (lock) {
      for (JobWrapper jw : jobsByKey.values()) {

        if (jw != null) {

          outList.add(jw.jobDetail.getName());
        }
      }
    }

    return outList == null ? java.util.Collections.<String>emptySet() : outList;
  }
60535
private String join(List<TaskInfo> taskInfoList) throws Exception {
    // get the job definition
    JobDefinition<JobConfig, Serializable, Serializable> definition =
        JobDefinitionRegistry.INSTANCE.getJobDefinition(mJobInfo.getJobConfig());
    Map<WorkerInfo, Serializable> taskResults = Maps.newHashMap();
    for (TaskInfo taskInfo : taskInfoList) {
      taskResults.put(mTaskIdToWorkerInfo.get(taskInfo.getTaskId()), taskInfo.getResult());
    }
    return definition.join(mJobInfo.getJobConfig(), taskResults);
  }
1319536
public JobResult job(String jobname) {
        HttpGet getRequest = new HttpGet(baseUrl + "job/" + jobname);
        getRequest.addHeader("Accept", "application/xml");
        return jobResult(getRequest);
    }