Gets the resolved result of the parse.

@return the result of the parse, not null
173482
TemporalAccessor toResolved(ResolverStyle resolverStyle, Set<TemporalField> resolverFields) {
        Parsed parsed = currentParsed();
        parsed.chrono = getEffectiveChronology();
        parsed.zone = (parsed.zone != null ? parsed.zone : formatter.getZone());
        return parsed.resolve(resolverStyle, resolverFields);
    }
1044085
public T get() throws E {
		// use a temporary variable to reduce the number of reads of the volatile field
		// see commons-lang3
		T result = object;
		if (object == null) {
			synchronized (this) {
				result = object;
				if (object == null) {
					object = result = initializer.get();
				}
			}
		}
		return result;
	}
1041782
public java.util.Map<String, String> getExprs() {
        if (exprs == null) {
            exprs = new com.amazonaws.internal.SdkInternalMap<String, String>();
        }
        return exprs;
    }
1301181
@SuppressWarnings("unchecked")
    ResolveResult<AbstractConfigObject> asObjectResult() {
        if (!(value instanceof AbstractConfigObject))
            throw new ConfigException.BugOrBroken("Expecting a resolve result to be an object, but it was " + value);
        Object o = this;
        return (ResolveResult<AbstractConfigObject>) o;
    }
517199
public String getResult() {

        String res;
        CmsSite site = OpenCms.getSiteManager().getSiteForSiteRoot(m_siteRoot);
        if (site == null) {
            res = CmsVaadinUtils.getMessageText(Messages.GUI_DATABASEAPP_STATS_RESULTS_ROOT_1, new Integer(m_count));
        } else {
            res = CmsVaadinUtils.getMessageText(
                Messages.GUI_DATABASEAPP_STATS_RESULTS_2,
                site.getTitle(),
                new Integer(m_count));
        }
        return res;
    }
703904
public boolean parseNextLine()
    {
        if (firstTime)
        {
            firstTime = false;
            
         // Obtain an instance of an XMLReader implementation from a system property
            try {
                XMLReader parser = org.xml.sax.helpers.XMLReaderFactory.createXMLReader();
            
                // Set the ContentHandler...
                parser.setContentHandler( m_handler );
        
                   // Parse the file...
                parser.parse( new InputSource( m_reader ));
        
            } catch (IOException e) {
                e.printStackTrace();
            } catch (SAXException e) {
                e.printStackTrace();
            }
            
            m_record.close();
        }
        try {
            return m_record.hasNext();
        } catch (DBException e) {
            e.printStackTrace();
        }
        return false;
    }
1371102
public LightweightTypeReference resolve() {
		if (internalIsResolved())
			return resolvedTo;
		List<LightweightBoundTypeArgument> allHints = getAllHints();
		if (!allHints.isEmpty() && resolveWithHints(allHints)) {
			LightweightTypeReference result = internalGetResolvedTo();
			if (result != null) {
				return result;
			}
		}
		resolveAgainstConstraints();
		return resolvedTo;
	}
918581
public ReviewResult parseResults() throws IOException {
        ReviewResult result = new ReviewResult();
        ObjectMapper mapper = new ObjectMapper();
        JsonNode rootNode = mapper.readTree(new FileReader(resultFile));
        JsonNode issues = rootNode.path("issues");
        Iterator<JsonNode> issuesIterator = issues.iterator();
        Map<String, Component> components = getComponents(rootNode.path("components"));

        while (issuesIterator.hasNext()) {
            JsonNode issue = issuesIterator.next();
            boolean isNew = issue.path("isNew").asBoolean();
            if (!isNew) {
                log.debug("Skipping already indexed issue: {}", issue.toString());
                continue;
            }
            JsonNode lineNode = issue.path("line");
            if (lineNode.isMissingNode()) {
                log.debug("Skipping an issue with no line information: {}", issue.toString());
                continue;
            }
            int line = lineNode.asInt();
            String message = issue.path("message").asText();
            String file = getIssueFilePath(issue.path("component").asText(), components);
            String severity = issue.path("severity").asText();
            String rule = issue.path("rule").asText();
            result.add(new Violation(file, line, String.format("%s (Rule: %s)", message, rule), getSeverity(severity)));
        }
        return result;
    }
1066078
public String getResolutionReportString() {
        ResolutionReport report = _reportRef.get();
        StringBuilder reportMessage = null;
        if (report != null) {
            Map<Resource, List<ResolutionReport.Entry>> unresolved;
            reportMessage = new StringBuilder().append("Resolver report:\n");
            unresolved = report.getEntries();
            if (!unresolved.isEmpty()) {
                for (Resource resource : unresolved.keySet()) {
                    reportMessage.append(report.getResolutionReportMessage(resource));
                }
            }
            if (report.getResolutionException() != null) {
                reportMessage.append("\nResolution exception:\n" + report.getResolutionException());
            }
        }
        return reportMessage == null ? "No resolution report generated." : reportMessage.toString();
    }
1154907
public Object getReturn() {
        Object result = null;

        if (this.containsKey(QUERY_PARAMS_RETURN) == true) {
            result = this.getValue(QUERY_PARAMS_RETURN);
        }

        return result;
    }
112645
private String resolveExpressionString(final String unresolvedString) throws OperationFailedException {

        // parseAndResolve should only be providing expressions with no leading or trailing chars
        assert unresolvedString.startsWith("${") && unresolvedString.endsWith("}");

        // Default result is no change from input
        String result = unresolvedString;

        ModelNode resolveNode = new ModelNode(new ValueExpression(unresolvedString));

        // Try plug-in resolution; i.e. vault
        resolvePluggableExpression(resolveNode);

        if (resolveNode.getType() == ModelType.EXPRESSION ) {
            // resolvePluggableExpression did nothing. Try standard resolution
            String resolvedString = resolveStandardExpression(resolveNode);
            if (!unresolvedString.equals(resolvedString)) {
                // resolveStandardExpression made progress
                result = resolvedString;
            } // else there is nothing more we can do with this string
        } else {
            // resolvePluggableExpression made progress
            result = resolveNode.asString();
        }

        return result;
    }
1120282
private final ParseTreeNode parse() throws ParserException {
	try {
	    createActionStack();
	    return LRTokenStreamConverter.convert(getTokenStream(), getGrammar(), actionStack);
	} catch (GrammarException e) {
	    logger.error(e.getMessage(), e);
	    throw new ParserException(e.getMessage());
	}
    }
553772
@Override
	public T get() {
		T result = object;
		if (result == null) {
			synchronized (this) {
				result = object;
				if (result == null) {
					object = result = init();
				}
			}
		}
		return result;
	}
701306
public Class<?> resolveReturnTypeGeneric() {
        final List<Class<?>> res = resolveReturnTypeGenerics();
        return res.isEmpty() ? null : res.get(0);
    }
1343069
@SuppressWarnings("unchecked")
    @NotNull
    public final Parser<Object> getParser() {
        if (parser != null) {
            return parser;
        }
        LOG.info("Creating parser: {}", className);
        if (className == null) {
            throw new IllegalStateException("Class name was not set: " + getName());
        }
        if (context == null) {
            throw new IllegalStateException("Context class loader was not set: " + getName() + " / " + className);
        }
        final Object obj = Utils4J.createInstance(className, context.getClassLoader());
        if (!(obj instanceof Parser<?>)) {
            throw new IllegalStateException("Expected class to be of type '" + Parser.class.getName() + "', but was: " + className);
        }
        parser = (Parser<Object>) obj;
        parser.initialize(context, this);
        return parser;
    }
198783
public Object next()
    {
        String result = null;

        if ( _literal != null )
        {
            result = _literal;
            _literal = null;
        }
        else if ( _token != null )
        {
            result = _token;
            _token = null;
        }
        return result;
    }
727014
public Object get() {
		Object result = null;
		if (over)
			return eventResult;
		try {
			boolean runOk = (Boolean) futureTask.get(timeoutforeturnResult, TimeUnit.MILLISECONDS);
			if (runOk) {
				result = this.eventResult;
			}
			over = true;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return result;
	}