WARNING: should really only be used by internal implementations.

@return
971215
public Set<Map.Entry<Buffer, Buffer>> getAllParameters() {
        consumeUntil(null);
        if (this.paramMap != null) {
            return this.paramMap.entrySet();
        }
        return null;
    }
1334220
public Throwable getMostSpecificCause()
    {
        Throwable rootCause = null;
        Throwable cause = getCause();
        while (cause != null  &&  cause != rootCause) {
            rootCause = cause;
            cause = cause.getCause();
        }

        return (rootCause == null ? this : rootCause);
    }
480051
public JSType build() {
    if (result == null) {
      result = reduceAlternatesWithoutUnion();
      if (result == null) {
        result = new UnionType(registry, ImmutableList.copyOf(getAlternates()));
      }
    }
    return result;
  }
713463
public boolean isSendAllowed()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
      SibTr.entry(tc, "isSendAllowed");
    
    boolean isSendAllowed = aliasDest.isSendAllowed();
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
      SibTr.exit(tc, "isSendAllowed", new Boolean(isSendAllowed));
    
    return isSendAllowed;
  }
45765
public final ThrowableSubject hasCauseThat() {
    // provides a more helpful error message if hasCauseThat() methods are chained too deep
    // e.g. assertThat(new Exception()).hCT().hCT()....
    // TODO(diamondm) in keeping with other subjects' behavior this should still NPE if the subject
    // *itself* is null, since there's no context to lose. See also b/37645583
    if (actual() == null) {
      check("getCause()").fail("Causal chain is not deep enough - add a .isNotNull() check?");
      return ignoreCheck()
          .that(
              new Throwable() {
                @Override
                public Throwable fillInStackTrace() {
                  setStackTrace(new StackTraceElement[0]); // for old versions of Android
                  return this;
                }
              });
    }
    return check("getCause()").that(actual().getCause());
  }
51909
@Override
    protected boolean isLocalOnly() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "isLocalOnly");
        boolean ret = false;

        String scopeToLocalQP = (String) properties.get(SCOPE_TO_LOCAL_QP);
        if (ApiJmsConstants.SCOPE_TO_LOCAL_QP_ON.equals(scopeToLocalQP)) {
            ret = true;
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "isLocalOnly", ret);
        return ret;
    }
897975
static Unsafe getUnsafe() {
      try {
         return Unsafe.getUnsafe();
      } catch (SecurityException tryReflectionInstead) {}
      try {
         return java.security.AccessController.doPrivileged
                 (new java.security.PrivilegedExceptionAction<Unsafe>() {
                    public Unsafe run() throws Exception {
                       Class<Unsafe> k = Unsafe.class;
                       for (java.lang.reflect.Field f : k.getDeclaredFields()) {
                          f.setAccessible(true);
                          Object x = f.get(null);
                          if (k.isInstance(x))
                             return k.cast(x);
                       }
                       throw new NoSuchFieldError("the Unsafe");
                    }});
      } catch (java.security.PrivilegedActionException e) {
         throw new RuntimeException("Could not initialize intrinsics",
                 e.getCause());
      }
   }
887099
public Boolean getEffectiveInternalSSL() {
        if (m_internalSSL != null) {
            return m_internalSSL;
        } else if (m_defaultConfig != null) {
            return m_defaultConfig.getEffectiveCallSSL();
        } else {
            return Boolean.FALSE;
        }
    }
265466
public java.util.List<String> getInstancesToTerminate() {
        if (instancesToTerminate == null) {
            instancesToTerminate = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return instancesToTerminate;
    }
978276
public boolean isThrowable() {
        if (isEnum() || isInterface() || isAnnotationType()) {
            return false;
        }
        for (Type t = type; t.hasTag(CLASS); t = env.types.supertype(t)) {
            if (t.tsym == env.syms.throwableType.tsym) {
                return true;
            }
        }
        return false;
    }
1316871
private Method[] getMethodsToProxyRecursive() {
        Set<MethodSetEntry> methodsToProxy = new HashSet<>();
        Set<MethodSetEntry> seenFinalMethods = new HashSet<>();
        // Traverse the class hierarchy to ensure that all concrete methods (which could be marked
        // as final) are visited before any abstract methods from interfaces.
        for (Class<?> c = baseClass; c != null; c = c.getSuperclass()) {
            getMethodsToProxy(methodsToProxy, seenFinalMethods, c);
        }
        // Now traverse the interface hierarchy, starting with the ones implemented by the class,
        // followed by any extra interfaces.
        for (Class<?> c = baseClass; c != null; c = c.getSuperclass()) {
            for (Class<?> i : c.getInterfaces()) {
                getMethodsToProxy(methodsToProxy, seenFinalMethods, i);
            }
        }
        for (Class<?> c : interfaces) {
            getMethodsToProxy(methodsToProxy, seenFinalMethods, c);
        }

        Method[] results = new Method[methodsToProxy.size()];
        int i = 0;
        for (MethodSetEntry entry : methodsToProxy) {
            results[i++] = entry.originalMethod;
        }

        return results;
    }
199683
private boolean isPropertyTypeInternal() {
        Class<?> type = getType();
        return
                // References are always contained in properties of type String or String[].
                isReference()
                        || isPropertyType(type)
                        || (type.isArray() || isCollectionType) && isPropertyType(getTypeParameter());
    }
910892
@Override
    public boolean isOptional()
    {
        boolean isNullable = true;
        if (!isId())
        {
            Column anno = member.getAnnotation(Column.class);
            if (anno != null)
            {
                isNullable = anno.nullable();
            }
        }
        else
        {
            isNullable = false;
        }
        return isNullable;
    }
821810
@Restricted(NoExternalUse.class) // called from newJob_button-bar view
    @SuppressWarnings("unused") // called from newJob_button-bar view
    public boolean isAddToCurrentView() {
        synchronized(this) {
            return !jobNames.isEmpty() || // There are already items in this view specified by name
                    (jobFilters.isEmpty() && includePattern == null) // No other way to include items is used
                    ;
        }
    }
1061899
public synchronized void unuse() {
        assert(inUse);
        inUse = false;
        compiler = null;
        fileManager = null;
        fileManagerBase = null;
        smartFileManager = null;
        context = null;
        subTasks = null;
    }
324534
protected T createInstance() {
		try {
			return targetClass.newInstance();
		} catch (InstantiationException e) {
			throw new RuntimeException(e);
		} catch (IllegalAccessException e) {
			throw new RuntimeException(e);
		}
	}
457937
public boolean isExecutable()
	{
		boolean result = isTag("object") || isTag("void") && hasAttr("class") //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
				&& hasAttr("method") || isTag("array") || isPrimitive() //$NON-NLS-1$ //$NON-NLS-2$
				|| isTag("class") || isTag("null"); //$NON-NLS-1$ //$NON-NLS-2$
		return result;
	}