Get the "complementary" TypeQualifierValues for given exclusive type
qualifier.

@param tqv
a type qualifier (which must be exclusive)
@return Collection of complementary exclusive type qualifiers
552970
public static Collection<TypeQualifierValue<?>> getComplementaryExclusiveTypeQualifierValue(TypeQualifierValue<?> tqv) {
        assert tqv.isExclusiveQualifier();

        LinkedList<TypeQualifierValue<?>> result = new LinkedList<>();

        for (TypeQualifierValue<?> t : instance.get().allKnownTypeQualifiers) {
            //
            // Any TypeQualifierValue with the same
            // annotation class but a different value is a complementary
            // type qualifier.
            //
            if (t.typeQualifier.equals(tqv.typeQualifier) && !Objects.equals(t.value, tqv.value)) {
                result.add(t);
            }
        }

        return result;
    }
1302739
public static Set<Type> getTypedTypes(Map<Class<?>, Type> typeClosure, Class<?> rawType, Typed typed) {
        Set<Type> types = new HashSet<Type>();
        for (Class<?> specifiedClass : typed.value()) {
            Type tmp = typeClosure.get(specifiedClass);
            if (tmp != null) {
                types.add(tmp);
            } else {
                throw BeanLogger.LOG.typedClassNotInHierarchy(specifiedClass.getName(), rawType, Formats.formatTypes(typeClosure.values()));
            }
        }
        types.add(Object.class);
        return types;
    }
391698
protected List<TypeName> getExtractedTypes(TypeName permutationType, TypeName paramType) {
    return match(permutationType)
        .when(typeOf(ParameterizedTypeName.class)).get(
            t -> {
              if (isDecomposableBuilder(t.rawType)) {
                return t.typeArguments.subList(1, t.typeArguments.size());
              } else if (t.rawType.equals(MATCH_ANY)) {
                return ImmutableList.of(paramType);
              } else {
                return Collections.<TypeName>emptyList();
              }
            })
        .when(typeOf(TypeVariableName.class)).get(t -> ImmutableList.of())
        .when(typeOf(ClassName.class)).get(t -> ImmutableList.of(paramType))
        .orElse(t -> ImmutableList.of(t))
        .getMatch();
  }
908144
@com.fasterxml.jackson.annotation.JsonProperty("MutuallyExclusiveParameters")
    public java.util.List<String> getMutuallyExclusiveParameters() {
        return mutuallyExclusiveParameters;
    }
1019957
def _get_qualifier(val):
        """"""
        quals = set()
        if val == '':
            return quals
        for val in val.split('|'):
            val = val.lower()
            quals.add(val if val != 'not' else 'NOT')
        return quals
436874
public java.lang.Object getTypeaheadValues() {
		return (java.lang.Object) getStateHelper().eval(PropertyKeys.typeaheadValues);
	}
567219
public static SqlType getSqlTypeForTypeVal(int typeVal) {
		// iterate through to save on the extra HashMap since only for errors
		for (Map.Entry<SqlType, int[]> entry : typeToValMap.entrySet()) {
			for (int val : entry.getValue()) {
				if (val == typeVal) {
					return entry.getKey();
				}
			}
		}
		return SqlType.UNKNOWN;
	}
820935
private static AnnotationMirror getQualifier(
      List<? extends AnnotationMirror> annotations) {
    AnnotationMirror qualifier = null;
    for (AnnotationMirror annotation : annotations) {
      if (annotation.getAnnotationType().asElement().getAnnotation(Qualifier.class) == null) {
        continue;
      }
      qualifier = annotation;
    }
    return qualifier;
  }
364830
private String addVersionQualifierToQualifiers(String qualifiers) {
        int versionQualifierApiLevel = ResBundle.getVersionQualifierApiLevel(qualifiers);
        if (versionQualifierApiLevel == -1) {
            if (qualifiers.length() > 0) {
                qualifiers += "-";
            }
            qualifiers += "v" + sdkConfig.getApiLevel();
        }
        return qualifiers;
    }
1280316
public void setParameter(MethodDescriptor methodDesc, int param, TypeQualifierValue<?> tqv, TypeQualifierAnnotation tqa) {
        Map<TypeQualifierValue<?>, TypeQualifierAnnotation> map = parameterMap.get(methodDesc, param);
        if (map == null) {
            map = new HashMap<>();
            parameterMap.put(methodDesc, param, map);
        }
        map.put(tqv, tqa);

        if (DEBUG) {
            System.out.println("tqdb: " + methodDesc + " parameter " + param + " for " + tqv + " ==> " + tqa);
        }
    }
431496
public List<? extends TypeMirror> getBounds(TypeParameterElement tpe) {
        List<? extends TypeMirror> bounds = tpe.getBounds();
        if (!bounds.isEmpty()) {
            TypeMirror upperBound = bounds.get(bounds.size() - 1);
            if (ignoreBounds(upperBound)) {
                return Collections.emptyList();
            }
        }
        return bounds;
    }
868104
private Iterator<Tuple> getSatisfyingTuples( final TestCaseDef testCase, VarTupleSet varTupleSet)
    {
    final Comparator<VarBindingDef> byUsage = byUsage( varTupleSet);

    return
      IteratorUtils.transformedIterator(
        // Iterate over all combinations of bindings...
        new CartesianProduct<VarBindingDef>(

          // ...combining members from all sets of bindings...
          new ArrayList<Set<VarBindingDef>>(
            CollectionUtils.collect(
              // ...where each set of bindings is derived from a disjunct of unsatisfied test case conditions....
              testCase.getRequired().getDisjuncts(),

              // ...and contains the set of compatible bindings that could satisfy this disjunct...
              disjunct ->
                {
                Set<String> unsatisfied =
                  CollectionUtils.collect(
                    disjunct.getAssertions(),
                    assertion -> assertion.getProperty(),
                    new HashSet<String>());

                Iterator<VarBindingDef> satisfyingBindings =
                  IteratorUtils.filteredIterator(
                    getPropertyProviders( unsatisfied).iterator(),
                    binding -> testCase.isCompatible( binding));

                // ...arranging satisfying bindings in order of decreasing preference...
                return
                  CollectionUtils.collect(
                    satisfyingBindings,
                    nopTransformer(),
                    new TreeSet<VarBindingDef>( byUsage));
                },

              // ...arranging sets in a well-defined order for repeatable combinations...
              new TreeSet<Set<VarBindingDef>>( varBindingSetSorter_))),
          
          // ...ignoring any infeasible combinations...
          bindings -> Tuple.of( bindings) != null),
        
         // ... forming each combination of satisfying bindings into a tuple...
        Tuple::of);
    }
434235
public static Collection<TypeQualifierValue<?>> getRelevantTypeQualifiers(MethodDescriptor methodDescriptor, CFG cfg)
            throws CheckedAnalysisException {

        final HashSet<TypeQualifierValue<?>> result = new HashSet<>();

        XMethod xmethod = XFactory.createXMethod(methodDescriptor);

        if (FIND_EFFECTIVE_RELEVANT_QUALIFIERS) {
            if (DEBUG_FIND_EFFECTIVE_RELEVANT_QUALIFIERS) {
                System.out.println("**** Finding effective type qualifiers for " + xmethod);
            }

            //
            // This will take care of methods using fields annotated with
            // a type qualifier.
            //
            getDirectlyRelevantTypeQualifiers(xmethod, result);

            // For all known type qualifiers, find the effective (direct,
            // inherited,
            // or default) type qualifier annotations
            // on the method and all methods directly called by the method.
            //

            addEffectiveRelevantQualifiers(result, xmethod);

            IAnalysisCache analysisCache = Global.getAnalysisCache();
            ConstantPoolGen cpg = analysisCache.getClassAnalysis(ConstantPoolGen.class, methodDescriptor.getClassDescriptor());
            for (Iterator<Location> i = cfg.locationIterator(); i.hasNext();) {
                Location location = i.next();
                Instruction ins = location.getHandle().getInstruction();
                if (ins instanceof InvokeInstruction) {
                    if (ins instanceof INVOKEDYNAMIC) {
                        // TODO handle INVOKEDYNAMIC
                    } else {
                        XMethod called = XFactory.createXMethod((InvokeInstruction) ins, cpg);
                        addEffectiveRelevantQualifiers(result, called);
                    }
                }

                if (DEBUG_FIND_EFFECTIVE_RELEVANT_QUALIFIERS) {
                    System.out.println("===> result: " + result);
                }
            }

            //
            // XXX: this code can go away eventually
            //

            if (!methodDescriptor.isStatic()) {
                // Instance method - must consider type qualifiers inherited
                // from superclasses

                SupertypeTraversalVisitor visitor = new OverriddenMethodsVisitor(xmethod) {
                    /*
                     * (non-Javadoc)
                     *
                     * @see edu.umd.cs.findbugs.ba.ch.OverriddenMethodsVisitor#
                     * visitOverriddenMethod(edu.umd.cs.findbugs.ba.XMethod)
                     */

                    @Override
                    protected boolean visitOverriddenMethod(XMethod xmethod) {
                        getDirectlyRelevantTypeQualifiers(xmethod, result);
                        return true;
                    }
                };

                try {
                    AnalysisContext.currentAnalysisContext().getSubtypes2()
                    .traverseSupertypesDepthFirst(xmethod.getClassDescriptor(), visitor);
                } catch (ClassNotFoundException e) {
                    AnalysisContext.currentAnalysisContext().getLookupFailureCallback().reportMissingClass(e);
                    return Collections.<TypeQualifierValue<?>> emptySet();
                } catch (UncheckedAnalysisException e) {
                    AnalysisContext.currentAnalysisContext().getLookupFailureCallback()
                    .logError("Error getting relevant type qualifiers for " + xmethod.toString(), e);
                    return Collections.<TypeQualifierValue<?>> emptySet();
                }
            }
        }

        return result;

    }
1074357
static Type getRawType(Type genericType, Map<TypeVariable, Type> typeVariableMap) {
		Type resolvedType = genericType;
		if (genericType instanceof TypeVariable) {
			TypeVariable tv = (TypeVariable) genericType;
			resolvedType = typeVariableMap.get(tv);
			if (resolvedType == null) {
				resolvedType = extractBoundForTypeVariable(tv);
			}
		}
		if (resolvedType instanceof ParameterizedType) {
			return ((ParameterizedType) resolvedType).getRawType();
		}
		else {
			return resolvedType;
		}
	}
715085
public StatementBuilder withQualifiers(SnakGroup qualifiers) {
		getQualifierList(qualifiers.getProperty()).addAll(qualifiers);
		return getThis();
	}
1369730
public final List<ChooseableSpecifics> retrieveAllChSpecifics(
    final Map<String, Object> pRqVs,
      final ChooseableSpecificsType pChSpecType) throws Exception {
    ChooseableSpecifics chs = new ChooseableSpecifics();
    chs.setItsType(pChSpecType);
    pRqVs.put("ChooseableSpecificsitsTypedeepLevel", 1); //only ID
    List<ChooseableSpecifics> result = getSrvOrm()
      .retrieveListForField(pRqVs, chs, "itsType");
    pRqVs.remove("ChooseableSpecificsitsTypedeepLevel");
    return result;
  }
592289
public List<A> findAllAttributesByQualifier(String qualifier) {
        return (List<A>)getModelStore().findAllAttributesByQualifier(qualifier);
    }