Returns whether a Header of the given type may be in this set or if it's been removed explicitly.

@param headerType
@return
559516
private boolean isRemoved(HeaderType<?> headerType)
	{
		for (HeaderType<?> type : mRemovedHeaderTypes)
		{
			if (type.equals(headerType))
			{
				return true;
			}
		}
		return false;
	}
368112
public static boolean isStructuredType(Type type) {
        MetaType metaType = type.getMetaType();
        return metaType == MetaType.ENTITY || metaType == MetaType.COMPLEX;
    }
203333
public static function removeHeader($type) {
		
		if(false == is_string($type)) {
			return trigger_error(sprintf('Argument 1 passed to %s() must be of the type string, "%s" given', __METHOD__, gettype($type)), E_USER_ERROR);
		}

		header_remove($type);
	}
1140950
public static boolean checkValidInclude(TemplateType includeeType,
			TemplateType includedType) {
		return allowedIncludes[includeeType.ordinal()][includedType.ordinal()];
	}
172533
@Override
    public boolean validForHeader(HeaderKeys hdr, boolean includesDollar) {
        // Only valid for Set-Cookie headers
        if (HttpHeaderKeys.HDR_SET_COOKIE.equals(hdr) || HttpHeaderKeys.HDR_SET_COOKIE2.equals(hdr)) {
            return !includesDollar;
        }
        return false;
    }
715216
public boolean contains( String name )
    {
        for ( Header header : headers ) {
            if ( header.getName().equals( name ) ) {
                return true;
            }
        }
        return false;
    }
902971
public static boolean isClassVetoed(Class<?> type) {
        if (type.isAnnotationPresent(Vetoed.class)) {
            return true;
        }
        return isPackageVetoed(type.getPackage());
    }
687257
public JWTHeader setType(String type) {
        this.type = type;
        this.put(HeaderConstants.TYPE, type);
        return this;
    }
174525
public static boolean isSerializable( JType type ) {
        return null != type.isInterface() && Serializable.class.getName().equals( type.getQualifiedSourceName() );
    }
83836
public boolean isSarlEvent(LightweightTypeReference type) {
		return !type.isInterfaceType() && (getSarlElementEcoreType(type) == SarlPackage.SARL_EVENT
				|| type.isSubtypeOf(Event.class));
	}
560410
final public Boolean checkPositionType(String type) {
    if (tokenPosition == null) {
      return false;
    } else {
      return tokenPosition.checkType(type);
    }
  }
644626
private boolean checkRequestHeaders(HeaderMap headers) {
        // :method pseudo-header must be present always exactly one time;
        // HTTP2 request MUST NOT contain 'connection' header
        if (headers.count(METHOD) != 1 || headers.contains(Headers.CONNECTION)) {
            return false;
        }

        // if CONNECT type is used, then we expect :method and :authority to be present only;
        // :scheme and :path must not be present
        if (headers.get(METHOD).contains(Methods.CONNECT_STRING)) {
            if (headers.contains(SCHEME) || headers.contains(PATH) || headers.count(AUTHORITY) != 1) {
                return false;
            }
        // For other HTTP methods we expect that :scheme, :method, and :path pseudo-headers are
        // present exactly one time.
        } else if (headers.count(SCHEME) != 1 || headers.count(PATH) != 1) {
            return false;
        }

        // HTTP2 request MAY contain TE header but if so, then only with 'trailers' value.
        if (headers.contains(Headers.TE)) {
            for (String value : headers.get(Headers.TE)) {
                if (!value.equals("trailers")) {
                    return false;
                }
            }
        }

        return true;
    }
1223457
public static boolean canAccept(String headerValue, boolean strict, String type) {
    if(headerValue != null && type != null)  {
      String availableTypes[] = headerValue.split(",");
      for(String availableType : availableTypes) {
        String typeParams[] = availableType.split(";");
        double qValue = 1.0d;
        if(typeParams.length > 0) {
          for(int i=1; i<typeParams.length; i++) {
            if(typeParams[i].trim().startsWith("q=")) {
              String qString = typeParams[i].substring(2).trim();
              if(qString.matches("\\A\\d+(\\.\\d*){0,1}\\Z")){
                qValue = Double.parseDouble(qString);
                break;
              } 
            }
          }
        }
        boolean matches = false;
        if(typeParams[0].equals("*") || typeParams[0].equals("*/*")) {
          matches = true;
        } else {
          matches = hasMatch(typeParams, type);
        }
        if(qValue == 0 && matches) {
          return false;
        } else if(matches){
          return true;
        }
      }
    }
    return !strict;
  }
33954
protected boolean shouldExcludeType(Class<?> type) {
        for (Class<?> t : excludedFieldTypes) {
            if (t.isAssignableFrom(type)) {
                return true;
            }
        }
        return false;
    }
689852
public static boolean isPrimitive(Class<?> type) {
		if (type.isPrimitive()) {
			return true;
		}
		// check if wrapper;
		if (PRIMITIVES_TO_WRAPPERS.values().contains(type)) {
			return true;
		}
		return false;
	}
279827
public static boolean areRequestHeadersValid(HeaderMap headers) {
        HeaderValues te = headers.get(Headers.TRANSFER_ENCODING);
        HeaderValues cl = headers.get(Headers.CONTENT_LENGTH);
        if(te != null && cl != null) {
            return false;
        } else if(te != null && te.size() > 1) {
            return false;
        } else if(cl != null && cl.size() > 1) {
            return false;
        }
        return true;
    }
107394
public Map<String, String> getHeaders(String type, Object target) {
        HeadersAccessor accessor = getHeadersAccessor(type);
        if (accessor != null) {
            Map<String, String> ret = accessor.getHeaders(target);
            return ret;
        }
        return null;
    }