Find {@link ru.yandex.qatools.allure.annotations.Issues} annotation and return respective key

@return issue keys or empty array if annotation isn't present
765047
public String[] getIssueKeys() {
        Issues issues = getAnnotation(Issues.class);
        if (issues == null) {
            return new String[0];
        }
        List<String> keys = new ArrayList<>();
        for (Issue issue : issues.value()) {
            keys.add(issue.value());
        }
        return keys.toArray(new String[keys.size()]);
    }
524855
public final String getAnnotatedQuery() {
		String valueParameter = getValueParameters();
		String whereParameters = getWhereParameters();
		String[] selectParameters = getSelectParameters();
		
		String result = QueryParserUtils.buildQueryFromQueryParameters(valueParameter, selectParameters, whereParameters,
				simpleDbDomain.getDomain(getDomainClass()));
		
		assertParameterNamesInAnnotatedQuery(result);
		
		return result;
	}
1135548
public function issues()
    {
        if (is_null($this->issueRequests)) {
            $this->issueRequests = new IssueRequests($this->client);
        }

        return $this->issueRequests;
    }
573099
private ArrayList<Pair<String, ?>> getKeyValues() {
		ArrayList<Pair<String, ?>> keyValPair = new ArrayList<>();
		Map<String, ?> map = preferenceUtils.getAll();
		Set<String> strings = map.keySet();
		Object value;
		for (String key : strings) {
			if (!key.contains(SharedPreferenceUtils.keyTestMode)) {
				value = map.get(key);
				keyValPair.add(new Pair<String, Object>(key, value));
			}
		}
		return keyValPair;
	}
1293161
@Override
    public Iterator<String> getEnclosingValidatorIds()
    {
        if (_enclosingValidatorIdsStack != null && !_enclosingValidatorIdsStack.isEmpty())
        {
            return new KeyEntryIterator<String, EditableValueHolderAttachedObjectHandler>
                (_enclosingValidatorIdsStack.iterator()); 
        }
        return null;
    }
75567
public List<Issue> getChildren(Issue redmineParentIssue) {
        List<Issue> rootIssues = new ArrayList<Issue>();
        Iterator<Issue> it = issuesMap.values().iterator();
        Integer parentID = null; // look for root level by default
        boolean lookingForRootTasks = true;
        if (redmineParentIssue != null) {
            parentID = redmineParentIssue.getId();
            lookingForRootTasks = false;
        }
        while (it.hasNext()) {
            Issue issue = it.next();
            if (lookingForRootTasks
                    && (issue.getParentId() == null)
                    || (!lookingForRootTasks && (issue.getParentId() != null) && (issue
                    .getParentId().equals(parentID)))) {
                rootIssues.add(issue);
            }
        }
        return rootIssues;
    }
83663
def join_issues(issues,
                    separator: ObjectInspector.configuration.issues_separator)
      the_issues = Array(issues).tap(&:compact!)
      the_issues.join(separator) if the_issues.any?
    end
870419
@SuppressWarnings("unchecked")
    public Collection<TextAnnotation> getTextAnnotations() {
        Collection<? extends Enhancement> result = enhancements
                .get(TextAnnotation.class);
        return result == null ? Collections.<TextAnnotation>emptySet() : 
            Collections.unmodifiableCollection((Collection<TextAnnotation>) result);
    }
1168961
public String[] getKeyStoreAliases() {
        Set<String> set = keyStoreMap.keySet();
        return set.toArray(new String[set.size()]);
    }
952844
def fetch_events_async(issues)
      i       = 0
      threads = []

      issues.each_slice(MAX_THREAD_NUMBER) do |issues_slice|
        issues_slice.each do |issue|
          threads << Thread.new do
            issue["events"] = []
            iterate_pages(@client, "issue_events", issue["number"]) do |new_event|
              issue["events"].concat(new_event)
            end
            issue["events"] = issue["events"].map { |event| stringify_keys_deep(event.to_hash) }
            print_in_same_line("Fetching events for issues and PR: #{i + 1}/#{issues.count}")
            i += 1
          end
        end
        threads.each(&:join)
        threads = []
      end

      # to clear line from prev print
      print_empty_line

      Helper.log.info "Fetching events for issues and PR: #{i}"
    end
637831
public final Problem getLeadProblem() {
		Collections.sort(this.problems);
		return this.problems.isEmpty() ? null : this.problems.get(this.problems.size() - 1);
	}
1081953
def get_missing_required_annotations(self) -> List[str]:
        """"""
        return [
            required_annotation
            for required_annotation in self.required_annotations
            if required_annotation not in self.annotations
        ]
19082
public AnnotationParameterValueList getParameterValues() {
        if (annotationParamValuesWithDefaults == null) {
            final ClassInfo classInfo = getClassInfo();
            if (classInfo == null) {
                // ClassInfo has not yet been set, just return values without defaults
                // (happens when trying to log AnnotationInfo during scanning, before ScanResult is available)
                return annotationParamValues == null ? AnnotationParameterValueList.EMPTY_LIST
                        : annotationParamValues;
            }

            // Lazily convert any Object[] arrays of boxed types to primitive arrays
            if (annotationParamValues != null && !annotationParamValuesHasBeenConvertedToPrimitive) {
                annotationParamValues.convertWrapperArraysToPrimitiveArrays(classInfo);
                annotationParamValuesHasBeenConvertedToPrimitive = true;
            }
            if (classInfo.annotationDefaultParamValues != null
                    && !classInfo.annotationDefaultParamValuesHasBeenConvertedToPrimitive) {
                classInfo.annotationDefaultParamValues.convertWrapperArraysToPrimitiveArrays(classInfo);
                classInfo.annotationDefaultParamValuesHasBeenConvertedToPrimitive = true;
            }

            // Check if one or both of the defaults and the values in this annotation instance are null (empty)
            final AnnotationParameterValueList defaultParamValues = classInfo.annotationDefaultParamValues;
            if (defaultParamValues == null && annotationParamValues == null) {
                return AnnotationParameterValueList.EMPTY_LIST;
            } else if (defaultParamValues == null) {
                return annotationParamValues;
            } else if (annotationParamValues == null) {
                return defaultParamValues;
            }

            // Overwrite defaults with non-defaults
            final Map<String, Object> allParamValues = new HashMap<>();
            for (final AnnotationParameterValue defaultParamValue : defaultParamValues) {
                allParamValues.put(defaultParamValue.getName(), defaultParamValue.getValue());
            }
            for (final AnnotationParameterValue annotationParamValue : this.annotationParamValues) {
                allParamValues.put(annotationParamValue.getName(), annotationParamValue.getValue());
            }

            // Put annotation values in the same order as the annotation methods (there is one method for each
            // annotation constant)
            if (classInfo.methodInfo == null) {
                // Should not happen (when classfile is read, methods are always read, whether or not
                // scanSpec.enableMethodInfo is true)
                throw new IllegalArgumentException("Could not find methods for annotation " + classInfo.getName());
            }
            annotationParamValuesWithDefaults = new AnnotationParameterValueList();
            for (final MethodInfo mi : classInfo.methodInfo) {
                final String paramName = mi.getName();
                switch (paramName) {
                // None of these method names should be present in the @interface class itself, it should only
                // contain methods for the annotation constants (but skip them anyway to be safe). These methods
                // should only exist in concrete instances of the annotation.
                case "<init>":
                case "<clinit>":
                case "hashCode":
                case "equals":
                case "toString":
                case "annotationType":
                    // Skip
                    break;
                default:
                    // Annotation constant
                    final Object paramValue = allParamValues.get(paramName);
                    // Annotation values cannot be null (or absent, from either defaults or annotation instance)
                    if (paramValue != null) {
                        annotationParamValuesWithDefaults.add(new AnnotationParameterValue(paramName, paramValue));
                    }
                    break;
                }
            }
        }
        return annotationParamValuesWithDefaults;
    }
1161806
public function getAnnotations(){
        if($this->reader === null){
            return null;
        }

        if($this->annotations === null){
            $this->annotations  = [];

            foreach($this->reader->getAnnotations() as $annotation){
                $key    = "";
                $value  = "";

                if(($pos = mb_strpos($annotation, " ")) === false){
                    $key    = mb_substr($annotation, 1);
                }else{
                    $key    = mb_substr($annotation, 1, $pos - 1);
                    $value  = ltrim(mb_substr($annotation, $pos));
                }

                if(!array_key_exists($key, $this->annotations)){
                    $this->annotations[$key]    = [];
                }

                $this->annotations[$key][]  = $value;
            }
        }

        return $this->annotations;
    }
649973
public SigningPolicy[] getSigningPolicies() {
        if (this.policyDNMap == null) {
            return null;
        }
        Collection values = this.policyDNMap.values();
        return (SigningPolicy[]) this.policyDNMap.values().toArray(new SigningPolicy[values.size()]);
    }
543530
@RequestMapping(value = "configuration/{configuration:.*}/issue/{key}", method = RequestMethod.GET)
    public Resource<OntrackSVNIssueInfo> issueInfo(@PathVariable String configuration, @PathVariable String key) {
        return Resource.of(
                svnInfoService.getIssueInfo(configuration, key),
                uri(on(getClass()).issueInfo(configuration, key))
        ).withView(Build.class);
    }
1296954
protected boolean reportCompilationIssues(Iterable<Issue> issues) {
		boolean hasError = false;
		for (final Issue issue : issues) {
			final String issueMessage = createIssueMessage(issue);
			switch (issue.getSeverity()) {
			case ERROR:
				hasError = true;
				getLogger().error(issueMessage);
				break;
			case WARNING:
				getLogger().warn(issueMessage);
				break;
			case INFO:
				getLogger().info(issueMessage);
				break;
			case IGNORE:
			default:
				break;
			}
			notifiesIssueMessageListeners(issue, issue.getUriToProblem(), issueMessage);
		}
		return hasError;
	}