Returns RequestReporter for the class specified for context parameter {@link SimonServletFilter#INIT_PARAM_REQUEST_REPORTER_CLASS}.
481111
public static RequestReporter initRequestReporter(FilterConfig filterConfig) {
		String className = filterConfig.getInitParameter(SimonServletFilter.INIT_PARAM_REQUEST_REPORTER_CLASS);

		if (className == null) {
			return new DefaultRequestReporter();
		} else {
			try {
				return (RequestReporter) Class.forName(className).newInstance();
			} catch (ClassNotFoundException | IllegalAccessException | InstantiationException classNotFoundException) {
				throw new IllegalArgumentException("Invalid Request reporter class name", classNotFoundException);
			}
		}
	}
424010
public static HOTPProvider instantiateProvider(boolean allowTestProvider) {
        HOTPProvider resultProvider = null;
        ServiceLoader<HOTPProvider> loader = ServiceLoader.load(HOTPProvider.class);
        Iterator<HOTPProvider> iterator = loader.iterator();
        if (iterator.hasNext()) {
            while (iterator.hasNext()) {
                HOTPProvider provider = iterator.next();
                if (!"com.payneteasy.superfly.spring.TestHOTPProvider".equals(provider.getClass().getName())
                        || allowTestProvider) {
                    resultProvider = provider;
                    break;
                }
            }
        }
        return resultProvider;
    }
369289
public static JUnitSecurityReportCollector newReportCollector() {
        String className = System.getProperty("soapui.junit.reportCollector", null);
        if (StringUtils.isNotBlank(className)) {
            try {
                return (JUnitSecurityReportCollector) Class.forName(className).getConstructor().newInstance();
            } catch (Exception e) {
                log.warn("Failed to create JUnitReportCollector class [" + className + "] so use the default one;"
                        + " error cause: " + e.toString());
            }
        }
        return new JUnitSecurityReportCollector();
    }
217413
protected void submitReport() {
    try {
      utilizationGauger.gauge();
      rpcCollector.reportTaskTrackerUtilization(
              utilizationGauger.getTaskTrackerUtilization(),
              utilizationGauger.getLocalJobUtilization());
    } catch (IOException e) {
      LOG.error(StringUtils.stringifyException(e));
    }
  }
1211834
public RequestDispatcher createRequestDispatcher(RequestImpl request, Klass<?> type, Object it, String viewName) throws IOException {
        return null;    // should be really abstract, but not
    }
1083766
public static WebRequestInterceptor[] lookupWebRequestInterceptors(ServletContext servletContext) {
        WebApplicationContext wac = WebApplicationContextUtils.getRequiredWebApplicationContext(servletContext);

        final Collection<WebRequestInterceptor> webRequestInterceptors = wac.getBeansOfType(WebRequestInterceptor.class).values();
        return webRequestInterceptors.toArray(new WebRequestInterceptor[webRequestInterceptors.size()]);
    }
1049090
public BaseMethodBinding<?> determineResourceMethod(RequestDetails requestDetails, String requestPath) {
		RequestTypeEnum requestType = requestDetails.getRequestType();

		ResourceBinding resourceBinding = null;
		BaseMethodBinding<?> resourceMethod = null;
		String resourceName = requestDetails.getResourceName();
		if (myServerConformanceMethod.incomingServerRequestMatchesMethod(requestDetails)) {
			resourceMethod = myServerConformanceMethod;
		} else if (resourceName == null) {
			resourceBinding = myServerBinding;
		} else {
			resourceBinding = myResourceNameToBinding.get(resourceName);
			if (resourceBinding == null) {
				throwUnknownResourceTypeException(resourceName);
			}
		}

		if (resourceMethod == null) {
			if (resourceBinding != null) {
				resourceMethod = resourceBinding.getMethod(requestDetails);
			}
			if (resourceMethod == null) {
				resourceMethod = myGlobalBinding.getMethod(requestDetails);
			}
		}
		if (resourceMethod == null) {
			if (isBlank(requestPath)) {
				throw new InvalidRequestException(myFhirContext.getLocalizer().getMessage(RestfulServer.class, "rootRequest"));
			}
			throwUnknownFhirOperationException(requestDetails, requestPath, requestType);
		}
		return resourceMethod;
	}
1269886
@Inject
    public void setReporterConfiguration(@Nullable Configuration.ReporterConfiguration reporterConfiguration) {
        if (reporterConfiguration != null) {
            configuration.withReporter(reporterConfiguration);
        }
    }
1254208
private final RequestMetricCollector findRequestMetricCollector(
            RequestMetricCollector reqLevelMetricsCollector) {
        if (reqLevelMetricsCollector != null) {
            return reqLevelMetricsCollector;
        } else if (getRequestMetricsCollector() != null) {
            return getRequestMetricsCollector();
        } else {
            return AwsSdkMetrics.getRequestMetricCollector();
        }
    }
1184779
function loadReporter(reporterPath) {
    var reporter;
    reporterPath = reporterPath || 'checkstyle';
    if (!fs.existsSync(path.resolve(reporterPath))) {
        try {
            reporter = require('./lib/reporters/' + reporterPath);
        } catch (e) {
            try {
                reporter = require('jscs/lib/reporters/' + reporterPath);
            }
            catch (e) {
                reporter = null;
            }
        }
    } else {
        try {
            reporter = require(path.resolve(reporterPath));
        } catch (e) {
            reporter = null;
        }
    }
    return reporter;
}
1366265
ReportBodyProvider getReportBodyProvider(ReportRequest request) {
    Preconditions.checkNotNull(request, "Null request");
    Preconditions.checkNotNull(request.getRequestType(), "Null request type");
    switch (request.getRequestType()) {
      case AWQL:
        return new AwqlReportBodyProvider(request.getReportRequestString(),
            request.getDownloadFormat().name());
      case XML:
        return new ReportDefinitionBodyProvider(request.getReportRequestString());
      default:
        throw new IllegalArgumentException(
            "Unrecognized request type: " + request.getRequestType());
    }
  }
1067595
private RPCBatchRequestSender getBatchRequestSender()
	{
		RPCBatchRequestSender sender = null;

		// test the last sender we have in the list
		if( !batchRequestSenders.isEmpty() )
		{
			sender = batchRequestSenders.get( batchRequestSenders.size() - 1 );
			if( sender.canAddRequest() )
				return sender;
		}

		// otherwise, create a new one
		sender = new RPCBatchRequestSender();
		sender.init( baseUrl, batchSenderCallback );
		batchRequestSenders.add( sender );

		return sender;
	}
78388
public static HttpServletRequest getHttpServletRequestFromExternalWebflowContext(final RequestContext context) {
        Assert.isInstanceOf(ServletExternalContext.class, context.getExternalContext(),
            "Cannot obtain HttpServletRequest from event of type: "
                + context.getExternalContext().getClass().getName());

        return (HttpServletRequest) context.getExternalContext().getNativeRequest();
    }
1330811
public Map<String, Serializable> getReportUserParametersForEdit(Report report) throws Exception {
        Map<String, Serializable> result = new LinkedHashMap<String, Serializable>();
        JasperReport jr = getJasperReport(report);
        Map<String, Serializable> map = JasperReportsUtil.getJasperReportUserParameters(jr);
        for (String key : map.keySet()) {
            JasperParameter jp = (JasperParameter) map.get(key);            
            JasperParameterSource sp = getParameterSources(report, jp);
            // this parameter is not defined inside the file
            if (sp == null) {
                sp = new JasperParameterSource(jp.getName());
                sp.setValueClassName(JasperReportsUtil.getValueClassName(storageService, report.getDataSource(), jp));
            }
            result.put(sp.getName(), sp);
        }
        return result;
    }
412001
@SuppressWarnings("unchecked")
	public void requestInitialized(ServletRequestEvent sre) {
		WebContext<HttpServletRequest> context = (WebContext<HttpServletRequest>) container.component(container.contexts().get(Request.class));
		context.associate((HttpServletRequest) sre.getServletRequest());
	}
1234075
public ReportModel getReportModel( Class<? extends Object> testClass ) {
        synchronized( reportModels ) {
            ReportModel reportModel = reportModels.get( testClass.getCanonicalName() );

            if( reportModel == null ) {
                reportModel = new ReportModel();
                reportModel.setTestClass( testClass );

                reportModels.put( testClass.getCanonicalName(), reportModel );
            }

            return reportModel;
        }
    }
142048
public ReportWriter getReportWriter(final JasperPrint _jasperPrint, final String _format, final Map<JRExporterParameter,Object> _parameters) {
        final JRExporter exporter = FormatInfoRegistry.getInstance().getExporter(_format);
        exporter.setParameters(_parameters);

        if (_jasperPrint.getPages().size() > PAGES_THRESHHOLD) {
            return new FileReportWriter(_jasperPrint, exporter);
        } else {
            return new MemoryReportWriter(_jasperPrint, exporter);
        }
    }