using pdfdocument c# : Change link in pdf Library control class asp.net web page winforms ajax WATUsageGuide31-part874

Java Programmer's Guide
309
API Attribute Type
Design Studio Attribute Type
Number
Number
Character
Character
Date
Date
Session
Session
Binary
Binary, Image, PDF
The API attribute types are then mapped to Java in the following way.
Table 
52. 
Java 
types 
for 
attributes
[api/com/kapowtech/robosuite/api/java/rql/construct/AttributeType.html]
Attribute Type
Java Class
Text
java.lang.String
Integer
java.lang.Long
Boolean
java.lang.Boolean
Number
java.lang.Double
Character
java.lang.Character
Date
java.util.Date
Session
com.kapowtech.robosuite.api.construct.Session
Binary
com.kapowtech.robosuite.api.construct.Binary
The RQlObjectBuilder's setAttribute method is overloaded so you don't need to specify the
attribute type explicitly when configuring an attribute through the API, as long as the right java class is
used as argument. Here is an example that shows how to set the attributes for an object with all possible
(Design Studio) attribute types.
Table 53. Recommended usage of setAttribute
Request request  = new Request("Library:/AllTypes.robot");
RQLObjectBuilder inputBuilder = request.createInputVariable("AllTypes");
inputBuilder.setAttribute("anInt", new Long(42L));
inputBuilder.setAttribute("aNumber", new Double(12.34));
inputBuilder.setAttribute("aBoolean", Boolean.TRUE);
inputBuilder.setAttribute("aCharacter", 'c');
inputBuilder.setAttribute("aShortText", "some text");
inputBuilder.setAttribute("aLongText", "a longer test");
inputBuilder.setAttribute("aPassword", "secret");
inputBuilder.setAttribute("aHTML", "<html>bla</html>");
inputBuilder.setAttribute("anXML", "<tag>text</tag>");
inputBuilder.setAttribute("aDate", new Date());
inputBuilder.setAttribute("aBinary", new Binary("some bytes".getBytes()));
inputBuilder.setAttribute("aPDF", (Binary) null);
inputBuilder.setAttribute("anImage", (Binary) null);
inputBuilder.setAttribute("aProperties", "name=value\nname2=value2");
inputBuilder.setAttribute("aSession", (Session) null);
inputBuilder.setAttribute("aCurrency", "USD");
inputBuilder.setAttribute("aCountry", "US");
Change link in pdf - insert, remove PDF links in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Free C# example code is offered for users to edit PDF document hyperlink (url), like inserting and deleting
add link to pdf acrobat; pdf link to specific page
Change link in pdf - VB.NET PDF url edit library: insert, remove PDF links in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Help to Insert a Hyperlink to Specified PDF Document Page
convert a word document to pdf with hyperlinks; add links to pdf acrobat
Java Programmer's Guide
310
inputBuilder.setAttribute("aLanguage", "en");
inputBuilder.setAttribute("aRefindKey", "Never use this a input");
The above example explicitly uses new Long(42L), and new Double(12.34), although 42L and 12.34 would
be sufficient due to auto boxing. Also notice that we have to cast null values, because the Java compiler
can't otherwise determine which of the overloaded setAttribute methods we want to call. However
since since unconfigured attributes will automatically be null, you never need to set null explicitly.
It is possible to specify the Attribute and AttributeType explicitly when creating input using the API. This
is approach is not recommended, but may be needed in rare cases, and would look like this.
Table 54. Not recommended usage of setAttribute
Request request  = new Request("Library:/AllTypes.robot");
RQLObjectBuilder inputBuilder = request.createInputVariable("AllTypes");
inputBuilder.setAttribute(new Attribute("anInt", "42", AttributeType.INTEGER));
inputBuilder.setAttribute(new Attribute("aNumber", "12.34", AttributeType.NUMBER));
inputBuilder.setAttribute(new Attribute("aBoolean", "true", AttributeType.BOOLEAN));
inputBuilder.setAttribute(new Attribute("aCharacter", "c", AttributeType.CHARACTER));
inputBuilder.setAttribute(new Attribute("aShortText", "some text", AttributeType.TEXT));
inputBuilder.setAttribute(new Attribute("aLongText", "a longer test", AttributeType.TEXT));
inputBuilder.setAttribute(new Attribute("aPassword", "secret", AttributeType.TEXT));
inputBuilder.setAttribute(new Attribute("aHTML", "<html>bla</html>", AttributeType.TEXT));
inputBuilder.setAttribute(new Attribute("anXML", "<tag>text</tag>", AttributeType.TEXT));
inputBuilder.setAttribute(new Attribute("aDate", "2012-01-15 23:59:59.123", AttributeType.DATE));
inputBuilder.setAttribute(new Attribute("aBinary", Base64Encoder.encode("some bytes".getBytes()), AttributeType.BINARY));
inputBuilder.setAttribute(new Attribute("aPDF", null, AttributeType.BINARY));
inputBuilder.setAttribute(new Attribute("anImage", null, AttributeType.BINARY));
inputBuilder.setAttribute(new Attribute("aProperties", "name=value\nname2=value2", AttributeType.TEXT));
inputBuilder.setAttribute(new Attribute("aSession", null, AttributeType.SESSION));
inputBuilder.setAttribute(new Attribute("aCurrency", "USD", AttributeType.TEXT));
inputBuilder.setAttribute(new Attribute("aCountry", "US", AttributeType.TEXT));
inputBuilder.setAttribute(new Attribute("aLanguage", "en", AttributeType.TEXT));
inputBuilder.setAttribute(new Attribute("aRefindKey", "Never use this a input", AttributeType.TEXT));
As we can see all attribute values must be provided in the form of strings. The string values are then
converted to the appropriate Java objects based on the Attribute type provided. This is only useful if you
build other generic APIs on top of the Kapow Katalyst Java API.
Execution Parameters
In addition to the createInputVariable method, the Request contains a number of methods that
controls how the robot executes on RoboServer.
Table 
55. 
Execution 
control 
methods 
on 
Request
[api/com/kapowtech/robosuite/api/java/rql/Request.html]
setMaxExecutionTime(int
seconds) 
[api/com/
kapowtech/robosuite/
api/java/rql/
Request.html#setMaxExecutionTime(int)]
Controls the execution time of the robot. When this time has elapsed
the robot will be stopped by RoboServer. The timer doesn't start until
the robot begins to execute, so if the robot is queued on RoboServer
this is not taken into account.
VB.NET PDF Password Library: add, remove, edit PDF file password
Add password to PDF. Change PDF original password. Remove password from PDF. Set PDF security level. VB: Change and Update PDF Document Password.
adding hyperlinks to pdf documents; pdf reader link
C# PDF Password Library: add, remove, edit PDF file password in C#
Able to change password on adobe PDF document in C#.NET. To C# Sample Code: Change and Update PDF Document Password in C#.NET. In
add hyperlink pdf file; chrome pdf from link
Java Programmer's Guide
311
setStopOnConnectionLost(boolean)
[api/com/kapowtech/
robosuite/api/java/
rql/
Request.html#setStopOnConnectionLost(boolean)]
When true (default) the robot will stop if RoboServer discovers that
the connection to the client application has been lost. You should have
a very good reason for setting this value to false - if your code is not
written to handle this, your application will not perform as expected.
setStopRobotOnApiException(boolean)
[api/com/kapowtech/
robosuite/api/java/
rql/
Request.html#setStopRobotOnApiException(boolean)]
When true (default) the robot will be stopped by RoboServer after the
first API exception is raised. By default most steps in a Robot will
raise an API exception if the step fails to execute - this is configured
on the steps error handling tab.
When  set  to  false,  the robot  will  continue  to  execute  regardless
of API exceptions, however  unless  your  application  is using  the
RequestExecutor streaming execution mode, an exception will
still be thrown by execute(), so be extremely careful when setting this
to false.
setUsername(String)
[api/com/kapowtech/
robosuite/api/java/
rql/
Request.html#setUsername(java.lang.String)],
setPassword(String)
[api/com/kapowtech/
robosuite/api/java/
rql/
Request.html#setPassword(java.lang.String)]
Sets the RoboServer credentials. RoboServer can be configured to
require authentication. When this option is enabled, the client must
provide credentials or RoboServer will reject the request.
setRobotLibrary(RobotLibrary)
[api/com/kapowtech/
robosuite/api/java/
rql/
Request.html#setRobotLibrary(com.kapowtech.robosuite.api.java.rql.construct.RobotLibrary)]
A robot library instructs RoboServer where to find the robot identified
in the request. Later examples will explore the various robot library
types and when/how to use them.
setExecutionId(String)
[api/com/kapowtech/
robosuite/api/java/
rql/
Request.html#setExecutionId(java.lang.String)]
Allows you to set the executionId for this request. If you don't provide
one, RoboServer will generate one automatically. The execution ID
is used for logging and also needed if your client needs to be able
to stop the robot programmatically. The ID must be globally unique
(over time). If two robots use the same execution ID, the logs will be
inconsistent.
setProject(String)
[api/com/kapowtech/
robosuite/api/java/
rql/
Request.html#setProject(java.lang.String)]
This is used solely for logging purposes. The Management Console
uses this field to link log messaged to project, so the log views can
filter by project.
If your application is not using the RepositoryRobotLibrary
you should probably set this value to inform the RoboServer logging
system which project (if any) this robot belongs to.
Robot Libraries
In Design Studio robots are grouped into projects. If you look in the file system you will see that these
projects are identified by a folder named Library, see Libraries and Projects for details.
When you build the execute request for RoboServer, you identify the robot by a robot URL, like this:
Request request = new Request("Library:/Input.robot");
VB.NET PDF File Compress Library: Compress reduce PDF size in vb.
3.pdf"; String outputFilePath = Program.RootPath + "\\" 3_optimized.pdf"; 'create optimizing options TargetResolution = 150.0F 'to change image compression
add a link to a pdf in acrobat; add hyperlink pdf document
C# PDF File Compress Library: Compress reduce PDF size in C#.net
3.pdf"; String outputFilePath = Program.RootPath + "\\" 3_optimized.pdf"; // create optimizing TargetResolution = 150F; // to change image compression mode
c# read pdf from url; add link to pdf file
Java Programmer's Guide
312
Here, Library:/ is a symbolic reference to a robot library, in which the RoboServer should look for
the robot. The RobotLibrary is then specified on the builder like this:
request.setRobotLibrary(new DefaultRobotLibrary());
There are three different robot library implementations, which one to select depends on you deployment
environment.
Table 56. Robot Libraries
Library Type
Description
DefaultRobotLibrary
[api/com/kapowtech/
robosuite/api/java/
rql/construct/
DefaultRobotLibrary.html]
This configures RoboServer to look for the robot in the current project
folder. This folder is defined in the Settings application.
If you have multiple RoboServers you will have to deploy your robots
on all RoboServers.
This robot library is not cached, so the robot is reloaded from disk
with every execution. This makes the library usable in a development
environment  where  robots  change  often,  but  not  suitable  for  a
production environment.
EmbeddedFileBasedRobotLibrary
[api/com/kapowtech/
robosuite/api/java/
rql/construct/
EmbeddedFileBasedRobotLibrary.html]
This library is embedded in the execute request sent to RoboServer.
To create this library you must create a zip file containing the robots
and all its dependencies (types, snippets and resources). This can be
done the Tools->Create Robot Library File menu in Design Studio.
The library is sent with every request, which adds some overhead for
large libraries, but the libraries cached on RoboServer, which offers
best possible performance.
One strength is that robots and code can be deployed as a single unit,
which offers clean migration from QA environment to production
environment. However, if the robots change often you will have to
redeploy them often.
You can use the following code to configure the embedded robot
library for your request.
Request request = new Request("Library:/Tutorials/NewsMagazine.robot");
RobotLibrary library = new EmbeddedFileBasedRobotLibrary(new
FileInputStream("c:\\embeddedLibrary.robotlib"));
request.setRobotLibrary(library);
RepositoryRobotLibrary
[api/com/kapowtech/
robosuite/api/java/
rql/construct/
RepositoryRobotLibrary.html]
This is the most flexible RobotLibrary.
This library uses the Management Console's built-in repository as a
robot library. When you use this library, RoboServer will contact the
Management Console which will send a robot library containing the
robot and its dependencies.
Caching occurs on a per robot basis, inside both Management Console
and RoboServer. Inside Management Console, the generated library is
cached based on the robot and its dependencies. On RoboServer, the
cache is based on a timeout, so it doesn't have to ask the Management
Console for each request. In addition, the library loading between
C# PDF Library SDK to view, edit, convert, process PDF file for C#
RasterEdge PDF SDK for .NET package offers robust APIs for editing PDF document hyperlink (url) and quick navigation link in PDF bookmark.
add hyperlink to pdf online; pdf link to email
RasterEdge .NET Document Imaging Trial Package Download Link.
Convert Jpeg to PDF; Merge PDF Files; Split PDF Document; Remove Password from PDF; Change PDF Permission Settings. FREE TRIAL: HOW TO:
add links to pdf in preview; adding links to pdf document
Java Programmer's Guide
313
Library Type
Description
RoboServer  and  Management  Console  uses  HTTP  public/private
caching, to further reduce bandwidth.
If  NewsMagazine.robot  has  been  uploaded  to  the  Management
Console we could use  the repository robot library like this when
executing the robot:
Request request = new Request("Library:/Tutorials/NewsMagazine.robot");
RobotLibrary library = new RepositoryRobotLibrary("http://localhost:50080", "Default Project", 60000);
request.setRobotLibrary(library);
This  will  instruct  RoboServer  to  load  the  robot  from  a  local
Management Console and cache it for one minute before checking
with the Management Console to see if a new version of the robot (it's
type and snippets) has been changed.
In addition any resource loaded through the Library:/ protocol,
will  cause  RoboServer  request  the  resource  directly  from  the
Management Console.
Advanced
In this section we will look a little closer at some of the more advanced features on the API. These include
output streaming, logging and SSL configuration, as well as parallel execution.
Load Distribution and Failover
Table 57. Load balanced executor
RoboServer prod = new RoboServer("prod.kapow.local", 50000);
RoboServer prod2 = new RoboServer("prod2.kapow.local", 50000);
Cluster cluster = new Cluster("Prod", new RoboServer[]{ prod, prod2}, false);
Request.registerCluster(cluster);
Let's look a little closer at what happens inside the RequestExecutor. The executor is given an array
of RoboServers. As the executor is constructed it tries to connect to each RoboServer. Once it is connected
it sends a ping request to each RoboServer to discover how the server is configured.
Load is distributed to each online RoboServer in the cluster, based on the number of unused execution slots
on the RoboServer. The next request is always distributed to the RoboServer with the most available slots.
The number of available execution slots is obtained through the initial Ping response, and the executor
keeps track of each robot it starts and when it completes. The number of execution slots on a RoboServer
is determined by the max concurrent robots on the Servers tab.
If a RoboServer goes offline it will not receive any robot execution requests before it has successfully
responded to the ping request.
Two client rule
You should only have one API client using a given cluster of RoboServer. If you have multiple JVMs
running robots against the same RoboServers, this will result in reduced performance.
.NET PDF SDK - Description of All PDF Processing Control Feastures
Easy to change PDF original password; Options for setting PDF security level; PDF text Support adding and inserting hyperlink (link) to PDF document; Allow to
clickable links in pdf from word; pdf link open in new window
C# PDF Page Rotate Library: rotate PDF page permanently in C#.net
C#.NET PDF Library - Rotate PDF Page in C#.NET. Empower C# Users to Change the Rotation Angle of PDF File Page Using C# Programming Language in .NET Application
add a link to a pdf in preview; add hyperlink to pdf acrobat
Java Programmer's Guide
314
Executor Logger
When you execute a request, the execute method will throw an exception if a robot generates an error.
Other types of errors and warnings are reported through the ExecutorLogger interface. In the previous
examples, we have not provided any ExecutionLogger when executing robots, which means means
we get the default implementation that will write to system out. Let's see how the ExecutorLogger
will report if one of our RoboServers goes offline.
The example configures a cluster with a RoboServer which is not online.
Table 
58. 
ExecutorLogger
[api/com/kapowtech/robosuite/api/java/rql/engine/hotstandby/ExecutorLogger.html],
offline server example
RoboServer rs = new RoboServer("localhost", 50000);
Cluster cluster = new Cluster("name", new RoboServer[]{rs}, false);
Request.registerCluster(cluster);
If you run this example if should print the following to the console:
Table 
59. 
ExecutorLogger
[api/com/kapowtech/robosuite/api/java/rql/engine/hotstandby/ExecutorLogger.html],
offline RoboServer console output
RoboServer{host='localhost', port=50000} went offline. Connection refused
Often you don't want to have your application writing directly to System.out, in that case you can
provide a different ExecutorLogger implementation, you can do so when registering the cluster, like
this
Table 
60. 
Use 
DebugExecutorLogger
[api/com/kapowtech/robosuite/api/java/rql/engine/hotstandby/DebugExecutorLogger.html]
Request.registerCluster(cluster, new DebugExecutorLogger());
This  example  uses  the  DebugExecutorLogger()  which  will  also  print  to  System.out,  but
only  if  the  API  debugging  is  enabled.  Alternative  you  can  provide  your  own  implementation
of  the  ExecutorLogger,  to  control  how  error  messages  should  be  handled.  Check
the    ExecutorLogger  [api/com/kapowtech/robosuite/api/java/rql/engine/
hotstandby/ExecutorLogger.html]  JavaDoc for additional details.
Data Streaming
Sometimes you need to present the results from a robot execution in real-time. In these cases you want
the API to return the extracted values immediately instead of waiting for the robot to finish its execution
and access the RQLResult.
The API offers the possibility to receive a callback every time the API receives a value that was returned
by the Robot. This is done through the RobotResponseHandler interface
Java Programmer's Guide
315
Table 
61. 
Response 
streaming 
using
AbstractFailFastRobotResponseHandler
[api/com/kapowtech/robosuite/api/java/rql/engine/hotstandby/AbstractFailFastRobotResponseHandler.html]
public class DataStreaming {
public static void main(String[] args) throws ClusterAlreadyDefinedException {
RoboServer server = new RoboServer("localhost", 50000);
Cluster cluster = new Cluster("MyCluster", new RoboServer[] {server}, false);
Request.registerCluster(cluster);
try {
Request request = new Request("Library:/Tutorials/NewsMagazine.robot");
RobotResponseHandler handler = new AbstractFailFastRobotResponseHandler() {
public void handleReturnedValue(RobotOutputObjectResponse response, Stoppable stoppable) throws RQLException {
RQLObject value = response.getOutputObject();
Long personId = (Long) value.get("personId");
String name = (String) value.get("name");
Long age = (Long) value.get("age");
System.out.println(personId + ", " + name + ", " + age);
}
};
request.execute("MyCluster", handler);
}
catch (RQLException e) {
e.printStackTrace();
}
}
}
The  above  example  uses  the  second  execute  method  of  the  Request,  which  expects
 RobotResponseHandler  in  addition  to  the  name  of  the  cluster  to  execute
the  robot  on.  In  this  example  we  create  a  RobotResponseHandler  by  extending
AbstractFailFastRobotResponseHandler, which provides default error handling, so we only
need to handle the values returned by the robot.
The handleReturnedValue method is called whenever the API receives a returned value from
RoboServer. The AbstractFailFastRobotResponseHandler used in this example, will throw
exceptions in the same way as the non-streaming execute method. This means that an exception will be
thrown in response to any API exceptions generated by the robot.
The RobotResponseHandler has several methods which can be grouped into 3 categories.
Robot life cycle events
Methods which are called when the robot's execution state change
on RoboServer, such as when it starts and finishes its execution.
Robot data events
Methods which are called when the robot returns data or errors to
the API.
Additional error handling
Methods which are called either due to an error inside RoboServer
or in the API.
Java Programmer's Guide
316
Table 62. RobotResponseHandler - robot life cycle events
Method name
Description
void
requestSent(RoboServer
roboServer,
ExecuteRequest
request) 
[api/com/
kapowtech/robosuite/
api/java/rql/engine/
hotstandby/
RobotResponseHandler.html#requestSent(com.kapowtech.robosuite.api.java.repository.construct.RoboServer,%20com.kapowtech.robosuite.api.java.rql.construct.ExecuteRequest)]
Called when the RequestExecutor has found the server which
will execute the request.
void
requestAccepted(String
executionId) [api/com/
kapowtech/robosuite/
api/java/rql/engine/
hotstandby/
RobotResponseHandler.html#requestAccepted(java.lang.String)]
Called when the found RoboServer has accepted the request and put
it into it queue.
void
robotStarted(Stoppable
stoppable) 
[api/com/
kapowtech/robosuite/
api/java/rql/engine/
hotstandby/
RobotResponseHandler.html#robotStarted(com.kapowtech.robosuite.api.java.rql.engine.hotstandby.Stoppable)]
Called when the RoboServer begins to execute the robot. This usually
occurs  immediately  after  the  robot  has  been  queued,  unless  the
RoboServer is under heavy load, or used by multiple API clients.
void
robotDone(RobotDoneEvent
reason) 
[api/com/
kapowtech/robosuite/
api/java/rql/engine/
hotstandby/
RobotResponseHandler.html#robotDone(com.kapowtech.robosuite.api.java.rql.engine.hotstandby.RobotDoneEvent)]
Called  when  the  robot  is  done  executing  on  RoboServer.  The
RobotDoneEvent is used to specify if the execution terminated
normally, due to an error, or if it was stopped.
Table 63. RobotResponseHandler - robot data events
Method name
Description
void
handleReturnedValue(RobotOutputObjectResponse
response, 
Stoppable
stoppable) 
[api/com/
kapowtech/robosuite/
api/java/rql/engine/
hotstandby/
RobotResponseHandler.html#handleReturnedValue(com.kapowtech.robosuite.api.java.rql.construct.RobotOutputObjectResponse,%20com.kapowtech.robosuite.api.java.rql.engine.hotstandby.Stoppable)]
Called when the robot has executed a Return Value action and the
value has been returned via the socket to the API.
void
handleRobotError(RobotErrorResponse
response, 
Stoppable
stoppable) 
[api/com/
kapowtech/robosuite/
api/java/rql/engine/
Called  when  the  robot  raises  an  API  exception.  Under
normal  circumstances  the  robot  will  stop  executing  after  the
first  API  exception.  This  behavior  can  be  overridden  by
using  Request.setStopRobotOnApiException(false),
in which case this method will be called multiple times. This is useful
Java Programmer's Guide
317
Method name
Description
hotstandby/
RobotResponseHandler.html#handleRobotError(com.kapowtech.robosuite.api.java.rql.construct.RobotErrorResponse,%20com.kapowtech.robosuite.api.java.rql.engine.hotstandby.Stoppable)]
if you want a data streaming robot to continue to execute regardless
of any generated errors.
void
handleWriteLog(RobotMessageResponse
response, 
Stoppable
stoppable) 
[api/com/
kapowtech/robosuite/
api/java/rql/engine/
hotstandby/
RobotResponseHandler.html#handleWriteLog(com.kapowtech.robosuite.api.java.rql.construct.RobotMessageResponse,%20com.kapowtech.robosuite.api.java.rql.engine.hotstandby.Stoppable)]
Called if the robot executes the Write Log action. This is useful if you
wish to provide additional logging info from within a robot.
Table 64. RobotResponseHandler - additional error handling
Method name
Description
void
handleServerError(ServerErrorResponse
response, 
Stoppable
stoppable) 
[api/com/
kapowtech/robosuite/
api/java/rql/engine/
hotstandby/
RobotResponseHandler.html#handleServerError(com.kapowtech.robosuite.api.java.rql.construct.ServerErrorResponse,%20com.kapowtech.robosuite.api.java.rql.engine.hotstandby.Stoppable)]
Called if RoboServer generates an error, for instance if the server too
busy to process any requests, or if an error occurs inside RoboServer
which prevents it from starting the robot.
handleError(RQLException
e, Stoppable stoppable)
[api/com/kapowtech/
robosuite/api/java/
rql/engine/hotstandby/
RobotResponseHandler.html#handleError(com.kapowtech.robosuite.api.java.rql.RQLException,%20com.kapowtech.robosuite.api.java.rql.engine.hotstandby.Stoppable)]
Called if an error occurs inside the API. Most commonly if the client
looses the connection to RoboServer.
Many of the methods will include a Stoppable  [api/com/kapowtech/robosuite/api/
java/rql/engine/hotstandby/Stoppable.html] object, this object can be used to stop for
instance in response to a specific error or value returned.
Some of these methods allow you to throw an RQLException, if you do this you should be aware of the
consequences. The thread that calls the handler is the thread the calls Request.execute(), this means
that any exceptions thrown will bubble up the call stack and out the execute method. If you throw an
exception in response to handleReturnedValue, handleRobotError or handleWriteLog it
is your responsibility to invoke Stoppable.stop(), or the robot may continue to execute even though
the call to Request.execute() has completed.
Data streaming is most often used in one of the following use cases.
• Ajax based web application, where results are presented to the user in real-time. If data was not streamed
results could not be shown until the robot was done running.
• Robots that return so much data that the client would not be able to hold it all in memory throughout
the robots execution.
• Processes that need to be optimized so the extracted values are processed in parallel with the robot
execution.
Java Programmer's Guide
318
• Processes that store data in databases in a custom format.
• Robots that should ignore or require custom handling of API exceptions (see below).
Table 
65. 
Response 
and 
error 
collecting 
using
AbstractFailFastRobotResponseHandler
[api/com/kapowtech/robosuite/api/java/rql/engine/hotstandby/AbstractFailFastRobotResponseHandler.html]
public class DataStreamingCollectErrorsAndValues {
public static void main(String[] args) throws ClusterAlreadyDefinedException {
RoboServer server = new RoboServer("localhost", 50000);
Cluster cluster = new Cluster("MyCluster", new RoboServer[] {server}, false);
Request.registerCluster(cluster);
try {
Request request = new Request("Library:/Tutorials/NewsMagazine.robot");
request.setStopRobotOnApiException(false);  // IMPORTANT!!
request.setRobotLibrary(new DefaultRobotLibrary());
ErrorCollectingRobotResponseHandler handler = new ErrorCollectingRobotResponseHandler();
request.execute("MyCluster", handler);
System.out.println("Extracted values:");
for (RobotOutputObjectResponse response : handler.getOutput()) {
RQLObject value = response.getOutputObject();
Long personId = (Long) value.get("personId");
String name = (String) value.get("name");
Long age = (Long) value.get("age");
System.out.println(personId + ", " + name + ", " + age);
}
System.out.println("Errors:");
for (RobotErrorResponse error : handler.getErrors()) {
System.out.println(error.getErrorLocationCode() + ", " + error.getErrorMessage());
}
}
catch (RQLException e) {
e.printStackTrace();
}
}
private static class ErrorCollectingRobotResponseHandler extends AbstractFailFastRobotResponseHandler {
private List<RobotErrorResponse> _errors = new LinkedList<RobotErrorResponse>();
private List<RobotOutputObjectResponse> _output = new LinkedList<RobotOutputObjectResponse>();
public void handleReturnedValue(RobotOutputObjectResponse response, Stoppable stoppable) throws RQLException {
_output.add(response);
}
@Override
public void handleRobotError(RobotErrorResponse response, Stoppable stoppable) throws RQLException {
// do not call super as this will stop the robot
Documents you may be interested
Documents you may be interested