/*
private boolean checkNoun(String noun) throws ParseException { return
_metaDataMapper.isValidXPathNoun(noun); }
199882
private String checkProperty(String propName) throws AttributeNotSupportedException {
        final String METHODNAME = "checkProperty";
        boolean inRepos = false;
        boolean inLA = false;
        if (propName.equals(xsiType)) {
/*
 * if (trcLogger.isLoggable(Level.FINER)) {
 * trcLogger.exiting(CLASSNAME, METHODNAME, " " + propName
 * + " is defined in Repository " + repos);
 * }
 */ return repos;
        }
        inRepos = false;
        for (int i = 0; i < entityTypes.size() && !inRepos; i++) {
            inRepos = _metaDataMapper.isPropertyInRepository(propName,
                                                             entityTypes.get(i));
        }
        if (!inRepos) {
            for (int i = 0; i < entityTypes.size(); i++) {
                inLA = _metaDataMapper.isPropertyInLookAside(propName,
                                                             entityTypes.get(i));
            }
        } else {
/*
 * if (trcLogger.isLoggable(Level.FINER)) {
 * trcLogger.exiting(CLASSNAME, METHODNAME, "Property " + propName
 * + " is defined in Repository " + repos);
 * }
 */ return repos;
        }
        if (!inRepos && !inLA) {
            throw new AttributeNotSupportedException(WIMMessageKey.ATTRIBUTE_NOT_SUPPORTED, WIMMessageKey.ATTRIBUTE_NOT_SUPPORTED);
        }
/*
 * if (trcLogger.isLoggable(Level.FINER)) {
 * trcLogger.exiting(CLASSNAME, METHODNAME, "Property " + propName
 * + " is defined in Repository " + la);
 * }
 */ return la;
    }
806393
private Snippet checkValidSnippet(Snippet sn) {
        if (sn == null) {
            throw new NullPointerException(messageFormat("jshell.exc.null"));
        } else {
            if (sn.key().state() != this) {
                throw new IllegalArgumentException(messageFormat("jshell.exc.alien"));
            }
            return sn;
        }
    }
454406
private Boolean readOptionalBoolean(JSONValue val) {

        JSONBoolean b = null == val ? null : val.isBoolean();
        if (b != null) {
            return Boolean.valueOf(b.booleanValue());
        }
        return null;
    }
325288
public boolean containsTagHandler(String ns, String localName)
    {
        return containsNamespace(ns) && _factories.containsKey(localName);
    }
408346
public static final Boolean parseExtendedAttributeBoolean(String value)
   {
      return ((value.equals("1") ? Boolean.TRUE : Boolean.FALSE));
   }
588168
public void checkNoXSLT(final HttpServletRequest request) {
    String reqpar = request.getParameter(getNoXSLTRequestName());

    if (reqpar != null) {
      if (reqpar.equals("!")) {
        // Go back to unsticky noXslt
        setNoXSLTSticky(false);
      } else {
        setNoXSLT(true);
      }
    }

    reqpar = request.getParameter(getNoXSLTStickyRequestName());
    if (reqpar != null) {
      if (reqpar.equals("!")) {
        // Go back to unsticky noXslt
        setNoXSLTSticky(false);
      } else {
        setNoXSLT(true);
        setNoXSLTSticky(true);
      }
    }
  }
264799
public final void booleanLiteral() throws RecognitionException {
		int booleanLiteral_StartIndex = input.index();

		try {
			if ( state.backtracking>0 && alreadyParsedRule(input, 63) ) { return; }

			// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:602:5: ( 'true' | 'false' )
			// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:
			{
			if ( input.LA(1)==82||input.LA(1)==115 ) {
				input.consume();
				state.errorRecovery=false;
				state.failed=false;
			}
			else {
				if (state.backtracking>0) {state.failed=true; return;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				throw mse;
			}
			}

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
			if ( state.backtracking>0 ) { memoize(input, 63, booleanLiteral_StartIndex); }

		}
	}
213476
protected boolean hasReadElfTag(String tag) {
        String tagValue = getReadElfTag(tag);
        return (tagValue != null && !tagValue.isEmpty());
    }
1065770
private static BooleanNode doesStringContain(JsonNode subject, JsonNode search) {
        if (subject.asText().contains(search.asText())) {
            return BooleanNode.TRUE;
        }
        return BooleanNode.FALSE;
    }
629688
private boolean matchPath(String expected, String actual) {

        return CmsStringUtil.joinPaths(actual, "/").equals(CmsStringUtil.joinPaths(expected, "/"));
    }
249433
def checkNode(self, namespaceURI=None, localName=None):
        '''
            
        '''
        namespaceURI = namespaceURI or self.namespaceURI
        localName = localName or self.name
        check = False
        if localName and self.node:
            check = self._dom.isElement(self.node, localName, namespaceURI)
        if not check:
            raise NamespaceError, 'unexpected node type %s, expecting %s' %(self.node, localName)
657907
static boolean isNameReferenced(Node node, String name, Predicate<Node> traverseChildrenPred) {
    return has(node, new MatchNameNode(name), traverseChildrenPred);
  }
278363
public boolean checkPosConstraint(Sentence s, String posConstraint, MatchResult m, JCas jcas) {
		Pattern paConstraint = Pattern.compile("group\\(([0-9]+)\\):(.*?):");
		for (MatchResult mr : Toolbox.findMatches(paConstraint,posConstraint)) {
			int groupNumber = Integer.parseInt(mr.group(1));
			int tokenBegin = s.getBegin() + m.start(groupNumber);
			int tokenEnd   = s.getBegin() + m.end(groupNumber);
			String pos = mr.group(2);
			String pos_as_is = getPosFromMatchResult(tokenBegin, tokenEnd ,s, jcas);
			if (pos_as_is.matches(pos)) {
				Logger.printDetail("POS CONSTRAINT IS VALID: pos should be "+pos+" and is "+pos_as_is);
			} else {
				return false;
			}
		}
		return true;
	}
1148257
public boolean parseBoolean(String name) {
        String property = getProperties().getProperty(name);
        if (property == null) {
            throw new IllegalArgumentException();
        }
        return Boolean.parseBoolean(property);
    }
1246406
public static boolean validatePath(String path) {
        if(path == null) {
            Log.w(TAG, "Uploading path not set");
            return false;
        }

        try {
            uriFromString(path);
            return true;
        } catch(DataSinkException e) {
            return false;
        }
    }
674857
public Boolean getAsBoolean() {
		if (value instanceof String) {
			return Boolean.parseBoolean((String)value);
		}
		return (Boolean)value;
	}
1046593
function isXPathValid(xpath, node) {
        var contextNode = mirror.getReflection();
        return (engine.setDocument(mirror.getReflection())
            .selectSingleNode(xpath, contextNode, namespaceResolver) === node);
    }