Examples of process()

• aQute.bnd.osgi.Macro.process()
• ag.ion.noa4e.internal.search.core.OfficeSearchVisitor.process()
  Starts the visit process. @param progressMonitor progress monitor to be used @author Andreas Br�ker @date 12.07.2006
• arq.cmdline.CmdLineArgs.process()
• ass3.program.core.message.Response.process()
• avrora.sim.Simulation.process()
  The process() method is called when the simulation is created from the command line. This gives the simulation instance a chance to read in options from the command line, instantiate nodes, and configure the simulation from the user's input. @param o the options processed so far from the command line @param args the command line arguments from the user @throws Exception if any type of exception occurs during this processing (e.g. FileNotFound)
• br.com.caelum.restfulie.request.RequestStack.process()
• br.com.caelum.tubaina.template.FreemarkerProcessor.process()
• cc.catalysts.cdoclet.handler.Handler.process()
• center.task.AProcessor.process()
• cfdict.decompress.Decompress.process()
• cfdict.downloader.Download.process()
• cfdict.generator.Generator.process()
• cfdict.parser.Parser.process()
• ch.hortis.sonar.core.service.SnapshotProcessor.process()
• ch.hortis.sonar.core.service.TransactionalSnapshotProcessor.process()
• ch.uzh.ifi.seal.changedistiller.ast.java.CommentCleaner.process()
  Processes the given {@link Comment}. If the previous comment was a line comment and the current is too, both are counted as "in the same block". {@link Comment.CommentType#JAVA_DOC JAVA_DOC} comments are ignored. @param comment to process
• com.Menu.process()
• com.adahas.tools.jmxeval.model.impl.JMXEval.process()
• com.adobe.epubcheck.xml.XMLParser.process()
• com.alexgilleran.icesoap.parser.processor.Processor.process()
• com.alibaba.otter.shared.etl.extend.processor.EventProcessor.process()
  自定义处理单条EventData对象，如果要改变数据内容，请直接修改原对象而非new一个新的对象

   EventData数据格式:  a. schema name / table name b. eventType : insert/update/delete c. executeTime : 执行时间 d. keys / oldKeys : 主键字段 (如果是有主键变更，需要带上老主键的信息在oldKeys中) e. columns :  非主键字段 EventColumn数据格式： a. index : 字段在数据表中的顺序下标 b. columnType : 对应于sqlType c. columnName : 字段名字 d. columnValue : 字段类型 e. isKey : 是否为主键 f. isNull : 是否为空值 

  @return false需要忽略该条数据，true代表继续处理
• com.alibaba.wasp.master.handler.OpenedEntityGroupHandler.process()
• com.alu.e3.auth.camel.producer.AuthProducer.process()
• com.android.dx.cf.direct.ClassPathOpener.process()
  Processes a path element. @return the OR of all return valuesfrom {@code Consumer.processFileBytes()}.
• com.android.manifmerger.ManifestMerger.process()
  id.com/apk/res/android minSdkVersion". (note the space separator between the attribute URI and its local name.) The elements will be created if they don't exists. Existing attributes will be modified. The replacement is done on the main document before merging. @param packageOverride an optional package override. This only affects the package attribute,all components (activities, receivers, etc...) are not affected by this. @return True if the merge was completed, false otherwise.
• com.arjuna.webservices.SoapProcessor.process()
  Process the input stream and generate a response. @param messageContext The message context for the request. @param responseMessageContext The message context for the response. @param action The transport SOAP action. @param reader The input reader. @return The SOAP response. @throws IOException For errors reading the input stream.
• com.artemis.World.process()
  Process all non-passive systems.
• com.artemis.model.ComponentDependencyMatrix.process()
• com.asakusafw.dmdl.spi.AttributeDriver.process()
  Processes and modifies the attributed declaration. @param environment the processing environment @param attribute the attribtue with the {@link #getTargetName() target name} @param declaration the declaration with the {@code attribute} @see #getTargetName()
• com.asakusafw.dmdl.util.AnalyzeTask.process()
  Analyzes all models from source repository in the current configuration. @param repository the source repository @return the analyzed model @throws IOException if failed to process DMDL scripts
• com.asakusafw.testdata.generator.GenerateTask.process()
  Generates all templates from source repository in the current configuration. @throws IOException if failed to process DMDL scripts, or failed to generate templates
• com.avaje.ebean.SqlQueryListener.process()
  Process the bean that has just been read.

  Note this bean will not be added to the List Set or Map.

• com.badlogic.gdx.tools.FileProcessor.process()
  @param outputRoot May be null. @see #process(File,File)
• com.barchart.feed.inst.participant.InstrumentState.process()
• com.baulsupp.kolja.ansi.reports.engine.ReportEngine.process()
• com.cloud.storage.template.Processor.process()
  Returns image format if it was able to process the original file and @param templatePath path to the templates to process. @param format Format of the original file. If null, it means unknown. If not null,there is already a file with thte template name and image format extension that exists in case a conversion can be done.
• com.cloud.storage.template.QCOW2Processor.process()
• com.cloud.storage.template.VhdProcessor.process()
• com.cloudera.cdk.morphline.api.Command.process()
  Processes the given record on the data plane of this command. @return true to indicate that processing shall continue, false to indicate that backtrackingshall be done
• com.dbxml.db.client.tools.CommandLine.process()
• com.dbxml.xml.dom.DOMProducer.process()
• com.dbxml.xml.dom.DOMTableGenerator.process()
• com.dbxml.xml.sax.SAXProducer.process()
• com.dbxml.xml.sax.SAXTableGenerator.process()
• com.dbxml.xml.text.TextProducer.process()
• com.dbxml.xml.text.TextTableGenerator.process()
• com.dianping.cat.consumer.cross.CrossAnalyzer.process()
• com.dianping.cat.consumer.dependency.DependencyAnalyzer.process()
• com.dianping.cat.consumer.event.EventAnalyzer.process()
• com.dianping.cat.consumer.matrix.MatrixAnalyzer.process()
• com.dianping.cat.consumer.metric.MetricAnalyzer.process()
• com.dianping.cat.consumer.problem.ProblemAnalyzer.process()
• com.dianping.cat.consumer.transaction.TransactionAnalyzer.process()
• com.dianping.cat.report.task.alert.sender.spliter.SpliterManager.process()
• com.discoverydns.dnsapiclient.DNSAPIClient.process()
  Process the given command, by sending it to the DNAPI server, and getting a {@link Response} back from it. @param < T> The expected type of the response given the command object @param command The command to send to the server @return The {@link Response} received from the server @throws Throwable In case of any error
• com.dotcms.publisher.receiver.BundlePublisher.process()
  Processes a Bundle, in order to do that it: Un-compress the Bundle file, then each handler for this Publisher will check if inside
  the bundle there is content it needs to be handle as each {@link IHandler Handler} handles a different type of content, and finally
  after the "handle" for each Handler the status are set depending if was a successful operation or not. @param status Current status of the Publishing process @return This bundle configuration ({@link PublisherConfig}) @throws DotPublishingException If fails Handling any on the elements of this bundle
• com.englishtown.vertx.jersey.inject.VertxRequestProcessor.process()
  Provide additional async request processing @param vertxRequest the vert.x http server request @param jerseyRequest the jersey container request @param done the done async callback handler
• com.espertech.esper.epl.join.assemble.BaseAssemblyNode.process()
  Process results. @param result is a list of result nodes per stream
• com.esri.gpt.catalog.publication.ResourceProcessor.process()
  Invokes processing against the resource. @throws Exception if an exception occurs
• com.facebook.presto.operator.Driver.process()
• com.facebook.thrift.TProcessor.process()
• com.github.dandelion.datatables.core.processor.ConfigurationProcessor.process()

  Processes the passed entry which is a {@link ConfigToken} from{@link ColumnConfig}. The value stored in the entry will be updated depending on the processor declared in the {@link ConfigToken}.

  If new entries are to be added, they will be added in the {@code stagingConfigurations} field of the passed{@link ColumnConfiguration} instance. @param configEntry The map entry to update. @param columnConfiguration The column configuration to be updated. @param tableConfiguration The table configuration to be updated.

• com.github.stephenc.javaisotools.iso9660.impl.CreateISO.process()
• com.github.xgameenginee.handler.GameHandler.process()
  处理玩家客户端发的消息或者服务器发的消息 @param obj @param buffer @throws Throwable
• com.google.checkout.example.merchantcalculation.MerchantCalculationCallbackProcessorImpl.process()
• com.google.checkout.example.merchantcalculation.SIMerchantCalculationCallbackProcessorImpl.process()
• com.google.checkout.example.notification.AuthorizationAmountNotificationProcessorImpl.process()
• com.google.checkout.example.notification.ChargeAmountNotificationProcessorImpl.process()
• com.google.checkout.example.notification.ChargebackAmountNotificationProcessorImpl.process()
• com.google.checkout.example.notification.NewOrderNotificationProcessorImpl.process()
• com.google.checkout.example.notification.OrderStateChangeNotificationProcessorImpl.process()
• com.google.checkout.example.notification.RefundNotificationProcessorImpl.process()
• com.google.checkout.example.notification.RiskInformationNotificationProcessorImpl.process()
• com.google.checkout.merchantcalculation.MerchantCalculationCallbackProcessor.process()
  Process the request and send the response back as a String. @return The merchant calculation response String.
• com.google.checkout.notification.AuthorizationAmountNotificationProcessor.process()
  Process the notification. @param notification The AuthorizationAmountNotification. @return The return String, typically a<notification-acknowledgment>. @see AuthorizationAmountNotification
• com.google.checkout.notification.ChargeAmountNotificationProcessor.process()
  Process the notification. @param notification The ChargeAmountNotification. @return The return String, typically a<notification-acknowledgment>. @see ChargeAmountNotification
• com.google.checkout.notification.ChargebackAmountNotificationProcessor.process()
  Process the notification. @param notification The ChargebackAmountNotification. @return The return String, typically a<notification-acknowledgment>. @see ChargebackAmountNotification
• com.google.checkout.notification.NewOrderNotificationProcessor.process()
  Process the notification. @param notification The NewOrderNotification. @return The return String, typically a<notification-acknowledgment>. @see NewOrderNotification
• com.google.checkout.notification.OrderStateChangeNotificationProcessor.process()
  Process the notification. @param notification The OrderStateChangeNotification. @return The return String, typically a<notification-acknowledgment>. @see OrderStateChangeNotification
• com.google.checkout.notification.RefundAmountNotificationProcessor.process()
  Process the notification. @param notification The RefundAmountNotification. @return The return String, typically a<notification-acknowledgment>. @see RefundAmountNotification
• com.google.checkout.notification.RiskInformationNotificationProcessor.process()
  Process the notification. @param notification The RiskInformationNotification. @return The return String, typically a<notification-acknowledgment>. @see RiskInformationNotification
• com.google.code.configprocessor.processing.properties.PropertiesActionProcessor.process()
• com.google.code.proto.gcless.MemlessParser.process()
• com.google.dataconnector.client.fetchrequest.HttpFetchStrategy.process()
  Implements the strategy method of processing the request and filling in the reply with results of processing. @param request The request. @param replyBuilder The reply to fill in.
• com.google.dataconnector.client.fetchrequest.URLConnectionStrategy.process()
  Implements the strategy method of processing the request and filling in the reply with results of processing. @param request The request. @param reply The reply to fill in.
• com.gramant.jtr.reporting.ReportsProcessor.process()
• com.hbasebook.hush.schema.SchemaManager.process()
• com.heatonresearch.aifh.evolutionary.score.parallel.ParallelScore.process()
  Calculate the scores.
• com.heatonresearch.aifh.examples.capstone.model.milestone2.FitTitanic.process()
  Fit a RBF model to the titanic. @param dataPath The path that contains the data file.
• com.icegreen.greenmail.imap.commands.ImapCommand.process()
  Performs all processing of the current Imap request. Reads command arguments from the request, performs processing, and writes responses back to the request object, which are sent to the client. @param request The current client request @param response The current server response @param session The current session
• com.ideo.jso.processor.ResourcesProcessor.process()
  Process list of resources inclusion. @param group Group to include @param resourcesName Resources to include @param servletContext @param out @param location Default location @throws IOException
• com.impetus.kundera.metadata.processor.GeneratedValueProcessor.process()
• com.intridea.io.vfs.operations.IAclGetter.process()
  Executes getter operation. Must be called before aby other operation methods
• com.intridea.io.vfs.operations.IAclSetter.process()
  Executes setter operations. Must be called after setAcl.
• com.itextpdf.text.Chunk.process()
  Processes the element by adding it (or the different parts) to an ElementListener. @param listener an ElementListener @return true if the element was processed successfully
• com.itextpdf.text.MarkedObject.process()
  Processes the element by adding it (or the different parts) to an ElementListener. @param listener an ElementListener @return true if the element was processed successfully
• com.jitlogic.zorka.core.spy.SpyProcessor.process()
  Transforms record passed by instrumentation engine. @param record record to be processed @return processed record (can be the same as passed with record argument)or null to indicate that record should be dropped by instrumentation engine.
• com.jitlogic.zorka.core.spy.plugins.GetterPresentingCollector.process()
• com.jitlogic.zorka.core.spy.plugins.ZorkaStatsCollector.process()
• com.kre8orz.i18n.mockup.ProcessorMockup.process()
• com.linkedin.databus.container.request.RegisterRequestProcessor.process()
• com.lowagie.text.Chunk.process()
  Processes the element by adding it (or the different parts) to an ElementListener. @param listener an ElementListener @return true if the element was processed successfully
• com.lowagie.text.MarkedObject.process()
  Processes the element by adding it (or the different parts) to an ElementListener. @param listener an ElementListener @return true if the element was processed successfully
• com.lowagie.text.MarkedSection.process()
  Processes the element by adding it (or the different parts) to an ElementListener. @param listener an ElementListener @return true if the element was processed successfully
• com.lowagie.text.pdf.FontSelector.process()
  Process the text so that it will render with a combination of fonts if needed. @param text the text @return a Phrase with one or more chunks
• com.netflix.suro.input.thrift.MessageSetProcessor.process()
• com.ontology2.haruhi.flows.AssignmentStep.process()
  Updates local variables with new computed values; you are not allowed to change a variable once it is set @param local -- pre-existing local arguments; this variable is not changed @param flowArgs -- a list of flow arguments that defines positional variable @return local arguments with the assignments added
• com.opensymphony.module.sitemesh.html.HTMLProcessor.process()
• com.pardot.rhombus.UpdateProcessor.process()
• com.peterhi.net.Local.process()
• com.puppycrawl.tools.checkstyle.Checker.process()
  Processes a set of files with all FileSetChecks. Once this is done, it is highly recommended to call for the destroy method to close and remove the listeners. @param aFiles the list of files to be audited. @return the total number of errors found @see #destroy()
• com.puppycrawl.tools.checkstyle.api.FileSetCheck.process()
  Processes a set of files and fires errors to the MessageDispatcher. The file set to process might contain files that are not interesting to the FileSetCheck. Such files should be ignored, no error message should be fired for them. For example a FileSetCheck that checks java files should ignore HTML or properties files. Once processing is done, it is highly recommended to call for the destroy method to close and remove the listeners. @param aFiles the files to be audited. @see #destroy()
• com.redhat.ceylon.compiler.typechecker.TypeChecker.process()
• com.salas.bbutilities.opml.Importer.process()
• com.sendmail.jilter.JilterProcessor.process()
• com.senseidb.indexing.hadoop.keyvalueformat.IntermediateForm.process()
  This method is used by the index update mapper and process a document operation into the current intermediate form. @param doc input document operation @param analyzer the analyzer @throws IOException
• com.senseidb.util.JsonTemplateProcessor.process()
• com.skaringa.json.parser.JsonParser.process()
  Parse the JSON and instantiate the Java object tree. @throws IOException If the reader fails. @throws DeserializerException If the desrialization failes (e.g. because of invalid JSON).
• com.sun.enterprise.admin.servermgmt.launch.ASLauncher.process()
  process - This is the method that performs the work of creating the java command line to execute. This is where the BootStrap launcher and general launcher execute the same track WBN Oct 2006 -- I'd like to change the signature to return int -- but it is public so I'll klunk up a instance variable instead.
• com.sun.enterprise.admin.servermgmt.launch.ASNativeLauncher.process()
• com.sun.enterprise.config.util.PortManager.process()
• com.sun.enterprise.deployment.annotation.AnnotationProcessor.process()
  Starts the annotation processing tool passing the processing context which encapuslate all information necessary for the configuration of the tool. @param ctx is the initialized processing context @return the result of the annoations processing
• com.sun.enterprise.ee.synchronization.processor.ByteProcessor.process()
• com.sun.enterprise.ee.synchronization.processor.ListProcessor.process()
• com.sun.enterprise.ee.synchronization.processor.ServletProcessor.process()
• com.sun.enterprise.ee.synchronization.processor.ZipProcessor.process()
• com.sun.jdi.VirtualMachine.process()
  Returns the {@link java.lang.Process} object for thisvirtual machine if launched by a {@link com.sun.jdi.connect.LaunchingConnector} @return the {@link java.lang.Process} object for this virtualmachine, or null if it was not launched by a {@link com.sun.jdi.connect.LaunchingConnector}. @throws VMCannotBeModifiedException if the VirtualMachine is read-only-see {@link VirtualMachine#canBeModified()}.
• com.sun.jdo.spi.persistence.support.ejb.ejbc.CMPProcessor.process()
  Create and execute the files.
• com.sun.jsftemplating.layout.template.EventParserCommand.process()

  This method processes a "custom" command. These are commands that start with a !. When this method receives control, the name (i.e. the token after the '!' character) has already been read. It is passed via the name parameter.

  This implementation processes events and their handlers. 2 syntaxes are supported:

  • <event type="beforeCreate">handler1(input="foo" output="bar"); ... </event>
  • <!beforeCreate handler1(input="foo" output="bar"); ... />

  The first format should be preferred.

  The {@link ProcessingContext} and{@link ProcessingContextEnvironment} are both available.

• com.sun.tools.javac.main.JavacOption.process()
  Process an option with an argument. @param options the accumulated set of analyzed options @param option the option to be processed @param arg the arg for the option to be processed @return true if an error was detected
• com.sun.tools.javac.main.JavacOption.Option.process()
• com.sun.tools.javac.main.Option.process()
• com.sun.tools.javac.tree.pql.PQLMagicSubexpr.process()
• com.sun.xml.internal.stream.buffer.sax.SAXBufferProcessor.process()
  Short-hand for {@link #setXMLStreamBuffer(XMLStreamBuffer)} then {@link #process()}. @deprecated Use {@link #process(XMLStreamBuffer,boolean)}
• com.sun.xml.internal.stream.buffer.stax.StreamWriterBufferProcessor.process()
• com.sun.xml.stream.buffer.sax.SAXBufferProcessor.process()
  Short-hand for {@link #setXMLStreamBuffer(XMLStreamBuffer)} then {@link #process()}. @deprecated Use {@link #process(XMLStreamBuffer,boolean)}
• com.sun.xml.stream.buffer.stax.StreamWriterBufferProcessor.process()
• com.sun.xml.ws.security.impl.policyconv.XWSSPolicyGenerator.process()
• com.sun.xml.ws.security.opt.api.keyinfo.TokenBuilder.process()
  Processes the token to obtain the keys etc @return a BuilderResult with all token details set in it @throws com.sun.xml.wss.XWSSecurityException exception if the various token information could not be obtained
• com.sun.xml.ws.security.opt.impl.incoming.Signature.process()
• com.sun.xml.ws.security.opt.impl.incoming.processor.ReferenceListProcessor.process()
  processes the ReferenceList and sets the refList member @param reader XMLStreamReader @throws javax.xml.stream.XMLStreamException
• com.sun.xml.ws.security.opt.impl.keyinfo.IssuedTokenBuilder.process()
  @return BuilderResult @throws com.sun.xml.wss.XWSSecurityException
• com.sun.xml.ws.security.opt.impl.keyinfo.KeyValueTokenBuilder.process()
  @return BuilderResult @throws com.sun.xml.wss.XWSSecurityException
• com.sun.xml.ws.security.opt.impl.keyinfo.SCTBuilder.process()
  @return BuilderResult @throws com.sun.xml.wss.XWSSecurityException
• com.sun.xml.ws.security.opt.impl.keyinfo.SamlTokenBuilder.process()
  @return BuilderResult @throws com.sun.xml.wss.XWSSecurityException
• com.sun.xml.ws.security.opt.impl.keyinfo.X509TokenBuilder.process()
  processes the token and obtain the keys @return BuilderResult @throws com.sun.xml.wss.XWSSecurityException
• com.sun.xml.ws.security.trust.TrustPlugin.process()
• com.tacitknowledge.flip.model.FeatureDescriptor.process()
  Processes the state of the feature. If this feature descriptor has set the overriding state then no rules will be processed and this state will be returned. If there are rules then the rules will be processed and the result of the first rule that matches will be returned as a state of the feature. If all of the rules do not matches then null will be returned. @param contextManager the context manager used to process the feature state. @return the state of the feature or null is it is impossible to calculate its state.
• com.tdunning.plume.DoFn.process()
• com.tinkerpop.rexster.protocol.server.RexProRequest.process()
• com.topologi.diffx.algorithm.DiffXAlgorithm.process()
  Performs the comparison and writes the results using the specified Diff-X formatter. @param formatter The formatter that will handle the output. @throws IOException If thrown by the formatter.
• com.topologi.diffx.algorithm.DiffXFitopsy.process()
  Writes the diff sequence using the specified formatter. @param formatter The formatter that will handle the output. @throws IOException If thrown by the formatter.
• com.topologi.diffx.algorithm.GuanoAlgorithm.process()
  Writes the diff sequence using the specified formatter. @param formatter The formatter that will handle the output. @throws IOException If thrown by the formatter.
• com.topologi.diffx.load.DOMRecorder.process()
  {@inheritDoc}
• com.topologi.diffx.load.Recorder.process()
  Runs the recorder on the specified file. @param file The file to process. @return The recorded sequence of events. @throws LoadingException If thrown while parsing. @throws IOException Should I/O error occur.
• com.topologi.diffx.load.SAXRecorder.process()
  Runs the recorder on the specified file.

  This method will count on the {@link InputSource} to guess the correct encoding. @param file The file to process. @return The recorded sequence of events. @throws LoadingException If thrown while parsing. @throws IOException Should I/O error occur.

• com.twitter.hbc.core.processor.HosebirdMessageProcessor.process()
• com.twitter.hbc.core.processor.StringDelimitedProcessor.process()
• com.twitter.hbc.twitter4j.Twitter4jSitestreamClient.process()
• com.twitter.hbc.twitter4j.Twitter4jStatusClient.process()
• com.vladium.emma.instr.InstrVisitor.process()
• com.vladium.emma.report.IReportGenerator.process()
• com.volantis.map.ics.imageprocessor.ImageProcessor.process()
  Processes input image with IPM and returns processed image. @param inputData - Image data to be processed. @param outputData - Output stream to be filled with processed image'sdata. @param params - Processing parameters. @return OutputStream filled with processed image's data. @throws ImageProcessorException - if there was something wrong duringprocessing.
• com.volantis.map.ics.imageprocessor.tool.Tool.process()
  Processes a set of images with pointed processing params and generate output set of images. @param ops - Images for processing, must not be null. @param params - Parameters for processing, must not be null. @return RenderedOp[] - processed images. @throws ToolException if it is impossible to process images.
• com.volantis.map.ics.imageprocessor.writer.ImageWriter.process()
  Translate single image or a number of images (in cases like parsing animated GIFs) into output image's data. @param ops - Image frames. @param params - Parameters. @param os - stream to write image's data into. @return ImageOutputStream - stream with written image's data. @throws ImageWriterException - of there is impossible to write image.
• com.volantis.mps.bms.MessageService.process()
  Returns a Failures object containing {@link Recipient} objects whichhave details about any failures. An empty Failures object indicates that there were no failures. @param sendRequest containing the Recipients and Message details -must be non-null @return Failures - will never be null @throws MessageServiceException if there was a problem processing therequest @throws IllegalArgumentException if the supplied SendRequest was null
• com.volantis.mps.bms.impl.local.InternalMessageService.process()
• com.zesped.model.Invoice.process()
• crosby.binary.file.BlockInputStream.process()
• crosby.binary.osmosis.OsmosisSerializer.process()
  {@inheritDoc}
• de.boksa.rt.rest.response.parser.processor.FieldProcessor.process()
• de.juwimm.torstats.util.FileParser.process()
• de.lmu.ifi.dbs.elki.evaluation.clustering.ClusterContingencyTable.process()
  Process two clustering results. @param result1 First clustering @param result2 Second clustering
• de.netseeker.ejoe.core.InJvmProcessor.process()
  Processes a client request directly with the ServerHandler of a local (within the same JVM) EJServer @param param client request @return the answer returned by the local EJServer instance @throws Exception
• de.odysseus.calyxo.control.impl.DefaultModule.process()
  Process request.

  Invoke action and dispatch according to the result. @param request the request we are processing @param response the response we are creating @param path module path used to lookup action configuration @throws ServletException if action lookup fails or if action instantiationfails. Also exceptions passed through by the invoker are caught, wrapped and thrown. @throws IOException passed through from dispatcher

• de.sciss.eisenkraut.render.FilterDialog.process()
• de.tu_darmstadt.informatik.rbg.hatlak.iso9660.impl.CreateISO.process()
• dk.brics.xmlgraph.Node.process()
• edu.brown.statistics.TableStatistics.process()
• edu.cmu.graphchi.preprocessing.FastSharder.process()
  Final processing after all edges have been received. @throws IOException
• edu.drexel.cs544.mcmuc.actions.Action.process()
  Process the action and send any necessary replies - implementation left to child classes @param channel
• edu.jhu.mb.ernst.engine.DiscreteEvent.process()
  Called at the event time to process the discrete event. @return Returns true if the event should be reinserted into the queue.
• edu.pitt.dbmi.nlp.noble.coder.NobleCoder.process()
  @param text @return @throws TerminologyException
• edu.pitt.dbmi.nlp.noble.tools.NegEx.process()
  process sentence and extract negated and indeterminate concepts @param Sentence @param Concept list of interesting concepts
• edu.pitt.text.tools.NegEx.process()
  process sentence and extract negated and indeterminate concepts @param Sentence @param Concept list of interesting concepts
• edu.stanford.nlp.pipeline.StanfordCoreNLP.process()
  Runs the entire pipeline on the content of the given text passed in. @param text The text to process @return An Annotation object containing the output of all annotators
• edu.ucla.sspace.text.DocumentPreprocessor.process()
  Processes the provided document and returns the cleaned version of the document. @param document a document to process @return a cleaned version of the document
• ehistory.server.api.EventsService.process()
• entagged.tageditor.tools.TrackEnumerator.process()
  This method will start the processing of the selection.
  @param preview true if no really change should be made. This could help counting (determining file count) and due to {@link ListingProgressListener}create a preview of the processing. @return the number of processed audio files @throws OperationException If Errors occur.
• er.selenium.io.SeleniumTestExporter.process()
• er.selenium.io.SeleniumTestImporter.process()
• eu.admire.gateway.core.dispel.DistributedDISPELProcessor.process()
• eu.admire.gateway.rest.dispel.DISPELValidator.process()
• eu.admire.ogsadai.activity.weka.ClassifyActivity.process()
• extdoc.jsdoc.processor.FileProcessor.process()
• fr.eolya.extraction.tika.TikaWrapper.process()
• fr.insalyon.citi.golo.doc.AbstractProcessor.process()
• freemarker.core.Environment.process()
  Processes the template to which this environment belongs.
• freemarker.template.Template.process()
  Processes the template, using data from the map, and outputs the resulting text to the supplied Writer The elements of the map are converted to template models using the default object wrapper returned by the {@link Configuration#getObjectWrapper() getObjectWrapper()}method of the Configuration. @param rootMap the root node of the data model. If null, anempty data model is used. Can be any object that the effective object wrapper can turn into a TemplateHashModel. Basically, simple and beans wrapper can turn java.util.Map objects into hashes and the Jython wrapper can turn both a PyDictionary as well as any object that implements __getitem__ into a template hash. Naturally, you can pass any object directly implementing TemplateHashModel as well. @param out a Writer to output the text to. @throws TemplateException if an exception occurs during template processing @throws IOException if an I/O exception occurs during writing to the writer.
• gov.nysenate.openleg.processors.AgendaProcessor.process()
• gov.nysenate.openleg.processors.BillProcessor.process()
  Applies change sets encoded in SOBI format to bill objects in storage. Creates new Bills as necessary. Does not flush changes to file system from storage. @param sobiFile - Must encode time stamp for the changes into the filename in SOBI.DYYMMDD.THHMMSS.TXT format. @param storage @throws IOException
• gov.nysenate.openleg.processors.CalendarProcessor.process()
• gov.nysenate.openleg.processors.TranscriptProcessor.process()
• hu.jokeman.xparser.parser.XMLProcessor.process()
• info.javadev.jSEO.filter.handler.IHandler.process()
• io.crate.analyze.CreateTableStatementAnalyzer.process()
• io.druid.query.groupby.GroupByQueryEngine.process()
• io.fabric8.watcher.Processor.process()
  Processes the given file
• io.lumify.core.model.longRunningProcess.LongRunningProcessRunner.process()
• ir.xweb.module.Module.process()
• it.unimi.dsi.mg4j.query.QueryEngine.process()
  Parses one or more comma-separated queries and deposits in a given array a segment of the results corresponding to the queries, using the current settings of this query engine.

  Results are accumulated with an “and-then” semantics: results are added from each query in order, provided they did not appear before. @param queries one or more queries separated by commas. @param offset the first result to be added to results. @param length the number of results to be added to results @param results an array list that will hold all results. @return the number of relevant documents scanned while filling results.

• jadx.core.dex.instructions.InsnDecoder.process()
• jadx.core.dex.nodes.parser.DebugInfoParser.process()
• java.util.regex.Pattern.process()
• javax.media.Renderer.process()
• jfun.yan.xml.NutsProcessor.process()
• jodd.db.oom.sqlgen.chunks.SqlChunk.process()
  Process the chunk and appends data to the output.
• juju.reattore.server.intercept.Interceptor.process()
  Process an incoming HTTP request if possible, filling in the given response as it goes. An interceptor may have side effects without actually performing the main processing and may pass it on to another interceptor. A authentication interceptor is a good example. @param req HTTP request to process @param resp Response to fill in @return true if the request was recognised and processed.
• juzu.impl.template.spi.juzu.compiler.ProcessPhase.process()
• kdu_jni.Kdu_region_compositor.Process()
• kdu_jni.Kdu_region_decompressor.Process()
• lupos.engine.operators.multiinput.join.parallel.ResultCollector.process()
• marvin.plugin.MarvinImagePlugin.process()
• net.algart.matrices.StreamingApertureProcessor.process()
  Equivalent to {@link #process(Matrix,Matrix,List,Pattern) process}(dest, src, {@link Matrices#several(Class,Matrix[]) Matrices.several}(PArray.class), pattern). @param dest the resulting matrix R. @param src the source matrix M. @param pattern the aperture shape P. @throws NullPointerException if one of the arguments is null. @throws SizeMismatchException if the passed matrices have different dimensions. @throws IllegalArgumentException if the number of the pattern dimensionspattern. {@link Pattern#dimCount() dimCount()} is not equal to src. {@link Matrix#dimCount() dimCount()} or if this implementation requires at least 1 additional matrix.
• net.azib.ipscan.exporters.ExportProcessor.process()
  Called to execute the actual scanning process. @param scanningResults the scanning results, which are available @param filter optional (can be null) - determines results for saving or skipping
• net.bpiwowar.mg4j.extensions.adhoc.RetrievalModel.process()
  Process a topic and return a set of results @param topic @param results @param capacity @param timer A timer
• net.citizensnpcs.utils.PageUtils.PageInstance.process()
• net.java.textilej.parser.tag.BlockTagProcessor.process()
  @param text a complete line of textile
• net.riccardocossu.autodoc.base.OutputPlugin.process()
  Process a list of packages @param packages list of packages to be processed @param baseOutputDirectory directory to write output files to
• net.rim.device.api.io.parser.json.JSONMessageProcessor.process()
• net.rim.device.api.io.parser.rss.RSSMessageProcessor.process()
• net.rim.device.api.io.parser.soap.SOAPMessageProcessor.process()
• net.rim.device.api.io.parser.xml.XMLHashtableMessageProcessor.process()
• net.sf.clairv.index.processor.ResourceProcessor.process()
  Processes the specified Resource object. A ResourceProcessor object can process more than one Resources before it gets closed. @param resource the Resource object to be handled @return the number of extracted documents; or -1 on error @see net.sf.clairv.index.resource.Resource#extractDocuments(ResourceProcessor);
• net.sf.isolation.template.IsoTemplateProcessor.process()
  et/users/mc_new">mc_new @since 1.0
• net.sf.jcontracts.dependencyanalyzer.DependencyAnalyzer.process()
• net.sf.jml.impl.MsnFileTransferImpl.process()
  Method to process new incoming data. Stores the data and fires events for processing and if finished the final event. Here we must remove the transfer from active ones if finished. @param bodyPart the current body bytes. @param currentLength the current part length. @param totalLength the total length to be processed. @param offset the offset of the current data.
• net.sf.jpluck.jxl.BookmarkProcessor.process()
• net.sf.jz3950.protocol.operation.Operation.process()
  Processes the given PDU in the context of this operation.

  The caller must have called {@link #processes(PDU_type)} beforehand.

  @param pdu the PDU to process @throws ProtocolException if an error occurs while processing the PDU
• net.sf.saxon.expr.Expression.process()
  Process the instruction, without returning any tail calls @param context The dynamic context, giving access to the current node,the current variables, etc.
• net.sf.toxicity.Pipeline.process()
• net.sf.urlchecker.commands.CheckUrlsCommand.process()
• net.sf.urlchecker.commands.Command.process()
  This method processes the input {@link net.sf.urlchecker.commands.Context} and forwards the results on tothe successor. @param input the input @return the set @throws org.apache.commons.configuration.ConfigurationException the configuration exception
• net.sf.urlchecker.commands.URLMatchCommand.process()
  {@inheritDoc}
• net.sourceforge.jaad.aac.tools.LTPrediction.process()
• net.sourceforge.javautil.developer.web.unit.mockserver.MockServerHost.process()
  @param request The request to process @return The response for the request @throws ServletException @throws IOException
• net.sourceforge.jiu.codecs.BMPCodec.process()
• net.sourceforge.jiu.codecs.ImageCodec.process()
• net.sourceforge.jiu.codecs.PNGCodec.process()
• net.sourceforge.jiu.codecs.PNMCodec.process()
• net.sourceforge.jiu.color.adjustment.Contrast.process()
• net.sourceforge.jiu.color.analysis.Histogram1DCreator.process()
• net.sourceforge.jiu.color.analysis.Histogram3DCreator.process()
• net.sourceforge.jiu.color.analysis.MeanDifference.process()
• net.sourceforge.jiu.color.promotion.PromotionRGB24.process()
• net.sourceforge.jiu.geometry.Resample.process()
  This method does the actual work of rescaling an image.
• net.sourceforge.pebble.web.action.Action.process()
  Performs the processing associated with this action. @param request the HttpServletRequest instance @param response the HttpServletResponse instance @return the name of the next view
• net.xoetrope.optional.filter.FilePreprocessor.process()
  Read the file from the input stream, do any substitutions required and return the processed file as a string. @param is The input stream @throws java.io.IOException thrown when there are problems reading the input stream @return the processed file
• nl2sql.parserQuestion.ColtechParser.Process()
• npanday.vendor.VendorInfoTransitionRule.process()
  Fills in some or all of the specified vendor info object and returns the new state. @param vendorInfo the vendor info to fill in @return the new state of the vendor info parameter
• one.nio.net.Session.process()
• oracle.toplink.essentials.internal.ejb.cmp3.metadata.accessors.ClassAccessor.process()
  INTERNAL: Process the items of interest on an entity or embeddable class. The order of processing is important, care must be taken if changes must be made.
• org.I0Itec.zkclient.ZkClient.process()
• org.activiti.spring.annotations.State.process()
• org.agilewiki.jactor.ExceptionHandler.process()
  Process an exception. @param exception The exception to be processed. @throws Exception Any uncaught exceptions raised while processing the exception.
• org.antlr.Tool.process()
• org.antlr.v4.Tool.process()
  To process a grammar, we load all of its imported grammars into subordinate grammar objects. Then we merge the imported rules into the root grammar. If a root grammar is a combined grammar, we have to extract the implicit lexer. Once all this is done, we process the lexer first, if present, and then the parser grammar
• org.antlr.v4.analysis.AnalysisPipeline.process()
• org.antlr.v4.codegen.CodeGenPipeline.process()
• org.antlr.v4.semantics.SemanticPipeline.process()
• org.antlr.v4.tool.GrammarTransformPipeline.process()
• org.apache.abdera.protocol.server.RequestHandler.process()
• org.apache.abdera.protocol.server.RequestProcessor.process()
  Provide the actual request processing logic. @param requestContext The {@link RequestContext} object, holding information about the request to process. @param workspaceManager The {@link WorkspaceManager} object, holding information useful for request processing. @param collectionAdapter The {@link CollectionAdapter} object, holding information useful for request processing; may be null if not needed. @return A {@link ResponseContext} object, as resulted from the request processing.
• org.apache.ace.deployment.processor.DeploymentProcessor.process()
  Post-process the stream and send it to the response. The input stream is the deployment package as it was generated. You should set the correct mime type and start writing to the response. @param inputStream the input stream for the deployment package @param request the original request, in case you want to access certain parameters @param response the response to write to
• org.apache.axis.client.AdminClient.process()
  host:8080/axis/servlet/AxisServlet.

  @param args Commands to process @return XML result or null in case of failure. In the case of multiplecommands, the XML results will be concatenated, separated by \n @exception Exception Could be an IO exception, an AxisFault or something else
• org.apache.axis2.corba.idl.IDLProcessor.process()
• org.apache.axis2.jaxws.sample.dlwmin.sei.Greeter.process()
• org.apache.beehive.netui.compiler.processor.PageFlowAnnotationProcessor.process()
• org.apache.blur.manager.writer.BlurIndex.process()
• org.apache.blur.thirdparty.thrift_0_9_0.TProcessor.process()
• org.apache.camel.AsyncProcessor.process()
  Processes the message exchange. Similar to {@link Processor#process}, but the caller supports having the exchange asynchronously processed. @param exchange the {@link Exchange} to process @param callback the {@link AsyncCallback} will be invoked when the processingof the exchange is completed. If the exchange is completed synchronously, then the callback is also invoked synchronously. The callback should therefore be careful of starting recursive loop. @return true if the processing was completed synchronously.
• org.apache.camel.Processor.process()
  Processes the message exchange @throws Exception if an internal processing error has occurred.
• org.apache.camel.Producer.process()
• org.apache.camel.component.bean.BeanProcessor.process()
• org.apache.camel.component.cxf.transport.CamelDestination.ConsumerProcessor.process()
• org.apache.camel.processor.MarshalProcessor.process()
• org.apache.camel.processor.MulticastProcessor.process()
• org.apache.camel.processor.Pipeline.process()
• org.apache.camel.processor.SendProcessor.process()
• org.apache.camel.processor.UnitOfWorkProducer.process()
• org.apache.camel.processor.UnmarshalProcessor.process()
• org.apache.camel.processor.aggregate.AggregateProcessor.process()
• org.apache.camel.processor.loadbalancer.LoadBalancer.process()
• org.apache.catalina.tribes.tcp.nio.NioSender.process()
  State machine to send data @param key SelectionKey @return boolean @throws IOException
• org.apache.catalina.tribes.transport.nio.NioSender.process()
  State machine to send data @param key SelectionKey @return boolean @throws IOException
• org.apache.catalina.util.ssi.SsiCommand.process()
  Process this request, used if isPrintable() returns false @param strParamType The type of parameter @param strParam The value of the parameter
• org.apache.cocoon.Cocoon.process()
  Process the given Environment to produce the output. @param environment an Environment value @return a boolean value @exception Exception if an error occurs
• org.apache.cocoon.Processor.process()
  Process the given Environment producing the output. @return If the processing is successfull true is returned.If not match is found in the sitemap false is returned. @throws ResourceNotFoundException If a sitemap component triesto access a resource which can not be found, e.g. the generator ConnectionResetException If the connection was reset
• org.apache.cocoon.bean.CocoonBean.process()
• org.apache.cocoon.components.pipeline.ProcessingPipeline.process()
  Process the given Environment, producing the output.
• org.apache.cocoon.components.pipeline.StreamPipeline.process()
  Process the given Environment producing the output
• org.apache.cocoon.components.treeprocessor.TreeProcessor.process()
  Process the given Environment producing the output. @return If the processing is successfull true is returned.If not match is found in the sitemap false is returned. @throws ResourceNotFoundException If a sitemap component triesto access a resource which can not be found, e.g. the generator ConnectionResetException If the connection was reset
• org.apache.cocoon.components.xpointer.XPointer.process()
• org.apache.cocoon.forms.formmodel.Form.process()
  Processes a form submit. If the form is finished, i.e. the form should not be redisplayed to the user, then this method returns true, otherwise it returns false. To know if the form was sucessfully validated, use the {@link #isValid()} method.

  Form processing consists in multiple steps:

  • all widgets read their value from the request (i.e. {@link #readFromRequest(FormContext)} is called recursively onthe whole widget tree)
  • if there is an action event, call the FormHandler
  • perform validation.

  This processing can be interrupted by the widgets (or their event listeners) by calling {@link #endProcessing(boolean)}.
• org.apache.cocoon.portal.PortalManager.process()
• org.apache.cocoon.portal.event.aspect.EventAspect.process()
• org.apache.cocoon.treeprocessor.TreeProcessor.process()
• org.apache.cocoon.woody.formmodel.Form.process()
  Processes a form submit. If the form is finished, i.e. the form should not be redisplayed to the user, then this method returns true, otherwise it returns false. To know if the form was sucessfully validated, use the {@link #isValid()} method.

  Form processing consists in multiple steps:

  • all widgets read their value from the request (i.e. {@link #readFromRequest(FormContext)} is called recursively onthe whole widget tree)
  • if there is an action event, call the FormHandler
  • perform validation.

  This processing can be interrupted by the widgets (or their event listeners) by calling {@link #endProcessing(boolean)}.
• org.apache.commons.cli2.Argument.process()
• org.apache.commons.cli2.Option.process()
  Processes String arguments into a CommandLine. The iterator will initially point at the first argument to be processed and at the end of the method should point to the first argument not processed. This method MUST process at least one argument from the ListIterator. @param commandLine The CommandLine object to store results in @param args The arguments to process @throws OptionException if any problems occur
• org.apache.commons.scaffold.util.BizService.process()
• org.apache.commons.validator.ValidatorResources.process()
  Process the ValidatorResources object. Currently sets the FastHashMap s to the 'fast' mode and call the processes all other resources. Note : The framework calls this automatically when ValidatorResources is created from an XML file. If you create an instance of this class by hand you must call this method when finished.
• org.apache.coyote.memory.MemoryProtocolHandler.process()
  Process specified request.
• org.apache.ctakes.preprocessor.ClinicalNotePreProcessor.process()
• org.apache.ctakes.preprocessor.PreProcessor.process()
  Process a document to retrieve meta data about the document. @param document @return @throws Exception
• org.apache.cxf.tools.common.Processor.process()
• org.apache.cxf.tools.corba.processors.idl.IDLToWSDLProcessor.process()
• org.apache.cxf.tools.corba.processors.wsdl.WSDLToCorbaProcessor.process()
• org.apache.cxf.tools.java2js.processor.JavaToJSProcessor.process()
• org.apache.cxf.tools.java2wsdl.processor.JavaToWSDLProcessor.process()
• org.apache.cxf.tools.java2wsdl.processor.internal.ClassProcessor.process()
• org.apache.cxf.tools.java2wsdl.processor.internal.jaxws.ClassProcessor.process()
• org.apache.cxf.tools.misc.processor.WSDLToServiceProcessor.process()
• org.apache.cxf.tools.misc.processor.WSDLToSoapProcessor.process()
• org.apache.cxf.tools.misc.processor.WSDLToXMLProcessor.process()
• org.apache.cxf.tools.misc.processor.XSDToWSDLProcessor.process()
• org.apache.cxf.tools.wsdl2java.processor.WSDLToJavaProcessor.process()
• org.apache.cxf.tools.wsdl2java.processor.internal.PortTypeProcessor.process()
• org.apache.cxf.tools.wsdl2java.processor.internal.SEIAnnotationProcessor.process()
• org.apache.cxf.tools.wsdl2java.processor.internal.ServiceProcessor.process()
• org.apache.cxf.tools.wsdlto.frontend.jaxws.processor.internal.PortTypeProcessor.process()
• org.apache.cxf.tools.wsdlto.frontend.jaxws.processor.internal.ServiceProcessor.process()
• org.apache.felix.tool.mangen.BundleJar.process()
  Process the bundle JAR. Every class's package name will be added to the list of possible exports. Class files will be parsed, and the packages for all referenced classes contained within them will be added to the list of possible imports.
• org.apache.flume.Sink.process()

  Requests the sink to attempt to consume data from attached channel

  Note: This method should be consuming from the channel within the bounds of a Transaction. On successful delivery, the transaction should be committed, and on failure it should be rolled back. @return READY if 1 or more Events were successfully delivered, BACKOFF ifno data could be retrieved from the channel feeding this sink @throws EventDeliveryException In case of any kind of failure todeliver data to the next hop destination.

• org.apache.flume.sink.NullSink.process()
• org.apache.flume.sink.hbase.HBaseSink.process()
• org.apache.geronimo.gshell.clp.CommandLineProcessor.process()
• org.apache.hadoop.chukwa.database.Aggregator.process()
• org.apache.hadoop.chukwa.extraction.database.MetricDataLoader.process()
• org.apache.hadoop.chukwa.extraction.demux.processor.mapper.MapProcessor.process()
• org.apache.hadoop.chukwa.extraction.demux.processor.reducer.ReduceProcessor.process()
• org.apache.hadoop.contrib.index.lucene.ShardWriter.process()
  Process an intermediate form by carrying out, on the Lucene instance of the shard, the deletes and the inserts (a ram index) in the form. @param form the intermediate form containing deletes and a ram index @throws IOException
• org.apache.hadoop.gateway.filter.rewrite.impl.UrlRewriteStepProcessorHolder.process()
• org.apache.hadoop.hbase.master.handler.EnableTableHandler.process()
• org.apache.hadoop.hbase.master.handler.OpenedRegionHandler.process()
• org.apache.hadoop.hbase.master.handler.ServerShutdownHandler.process()
• org.apache.hadoop.hbase.master.handler.TruncateTableHandler.process()
• org.apache.helix.controller.stages.CompatibilityCheckStage.process()
• org.apache.helix.controller.stages.ResourceComputationStage.process()
• org.apache.hivemind.impl.InterceptorStackImpl.process()
  Invoked to process the next interceptor contribution; these should be processed in ascending order.
• org.apache.hivemind.impl.SchemaProcessorImpl.process()
  Processes a single extension. @param container the container object in that the parsed elements are placed
• org.apache.http.HttpRequestInterceptor.process()
  Processes a request. On the client side, this step is performed before the request is sent to the server. On the server side, this step is performed on incoming messages before the message body is evaluated. @param request the request to preprocess @param context the context for the request @throws IOException in case of an IO problem @throws HttpException in case of a protocol or other problem
• org.apache.http.HttpResponseInterceptor.process()
  Processes a response. On the server side, this step is performed before the response is sent to the client. On the client side, this step is performed on incoming messages before the message body is evaluated. @param response the response to postprocess @param context the context for the request @throws IOException in case of an IO problem @throws HttpException in case of a protocol or other problem
• org.apache.http.protocol.HttpProcessor.process()
• org.apache.isis.core.metamodel.facets.FacetFactory.process()
  Process the class, and return the correctly setup annotation if present.
• org.apache.isis.core.metamodel.facets.actions.defaults.method.ActionDefaultsFacetViaMethodFactory.process()
• org.apache.isis.core.metamodel.facets.actions.interaction.ActionInteractionFacetFactory.process()
• org.apache.isis.core.metamodel.facets.actions.validate.method.ActionValidationFacetViaMethodFactory.process()
• org.apache.isis.core.metamodel.facets.collections.accessor.CollectionAccessorFacetViaAccessorFactory.process()
• org.apache.isis.core.metamodel.facets.collections.clear.CollectionClearFacetFactory.process()
• org.apache.isis.core.metamodel.facets.collections.notpersisted.annotation.NotPersistedFacetOnCollectionAnnotationFactory.process()
• org.apache.isis.core.metamodel.facets.members.cssclass.annotprop.CssClassFacetOnMemberFactory.process()
• org.apache.isis.core.metamodel.facets.members.cssclassfa.annotprop.CssClassFaFacetOnMemberFactory.process()
• org.apache.isis.core.metamodel.facets.members.describedas.annotprop.DescribedAsFacetOnMemberFactory.process()
• org.apache.isis.core.metamodel.facets.members.describedas.staticmethod.DescribedAsFacetStaticMethodFactory.process()
• org.apache.isis.core.metamodel.facets.members.disabled.forsession.DisableForSessionFacetViaMethodFactory.process()
• org.apache.isis.core.metamodel.facets.members.disabled.method.DisableForContextFacetViaMethodFactory.process()
• org.apache.isis.core.metamodel.facets.members.disabled.staticmethod.DisabledFacetStaticMethodFacetFactory.process()
• org.apache.isis.core.metamodel.facets.members.hidden.forsession.HideForSessionFacetViaMethodFactory.process()
• org.apache.isis.core.metamodel.facets.members.hidden.method.HideForContextFacetViaMethodFactory.process()
• org.apache.isis.core.metamodel.facets.members.hidden.staticmethod.HiddenFacetStaticMethodFactory.process()
• org.apache.isis.core.metamodel.facets.members.named.annotprop.NamedFacetOnMemberFactory.process()
• org.apache.isis.core.metamodel.facets.members.named.staticmethod.NamedFacetStaticMethodFactory.process()
• org.apache.isis.core.metamodel.facets.object.cssclass.annotation.CssClassFacetOnTypeAnnotationFactory.process()
• org.apache.isis.core.metamodel.facets.object.cssclassfa.annotation.annotation.CssClassFaFacetOnTypeAnnotationFactory.process()
• org.apache.isis.core.metamodel.facets.object.describedas.annotation.DescribedAsFacetOnTypeAnnotationFactory.process()
• org.apache.isis.core.metamodel.facets.object.mask.annotation.MaskFacetOnTypeAnnotationFactory.process()
  In readiness for supporting @Value in the future.
• org.apache.isis.core.metamodel.facets.object.multiline.annotation.MultiLineFacetOnTypeAnnotationFactory.process()
  In readiness for supporting @Value in the future.
• org.apache.isis.core.metamodel.facets.object.named.annotation.NamedFacetOnTypeAnnotationFactory.process()
• org.apache.isis.core.metamodel.facets.object.regex.annotation.RegExFacetOnTypeAnnotationFactory.process()
• org.apache.isis.core.metamodel.facets.param.autocomplete.method.ActionParameterAutoCompleteFacetViaMethodFactory.process()
• org.apache.isis.core.metamodel.facets.param.choices.method.ActionChoicesFacetViaMethodFactory.process()
• org.apache.isis.core.metamodel.facets.param.choices.methodnum.ActionParameterChoicesFacetViaMethodFactory.process()
• org.apache.isis.core.metamodel.facets.param.defaults.methodnum.ActionParameterDefaultsFacetViaMethodFactory.process()
• org.apache.isis.core.metamodel.facets.param.validating.regexannot.RegExFacetFacetOnParameterAnnotationFactory.process()
• org.apache.isis.core.metamodel.facets.properties.accessor.PropertyAccessorFacetViaAccessorFactory.process()
• org.apache.isis.core.metamodel.facets.properties.autocomplete.method.PropertyAutoCompleteFacetMethodFactory.process()
• org.apache.isis.core.metamodel.facets.properties.bigdecimal.javaxvaldigits.BigDecimalFacetOnPropertyFromJavaxValidationDigitsAnnotationFactory.process()
• org.apache.isis.core.metamodel.facets.properties.choices.method.PropertyChoicesFacetViaMethodFactory.process()
• org.apache.isis.core.metamodel.facets.properties.defaults.method.PropertyDefaultFacetViaMethodFactory.process()
• org.apache.isis.core.metamodel.facets.properties.disabled.inferred.DisabledFacetOnPropertyInferredFactory.process()
• org.apache.isis.core.metamodel.facets.properties.labelat.annotation.LabelAtFacetOnPropertyFactory.process()
• org.apache.isis.core.metamodel.facets.properties.mandatory.annotation.mandatory.MandatoryFacetOnPropertyMandatoryAnnotationFactory.process()
• org.apache.isis.core.metamodel.facets.properties.mandatory.annotation.optional.MandatoryFacetOnPropertyInvertedByOptionalAnnotationFactory.process()
• org.apache.isis.core.metamodel.facets.properties.multiline.annotation.MultiLineFacetOnPropertyFactory.process()
• org.apache.isis.core.metamodel.facets.properties.notpersisted.annotation.NotPersistedFacetOnPropertyAnnotationFactory.process()
• org.apache.isis.core.metamodel.facets.properties.renderedasdaybefore.annotation.RenderedAsDayBeforeAnnotationOnPropertyFacetFactory.process()
• org.apache.isis.core.metamodel.facets.properties.typicallen.annotation.TypicalLengthOnPropertyFacetFactory.process()
• org.apache.isis.core.metamodel.facets.properties.update.PropertyModifyFacetFactory.process()
• org.apache.isis.core.metamodel.facets.properties.update.PropertySetAndClearFacetFactory.process()
• org.apache.isis.core.metamodel.facets.properties.validating.maskannot.MaskFacetOnPropertyAnnotationFactory.process()
  In readiness for supporting @Value in the future.
• org.apache.isis.core.metamodel.facets.properties.validating.method.PropertyValidateFacetViaMethodFactory.process()
• org.apache.isis.core.metamodel.facets.properties.validating.mustsatisfyspec.MustSatisfySpecificationOnPropertyFacetFactory.process()
• org.apache.isis.core.metamodel.facets.properties.validating.regexannot.RegExFacetFacetOnPropertyAnnotationFactory.process()
• org.apache.isis.core.progmodel.facets.actions.defaults.method.ActionDefaultsFacetFactory.process()
• org.apache.isis.core.progmodel.facets.actions.invoke.ActionInvocationFacetFactory.process()
• org.apache.isis.core.progmodel.facets.actions.validate.method.ActionValidationFacetViaValidateMethodFacetFactory.process()
• org.apache.isis.core.progmodel.facets.collections.accessor.CollectionAccessorFacetFactory.process()
• org.apache.isis.core.progmodel.facets.collections.clear.CollectionClearFacetFactory.process()
• org.apache.isis.core.progmodel.facets.collections.modify.CollectionAddRemoveAndValidateFacetFactory.process()
• org.apache.isis.core.progmodel.facets.collections.notpersisted.annotation.NotPersistedAnnotationForCollectionFacetFactory.process()
• org.apache.isis.core.progmodel.facets.members.describedas.annotation.DescribedAsAnnotationOnMemberFacetFactory.process()
• org.apache.isis.core.progmodel.facets.members.describedas.annotation.DescribedAsOnMemberFacetFactory.process()
• org.apache.isis.core.progmodel.facets.members.describedas.staticmethod.DescribedAsFacetViaDescriptionMethodFacetFactory.process()
• org.apache.isis.core.progmodel.facets.members.disable.forsession.DisabledFacetViaDisableForSessionMethodFacetFactory.process()
• org.apache.isis.core.progmodel.facets.members.disable.method.DisabledFacetViaDisableMethodFacetFactory.process()
• org.apache.isis.core.progmodel.facets.members.disable.staticmethod.DisabledFacetViaProtectMethodFacetFactory.process()
• org.apache.isis.core.progmodel.facets.members.disabled.forsession.DisabledFacetViaDisableForSessionMethodFacetFactory.process()
• org.apache.isis.core.progmodel.facets.members.disabled.method.DisabledFacetViaDisableMethodFacetFactory.process()
• org.apache.isis.core.progmodel.facets.members.disabled.staticmethod.DisabledFacetViaProtectMethodFacetFactory.process()
• org.apache.isis.core.progmodel.facets.members.hidden.forsession.HiddenFacetViaHideForSessionMethodFacetFactory.process()
• org.apache.isis.core.progmodel.facets.members.hidden.method.HiddenFacetViaHideMethodFacetFactory.process()
• org.apache.isis.core.progmodel.facets.members.hidden.staticmethod.HiddenFacetViaAlwaysHideMethodFacetFactory.process()
• org.apache.isis.core.progmodel.facets.members.hide.forsession.HiddenFacetViaHideForSessionMethodFacetFactory.process()
• org.apache.isis.core.progmodel.facets.members.hide.method.HiddenFacetViaHideMethodFacetFactory.process()
• org.apache.isis.core.progmodel.facets.members.hide.staticmethod.HiddenFacetViaAlwaysHideMethodFacetFactory.process()
• org.apache.isis.core.progmodel.facets.members.named.annotation.NamedAnnotationOnMemberFacetFactory.process()
• org.apache.isis.core.progmodel.facets.members.named.annotation.NamedOnMemberFacetFactory.process()
• org.apache.isis.core.progmodel.facets.members.named.staticmethod.NamedFacetViaNameMethodFacetFactory.process()
• org.apache.isis.core.progmodel.facets.object.describedas.annotation.DescribedAsAnnotationOnTypeFacetFactory.process()
• org.apache.isis.core.progmodel.facets.object.mask.annotation.MaskAnnotationForTypeFacetFactory.process()
  In readiness for supporting @Value in the future.
• org.apache.isis.core.progmodel.facets.object.multiline.annotation.MultiLineAnnotationOnTypeFacetFactory.process()
  In readiness for supporting @Value in the future.
• org.apache.isis.core.progmodel.facets.object.named.annotation.NamedAnnotationOnTypeFacetFactory.process()
• org.apache.isis.core.progmodel.facets.object.regex.annotation.RegExFacetAnnotationForTypeFacetFactory.process()
• org.apache.isis.core.progmodel.facets.param.autocomplete.ActionParameterAutoCompleteFacetFactory.process()
• org.apache.isis.core.progmodel.facets.param.choices.method.ActionChoicesFacetFactory.process()
• org.apache.isis.core.progmodel.facets.param.choices.methodnum.ActionParameterChoicesFacetFactory.process()
• org.apache.isis.core.progmodel.facets.param.defaults.methodnum.ActionParameterDefaultsFacetFactory.process()
• org.apache.isis.core.progmodel.facets.param.validate.regexannot.RegExFacetAnnotationForParameterFacetFactory.process()
• org.apache.isis.core.progmodel.facets.properties.accessor.PropertyAccessorFacetFactory.process()
• org.apache.isis.core.progmodel.facets.properties.autocomplete.PropertyAutoCompleteFacetFactory.process()
• org.apache.isis.core.progmodel.facets.properties.choices.method.PropertyChoicesFacetFactory.process()
• org.apache.isis.core.progmodel.facets.properties.defaults.method.PropertyDefaultFacetFactory.process()
• org.apache.isis.core.progmodel.facets.properties.javaxvaldigits.BigDecimalForPropertyDerivedFromJavaxValidationDigitsFacetFactory.process()
• org.apache.isis.core.progmodel.facets.properties.mandatory.annotation.MandatoryAnnotationForPropertyFacetFactory.process()
• org.apache.isis.core.progmodel.facets.properties.mandatory.annotation.OptionalAnnotationForPropertyFacetFactory.process()
• org.apache.isis.core.progmodel.facets.properties.modify.PropertyModifyFacetFactory.process()
• org.apache.isis.core.progmodel.facets.properties.modify.PropertySetAndClearFacetFactory.process()
• org.apache.isis.core.progmodel.facets.properties.multiline.annotation.MultiLineAnnotationOnPropertyFacetFactory.process()
• org.apache.isis.core.progmodel.facets.properties.multiline.annotation.MultiLineOnPropertyFacetFactory.process()
• org.apache.isis.core.progmodel.facets.properties.notpersisted.annotation.NotPersistedAnnotationForPropertyFacetFactory.process()
• org.apache.isis.core.progmodel.facets.properties.renderedasdaybefore.annotation.RenderedAsDayBeforeAnnotationOnPropertyFacetFactory.process()
• org.apache.isis.core.progmodel.facets.properties.typicallen.annotation.TypicalLengthAnnotationOnPropertyFacetFactory.process()
• org.apache.isis.core.progmodel.facets.properties.typicallen.annotation.TypicalLengthOnPropertyFacetFactory.process()
• org.apache.isis.core.progmodel.facets.properties.validate.PropertyValidateFacetFactory.process()
• org.apache.isis.core.progmodel.facets.properties.validate.maskannot.MaskAnnotationForPropertyFacetFactory.process()
  In readiness for supporting @Value in the future.
• org.apache.isis.core.progmodel.facets.properties.validate.perspec.MustSatisfySpecificationOnPropertyFacetFactory.process()
• org.apache.isis.core.progmodel.facets.properties.validate.regexannot.RegExFacetAnnotationForPropertyFacetFactory.process()
• org.apache.jackrabbit.core.cluster.ClusterRecord.process()
  Process this record, calling the appropriate process method. @param processor processor
• org.apache.james.imapserver.commands.ImapCommand.process()
• org.apache.jetspeed.aggregator.impl.WorkerMonitorImpl.process()
  Assign a job to a worker and execute it or queue the job if no worker is available. @param job the Job to process
• org.apache.jmeter.processor.PostProcessor.process()
  Provides the PostProcessor with a SampleResult object from which to extract values for use in future Queries.
• org.apache.jmeter.processor.PreProcessor.process()
• org.apache.lucene.queryParser.core.processors.QueryNodeProcessor.process()
  Processes a query node tree. It may return the same or another query tree. I should never return null. @param queryTree tree root node @return the processed query tree @throws QueryNodeException
• org.apache.lucene.queryParser.core.processors.QueryNodeProcessorPipeline.process()
  For reference about this method check: {@link QueryNodeProcessor#process(QueryNode)}. @param queryTree the query node tree to be processed @throws QueryNodeException if something goes wrong during the query nodeprocessing @see QueryNode
• org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessor.process()
  Processes a query node tree. It may return the same or another query tree. I should never return null. @param queryTree tree root node @return the processed query tree
• org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessorPipeline.process()
  For reference about this method check: {@link QueryNodeProcessor#process(QueryNode)}. @param queryTree the query node tree to be processed @throws QueryNodeException if something goes wrong during the query nodeprocessing @see QueryNode
• org.apache.maven.jxr.pacman.PackageManager.process()
  Description of the Method
• org.apache.muse.ws.notification.NotificationMessageListener.process()
  This method is invoked ('fired') by the WS-N implementation whenever a message is received that matches the criteria (accepts()) of the listener. @param message
• org.apache.oozie.dependency.hcat.HCatMessageHandler.process()
  Process JMS message produced by HCat. @param msg : to be processed
• org.apache.pdfbox.contentstream.operator.OperatorProcessor.process()
  Process the operator. @param operator the operator to process @param operands the operands to use when processing @throws IOException if the operator cannot be processed
• org.apache.pdfbox.util.operator.OperatorProcessor.process()
  process the operator. @param operator The operator that is being processed. @param arguments arguments needed by this operator. @throws IOException If there is an error processing the operator.
• org.apache.qpid.management.domain.handler.base.IMessageHandler.process()
  Processes the (incoming) stream message. Note that the main controller (the component that is controlling this handler) has already read the magic number and the sequence number so here concrete implementors must start from that point (that is, just after the sequence number). @param decoder the stream decoder. @param sequenceNumber the sequence number of the message.
• org.apache.qpid.proton.driver.Connector.process()
  Service the given connector. Handle any inbound data, outbound data, or timing events pending on the connector.
• org.apache.rampart.RampartEngine.process()
• org.apache.servicemix.jbi.framework.support.EndpointProcessor.process()
  Post process the endpoint. @param serviceEndpoint the endpoint
• org.apache.shale.remoting.Processor.process()

  Process the current request, producing the corresponding response by whatever means is appropriate. The state of the current request can be derived by calling FacesContext.getCurrentInstance(). Typically, an implementation of this method will call the responseComplete() method on this FacesContext instance, to bypass the remainder of the standard JavaServer Faces request processing lifecycle.

  @param context FacesContext for the current request @param resourceId Resource identifier used to select the appropriate response(this will generally be a context relative path starting with "/") @exception IOException if an input/output error occurs @exception NullPointerException if resourceId is null
• org.apache.shindig.gadgets.templates.tags.TagHandler.process()
  Processes the custom tag. @param result A Node to append output to. @param tag The Element reference to the tag, useful for inspecting attributes and children @param processor A TemplateProcessor, used to evaluate expressions and rendersub-templates if needed.
• org.apache.slide.projector.Processor.process()
  Implement this method to provide the logic of the processor @param parameter a map containing the parameters for this process call.This values are typically simple values of type String or be resource references @return a array of results @throws Exception
• org.apache.sling.junit.TestObjectProcessor.process()
• org.apache.sling.replication.queue.ReplicationQueueProcessor.process()
  Process an item from a certain ReplicationQueue @param queueName the name of the ReplicationQueue to be processed @param replicationQueueItem the ReplicationQueueItem to be processed @return true if the item was successfully processed, false otherwise
• org.apache.solr.client.solrj.SolrRequest.process()
• org.apache.solr.client.solrj.request.ContentStreamUpdateRequest.process()
• org.apache.solr.client.solrj.request.DirectXmlRequest.process()
• org.apache.solr.client.solrj.request.LukeRequest.process()
• org.apache.solr.client.solrj.request.QueryRequest.process()
• org.apache.solr.client.solrj.request.SolrPing.process()
• org.apache.solr.client.solrj.request.UpdateRequest.process()
• org.apache.solr.handler.component.QueryComponent.process()
  Actually run the query
• org.apache.stanbol.commons.solr.utils.StreamQueryRequest.process()
• org.apache.stanbol.enhancer.engines.entitylinking.impl.EntityLinker.process()
  Steps over the sentences, chunks, tokens of the {@link #sentences}
• org.apache.stanbol.enhancer.engines.keywordextraction.impl.EntityLinker.process()
  Steps over the sentences, chunks, tokens of the {@link #sentences}
• org.apache.stanbol.enhancer.engines.keywordextraction.linking.EntityLinker.process()
  Steps over the sentences, chunks, tokens of the {@link #sentences}
• org.apache.stanbol.entityhub.indexing.core.EntityProcessor.process()
  Processes the source representation based on some processing rules. This interface is used by the {@link IndexerImpl} to process Entitiesretrieved from the Source before they are stored to the {@link Yard}. If a processor returns null for an parsed source than this Entity is not indexed - filtered. @param source the source @return the processed/mapped representation or null to filter(do not index) the parsed Representation
• org.apache.struts.action.RequestProcessor.process()

  Process an HttpServletRequest and create the corresponding HttpServletResponse or dispatch to another resource.

  @param request The servlet request we are processing @param response The servlet response we are creating @throws IOException if an input/output error occurs @throws ServletException if a processing exception occurs
• org.apache.synapse.Processor.process()
  This method is used to process a message. A response of true indicates continue processing. A response of false indicates to stop processing.
• org.apache.synapse.processors.InProcessor.process()
• org.apache.synapse.processors.StageProcessor.process()
• org.apache.synapse.processors.builtin.LogProcessor.process()
• org.apache.synapse.processors.builtin.axis2.AddressingInProcessor.process()
• org.apache.synapse.processors.builtin.xslt.XSLTProcessor.process()
• org.apache.synapse.processors.mediatortypes.ClassMediatorProcessor.process()
• org.apache.synapse.processors.mediatortypes.axis2.ServiceMediatorProcessor.process()
• org.apache.synapse.processors.rules.RegexProcessor.process()
• org.apache.synapse.processors.rules.XPathProcessor.process()
• org.apache.thrift.TProcessor.process()
• org.apache.tomcat.util.XMLParser.process()
• org.apache.torque.generator.control.TokenReplacer.process()
  Resolves all Tokens ${option:optionName} and replaces them with the appropriate value. @param toProcess the String to remove tokens from, or null.
• org.apache.torque.generator.processor.string.Camelbacker.process()
  Does the camelback processing according to the settings.
• org.apache.tuscany.spi.builder.WirePostProcessor.process()
  @param source @param target
• org.apache.tuscany.spi.builder.WirePostProcessorRegistry.process()
• org.apache.uima.adapter.jms.client.BaseUIMAAsynchronousEngine_impl.process()
• org.apache.uima.analysis_engine.AnalysisEngine.process()
  Invokes this AnalysisEngine's analysis logic. Prior to calling this method, the caller must ensure that the CAS has been populated with the artifact to be analyzed as well as any inputs required by this AnalysisEngine (as defined by this AnalysisEngine's {@link org.apache.uima.resource.metadata.Capability} specification.)

  This version of the process method takes a {@link ResultSpecification} as anargument. The ResultSpecification is alist of output types and features that the application wants this AnalysisEngine to produce. If you are going to use the same {@link ResultSpecification} for multiple calls to process, it is notrecommended to use this method. Instead call {@link #setResultSpecification(ResultSpecification)} once and then call {@link #process(CAS)}for each CAS that you want to process. @param aCAS the CAS containing the inputs to the processing. Analysis results will also be written to this CAS. @param aResultSpec a list of outputs that this AnalysisEngine should produce. @return an object containing information about which AnalysisEngine components have executedand information, such as timing, about that execution. @throws ResultNotSupportedException if this AnalysisEngine is not capable of producing the results requested in aResultSpec. @throws AnalysisEngineProcessException if a failure occurs during processing.

• org.apache.uima.analysis_engine.TextAnalysisEngine.process()
• org.apache.uima.collection.CollectionProcessingEngine.process()
  Initiates processing of a collection. This method starts the processing in another thread and returns immediately. Status of the processing can be obtained by registering a listener with the {@link #addStatusCallbackListener(StatusCallbackListener)} method.

  A CPE can only process one collection at a time. If this method is called while a previous processing request has not yet completed, a UIMA_IllegalStateException will result. To find out whether a CPE is free to begin another processing request, call the {@link #isProcessing()} method. @throws ResourceInitializationException if an error occurs during initialization @throws org.apache.uima.UIMA_IllegalStateException if this CPE is currently processing

• org.apache.uima.collection.CollectionProcessingManager.process()
  Initiates processing of a collection. CollectionReader initializes the CAS with Documents from the Colection. This method starts the processing in another thread and returns immediately. Status of the processing can be obtained by registering a listener with the {@link #addStatusCallbackListener(StatusCallbackListener)} method.

  A CPM can only process one collection at a time. If this method is called while a previous processing request has not yet completed, a UIMA_IllegalStateException will result. To find out whether a CPM is free to begin another processing request, call the {@link #isProcessing()} method. @param aCollectionReader the CollectionReader from which to obtain the Entities to be processed @throws ResourceInitializationException if an error occurs during initialization @throws org.apache.uima.UIMA_IllegalStateException if this CPM is currently processing

• org.apache.velocity.Template.process()
  gets the named resource as a stream, parses and inits @return true if successful @throws ResourceNotFoundException if template not foundfrom any available source. @throws ParseErrorException if template cannot be parsed dueto syntax (or other) error. @throws Exception some other problem, should only be frominitialization of the template AST.
• org.apache.velocity.runtime.resource.Resource.process()
  Perform any subsequent processing that might need to be done by a resource. In the case of a template the actual parsing of the input stream needs to be performed. @return Whether the resource could be processed successfully.For a {@link org.apache.velocity.Template} or {@link org.apache.velocity.runtime.resource.ContentResource}, this indicates whether the resource could be read. @exception ResourceNotFoundException Similar in semantics asreturning false.
• org.apache.wink.server.internal.application.ApplicationProcessor.process()
• org.apache.wookie.util.html.HtmlCleaner.process()
• org.apache.wookie.util.html.IHtmlProcessor.process()
  Processes the HTML and writes the output to the specified writer @throws IOException if the file cannot be processed or written
• org.apache.xalan.xslt.StylesheetRoot.process()
  Transform the source tree to the output in the given result tree target. @param inputSource The input source tree. @param outputTarget The output source tree. @exception XSLProcessorException thrown if the active ProblemListener and XMLParserLiaison decide the error condition is severe enough to halt processing.
• org.apache.xalan.xslt.XSLTProcessor.process()
  Use the XSL stylesheet to transform the XML source document, placing the result in the result tree. @param xmlSource The XML source document to be transformed. @param xslStylesheet The XSL stylesheet to be used for the transformation. May be null if inputsource has an XSL stylesheet PI. @param resultTree The tree where the result of the transformation is placed. @exception XSLProcessorException thrown if the active ProblemListener and XMLParserLiaison decidethe error condition is severe enough to halt processing.
• org.apache.yoko.tools.processors.idl.IDLToWSDLProcessor.process()
• org.apache.yoko.tools.processors.wsdl.WSDLToCorbaProcessor.process()
• org.apache.zookeeper.Watcher.process()
• org.aperteworkflow.scripting.ScriptProcessor.process()
• org.archive.modules.fetcher.FetchHTTP.process()
• org.archive.modules.recrawl.FetchHistoryProcessor.process()
• org.archive.modules.writer.WARCWriterProcessor.process()
• org.aspectj.asm.HierarchyWalker.process()
• org.axsl.ps.PsInterpreter.process()
  Parses and interprets the input. @throws PsInterpreterException For any PostScript error.
• org.beangle.commons.text.replacer.Replacer.process()
• org.camunda.bpm.engine.spring.annotations.State.process()
• org.candle.decompiler.ast.BlockVisitor.process()
• org.candle.decompiler.instruction.graph.InstructionGraphFactory.process()
• org.carrot2.core.Controller.process()
  Convenience method for performing processing with the provided query and number of results. The typical use cases for this method is fetching the specified number of results from an {@link IDocumentSource} and, optionally, clustering them with an{@link IClusteringAlgorithm}.

  For a method allowing to pass more attributes, see: {@link #process(Map,Class)}.

  @param query the query to use during processing @param results the number of results to fetch. If null is provided,the default number of results will be requested. @param processingComponentClasses classes of components to perform processing inthe order they should be arranged in the pipeline. Each provided class must implement {@link IProcessingComponent}. @return results of the processing
• org.cipango.sipapp.StandardDescriptorProcessor.process()
• org.codehaus.groovy.antlr.AntlrASTProcessSnippets.process()
  decorate antlr AST with ending line/col info, and if possible the snipppet of source from the start/end line/col for each node. @param t the AST to decorate @return the decorated AST
• org.codehaus.groovy.antlr.AntlrASTProcessor.process()
  performs some processing on the supplied AST node. @param t the AST node to process. @return possibly returns the AST modified or null, depends on the implementation.
• org.codehaus.groovy.antlr.treewalker.PreOrderTraversal.process()
• org.codehaus.plexus.configuration.processor.ConfigurationProcessor.process()
• org.cometd.annotation.ServerAnnotationProcessor.process()
  Processes dependencies annotated with {@link Inject} and {@link Session}, lifecycle methods annotated with {@link PostConstruct}, and callback methods annotated with {@link Listener}and {@link Subscription}. @param bean the annotated service instance @return true if the bean contains at least one annotation that has been processed, false otherwise
• org.concordion.Concordion.process()
• org.corrib.s3b.mbb.beans.KeywordQueryFilter.process()
  @return a processed version of the value definitions
• org.corrib.s3b.mbb.beans.ValueFilter.process()
  @return a processed version of the value definitions
• org.corrib.s3b.mbb.db.rdf.GraphStatistics.process()
  Processes associated graph @param skipGraph @param skipLabels @param skipTypes
• org.datanucleus.state.RelationshipManager.process()
  Method to process the (bidirectional) relations for this object.
• org.docx4j.model.datastorage.OpenDoPEIntegrity.process()
• org.dspace.checker.CheckerCommand.process()

  Uses the options set up on this checker to determine a mode of execution, and then accepts bitstream ids from the dispatcher and checks their bitstreams against the db records.

  N.B. a valid BitstreamDispatcher must be provided using setBitstreamDispatcher before calling this method

• org.eclipse.ecf.protocol.msn.internal.encode.ResponseCommand.process()
  Process the given line. It will store the first three characters as the command and the rest of the line will be split by a single space and stored as a String array. If line is null, both the command and the String array will store null pointers. @param line the line to be processed
• org.eclipse.jetty.http2.IStream.process()
• org.eclipse.orion.server.cf.manifest.v2.Preprocessor.process()
  Processes the raw input into a list of significant input lines ready to be processed by the {@link Tokenizer}. @param inputStream The input stream. @return List of significant input lines.
• org.eclipse.orion.server.cf.manifest.v2.utils.ManifestPreprocessor.process()
• org.eclipse.persistence.internal.jpa.metadata.accessors.classes.EmbeddableAccessor.process()
  INTERNAL: Process the items of interest on an embeddable class.
• org.eclipse.persistence.internal.jpa.metadata.accessors.classes.InterfaceAccessor.process()
  INTERNAL:
• org.eclipse.persistence.internal.jpa.metadata.converters.AbstractConverterMetadata.process()
  INTERNAL: Every converter needs to be able to process themselves.
• org.eclipse.persistence.internal.jpa.metadata.listeners.EntityListenerMetadata.process()
  INTERNAL:
• org.eclipse.persistence.internal.jpa.metadata.mappings.MapKeyMetadata.process()
  INTERNAL: Process a map key for a 1-M or M-M mapping. Will return the map key method name that should be use, null otherwise.
• org.eclipse.persistence.internal.jpa.metadata.queries.ComplexTypeMetadata.process()
  Build a runtime type from the meta-data.
• org.eclipse.persistence.internal.jpa.metadata.queries.PLSQLComplexTypeMetadata.process()
  Build a runtime type from the meta-data.
• org.eclipse.persistence.internal.jpa.metadata.sequencing.TableGeneratorMetadata.process()
  INTERNAL:
• org.ejbca.core.protocol.ocsp.IOCSPExtension.process()
  Called by OCSP responder when the configured extension is found in the request. @param request HttpServletRequest that can be used to find out information about caller, TLS certificate etc. @param cert X509Certificate the caller asked for in the OCSP request @return Hashtable with X509Extensions that will be added to responseExtensions by OCSP responder, or null if an error occurs
• org.elasticsearch.action.admin.cluster.node.info.NodesInfoRequest.process()
  Should the node Process be returned.
• org.elasticsearch.action.admin.cluster.node.stats.NodesStatsRequest.process()
  Should the node Process be returned.
• org.elasticsearch.action.index.IndexRequest.process()
• org.emrys.webosgi.core.resource.extension.IUploadFileReciever.process()
  Each Feature Update Site including features and bundles will be received and restored into a folder with name like ${site-name}/${version-obtained-from version.text file under site folder}/. Ant he existing version folder will be replaced fully. If not version.txt file found, the contents of received site folder will be stored in a folder named "current" and this will always replace the existing folder.Not use IUploadFileReceiver.interested() method to judge whether the receiver support the uploaded file. In process method, if the receiver not support ,return false directly. @param response @param params @param files @return processed, other receiver may need to process also.
• org.encog.app.analyst.analyze.PerformAnalysis.process()
  Perform the analysis. @param target The Encog analyst object to analyze.
• org.encog.app.analyst.csv.AnalystClusterCSV.process()
  Process the file and cluster. @param outputFile The output file. @param clusters The number of clusters. @param theAnalyst The analyst to use. @param iterations The number of iterations to use.
• org.encog.app.analyst.csv.AnalystEvaluateCSV.process()
  Process the file. @param outputFile The output file. @param method THe method to use.
• org.encog.app.analyst.csv.AnalystEvaluateRawCSV.process()
  Process the file. @param outputFile The output file. @param method The method to use.
• org.encog.app.analyst.csv.TimeSeriesUtil.process()
  Process a row. @param input The input. @return The output.
• org.encog.app.analyst.csv.balance.BalanceCSV.process()
  Process and balance the data. @param outputFile The output file to write data to. @param targetField The field that is being balanced, this field determines the classes. @param countPer The desired count per class.
• org.encog.app.analyst.csv.filter.FilterCSV.process()
  Process the input file. @param outputFile The output file to write to.
• org.encog.app.analyst.csv.process.AnalystProcess.process()
  Process, and generate the output file. @param outputFile The output file.
• org.encog.app.analyst.csv.segregate.SegregateCSV.process()
  Process the input file and segregate into the output files.
• org.encog.app.analyst.csv.shuffle.ShuffleCSV.process()
  Process, and generate the output file. @param outputFile The output file.
• org.encog.app.analyst.csv.sort.SortCSV.process()
  Process, and sort the files. @param inputFile The input file. @param outputFile The output file. @param headers True, if headers are to be used. @param format The format of the file.
• org.encog.app.quant.indicators.ProcessIndicators.process()
  Process and write the specified output file. @param output The output file.
• org.encog.app.quant.ninja.NinjaFileConvert.process()
  Process the file and output to the target file. @param target The target file to write to.
• org.encog.ml.data.cross.KFoldCrossvalidation.process()
• org.encog.ml.ea.score.parallel.ParallelScore.process()
  Calculate the scores.
• org.encog.util.arrayutil.NormalizeArray.process()
  Normalize the array. Return the new normalized array. @param inputArray The input array. @return The normalized array.
• org.encog.util.arrayutil.TemporalWindowArray.process()
  Process the array. @param data The array to process. @return A neural data set that contains the time-series.
• org.encog.util.benchmark.EncogBenchmark.process()
  Perform the benchmark. Returns the total amount of time for all of the benchmarks. Returns the final score. The lower the better for a score. @return The total time, which is the final Encog benchmark score.
• org.encog.util.normalize.DataNormalization.process()
  Call this method to begin the normalization process. Any status updates will be sent to the class specified in the constructor.
• org.encog.workbench.dialogs.EvaluateDialog.process()
• org.encog.workbench.dialogs.ImportExportDialog.process()
• org.encog.workbench.dialogs.RandomizeNetworkDialog.process()
• org.encog.workbench.dialogs.SaveImageDialog.process()
• org.encog.workbench.dialogs.activation.ActivationDialog.process()
• org.encog.workbench.dialogs.binary.DialogBinary2External.process()
• org.encog.workbench.dialogs.binary.DialogCSV.process()
• org.encog.workbench.dialogs.binary.DialogExternal2Binary.process()
• org.encog.workbench.dialogs.config.EncogConfigDialog.process()
• org.encog.workbench.dialogs.createfile.CreateFileDialog.process()
• org.encog.workbench.dialogs.createnetwork.CreateADALINEDialog.process()
• org.encog.workbench.dialogs.createnetwork.CreateART1.process()
• org.encog.workbench.dialogs.createnetwork.CreateAutomatic.process()
• org.encog.workbench.dialogs.createnetwork.CreateBAMDialog.process()
• org.encog.workbench.dialogs.createnetwork.CreateBlotzmannDialog.process()
• org.encog.workbench.dialogs.createnetwork.CreateCPNDialog.process()
• org.encog.workbench.dialogs.createnetwork.CreateElmanDialog.process()
• org.encog.workbench.dialogs.createnetwork.CreateFeedforward.process()
• org.encog.workbench.dialogs.createnetwork.CreateHopfieldDialog.process()
• org.encog.workbench.dialogs.createnetwork.CreateJordanDialog.process()
• org.encog.workbench.dialogs.createnetwork.CreateNeuralNetworkDialog.process()
• org.encog.workbench.dialogs.createnetwork.CreatePNN.process()
• org.encog.workbench.dialogs.createnetwork.CreateRBFDialog.process()
• org.encog.workbench.dialogs.createnetwork.CreateSOMDialog.process()
• org.encog.workbench.dialogs.createnetwork.CreateSVMDialog.process()
• org.encog.workbench.dialogs.newdoc.CreateNewDocument.process()
• org.encog.workbench.dialogs.population.EditNEATPopulationDialog.process()
• org.encog.workbench.dialogs.population.ExtractGenomes.process()
• org.encog.workbench.dialogs.population.NewPopulationDialog.process()
• org.encog.workbench.dialogs.splash.EncogWorkbenchSplash.process()
• org.encog.workbench.dialogs.training.ChooseBasicNetworkTrainingMethod.process()
• org.encog.workbench.dialogs.training.TrainDialog.process()
• org.encog.workbench.dialogs.training.methods.InputADALINE.process()
• org.encog.workbench.dialogs.training.methods.InputAnneal.process()
• org.encog.workbench.dialogs.training.methods.InputBackpropagation.process()
• org.encog.workbench.dialogs.training.methods.InputGenetic.process()
• org.encog.workbench.dialogs.training.methods.InputInstar.process()
• org.encog.workbench.dialogs.training.methods.InputLMA.process()
• org.encog.workbench.dialogs.training.methods.InputManhattan.process()
• org.encog.workbench.dialogs.training.methods.InputNEAT.process()
• org.encog.workbench.dialogs.training.methods.InputOutstar.process()
• org.encog.workbench.dialogs.training.methods.InputQPROP.process()
• org.encog.workbench.dialogs.training.methods.InputResilient.process()
• org.encog.workbench.dialogs.training.methods.InputSCG.process()
• org.encog.workbench.dialogs.training.methods.InputSOM.process()
• org.encog.workbench.dialogs.training.methods.InputSVM.process()
• org.encog.workbench.dialogs.training.methods.InputSearchSVM.process()
• org.encog.workbench.dialogs.trainingdata.CreateEmptyTrainingDialog.process()
• org.encog.workbench.dialogs.trainingdata.CreateMarketTrainingDialog.process()
• org.encog.workbench.dialogs.trainingdata.CreateTrainingDataDialog.process()
• org.encog.workbench.dialogs.trainingdata.RandomTrainingDataDialog.process()
• org.encog.workbench.dialogs.validate.InputValidationChart.process()
• org.encog.workbench.dialogs.visualize.scatter.ScatterChooseClass.process()
• org.encog.workbench.dialogs.wizard.analyst.AnalystWizardDialog.process()
• org.evolizer.famix.importer.unresolved.UnresolvedInvocationHandler.process()
  Processes all unresolved calls to determine potential callee methods from the set of unresolved method declarations. These are method declarations within the source code that could not be resolved (i.e., a parameter type could not be resolved). @param monitor Instance of the progress monitor @return Status OK, if no errors have been encountered
• org.exist.atom.AtomModule.process()
• org.fcrepo.client.batch.BatchTool.process()
• org.fenixedu.academic.domain.accounting.Event.process()
• org.fenixedu.academic.domain.accounting.PaymentCode.process()
• org.fenixedu.academic.domain.phd.debts.ExternalScholarshipPhdGratuityContribuitionEvent.process()
• org.fenixedu.academic.domain.serviceRequests.RegistrationAcademicServiceRequest.process()
• org.fenixedu.academic.ui.struts.action.teacher.siteArchive.Fetcher.process()
  Processes the current queue retrieving all resources and saving them in the archive.
• org.foray.core.FOraySession.process()
  Iterates through the collection of FOrayDocuments to be processed, and processes each one. @throws FOrayException For errors during document processing.
• org.foray.ps.PsInterpreter4a.process()
  {@inheritDoc}
• org.gatein.pc.controller.PortletController.process()
• org.gcontracts.common.spi.AnnotationProcessor.process()
• org.geotools.coverage.io.impl.DefaultFileDriver.process()
• org.gephi.filters.FilterProcessor.process()
• org.gephi.io.importer.api.ImportController.process()
• org.gephi.io.processor.plugin.DefaultProcessor.process()
• org.ggp.base.player.request.grammar.Request.process()
• org.glassfish.appclient.server.core.jws.servedcontent.StaticContent.process()
  Process the static content, adding the correct data to the response. @param relativeURIString URI path by which the content was addressed @param gReq the request @param gResp the response @throws Exception
• org.glassfish.jersey.server.internal.scanning.AnnotationAcceptingListener.process()
• org.hibernate.loader.custom.sql.SQLQueryReturnProcessor.process()
• org.impalaframework.module.TransitionProcessor.process()
• org.impalaframework.module.spi.TransitionProcessor.process()
• org.impalaframework.module.transition.TransitionProcessor.process()
• org.infinispan.persistence.spi.AdvancedCacheLoader.process()
  Iterates in parallel over the entries in the storage using the threads from the executor pool. For each entry the {@link CacheLoaderTask#processEntry(MarshalledEntry,TaskContext)} isinvoked. Before passing an entry to the callback task, the entry should be validated against the filter. Implementors should build an {@link TaskContext} instance (implementation) that is fed to the {@link CacheLoaderTask} on every invocation. The {@link CacheLoaderTask} might invoke {@link org.infinispan.persistence.spi.AdvancedCacheLoader.TaskContext#stop()} at any time, so implementors of this methodshould verify TaskContext's state for early termination of iteration. The method should only return once the iteration is complete or as soon as possible in the case TaskContext.stop() is invoked. @param filter to validate which entries should be feed into the task. Might be null. @param task callback to be invoked in parallel for each stored entry that passes the filter check @param executor an external thread pool to be used for parallel iteration @param fetchValue whether or not to fetch the value from the persistent store. E.g. if the iteration isintended only over the key set, no point fetching the values from the persistent store as well @param fetchMetadata whether or not to fetch the metadata from the persistent store. E.g. if the iteration isintended only ove the key set, then no pint fetching the metadata from the persistent store as well @throws PersistenceException in case of an error, e.g. communicating with the external storage
• org.intellij.erlang.debugger.node.events.ErlangDebuggerEvent.process()
• org.intellij.sonar.util.TemplateProcessor.process()
• org.itsnat.impl.core.req.norm.RequestNormalLoadDocAttachedServerImpl.process()
• org.itsnat.impl.core.servlet.DeserialPendingTask.process()
• org.iupac.goldbook.goldify.processors.DocumentProcessor.process()
• org.jasig.portal.tools.dbloader.DbLoader.process()
• org.jasig.portal.tools.dbloader.IDbLoader.process()
  Executes database loading based on the provided configuration
• org.jboss.aerogear.controller.mocks.RouteTester.process()
• org.jboss.aerogear.controller.router.rest.pagination.PagingStrategy.process()
  Process allows for manipulating the result of an endpoint target method invocation. @param result the result returned from the target endpoint method. @param routeContext the {@link RouteContext}. @return {@code Object} Either the unchanged result or a modified result depending on the underlying implementation.
• org.jboss.arquillian.container.test.spi.client.deployment.ApplicationArchiveProcessor.process()
  @param applicationArchive The user defined deployment archive @param testClass The users test class
• org.jboss.arquillian.spi.ApplicationArchiveProcessor.process()
  @param applicationArchive The user defined deployment archive @param testClass The users test class
• org.jboss.deployers.client.spi.DeployerClient.process()
  Process the outstanding deployments.
• org.jboss.deployers.client.spi.main.MainDeployer.process()
• org.jboss.deployers.plugins.main.MainDeployerImpl.process()
• org.jboss.deployers.spi.management.ManagementView.process()
  Process the changes made to the profile. @throws Exception
• org.jboss.dna.graph.request.processor.RequestProcessor.process()
  Process a request by determining the type of request and delegating to the appropriate process method for that type.

  This method does nothing if the request is null.

  @param request the general request
• org.jboss.dna.graph.requests.processor.RequestProcessor.process()
• org.jboss.dna.graph.search.SearchEngineProcessor.process()
• org.jboss.embedded.DeploymentGroup.process()
  Ask the mainDeployer to process the set of files you added to the group this will also check the processing @throws org.jboss.deployers.spi.DeploymentException
• org.jboss.forge.addon.templates.Template.process()
  Process the given model and return a {@link String} result containing {@link Template} output.
• org.jboss.forge.addon.templates.TemplateProcessor.process()
  Returns a {@link String}
• org.jboss.jca.codegenerator.SimpleTemplate.process()
  Processes the template @param varMap variable map @param out the writer to output the text to.
• org.jboss.jca.codegenerator.Template.process()
  Processes the template @param varMap variable map @param out the writer to output the text to.
• org.jboss.metadata.annotation.creator.DeclareRolesProcessor.process()
• org.jboss.metadata.annotation.creator.web.MultipartConfigProcessor.process()
• org.jboss.metadata.annotation.creator.web.RunAsProcessor.process()
• org.jboss.metadata.annotation.creator.web.ServletSecurityProcessor.process()
• org.jboss.metadata.annotation.creator.web.WebFilterProcessor.process()
• org.jboss.metadata.annotation.creator.web.WebListenerProcessor.process()
• org.jboss.metadata.annotation.creator.web.WebServletProcessor.process()
• org.jboss.profileservice.spi.managed.ManagedProfileDeployer.process()
• org.jboss.resteasy.client.jaxrs.internal.proxy.processors.InvocationProcessor.process()
• org.jboss.resteasy.client.jaxrs.internal.proxy.processors.WebTargetProcessor.process()
• org.jboss.resteasy.plugins.guice.ModuleProcessor.process()
• org.jboss.soa.esb.actions.ActionPipelineProcessor.process()
  Perform the action processing on the specified message. This method is invoked for each message passing throught the pipeline. @param message The current message being processed. @return The message to be passed to the next stage of the pipeline. @throws ActionProcessingException for errors during processing.
• org.jboss.soa.esb.actions.MessagePersister.process()
  Persists the message to the MessageStore. @return if this is a terminal action then null otherwise the originalinput message.
• org.jboss.soa.esb.actions.routing.http.HttpRouter.process()
• org.jboss.soa.esb.listeners.message.ActionProcessingPipeline.process()
  Process the specified message. @param message The current message. @return true if the processing was successful, false otherwise.
• org.jboss.test.deployers.managed.support.MockProfileService.process()
• org.jboss.test.microcontainer.support.deployers.IMainDeployer.process()
• org.jboss.ws.extensions.security.operation.AuthorizeOperation.process()
• org.jboss.ws.extensions.security.operation.DecryptionOperation.process()
• org.jboss.ws.extensions.security.operation.SignatureVerificationOperation.process()
• org.jboss.ws.extensions.security.operation.TimestampVerificationOperation.process()
• org.jiql.db.jdbc.stat.StatementProcessor.process()
• org.jiql.db.select.FunctionBase.process()
• org.jitterbit.integration.client.project.caseconverter.ProjectProcessor.process()
• org.jitterbit.integration.client.ui.interchange.entity.operation.graph2d.controller.NewOperationProcessor.process()
• org.jivesoftware.openfire.handler.IQHandler.process()
• org.jivesoftware.openfire.handler.PresenceUpdateHandler.process()
• org.jivesoftware.openfire.net.StanzaHandler.process()
• org.jivesoftware.openfire.session.ClientSession.process()
• org.jivesoftware.openfire.session.ConnectionMultiplexerSession.process()
• org.jivesoftware.openfire.session.LocalClientSession.process()
• org.jivesoftware.openfire.session.Session.process()
• org.jostraca.BasicDirectiveElementProcessor.process()
• org.jostraca.BasicExpressionElementProcessor.process()
• org.jostraca.BasicScriptElementProcessor.process()
• org.jostraca.BasicTemplateElementProcessor.process()
  @see org.jostraca.TemplateElementProcessor
• org.jostraca.BasicTextElementProcessor.process()
  @see BasicGenericElementProcessor A text block is translated to a call to the _insert method of the code writer.
• org.jostraca.process.BasicProcessManager.process()
• org.jostraca.process.CompilerProcessStage.process()
• org.jostraca.process.ControllerProcessStage.process()
• org.jostraca.process.MergerProcessStage.process()
• org.jostraca.process.ParserProcessStage.process()
• org.jostraca.process.PreparerProcessStage.process()
• org.jostraca.process.ProcessManager.process()
• org.jostraca.process.SaverProcessStage.process()
• org.jostraca.process.TemplateHandler.process()
• org.jostraca.unit.BasicUnitProcessor.process()
• org.jostraca.unit.DebugUnitProcessor.process()
  @see org.jostraca.unit.UnitProcessor
• org.kite9.tool.BasicKite9Runner.process()
• org.kitesdk.morphline.api.Command.process()
  Processes the given record on the data plane of this command. @return true to indicate that processing shall continue, false to indicate that backtrackingshall be done
• org.kuali.rice.krad.datadictionary.validation.processor.ValidCharactersConstraintProcessor.process()
• org.lilystudio.smarty4j.Operation.process()
  处理操作符，采用的是类似逆波兰式的算法实现。 @param expressions 逆波兰式需要的栈内表达式列表 @param expressionSize 逆波兰式需要的栈内表达式数量 @param mode 运算的模式，0表示浮点数方式，1表示整数方式，2表示对象方式 @return 操作符合并的表达式数量 @throws ParseException 如果参数不足
• org.maltparserx.core.flow.FlowChartInstance.process()
• org.marian.processors.MessageProcessor.process()
  Process a message @param m Message to process @param co Core objects @throws java.lang.Exception Can be thrown for some implementation
• org.markdown4j.Markdown4jProcessor.process()
• org.meshcms.util.DirectoryRemover.process()
• org.mifosplatform.infrastructure.hooks.processor.HookProcessor.process()
• org.milyn.container.plugin.PayloadProcessor.process()
  Process the supplied payload.

  See class level javadoc. @param payload The payload to be filtered. See class level javadoc for supported data types. @return The filter result. Will be "unpacked" as per the {@link ResultType} supplied in the{@link #PayloadProcessor(org.milyn.Smooks,ResultType) constructor}. @throws SmooksException

• org.milyn.edisax.interchange.ControlBlockHandler.process()
  Process an interchange control block. @param interchangeContext The interchange context. @throws IOException Error reading from stream. @throws SAXException SAX Error handling segment data.
• org.mockito.configuration.AnnotationEngine.process()
  Allows extending the interface to perform action on specific fields on the test class.

  See the implementation of this method to figure out what is it for. @param clazz Class where to extract field information, check implementation for details @param testInstance Test instance

• org.mokai.Processor.process()
  Called when a message needs to be processed. @param message the {@link Message} that needs to be processed. @throws Exception
• org.mokai.connector.FakeProcessor.process()
• org.mokai.connector.RoundRobinProcessor.process()
• org.mokai.connector.http.HttpConnector.process()
• org.mokai.connector.smpp.SmppConnector.process()
  Sends an SMS message to the SMSC. If not connected, an IllegalStateException will be thrown. This method expects the following properties keys:

  • "to" - the destination of the SMS message
  • "from - the short code of the SMS message
  • "text" - the text of the SMS message
• org.mokai.connector.smpp.SmppServerConnector.process()
• org.mongeez.Mongeez.process()
• org.movsim.consumption.offline.ConsumptionCalculation.process()
• org.mule.api.component.InterfaceBinding.process()
  This method is responsible for routing the Message via the MuleSession. The logic for this method will change for each type of router depending on expected behaviour. For example, a MulticastingRouter might just iterate through the list of assoaciated endpoints sending the message. Another type of router such as the ExceptionBasedRouter will hit the first endpoint, if it fails try the second, and so on. Most router implementations will extends the FilteringOutboundRouter which implements all the common logic need for a router. @return a result message if any from the invocation. If the endpoint bound hasa one-way exchange pattern configured a null result will always be returned. @throws MessagingException if any errors occur during the sending of messages @throws MuleException @see org.mule.routing.outbound.FilteringOutboundRouter @see org.mule.routing.outbound.ExceptionBasedRouter @see org.mule.routing.outbound.MulticastingRouter @since 2.1 the synchronous argument has been removed. Instead use thesynchronous attribute of the endpoint you are dispatching to.
• org.mule.api.endpoint.OutboundEndpoint.process()
• org.mule.api.processor.InterceptingMessageProcessor.process()
• org.mule.api.processor.MessageProcessor.process()
  Invokes the MessageProcessor. @param event MuleEvent to be processed @return optional response MuleEvent @throws MuleException
• org.mule.api.processor.MessageProcessorChain.process()
• org.mule.api.processor.RequestReplyRequesterMessageProcessor.process()
• org.mule.api.routing.MatchableMessageProcessor.process()
• org.mule.api.routing.OutboundRouter.process()
• org.mule.api.transformer.Transformer.process()
• org.mule.api.transport.MessageDispatcher.process()
• org.mule.construct.Flow.process()
• org.mule.construct.SimpleFlowConstruct.process()
• org.mule.endpoint.DynamicOutboundEndpoint.process()
• org.mule.enricher.MessageEnricher.process()
• org.mule.execution.PhaseExecutionEngine.process()
• org.mule.processor.AsyncInterceptingMessageProcessor.process()
• org.mule.routing.outbound.DefaultOutboundRouterCollection.process()
• org.mule.routing.outbound.MulticastingRouter.process()
• org.mule.tck.functional.AssertionMessageProcessor.process()
• org.mule.transformer.simple.StringAppendTransformer.process()
• org.mule.transport.soap.axis.AxisMessageDispatcher.process()
• org.mule.transport.vm.VMMessageDispatcher.process()
• org.need4steed.cccount.Counter.Process()
• org.netbeans.modules.php.nette.editor.completion.processors.HelperCompletionProcessor.process()
• org.netbeans.modules.php.nette.editor.completion.processors.MacroCompletionProcessor.process()
• org.netbeans.modules.php.nette.editor.completion.processors.ParamCompletionProcessor.process()
• org.netbeans.modules.php.nette.editor.macros.processors.MacroProcessor.process()
• org.netbeans.server.uihandler.statistics.NetBeansModules.process()
• org.newdawn.slick.svg.inkscape.ElementProcessor.process()
  Process a document extracting all the elements that the processor is interested in and producing appropriate diagram components for the element. @param loader The loader/context of the parsing @param element The element to be processed @param diagram The diagram to be built @param transform The transform to apply to all elements at this level @throws ParsingException Indicates an invalid content to an element
• org.nijhazer.bazaarvoice.core.request.BVRequest.process()
• org.nutz.mvc.Processor.process()
• org.nutz.mvc.impl.processor.ViewProcessor.process()
• org.objectweb.celtix.bindings.Request.process()
• org.objectweb.celtix.tools.processors.java2.JavaToWSDLProcessor.process()
• org.objectweb.celtix.tools.processors.java2.internal.ClassProcessor.process()
• org.objectweb.celtix.tools.processors.wsdl2.WSDLToJavaProcessor.process()
• org.objectweb.celtix.tools.processors.wsdl2.WSDLToServiceProcessor.process()
• org.objectweb.celtix.tools.processors.wsdl2.WSDLToSoapProcessor.process()
• org.objectweb.celtix.tools.processors.wsdl2.WSDLToXMLProcessor.process()
• org.objectweb.celtix.tools.processors.wsdl2.internal.PortTypeProcessor.process()
• org.objectweb.celtix.tools.processors.wsdl2.internal.SEIAnnotationProcessor.process()
• org.objectweb.celtix.tools.processors.wsdl2.internal.ServiceProcessor.process()
• org.objectweb.celtix.tools.processors.xsd2.XSDToWSDLProcessor.process()
• org.openbravo.dal.xml.EntityXMLConverter.process()
  Processes one business object and outputs it to the writer ( {@link #setOutput(Writer)}). @param bob the business object to convert to xml (dom4j)
• org.openbravo.dal.xml.StaxXMLEntityConverter.process()
  The main entry point. This method creates a XMLStreamReader and then calls process(XMLStreamReader). @param reader the xml @return the list of BaseOBObject present in the root of the xml. This list contains theto-be-updated, to-be-inserted as well as the unchanged business objects
• org.openbravo.dal.xml.XMLEntityConverter.process()
  The main entry point. This method creates a Dom4j Document and then calls {@link #process(Document)}. @param xml the xml string @return the list of BaseOBObject present in the root of the xml. This list contains theto-be-updated, to-be-inserted as well as the unchanged business objects
• org.openntf.domino.helpers.DocumentSyncHelper.process()
  Process a specific DocumentCollection. WARNING: Does not currently check that all properties of the SyncHelper have been set up @param coll DocumentCollection of source documents @since org.openntf.domino 1.0.0
• org.openstreetmap.osmosis.xml.v0_6.XmlChangeWriter.process()
  {@inheritDoc}
• org.openstreetmap.osmosis.xml.v0_6.XmlWriter.process()
  {@inheritDoc}
• org.osgi.service.deploymentadmin.spi.ResourceProcessor.process()
  Called when a resource is encountered in the deployment package for which this resource processor has been selected to handle the processing of that resource. @param name The name of the resource relative to the deployment packageroot directory. @param stream The stream for the resource. @throws ResourceProcessorException if the resource cannot be processed.Only {@link ResourceProcessorException#CODE_RESOURCE_SHARING_VIOLATION}and {@link ResourceProcessorException#CODE_OTHER_ERROR} errorcodes are allowed.
• org.owasp.jbrofuzz.io.CommandLineInterpreter.process()
  @author daemonmidi@gmail.com @since version 2.4 @param String [] args - commandline arguments @return int resultCode - > 0 == ok and < 0 == failed
• org.owasp.passfault.finders.RepeatingPatternFinder.process()
• org.pdfbox.util.operator.OperatorProcessor.process()
  process the operator. @param operator The operator that is being processed. @param arguments arguments needed by this operator. @throws IOException If there is an error processing the operator.
• org.pdfsam.guiclient.business.thumbnails.JPodRenderer.process()
• org.pentaho.cdf.comments.CommentsEngine.process()
• org.pentaho.cdf.storage.StorageEngine.process()
• org.picketlink.identity.federation.web.process.ServiceProviderBaseProcessor.process()
• org.picketlink.identity.federation.web.process.ServiceProviderSAMLRequestProcessor.process()
  Process the message @param samlRequest @param httpContext @param handlers @param chainLock A Lock on the chain of handlers that needs to be used for locking @return @throws ProcessingException @throws IOException @throws ParsingException @throws ConfigurationException
• org.picketlink.identity.federation.web.process.ServiceProviderSAMLResponseProcessor.process()
  Process the message @param samlResponse @param httpContext @param handlers @param chainLock a lock that needs to be used to process the chain of handlers @return @throws ProcessingException @throws IOException @throws ParsingException @throws ConfigurationException
• org.quna.rsc.ActionListener.process()
• org.richfaces.resource.optimizer.resource.writer.ResourceProcessor.process()
• org.rsbot.loader.script.ModScript.process()
• org.saiku.service.datasource.IDatasourceProcessor.process()
• org.salamandra.web.core.transformer.processor.Processor.process()
• org.semarglproject.source.StreamProcessor.process()
• org.sf.jlaunchpad.xml.ProxiesXmlHelper.process()
• org.sodbeans.phonemic.SpeechProcessor.process()
  Process the input text. @return
• org.spout.api.command.Command.process()
• org.springframework.batch.item.ItemProcessor.process()
  Process the provided item, returning a potentially modified or new item for continued processing. If the returned result is null, it is assumed that processing of the item should not continue. @param item to be processed @return potentially modified or new item for continued processing, null if processing of the provided item should not continue. @throws Exception
• org.springframework.data.solr.core.QueryParserBase.BasePredicateProcessor.process()
• org.springframework.extensions.webscripts.TemplateProcessor.process()
• org.springframework.hateoas.client.Browsable.process()
• org.springframework.ide.eclipse.wizard.template.infrastructure.processor.Processor.process()
• org.teiid.query.processor.xml.InitializeDocumentInstruction.process()
  @see ProcessorInstruction#getCapabilities(ProcessorEnvironment,DocumentInProgress)
• org.terasology.world.propagation.BatchPropagator.process()
• org.terasology.world.propagation.StandardBatchPropagator.process()
• org.thymeleaf.TemplateEngine.process()

  Process a template. This method receives both a template name and a context.

  The template name will be used as input for the template resolvers, queried in chain until one of them resolves the template, which will then be executed.

  The context will contain the variables that will be available for the execution of expressions inside the template.

  @param templateName the name of the template. @param context the context. @return a String containing the result of evaluating the specified template with the provided context.
• org.thymeleaf.dom.Document.process()
• org.thymeleaf.spring3.SpringTemplateEngine.process()
• org.torquebox.messaging.component.MessageProcessorComponent.process()
• org.tuba.operation.emftext2text.operation.EMFText2TextOperation.process()
• org.tuba.plugins.IArtefactOperation.process()
• org.tuba.spatschorke.diploma.operation.ecoretools.generatediagram.Operation.process()
• org.tuba.spatschorke.diploma.operation.image.scale.ImageScaler.process()
• org.tuba.spatschorke.diploma.operation.sdedit.image.ImageGenerator.process()
• org.tuckey.web.filters.urlrewrite.utils.ModRewriteConfLoader.process()
• org.uispec4j.interception.WindowInterceptor.process()
  Processes a modal dialog. The provided WindowHandler must return a trigger that will cause the window to be closed, in order to prevent the application to be stopped.
• org.uispec4j.interception.handlers.InterceptionHandler.process()
  Called to process a modal dialog when it is shown.
• org.w3c.tools.codec.Base64Decoder.process()
  Do the actual decoding. Process the input stream by decoding it and emiting the resulting bytes into the output stream. @exception IOException If the input or output stream accesses failed. @exception Base64FormatException If the input stream is not compliantwith the BASE64 specification.
• org.w3c.tools.codec.Base64Encoder.process()
  Process the data: encode the input stream to the output stream. This method runs through the input stream, encoding it to the output stream. @exception IOException If we weren't able to access the input stream orthe output stream.
• org.wso2.carbon.identity.sso.saml.processors.AuthnRequestProcessor.process()
• org.wso2.carbon.identity.sso.saml.processors.LogoutRequestProcessor.process()
• org.wso2.carbon.identity.sts.passive.processors.RequestProcessor.process()
• org.wso2.carbon.ui.ext.CarbonUIFragmentInitializer.process()
  processing work to be done inside callback class should go inside process method
• org.xmlvm.refcount.ReferenceCounting.process()
  The entry point to this class. This function takes a method element and processes it, adding instructions to release and retain objects as needed. For the command set that it adds, see the InstructionProcessor class.
• org.xtreemfs.babudb.api.dev.transaction.InMemoryProcessing.process()
  The database changes made by the operation can be read after this method returns. Although there are no persistence guarantees on a database crash e.g. there is no entry written to the log. @param operation @return a possible return value for the in-memory processing of the operation, may be null. @throws BabuDBException if the operation could not have been processed, due a user error.
• org.xulfaces.annotation.faces.COMPONENT.process()
• org.yaac.server.egql.processor.DatastoreLoader.process()
• org.yaac.server.egql.processor.Processor.process()
  @param context @param input @return output
• org.yaac.server.egql.processor.SelectProccesor.process()
• org.zkoss.zk.ui.impl.EventProcessor.process()
  Process the event. Note: it doesn't invoke EventThreadInit and EventThreadCleanup.

  This method is to implement {@link org.zkoss.zk.ui.sys.EventProcessingThread}. See also {@link org.zkoss.zk.ui.util.Configuration#isEventThreadEnabled}.

• org.zkoss.zss.ui.au.in.Command.process()
• ro.isdc.wro.extensions.processor.css.CssLintProcessor.process()
  {@inheritDoc}
• ro.isdc.wro.extensions.processor.css.NodeLessCssProcessor.process()
  {@inheritDoc}
• ro.isdc.wro.extensions.processor.css.RhinoLessCssProcessor.process()
  {@inheritDoc}
• ro.isdc.wro.extensions.processor.css.SassCssProcessor.process()
  {@inheritDoc}
• ro.isdc.wro.extensions.processor.js.BeautifyJsProcessor.process()
  {@inheritDoc}
• ro.isdc.wro.extensions.processor.js.CJsonProcessor.process()
  {@inheritDoc}
• ro.isdc.wro.extensions.processor.js.DustJsProcessor.process()
• ro.isdc.wro.extensions.processor.js.EmberJsProcessor.process()
• ro.isdc.wro.extensions.processor.js.HandlebarsJsProcessor.process()
• ro.isdc.wro.extensions.processor.js.HoganJsProcessor.process()
• ro.isdc.wro.extensions.processor.js.JsHintProcessor.process()
• ro.isdc.wro.extensions.processor.js.JsLintProcessor.process()
• ro.isdc.wro.extensions.processor.js.JsonHPackProcessor.process()
  {@inheritDoc}
• ro.isdc.wro.extensions.processor.js.NodeCoffeeScriptProcessor.process()
  {@inheritDoc}
• ro.isdc.wro.extensions.processor.js.NodeTypeScriptProcessor.process()
  {@inheritDoc}
• ro.isdc.wro.extensions.processor.js.PackerJsProcessor.process()
  {@inheritDoc}
• ro.isdc.wro.extensions.processor.js.RhinoCoffeeScriptProcessor.process()
  {@inheritDoc}
• ro.isdc.wro.extensions.processor.js.RhinoTypeScriptProcessor.process()
  {@inheritDoc}
• ro.isdc.wro.extensions.processor.js.UglifyJsProcessor.process()
• ro.isdc.wro.extensions.processor.support.sass.RubySassEngine.process()
  Transforms a sass content into css using Sass ruby engine. This method is synchronized because the engine itself is not thread-safe. @param content the Sass content to process.
• ro.isdc.wro.extensions.processor.support.sass.SassCss.process()
  @param data css content to process. @return processed css content.
• ro.isdc.wro.extensions.processor.support.uglify.UglifyJs.process()
  @param data js content to process. @return packed js content.
• ro.isdc.wro.manager.WroManager.process()
  Perform processing of the uri. @throws IOException when any IO related problem occurs or if the request cannot be processed.
• ro.isdc.wro.model.resource.processor.ResourcePostProcessor.process()
  Perform actual resource processing. The content to be processed is read from source Reader and is written to destination Writer. It is the client responsibility to close both: Reader and writer. @param reader source stream. @param writer destination stream.
• ro.isdc.wro.model.resource.processor.ResourcePreProcessor.process()
  Process a content supplied by a reader and perform some sort of processing. It is important to know that you should use reader for processing instead of trying to access the resource original content using {@link Resource}, because this way you can ignore the other preProcessors from the chain.
  It is not require to explicitly handle exception. When the processing fails, the following can happen:

  • the exception is wrapped in {@link RuntimeException} and the processing chain is interrupted (by default)
  • content remains unchanged (if {@link WroConfiguration#isIgnoreFailingProcessor()} is true)

  
  It is not required to close the reader and writers, because these will be closed for you. @param resource the original resource as it found in the model. @param reader {@link Reader} used to read processed resource content. @param writer {@link Writer} where used to write processed results. @throws IOException when an exception occurs. The future version will change the exception type to {@link Exception}, because any exception may occur during processing. The processing failure will be handled based on value of {@link WroConfiguration#isIgnoreFailingProcessor()} configuration flag.
• ro.isdc.wro.model.resource.processor.decorator.ExceptionHandlingProcessorDecorator.process()
  {@inheritDoc}
• ro.isdc.wro.model.resource.processor.decorator.LazyProcessorDecorator.process()
  {@inheritDoc}
• ro.isdc.wro.model.resource.processor.decorator.ProcessorDecorator.process()
  {@inheritDoc}
• rocket.beans.rebind.xml.DocumentWalker.process()
  Initializes this document walker so that it may be used to travel about the dom. @param fileName The name of the first xml document to be processed.
• ru.petrsu.akolosov.flowbrook.processing.ConcurrentFlowSourceSetHandler.process()
• ru.petrsu.akolosov.flowbrook.processing.FlowSourceSetHandler.process()
• ru.snake.spritepacker.core.packer.ImagePacker.process()
• scala.tools.nsc.interpreter.ILoop.process()
• se.arnetheduck.j2c.transform.Transformer.process()
• securepay.jxa.api.Payment.process()
• siena.remote.RemoteStub.process()
• sos.scheduler.launcher.JobSchedulerLoadTestLauncher.process()
  In dieser Methode wird eine Verbindung zu der Scheduler aufgebaut und das Request wird an den Job bzw. Order gesendet. @throws Exception
• sos.textprocessor.SOSTextProcessor.process()
  process text: this method has to be implemented by derived text processors @throws java.lang.Exception
• spoon.processing.ProcessingManager.process()
• spoon.support.QueueProcessingManager.process()
• sql.optimizers.name.ProjGlobalCollect.process()
• statechum.apps.QSMTool.process()
• sun.security.util.SignatureFileVerifier.process()
  process the signature block file. Goes through the .SF file and adds code signers for each section where the .SF section hash was verified against the Manifest section.
• sunlabs.brazil.template.TemplateRunner.process()
  Processes the next token in the HTML document represented by the given RewriteContext. Processing a token involves either dispatching to a tag-handling method in one of the Template objects, or just advancing to the next token if no Template was interested. @param hr The RewriteContext holding the state of the HTML document.
• systole.processor.SignalProcessor.process()
  @param segments list of segment selected @return the final segment
• thirdparty.marvin.image.grayScale.GrayScale.process()
• tk.eclipse.plugin.htmleditor.ICustomTagConverter.process()
• transientlibs.processors.misc.ClickProcessor.process()
• ua.pp.bizon.cripto.keystore.CryptoUtil.process()
• uk.ac.cam.ch.wwmm.oscar3.preprocessor.HTMLPreprocessor.process()
• uk.ac.cam.ch.wwmm.oscar3.preprocessor.PlainTextPreprocessor.process()
• uk.ac.ucl.panda.retrieval.TrecRetrieval.process()
• uk.co.cwspencer.gdb.gdbmi.GdbMiParser2.process()
  Processes the given data. @param data Data read from the GDB process.
• uk.gov.nationalarchives.droid.command.container.Ole2ContainerContentIdentifier.process()
• uk.gov.nationalarchives.droid.command.container.ZipContainerContentIdentifier.process()
• vavi.sound.mfi.vavi.sequencer.MachineDependFunction.process()
• weka.gui.explorer.ClassifierErrorsPlotInstances.process()
  Process a classifier's prediction for an instance and update a set of plotting instances and additional plotting info. m_PlotShape for nominal class datasets holds shape types (actual data points have automatic shape type assignment; classifier error data points have box shape type). For numeric class datasets, the actual data points are stored in m_PlotInstances and m_PlotSize stores the error (which is later converted to shape size values). @param toPredict the actual data point @param classifier the classifier @param eval the evaluation object to use for evaluating the classifier onthe instance to predict @see #m_PlotShapes @see #m_PlotSizes @see #m_PlotInstances
• xbird.util.cmdline.Command.process()

Examples of org.jostraca.process.ProcessManager.process()

Examples of org.jostraca.process.SaverProcessStage.process()

Examples of org.jostraca.process.TemplateHandler.process()

Examples of org.jostraca.unit.BasicUnitProcessor.process()

Examples of org.jostraca.unit.DebugUnitProcessor.process()

Examples of org.kite9.tool.BasicKite9Runner.process()

Examples of org.kitesdk.morphline.api.Command.process()

Examples of org.kuali.rice.krad.datadictionary.validation.processor.ValidCharactersConstraintProcessor.process()

Examples of org.lilystudio.smarty4j.Operation.process()

Examples of org.maltparserx.core.flow.FlowChartInstance.process()