/*
* Copyright 2013, The Sporting Exchange Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* Copyright 2013, The Sporting Exchange Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* Copyright 2013, The Sporting Exchange Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
// Generated from clientSyncServiceImpl.ftl
package com.betfair.baseline.v2;
import com.betfair.baseline.v2.to.*;
import com.betfair.baseline.v2.enumerations.*;
import com.betfair.baseline.v2.exception.*;
import com.betfair.cougar.api.*;
import com.betfair.cougar.core.api.client.EnumWrapper;
import com.betfair.cougar.core.api.ServiceVersion;
import com.betfair.cougar.api.fault.CougarApplicationException;
import com.betfair.cougar.core.api.ev.*;
import com.betfair.cougar.core.api.exception.CougarException;
import com.betfair.cougar.core.api.exception.CougarClientException;
import com.betfair.cougar.core.api.exception.CougarFrameworkException;
import com.betfair.cougar.core.api.exception.ServerFaultCode;
import com.betfair.cougar.core.impl.DefaultTimeConstraints;
import com.betfair.tornjak.monitor.MonitorRegistry;
import java.util.*;
import java.util.concurrent.TimeoutException;
/**
*
* The Baseline Service
*/
/* * Copyright 2013, The Sporting Exchange Limited * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /* * Copyright 2013, The Sporting Exchange Limited * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ @SuppressWarnings("all")public class BaselineSyncClientImpl implements BaselineSyncClient {
private static final ServiceVersion serviceVersion = new ServiceVersion("v2.0");
private ExecutionVenue ev;
private String namespace;
/**
* Protected constructor and setters for backward compatibility
*/
protected BaselineSyncClientImpl() {
}
protected void setEv(ExecutionVenue ev) {
this.ev = ev;
}
protected void setNamespace(String namespace) {
this.namespace = namespace;
}
public BaselineSyncClientImpl(ExecutionVenue ev) {
this.ev = ev;
}
public BaselineSyncClientImpl(ExecutionVenue ev, String namespace) {
this.ev = ev;
this.namespace = namespace;
}
private OperationKey getOperationKey(OperationKey key) {
return namespace == null ? key : new OperationKey(key, namespace);
}
/**
* Echos list where the element itself is a complex type with mandatory items. Calls mandatoryCollectionElementTest allowing you to specify a timeout
* @param ctx the context of the request.
* @param inputList input list
* @param inputMap input map
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns void
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public void mandatoryCollectionElementTest (ExecutionContext ctx , List < ComplexObject > inputList , Map < String , ComplexObject > inputMap , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
mandatoryCollectionElementTest(ctx,inputList,inputMap, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Echos list where the element itself is a complex type with mandatory items. Calls mandatoryCollectionElementTest allowing you to specify a timeout
* @param ctx the context of the request.
* @param inputList input list
* @param inputMap input map
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns void
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public void mandatoryCollectionElementTest (ExecutionContext ctx , List < ComplexObject > inputList , Map < String , ComplexObject > inputMap , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.mandatoryCollectionElementTestKey),
new Object[] { inputList , inputMap },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation mandatoryCollectionElementTest timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return;
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Echos list where the element itself is a complex type with mandatory items
* @param ctx the context of the request.
* @param inputList input list
* @param inputMap input map
* @return returns void
*/
@Override
public void mandatoryCollectionElementTest (ExecutionContext ctx , List < ComplexObject > inputList , Map < String , ComplexObject > inputMap ) throws SimpleException {
try {
mandatoryCollectionElementTest(ctx,inputList,inputMap, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation mandatoryCollectionElementTest was interrupted!");
}
}
/**
* Will make a call that causes a SimpleException to be thrown from an interceptor. Calls interceptorCheckedExceptionOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param preOrPostException Set this parameter to PRE or POST for an exception to be thrown either pre or post execution
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns void
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public void interceptorCheckedExceptionOperation (ExecutionContext ctx , PreOrPostInterceptorException preOrPostException , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
interceptorCheckedExceptionOperation(ctx,preOrPostException, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Will make a call that causes a SimpleException to be thrown from an interceptor. Calls interceptorCheckedExceptionOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param preOrPostException Set this parameter to PRE or POST for an exception to be thrown either pre or post execution
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns void
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public void interceptorCheckedExceptionOperation (ExecutionContext ctx , PreOrPostInterceptorException preOrPostException , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.interceptorCheckedExceptionOperationKey),
new Object[] { preOrPostException },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation interceptorCheckedExceptionOperation timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return;
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Will make a call that causes a SimpleException to be thrown from an interceptor
* @param ctx the context of the request.
* @param preOrPostException Set this parameter to PRE or POST for an exception to be thrown either pre or post execution
* @return returns void
*/
@Override
public void interceptorCheckedExceptionOperation (ExecutionContext ctx , PreOrPostInterceptorException preOrPostException ) throws SimpleException {
try {
interceptorCheckedExceptionOperation(ctx,preOrPostException, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation interceptorCheckedExceptionOperation was interrupted!");
}
}
/**
* Operation to pass a list of complex objects to check missing fields of entries are detected. Calls listOfComplexOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param inputList input list
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns void
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public void listOfComplexOperation (ExecutionContext ctx , List < ComplexObject > inputList , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
listOfComplexOperation(ctx,inputList, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Operation to pass a list of complex objects to check missing fields of entries are detected. Calls listOfComplexOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param inputList input list
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns void
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public void listOfComplexOperation (ExecutionContext ctx , List < ComplexObject > inputList , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.listOfComplexOperationKey),
new Object[] { inputList },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation listOfComplexOperation timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return;
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Operation to pass a list of complex objects to check missing fields of entries are detected
* @param ctx the context of the request.
* @param inputList input list
* @return returns void
*/
@Override
public void listOfComplexOperation (ExecutionContext ctx , List < ComplexObject > inputList ) throws SimpleException {
try {
listOfComplexOperation(ctx,inputList, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation listOfComplexOperation was interrupted!");
}
}
/**
* Operation to pass a set of complex objects to check missing fields of entries are detected. Calls setOfComplexOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param inputSet input list
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns void
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public void setOfComplexOperation (ExecutionContext ctx , Set < ComplexObject > inputSet , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
setOfComplexOperation(ctx,inputSet, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Operation to pass a set of complex objects to check missing fields of entries are detected. Calls setOfComplexOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param inputSet input list
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns void
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public void setOfComplexOperation (ExecutionContext ctx , Set < ComplexObject > inputSet , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.setOfComplexOperationKey),
new Object[] { inputSet },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation setOfComplexOperation timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return;
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Operation to pass a set of complex objects to check missing fields of entries are detected
* @param ctx the context of the request.
* @param inputSet input list
* @return returns void
*/
@Override
public void setOfComplexOperation (ExecutionContext ctx , Set < ComplexObject > inputSet ) throws SimpleException {
try {
setOfComplexOperation(ctx,inputSet, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation setOfComplexOperation was interrupted!");
}
}
/**
* Operation to pass a map of string:complex objects to check missing fields of entries are detected. Calls mapOfComplexOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param inputMap input list
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns void
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public void mapOfComplexOperation (ExecutionContext ctx , Map < String , ComplexObject > inputMap , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
mapOfComplexOperation(ctx,inputMap, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Operation to pass a map of string:complex objects to check missing fields of entries are detected. Calls mapOfComplexOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param inputMap input list
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns void
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public void mapOfComplexOperation (ExecutionContext ctx , Map < String , ComplexObject > inputMap , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.mapOfComplexOperationKey),
new Object[] { inputMap },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation mapOfComplexOperation timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return;
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Operation to pass a map of string:complex objects to check missing fields of entries are detected
* @param ctx the context of the request.
* @param inputMap input list
* @return returns void
*/
@Override
public void mapOfComplexOperation (ExecutionContext ctx , Map < String , ComplexObject > inputMap ) throws SimpleException {
try {
mapOfComplexOperation(ctx,inputMap, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation mapOfComplexOperation was interrupted!");
}
}
/**
* Takes a list arg and echos it back in a list. Calls testSimpleDateListGet allowing you to specify a timeout
* @param ctx the context of the request.
* @param inputList the parameter name (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns List<Date>
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public List<Date> testSimpleDateListGet (ExecutionContext ctx , List < Date > inputList , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return testSimpleDateListGet(ctx,inputList, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Takes a list arg and echos it back in a list. Calls testSimpleDateListGet allowing you to specify a timeout
* @param ctx the context of the request.
* @param inputList the parameter name (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns List<Date>
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public List<Date> testSimpleDateListGet (ExecutionContext ctx , List < Date > inputList , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.testSimpleDateListGetKey),
new Object[] { inputList },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation testSimpleDateListGet timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (List<Date>) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Takes a list arg and echos it back in a list
* @param ctx the context of the request.
* @param inputList the parameter name (mandatory)
* @return returns List<Date>
*/
@Override
public List<Date> testSimpleDateListGet (ExecutionContext ctx , List < Date > inputList ) throws SimpleException {
try {
return testSimpleDateListGet(ctx,inputList, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation testSimpleDateListGet was interrupted!");
}
return null;
}
/**
* Takes a single arg and echos it back in a map. Calls testSimpleMapGet allowing you to specify a timeout
* @param ctx the context of the request.
* @param inputMap the parameter name (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns Map<String,String>
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public Map<String,String> testSimpleMapGet (ExecutionContext ctx , Map < String , String > inputMap , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return testSimpleMapGet(ctx,inputMap, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Takes a single arg and echos it back in a map. Calls testSimpleMapGet allowing you to specify a timeout
* @param ctx the context of the request.
* @param inputMap the parameter name (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns Map<String,String>
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public Map<String,String> testSimpleMapGet (ExecutionContext ctx , Map < String , String > inputMap , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.testSimpleMapGetKey),
new Object[] { inputMap },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation testSimpleMapGet timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (Map<String,String>) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Takes a single arg and echos it back in a map
* @param ctx the context of the request.
* @param inputMap the parameter name (mandatory)
* @return returns Map<String,String>
*/
@Override
public Map<String,String> testSimpleMapGet (ExecutionContext ctx , Map < String , String > inputMap ) throws SimpleException {
try {
return testSimpleMapGet(ctx,inputMap, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation testSimpleMapGet was interrupted!");
}
return null;
}
/**
* Takes a list arg and echos it back in a list. Calls testSimpleListGet allowing you to specify a timeout
* @param ctx the context of the request.
* @param inputList the parameter name (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns List<String>
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public List<String> testSimpleListGet (ExecutionContext ctx , List < String > inputList , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return testSimpleListGet(ctx,inputList, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Takes a list arg and echos it back in a list. Calls testSimpleListGet allowing you to specify a timeout
* @param ctx the context of the request.
* @param inputList the parameter name (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns List<String>
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public List<String> testSimpleListGet (ExecutionContext ctx , List < String > inputList , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.testSimpleListGetKey),
new Object[] { inputList },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation testSimpleListGet timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (List<String>) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Takes a list arg and echos it back in a list
* @param ctx the context of the request.
* @param inputList the parameter name (mandatory)
* @return returns List<String>
*/
@Override
public List<String> testSimpleListGet (ExecutionContext ctx , List < String > inputList ) throws SimpleException {
try {
return testSimpleListGet(ctx,inputList, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation testSimpleListGet was interrupted!");
}
return null;
}
/**
* Takes a set arg and echos it back in a set. Calls testSimpleSetGet allowing you to specify a timeout
* @param ctx the context of the request.
* @param inputSet the parameter name (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns Set<String>
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public Set<String> testSimpleSetGet (ExecutionContext ctx , Set < String > inputSet , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return testSimpleSetGet(ctx,inputSet, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Takes a set arg and echos it back in a set. Calls testSimpleSetGet allowing you to specify a timeout
* @param ctx the context of the request.
* @param inputSet the parameter name (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns Set<String>
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public Set<String> testSimpleSetGet (ExecutionContext ctx , Set < String > inputSet , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.testSimpleSetGetKey),
new Object[] { inputSet },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation testSimpleSetGet timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (Set<String>) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Takes a set arg and echos it back in a set
* @param ctx the context of the request.
* @param inputSet the parameter name (mandatory)
* @return returns Set<String>
*/
@Override
public Set<String> testSimpleSetGet (ExecutionContext ctx , Set < String > inputSet ) throws SimpleException {
try {
return testSimpleSetGet(ctx,inputSet, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation testSimpleSetGet was interrupted!");
}
return null;
}
/**
* test of an idempotent service. takes a single arg and echos it back. Calls testSimpleGet allowing you to specify a timeout
* @param ctx the context of the request.
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns SimpleResponse
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public SimpleResponse testSimpleGet (ExecutionContext ctx , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return testSimpleGet(ctx, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* test of an idempotent service. takes a single arg and echos it back. Calls testSimpleGet allowing you to specify a timeout
* @param ctx the context of the request.
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns SimpleResponse
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public SimpleResponse testSimpleGet (ExecutionContext ctx , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.testSimpleGetKey),
new Object[] { },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation testSimpleGet timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (SimpleResponse) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* test of an idempotent service. takes a single arg and echos it back
* @param ctx the context of the request.
* @return returns SimpleResponse
*/
@Override
public SimpleResponse testSimpleGet (ExecutionContext ctx ) throws SimpleException {
try {
return testSimpleGet(ctx, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation testSimpleGet was interrupted!");
}
return null;
}
/**
* test of an idempotent service. takes a single arg and echos it back. Calls testSimpleGetQA allowing you to specify a timeout
* @param ctx the context of the request.
* @param message the message to echo (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns SimpleResponse
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public SimpleResponse testSimpleGetQA (ExecutionContext ctx , String message , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return testSimpleGetQA(ctx,message, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* test of an idempotent service. takes a single arg and echos it back. Calls testSimpleGetQA allowing you to specify a timeout
* @param ctx the context of the request.
* @param message the message to echo (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns SimpleResponse
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public SimpleResponse testSimpleGetQA (ExecutionContext ctx , String message , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.testSimpleGetQAKey),
new Object[] { message },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation testSimpleGetQA timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (SimpleResponse) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* test of an idempotent service. takes a single arg and echos it back
* @param ctx the context of the request.
* @param message the message to echo (mandatory)
* @return returns SimpleResponse
*/
@Override
public SimpleResponse testSimpleGetQA (ExecutionContext ctx , String message ) throws SimpleException {
try {
return testSimpleGetQA(ctx,message, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation testSimpleGetQA was interrupted!");
}
return null;
}
/**
* Test of an idempotent service. Takes a number and returns a list of
complex objects of the size specified. Used to test output parsing speed. Calls testLargeGet allowing you to specify a timeout
* @param ctx the context of the request.
* @param size the list of complex objects (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns LargeRequest
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public LargeRequest testLargeGet (ExecutionContext ctx , Integer size , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return testLargeGet(ctx,size, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Test of an idempotent service. Takes a number and returns a list of
complex objects of the size specified. Used to test output parsing speed. Calls testLargeGet allowing you to specify a timeout
* @param ctx the context of the request.
* @param size the list of complex objects (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns LargeRequest
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public LargeRequest testLargeGet (ExecutionContext ctx , Integer size , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.testLargeGetKey),
new Object[] { size },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation testLargeGet timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (LargeRequest) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Test of an idempotent service. Takes a number and returns a list of
complex objects of the size specified. Used to test output parsing speed
* @param ctx the context of the request.
* @param size the list of complex objects (mandatory)
* @return returns LargeRequest
*/
@Override
public LargeRequest testLargeGet (ExecutionContext ctx , Integer size ) throws SimpleException {
try {
return testLargeGet(ctx,size, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation testLargeGet was interrupted!");
}
return null;
}
/**
* Test of an idempotent service. Takes a number and returns a list of
complex objects of the size specified. Used to test output parsing speed. Calls testLargeMapGet allowing you to specify a timeout
* @param ctx the context of the request.
* @param size the list of complex objects (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns MapDataType
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public MapDataType testLargeMapGet (ExecutionContext ctx , Integer size , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return testLargeMapGet(ctx,size, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Test of an idempotent service. Takes a number and returns a list of
complex objects of the size specified. Used to test output parsing speed. Calls testLargeMapGet allowing you to specify a timeout
* @param ctx the context of the request.
* @param size the list of complex objects (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns MapDataType
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public MapDataType testLargeMapGet (ExecutionContext ctx , Integer size , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.testLargeMapGetKey),
new Object[] { size },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation testLargeMapGet timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (MapDataType) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Test of an idempotent service. Takes a number and returns a list of
complex objects of the size specified. Used to test output parsing speed
* @param ctx the context of the request.
* @param size the list of complex objects (mandatory)
* @return returns MapDataType
*/
@Override
public MapDataType testLargeMapGet (ExecutionContext ctx , Integer size ) throws SimpleException {
try {
return testLargeMapGet(ctx,size, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation testLargeMapGet was interrupted!");
}
return null;
}
/**
* . Calls testMapsNameClash allowing you to specify a timeout
* @param ctx the context of the request.
* @param mapParam the list of complex objects (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns SimpleResponseMap
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public SimpleResponseMap testMapsNameClash (ExecutionContext ctx , SimpleMap mapParam , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return testMapsNameClash(ctx,mapParam, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* . Calls testMapsNameClash allowing you to specify a timeout
* @param ctx the context of the request.
* @param mapParam the list of complex objects (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns SimpleResponseMap
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public SimpleResponseMap testMapsNameClash (ExecutionContext ctx , SimpleMap mapParam , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.testMapsNameClashKey),
new Object[] { mapParam },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation testMapsNameClash timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (SimpleResponseMap) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
*
* @param ctx the context of the request.
* @param mapParam the list of complex objects (mandatory)
* @return returns SimpleResponseMap
*/
@Override
public SimpleResponseMap testMapsNameClash (ExecutionContext ctx , SimpleMap mapParam ) throws SimpleException {
try {
return testMapsNameClash(ctx,mapParam, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation testMapsNameClash was interrupted!");
}
return null;
}
/**
* provides a call that will sleep for the supplied period. Calls testSleep allowing you to specify a timeout
* @param ctx the context of the request.
* @param sleep The length of time in millis this method is to sleep. must be > 0 (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns void
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public void testSleep (ExecutionContext ctx , Long sleep , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
testSleep(ctx,sleep, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* provides a call that will sleep for the supplied period. Calls testSleep allowing you to specify a timeout
* @param ctx the context of the request.
* @param sleep The length of time in millis this method is to sleep. must be > 0 (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns void
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public void testSleep (ExecutionContext ctx , Long sleep , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.testSleepKey),
new Object[] { sleep },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation testSleep timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return;
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* provides a call that will sleep for the supplied period
* @param ctx the context of the request.
* @param sleep The length of time in millis this method is to sleep. must be > 0 (mandatory)
* @return returns void
*/
@Override
public void testSleep (ExecutionContext ctx , Long sleep ) throws SimpleException {
try {
testSleep(ctx,sleep, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation testSleep was interrupted!");
}
}
/**
* Ensure that REST parameters can be taken from different sources. Calls testParameterStyles allowing you to specify a timeout
* @param ctx the context of the request.
* @param HeaderParam the header parameter
* @param secondHeaderParam the second (unbounded) header parameter
* @param queryParam the query parameter (mandatory)
* @param dateQueryParam the query parameter (mandatory)
* @param ok some old stuff
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns List<String>
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public List<String> testParameterStyles (ExecutionContext ctx , TestParameterStylesHeaderParamEnum HeaderParam , String secondHeaderParam , String queryParam , Date dateQueryParam , Float ok , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return testParameterStyles(ctx,HeaderParam,secondHeaderParam,queryParam,dateQueryParam,ok, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Ensure that REST parameters can be taken from different sources. Calls testParameterStyles allowing you to specify a timeout
* @param ctx the context of the request.
* @param HeaderParam the header parameter
* @param secondHeaderParam the second (unbounded) header parameter
* @param queryParam the query parameter (mandatory)
* @param dateQueryParam the query parameter (mandatory)
* @param ok some old stuff
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns List<String>
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public List<String> testParameterStyles (ExecutionContext ctx , TestParameterStylesHeaderParamEnum HeaderParam , String secondHeaderParam , String queryParam , Date dateQueryParam , Float ok , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.testParameterStylesKey),
new Object[] { HeaderParam , secondHeaderParam , queryParam , dateQueryParam , ok },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation testParameterStyles timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (List<String>) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Ensure that REST parameters can be taken from different sources
* @param ctx the context of the request.
* @param HeaderParam the header parameter
* @param secondHeaderParam the second (unbounded) header parameter
* @param queryParam the query parameter (mandatory)
* @param dateQueryParam the query parameter (mandatory)
* @param ok some old stuff
* @return returns List<String>
*/
@Override
public List<String> testParameterStyles (ExecutionContext ctx , TestParameterStylesHeaderParamEnum HeaderParam , String secondHeaderParam , String queryParam , Date dateQueryParam , Float ok ) throws SimpleException {
try {
return testParameterStyles(ctx,HeaderParam,secondHeaderParam,queryParam,dateQueryParam,ok, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation testParameterStyles was interrupted!");
}
return null;
}
/**
* Ensure that REST parameters can be taken from different sources. Calls testParameterStylesQA allowing you to specify a timeout
* @param ctx the context of the request.
* @param HeaderParam the header parameter (mandatory)
* @param queryParam the query parameter (mandatory)
* @param dateQueryParam the query parameter (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns SimpleResponse
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public SimpleResponse testParameterStylesQA (ExecutionContext ctx , TestParameterStylesQAHeaderParamEnum HeaderParam , String queryParam , Date dateQueryParam , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return testParameterStylesQA(ctx,HeaderParam,queryParam,dateQueryParam, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Ensure that REST parameters can be taken from different sources. Calls testParameterStylesQA allowing you to specify a timeout
* @param ctx the context of the request.
* @param HeaderParam the header parameter (mandatory)
* @param queryParam the query parameter (mandatory)
* @param dateQueryParam the query parameter (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns SimpleResponse
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public SimpleResponse testParameterStylesQA (ExecutionContext ctx , TestParameterStylesQAHeaderParamEnum HeaderParam , String queryParam , Date dateQueryParam , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.testParameterStylesQAKey),
new Object[] { HeaderParam , queryParam , dateQueryParam },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation testParameterStylesQA timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (SimpleResponse) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Ensure that REST parameters can be taken from different sources
* @param ctx the context of the request.
* @param HeaderParam the header parameter (mandatory)
* @param queryParam the query parameter (mandatory)
* @param dateQueryParam the query parameter (mandatory)
* @return returns SimpleResponse
*/
@Override
public SimpleResponse testParameterStylesQA (ExecutionContext ctx , TestParameterStylesQAHeaderParamEnum HeaderParam , String queryParam , Date dateQueryParam ) throws SimpleException {
try {
return testParameterStylesQA(ctx,HeaderParam,queryParam,dateQueryParam, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation testParameterStylesQA was interrupted!");
}
return null;
}
/**
* Return some date information. Calls testDateRetrieval allowing you to specify a timeout
* @param ctx the context of the request.
* @param inputDates the query parameter (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns DateContainer
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public DateContainer testDateRetrieval (ExecutionContext ctx , DateContainer inputDates , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return testDateRetrieval(ctx,inputDates, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Return some date information. Calls testDateRetrieval allowing you to specify a timeout
* @param ctx the context of the request.
* @param inputDates the query parameter (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns DateContainer
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public DateContainer testDateRetrieval (ExecutionContext ctx , DateContainer inputDates , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.testDateRetrievalKey),
new Object[] { inputDates },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation testDateRetrieval timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (DateContainer) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Return some date information
* @param ctx the context of the request.
* @param inputDates the query parameter (mandatory)
* @return returns DateContainer
*/
@Override
public DateContainer testDateRetrieval (ExecutionContext ctx , DateContainer inputDates ) throws SimpleException {
try {
return testDateRetrieval(ctx,inputDates, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation testDateRetrieval was interrupted!");
}
return null;
}
/**
* Return some date information. Calls testDoubleHandling allowing you to specify a timeout
* @param ctx the context of the request.
* @param doubleContainer the query parameter (mandatory)
* @param doubleVal the query parameter (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns DoubleResponse
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public DoubleResponse testDoubleHandling (ExecutionContext ctx , DoubleContainer doubleContainer , Double doubleVal , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return testDoubleHandling(ctx,doubleContainer,doubleVal, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Return some date information. Calls testDoubleHandling allowing you to specify a timeout
* @param ctx the context of the request.
* @param doubleContainer the query parameter (mandatory)
* @param doubleVal the query parameter (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns DoubleResponse
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public DoubleResponse testDoubleHandling (ExecutionContext ctx , DoubleContainer doubleContainer , Double doubleVal , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.testDoubleHandlingKey),
new Object[] { doubleContainer , doubleVal },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation testDoubleHandling timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (DoubleResponse) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Return some date information
* @param ctx the context of the request.
* @param doubleContainer the query parameter (mandatory)
* @param doubleVal the query parameter (mandatory)
* @return returns DoubleResponse
*/
@Override
public DoubleResponse testDoubleHandling (ExecutionContext ctx , DoubleContainer doubleContainer , Double doubleVal ) throws SimpleException {
try {
return testDoubleHandling(ctx,doubleContainer,doubleVal, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation testDoubleHandling was interrupted!");
}
return null;
}
/**
* Return some lists. Calls testListRetrieval allowing you to specify a timeout
* @param ctx the context of the request.
* @param seed the seed (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns PrimitiveLists
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public PrimitiveLists testListRetrieval (ExecutionContext ctx , Integer seed , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return testListRetrieval(ctx,seed, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Return some lists. Calls testListRetrieval allowing you to specify a timeout
* @param ctx the context of the request.
* @param seed the seed (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns PrimitiveLists
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public PrimitiveLists testListRetrieval (ExecutionContext ctx , Integer seed , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.testListRetrievalKey),
new Object[] { seed },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation testListRetrieval timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (PrimitiveLists) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Return some lists
* @param ctx the context of the request.
* @param seed the seed (mandatory)
* @return returns PrimitiveLists
*/
@Override
public PrimitiveLists testListRetrieval (ExecutionContext ctx , Integer seed ) throws SimpleException {
try {
return testListRetrieval(ctx,seed, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation testListRetrieval was interrupted!");
}
return null;
}
/**
* test of a service that takes a complex object and returns a complex object. Calls testComplexMutator allowing you to specify a timeout
* @param ctx the context of the request.
* @param message the complex object (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns SimpleResponse
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public SimpleResponse testComplexMutator (ExecutionContext ctx , ComplexObject message , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return testComplexMutator(ctx,message, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* test of a service that takes a complex object and returns a complex object. Calls testComplexMutator allowing you to specify a timeout
* @param ctx the context of the request.
* @param message the complex object (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns SimpleResponse
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public SimpleResponse testComplexMutator (ExecutionContext ctx , ComplexObject message , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.testComplexMutatorKey),
new Object[] { message },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation testComplexMutator timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (SimpleResponse) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* test of a service that takes a complex object and returns a complex object
* @param ctx the context of the request.
* @param message the complex object (mandatory)
* @return returns SimpleResponse
*/
@Override
public SimpleResponse testComplexMutator (ExecutionContext ctx , ComplexObject message ) throws SimpleException {
try {
return testComplexMutator(ctx,message, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation testComplexMutator was interrupted!");
}
return null;
}
/**
* Takes a list of complex objects and returns the number of values in the list.
Used to test input parsing speed.. Calls testLargePost allowing you to specify a timeout
* @param ctx the context of the request.
* @param largeRequest the list of complex objects (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns SimpleResponse
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public SimpleResponse testLargePost (ExecutionContext ctx , LargeRequest largeRequest , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return testLargePost(ctx,largeRequest, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Takes a list of complex objects and returns the number of values in the list.
Used to test input parsing speed.. Calls testLargePost allowing you to specify a timeout
* @param ctx the context of the request.
* @param largeRequest the list of complex objects (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns SimpleResponse
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public SimpleResponse testLargePost (ExecutionContext ctx , LargeRequest largeRequest , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.testLargePostKey),
new Object[] { largeRequest },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation testLargePost timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (SimpleResponse) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Takes a list of complex objects and returns the number of values in the list.
Used to test input parsing speed.
* @param ctx the context of the request.
* @param largeRequest the list of complex objects (mandatory)
* @return returns SimpleResponse
*/
@Override
public SimpleResponse testLargePost (ExecutionContext ctx , LargeRequest largeRequest ) throws SimpleException {
try {
return testLargePost(ctx,largeRequest, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation testLargePost was interrupted!");
}
return null;
}
/**
* Takes a list of complex objects and returns the number of values in the list.
Used to test input parsing speed.. Calls testLargePostQA allowing you to specify a timeout
* @param ctx the context of the request.
* @param largeRequest the list of complex objects (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns SimpleResponse
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public SimpleResponse testLargePostQA (ExecutionContext ctx , LargeRequest largeRequest , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return testLargePostQA(ctx,largeRequest, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Takes a list of complex objects and returns the number of values in the list.
Used to test input parsing speed.. Calls testLargePostQA allowing you to specify a timeout
* @param ctx the context of the request.
* @param largeRequest the list of complex objects (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns SimpleResponse
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public SimpleResponse testLargePostQA (ExecutionContext ctx , LargeRequest largeRequest , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.testLargePostQAKey),
new Object[] { largeRequest },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation testLargePostQA timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (SimpleResponse) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Takes a list of complex objects and returns the number of values in the list.
Used to test input parsing speed.
* @param ctx the context of the request.
* @param largeRequest the list of complex objects (mandatory)
* @return returns SimpleResponse
*/
@Override
public SimpleResponse testLargePostQA (ExecutionContext ctx , LargeRequest largeRequest ) throws SimpleException {
try {
return testLargePostQA(ctx,largeRequest, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation testLargePostQA was interrupted!");
}
return null;
}
/**
* a service that always throws an exception. Calls testException allowing you to specify a timeout
* @param ctx the context of the request.
* @param responseCode The service response code (mandatory)
* @param message The service Parameter (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns SimpleResponse
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public SimpleResponse testException (ExecutionContext ctx , String responseCode , String message , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return testException(ctx,responseCode,message, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* a service that always throws an exception. Calls testException allowing you to specify a timeout
* @param ctx the context of the request.
* @param responseCode The service response code (mandatory)
* @param message The service Parameter (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns SimpleResponse
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public SimpleResponse testException (ExecutionContext ctx , String responseCode , String message , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.testExceptionKey),
new Object[] { responseCode , message },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation testException timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (SimpleResponse) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* a service that always throws an exception
* @param ctx the context of the request.
* @param responseCode The service response code (mandatory)
* @param message The service Parameter (mandatory)
* @return returns SimpleResponse
*/
@Override
public SimpleResponse testException (ExecutionContext ctx , String responseCode , String message ) throws SimpleException {
try {
return testException(ctx,responseCode,message, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation testException was interrupted!");
}
return null;
}
/**
* a service that always throws an exception. Calls testExceptionQA allowing you to specify a timeout
* @param ctx the context of the request.
* @param message The service Parameter (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns SimpleResponse
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
* @throws WotsitException if the remote Application threw WotsitException
*/
public SimpleResponse testExceptionQA (ExecutionContext ctx , String message , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException , WotsitException {
return testExceptionQA(ctx,message, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* a service that always throws an exception. Calls testExceptionQA allowing you to specify a timeout
* @param ctx the context of the request.
* @param message The service Parameter (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns SimpleResponse
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
* @throws WotsitException if the remote Application threw WotsitException
*/
public SimpleResponse testExceptionQA (ExecutionContext ctx , String message , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException , WotsitException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.testExceptionQAKey),
new Object[] { message },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation testExceptionQA timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (SimpleResponse) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else if (className.equals("WotsitException")) {
throw new WotsitException(
cex.getResponseCode(),
WotsitExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
WotsitExceptionTypeEnum.valueOf(exceptionParams.get(1)[1]),
(exceptionParams.get(2)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* a service that always throws an exception
* @param ctx the context of the request.
* @param message The service Parameter (mandatory)
* @return returns SimpleResponse
*/
@Override
public SimpleResponse testExceptionQA (ExecutionContext ctx , String message ) throws SimpleException, WotsitException {
try {
return testExceptionQA(ctx,message, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation testExceptionQA was interrupted!");
}
return null;
}
/**
* a service with a security attribute - cannot be called without an Authorisation token.
Models placing a bet on an Australian exchange
use CoUGARAUS as the token you should have permission to call the service
use CoUGARUK as the token and the call will be rejected
no token and the call will be rejected. Calls testSecureService allowing you to specify a timeout
* @param ctx the context of the request.
* @param message The service Parameter (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns SimpleResponse
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public SimpleResponse testSecureService (ExecutionContext ctx , String message , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return testSecureService(ctx,message, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* a service with a security attribute - cannot be called without an Authorisation token.
Models placing a bet on an Australian exchange
use CoUGARAUS as the token you should have permission to call the service
use CoUGARUK as the token and the call will be rejected
no token and the call will be rejected. Calls testSecureService allowing you to specify a timeout
* @param ctx the context of the request.
* @param message The service Parameter (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns SimpleResponse
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public SimpleResponse testSecureService (ExecutionContext ctx , String message , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.testSecureServiceKey),
new Object[] { message },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation testSecureService timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (SimpleResponse) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* a service with a security attribute - cannot be called without an Authorisation token.
Models placing a bet on an Australian exchange
use CoUGARAUS as the token you should have permission to call the service
use CoUGARUK as the token and the call will be rejected
no token and the call will be rejected
* @param ctx the context of the request.
* @param message The service Parameter (mandatory)
* @return returns SimpleResponse
*/
@Override
public SimpleResponse testSecureService (ExecutionContext ctx , String message ) throws SimpleException {
try {
return testSecureService(ctx,message, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation testSecureService was interrupted!");
}
return null;
}
/**
* No Params test. Calls testNoParams allowing you to specify a timeout
* @param ctx the context of the request.
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns NoParamsResponse
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public NoParamsResponse testNoParams (ExecutionContext ctx , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return testNoParams(ctx, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* No Params test. Calls testNoParams allowing you to specify a timeout
* @param ctx the context of the request.
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns NoParamsResponse
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public NoParamsResponse testNoParams (ExecutionContext ctx , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.testNoParamsKey),
new Object[] { },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation testNoParams timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (NoParamsResponse) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* No Params test
* @param ctx the context of the request.
* @return returns NoParamsResponse
*/
@Override
public NoParamsResponse testNoParams (ExecutionContext ctx ) throws SimpleException {
try {
return testNoParams(ctx, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation testNoParams was interrupted!");
}
return null;
}
/**
* Identity chain test. Calls testIdentityChain allowing you to specify a timeout
* @param ctx the context of the request.
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns IdentChain
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public IdentChain testIdentityChain (ExecutionContext ctx , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return testIdentityChain(ctx, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Identity chain test. Calls testIdentityChain allowing you to specify a timeout
* @param ctx the context of the request.
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns IdentChain
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public IdentChain testIdentityChain (ExecutionContext ctx , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.testIdentityChainKey),
new Object[] { },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation testIdentityChain timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (IdentChain) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Identity chain test
* @param ctx the context of the request.
* @return returns IdentChain
*/
@Override
public IdentChain testIdentityChain (ExecutionContext ctx ) throws SimpleException {
try {
return testIdentityChain(ctx, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation testIdentityChain was interrupted!");
}
return null;
}
/**
* Test that simple types are handled by Cougar. Calls testSimpleTypeReplacement allowing you to specify a timeout
* @param ctx the context of the request.
* @param simpleInt A simple value (mandatory)
* @param simpleDouble A simple value (mandatory)
* @param simpleString A simple value (mandatory)
* @param simpleEnum A simple value (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns SimpleContainer
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public SimpleContainer testSimpleTypeReplacement (ExecutionContext ctx , Integer simpleInt , Double simpleDouble , String simpleString , SimpleValidValue simpleEnum , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return testSimpleTypeReplacement(ctx,simpleInt,simpleDouble,simpleString,simpleEnum, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Test that simple types are handled by Cougar. Calls testSimpleTypeReplacement allowing you to specify a timeout
* @param ctx the context of the request.
* @param simpleInt A simple value (mandatory)
* @param simpleDouble A simple value (mandatory)
* @param simpleString A simple value (mandatory)
* @param simpleEnum A simple value (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns SimpleContainer
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public SimpleContainer testSimpleTypeReplacement (ExecutionContext ctx , Integer simpleInt , Double simpleDouble , String simpleString , SimpleValidValue simpleEnum , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.testSimpleTypeReplacementKey),
new Object[] { simpleInt , simpleDouble , simpleString , simpleEnum },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation testSimpleTypeReplacement timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (SimpleContainer) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Test that simple types are handled by Cougar
* @param ctx the context of the request.
* @param simpleInt A simple value (mandatory)
* @param simpleDouble A simple value (mandatory)
* @param simpleString A simple value (mandatory)
* @param simpleEnum A simple value (mandatory)
* @return returns SimpleContainer
*/
@Override
public SimpleContainer testSimpleTypeReplacement (ExecutionContext ctx , Integer simpleInt , Double simpleDouble , String simpleString , SimpleValidValue simpleEnum ) throws SimpleException {
try {
return testSimpleTypeReplacement(ctx,simpleInt,simpleDouble,simpleString,simpleEnum, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation testSimpleTypeReplacement was interrupted!");
}
return null;
}
/**
* Test that lists are stringable if they are enums or integers. Calls testStringableLists allowing you to specify a timeout
* @param ctx the context of the request.
* @param intList A simple value (mandatory)
* @param stringList A simple value (mandatory)
* @param enumList A simple value (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns SimpleListContainer
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public SimpleListContainer testStringableLists (ExecutionContext ctx , Set < Integer > intList , List < String > stringList , List < SimpleValidValue > enumList , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return testStringableLists(ctx,intList,stringList,enumList, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Test that lists are stringable if they are enums or integers. Calls testStringableLists allowing you to specify a timeout
* @param ctx the context of the request.
* @param intList A simple value (mandatory)
* @param stringList A simple value (mandatory)
* @param enumList A simple value (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns SimpleListContainer
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public SimpleListContainer testStringableLists (ExecutionContext ctx , Set < Integer > intList , List < String > stringList , List < SimpleValidValue > enumList , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.testStringableListsKey),
new Object[] { intList , stringList , enumList },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation testStringableLists timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (SimpleListContainer) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Test that lists are stringable if they are enums or integers
* @param ctx the context of the request.
* @param intList A simple value (mandatory)
* @param stringList A simple value (mandatory)
* @param enumList A simple value (mandatory)
* @return returns SimpleListContainer
*/
@Override
public SimpleListContainer testStringableLists (ExecutionContext ctx , Set < Integer > intList , List < String > stringList , List < SimpleValidValue > enumList ) throws SimpleException {
try {
return testStringableLists(ctx,intList,stringList,enumList, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation testStringableLists was interrupted!");
}
return null;
}
/**
* test of a multi-bodied service. Calls testBodyParams allowing you to specify a timeout
* @param ctx the context of the request.
* @param message the complex object (mandatory)
* @param value the complex object (mandatory)
* @param complex the complex object (mandatory)
* @param myEnum the complex object (mandatory)
* @param anotherComplex the complex object (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns SimpleResponse
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public SimpleResponse testBodyParams (ExecutionContext ctx , String message , Integer value , ComplexObject complex , SimpleValidValue myEnum , ComplexObject anotherComplex , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return testBodyParams(ctx,message,value,complex,myEnum,anotherComplex, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* test of a multi-bodied service. Calls testBodyParams allowing you to specify a timeout
* @param ctx the context of the request.
* @param message the complex object (mandatory)
* @param value the complex object (mandatory)
* @param complex the complex object (mandatory)
* @param myEnum the complex object (mandatory)
* @param anotherComplex the complex object (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns SimpleResponse
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public SimpleResponse testBodyParams (ExecutionContext ctx , String message , Integer value , ComplexObject complex , SimpleValidValue myEnum , ComplexObject anotherComplex , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.testBodyParamsKey),
new Object[] { message , value , complex , myEnum , anotherComplex },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation testBodyParams timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (SimpleResponse) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* test of a multi-bodied service
* @param ctx the context of the request.
* @param message the complex object (mandatory)
* @param value the complex object (mandatory)
* @param complex the complex object (mandatory)
* @param myEnum the complex object (mandatory)
* @param anotherComplex the complex object (mandatory)
* @return returns SimpleResponse
*/
@Override
public SimpleResponse testBodyParams (ExecutionContext ctx , String message , Integer value , ComplexObject complex , SimpleValidValue myEnum , ComplexObject anotherComplex ) throws SimpleException {
try {
return testBodyParams(ctx,message,value,complex,myEnum,anotherComplex, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation testBodyParams was interrupted!");
}
return null;
}
/**
* Return a map. Calls testDirectMapReturn allowing you to specify a timeout
* @param ctx the context of the request.
* @param seed the seed (mandatory)
* @param async how the result is to be returned (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns Map<String,SimpleResponse>
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public Map<String,SimpleResponse> testDirectMapReturn (ExecutionContext ctx , Integer seed , AsyncBehaviour async , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return testDirectMapReturn(ctx,seed,async, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Return a map. Calls testDirectMapReturn allowing you to specify a timeout
* @param ctx the context of the request.
* @param seed the seed (mandatory)
* @param async how the result is to be returned (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns Map<String,SimpleResponse>
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public Map<String,SimpleResponse> testDirectMapReturn (ExecutionContext ctx , Integer seed , AsyncBehaviour async , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.testDirectMapReturnKey),
new Object[] { seed , async },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation testDirectMapReturn timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (Map<String,SimpleResponse>) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Return a map
* @param ctx the context of the request.
* @param seed the seed (mandatory)
* @param async how the result is to be returned (mandatory)
* @return returns Map<String,SimpleResponse>
*/
@Override
public Map<String,SimpleResponse> testDirectMapReturn (ExecutionContext ctx , Integer seed , AsyncBehaviour async ) throws SimpleException {
try {
return testDirectMapReturn(ctx,seed,async, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation testDirectMapReturn was interrupted!");
}
return null;
}
/**
* Return a list. Calls testDirectListReturn allowing you to specify a timeout
* @param ctx the context of the request.
* @param seed the seed (mandatory)
* @param async how the result is to be returned (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns List<SimpleResponse>
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public List<SimpleResponse> testDirectListReturn (ExecutionContext ctx , Integer seed , AsyncBehaviour async , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return testDirectListReturn(ctx,seed,async, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Return a list. Calls testDirectListReturn allowing you to specify a timeout
* @param ctx the context of the request.
* @param seed the seed (mandatory)
* @param async how the result is to be returned (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns List<SimpleResponse>
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public List<SimpleResponse> testDirectListReturn (ExecutionContext ctx , Integer seed , AsyncBehaviour async , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.testDirectListReturnKey),
new Object[] { seed , async },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation testDirectListReturn timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (List<SimpleResponse>) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Return a list
* @param ctx the context of the request.
* @param seed the seed (mandatory)
* @param async how the result is to be returned (mandatory)
* @return returns List<SimpleResponse>
*/
@Override
public List<SimpleResponse> testDirectListReturn (ExecutionContext ctx , Integer seed , AsyncBehaviour async ) throws SimpleException {
try {
return testDirectListReturn(ctx,seed,async, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation testDirectListReturn was interrupted!");
}
return null;
}
/**
* logs a message. Calls kpiTesting allowing you to specify a timeout
* @param ctx the context of the request.
* @param message the message to log (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns SimpleResponse
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public SimpleResponse kpiTesting (ExecutionContext ctx , String message , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return kpiTesting(ctx,message, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* logs a message. Calls kpiTesting allowing you to specify a timeout
* @param ctx the context of the request.
* @param message the message to log (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns SimpleResponse
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public SimpleResponse kpiTesting (ExecutionContext ctx , String message , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.kpiTestingKey),
new Object[] { message },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation kpiTesting timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (SimpleResponse) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* logs a message
* @param ctx the context of the request.
* @param message the message to log (mandatory)
* @return returns SimpleResponse
*/
@Override
public SimpleResponse kpiTesting (ExecutionContext ctx , String message ) throws SimpleException {
try {
return kpiTesting(ctx,message, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation kpiTesting was interrupted!");
}
return null;
}
/**
* logs a message. Calls waitSeconds allowing you to specify a timeout
* @param ctx the context of the request.
* @param seconds the message to log (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns SimpleResponse
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public SimpleResponse waitSeconds (ExecutionContext ctx , String seconds , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return waitSeconds(ctx,seconds, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* logs a message. Calls waitSeconds allowing you to specify a timeout
* @param ctx the context of the request.
* @param seconds the message to log (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns SimpleResponse
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public SimpleResponse waitSeconds (ExecutionContext ctx , String seconds , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.waitSecondsKey),
new Object[] { seconds },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation waitSeconds timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (SimpleResponse) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* logs a message
* @param ctx the context of the request.
* @param seconds the message to log (mandatory)
* @return returns SimpleResponse
*/
@Override
public SimpleResponse waitSeconds (ExecutionContext ctx , String seconds ) throws SimpleException {
try {
return waitSeconds(ctx,seconds, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation waitSeconds was interrupted!");
}
return null;
}
/**
* logs a message. Calls logMessage allowing you to specify a timeout
* @param ctx the context of the request.
* @param logString the message to log (mandatory)
* @param logLevel log level (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns SimpleResponse
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public SimpleResponse logMessage (ExecutionContext ctx , String logString , String logLevel , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return logMessage(ctx,logString,logLevel, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* logs a message. Calls logMessage allowing you to specify a timeout
* @param ctx the context of the request.
* @param logString the message to log (mandatory)
* @param logLevel log level (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns SimpleResponse
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public SimpleResponse logMessage (ExecutionContext ctx , String logString , String logLevel , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.logMessageKey),
new Object[] { logString , logLevel },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation logMessage timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (SimpleResponse) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* logs a message
* @param ctx the context of the request.
* @param logString the message to log (mandatory)
* @param logLevel log level (mandatory)
* @return returns SimpleResponse
*/
@Override
public SimpleResponse logMessage (ExecutionContext ctx , String logString , String logLevel ) throws SimpleException {
try {
return logMessage(ctx,logString,logLevel, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation logMessage was interrupted!");
}
return null;
}
/**
* logs a message. Calls bulkCaller allowing you to specify a timeout
* @param ctx the context of the request.
* @param cycles The number of cycles (mandatory)
* @param logLevel log level
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns Long
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public Long bulkCaller (ExecutionContext ctx , Integer cycles , String logLevel , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return bulkCaller(ctx,cycles,logLevel, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* logs a message. Calls bulkCaller allowing you to specify a timeout
* @param ctx the context of the request.
* @param cycles The number of cycles (mandatory)
* @param logLevel log level
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns Long
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public Long bulkCaller (ExecutionContext ctx , Integer cycles , String logLevel , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.bulkCallerKey),
new Object[] { cycles , logLevel },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation bulkCaller timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (Long) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* logs a message
* @param ctx the context of the request.
* @param cycles The number of cycles (mandatory)
* @param logLevel log level
* @return returns Long
*/
@Override
public Long bulkCaller (ExecutionContext ctx , Integer cycles , String logLevel ) throws SimpleException {
try {
return bulkCaller(ctx,cycles,logLevel, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation bulkCaller was interrupted!");
}
return null;
}
/**
* logs a message. Calls changeLogLevel allowing you to specify a timeout
* @param ctx the context of the request.
* @param logName the name of the log to change logging level on (mandatory)
* @param level the logging level to set the log to (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns SimpleResponse
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public SimpleResponse changeLogLevel (ExecutionContext ctx , String logName , String level , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return changeLogLevel(ctx,logName,level, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* logs a message. Calls changeLogLevel allowing you to specify a timeout
* @param ctx the context of the request.
* @param logName the name of the log to change logging level on (mandatory)
* @param level the logging level to set the log to (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns SimpleResponse
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public SimpleResponse changeLogLevel (ExecutionContext ctx , String logName , String level , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.changeLogLevelKey),
new Object[] { logName , level },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation changeLogLevel timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (SimpleResponse) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* logs a message
* @param ctx the context of the request.
* @param logName the name of the log to change logging level on (mandatory)
* @param level the logging level to set the log to (mandatory)
* @return returns SimpleResponse
*/
@Override
public SimpleResponse changeLogLevel (ExecutionContext ctx , String logName , String level ) throws SimpleException {
try {
return changeLogLevel(ctx,logName,level, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation changeLogLevel was interrupted!");
}
return null;
}
/**
* Takes one of each rest parameter type, that is an enum. Calls enumOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param headerParam the header parameter (mandatory)
* @param queryParam the message to echo (mandatory)
* @param message the message to echo (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns EnumOperationResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public EnumOperationResponseObject enumOperation (ExecutionContext ctx , EnumOperationHeaderParamEnum headerParam , EnumOperationQueryParamEnum queryParam , BodyParamEnumObject message , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return enumOperation(ctx,headerParam,queryParam,message, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Takes one of each rest parameter type, that is an enum. Calls enumOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param headerParam the header parameter (mandatory)
* @param queryParam the message to echo (mandatory)
* @param message the message to echo (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns EnumOperationResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public EnumOperationResponseObject enumOperation (ExecutionContext ctx , EnumOperationHeaderParamEnum headerParam , EnumOperationQueryParamEnum queryParam , BodyParamEnumObject message , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.enumOperationKey),
new Object[] { headerParam , queryParam , message },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation enumOperation timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (EnumOperationResponseObject) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Takes one of each rest parameter type, that is an enum
* @param ctx the context of the request.
* @param headerParam the header parameter (mandatory)
* @param queryParam the message to echo (mandatory)
* @param message the message to echo (mandatory)
* @return returns EnumOperationResponseObject
*/
@Override
public EnumOperationResponseObject enumOperation (ExecutionContext ctx , EnumOperationHeaderParamEnum headerParam , EnumOperationQueryParamEnum queryParam , BodyParamEnumObject message ) throws SimpleException {
try {
return enumOperation(ctx,headerParam,queryParam,message, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation enumOperation was interrupted!");
}
return null;
}
/**
* Takes one of each rest parameter type, that is an Integer. Calls i32Operation allowing you to specify a timeout
* @param ctx the context of the request.
* @param headerParam the header parameter (mandatory)
* @param queryParam the message to echo (mandatory)
* @param message the message to echo (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns I32OperationResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public I32OperationResponseObject i32Operation (ExecutionContext ctx , Integer headerParam , Integer queryParam , BodyParamI32Object message , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return i32Operation(ctx,headerParam,queryParam,message, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Takes one of each rest parameter type, that is an Integer. Calls i32Operation allowing you to specify a timeout
* @param ctx the context of the request.
* @param headerParam the header parameter (mandatory)
* @param queryParam the message to echo (mandatory)
* @param message the message to echo (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns I32OperationResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public I32OperationResponseObject i32Operation (ExecutionContext ctx , Integer headerParam , Integer queryParam , BodyParamI32Object message , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.i32OperationKey),
new Object[] { headerParam , queryParam , message },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation i32Operation timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (I32OperationResponseObject) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Takes one of each rest parameter type, that is an Integer
* @param ctx the context of the request.
* @param headerParam the header parameter (mandatory)
* @param queryParam the message to echo (mandatory)
* @param message the message to echo (mandatory)
* @return returns I32OperationResponseObject
*/
@Override
public I32OperationResponseObject i32Operation (ExecutionContext ctx , Integer headerParam , Integer queryParam , BodyParamI32Object message ) throws SimpleException {
try {
return i32Operation(ctx,headerParam,queryParam,message, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation i32Operation was interrupted!");
}
return null;
}
/**
* Takes one of each rest parameter type, that is an Integer. Calls i64Operation allowing you to specify a timeout
* @param ctx the context of the request.
* @param headerParam the header parameter (mandatory)
* @param queryParam the message to echo (mandatory)
* @param message the message to echo (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns I64OperationResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public I64OperationResponseObject i64Operation (ExecutionContext ctx , Long headerParam , Long queryParam , BodyParamI64Object message , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return i64Operation(ctx,headerParam,queryParam,message, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Takes one of each rest parameter type, that is an Integer. Calls i64Operation allowing you to specify a timeout
* @param ctx the context of the request.
* @param headerParam the header parameter (mandatory)
* @param queryParam the message to echo (mandatory)
* @param message the message to echo (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns I64OperationResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public I64OperationResponseObject i64Operation (ExecutionContext ctx , Long headerParam , Long queryParam , BodyParamI64Object message , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.i64OperationKey),
new Object[] { headerParam , queryParam , message },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation i64Operation timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (I64OperationResponseObject) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Takes one of each rest parameter type, that is an Integer
* @param ctx the context of the request.
* @param headerParam the header parameter (mandatory)
* @param queryParam the message to echo (mandatory)
* @param message the message to echo (mandatory)
* @return returns I64OperationResponseObject
*/
@Override
public I64OperationResponseObject i64Operation (ExecutionContext ctx , Long headerParam , Long queryParam , BodyParamI64Object message ) throws SimpleException {
try {
return i64Operation(ctx,headerParam,queryParam,message, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation i64Operation was interrupted!");
}
return null;
}
/**
* Takes one of each rest parameter type, that is a byte. Calls byteOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param headerParam the header parameter (mandatory)
* @param queryParam the message to echo (mandatory)
* @param message the message to echo (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns ByteOperationResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public ByteOperationResponseObject byteOperation (ExecutionContext ctx , Byte headerParam , Byte queryParam , BodyParamByteObject message , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return byteOperation(ctx,headerParam,queryParam,message, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Takes one of each rest parameter type, that is a byte. Calls byteOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param headerParam the header parameter (mandatory)
* @param queryParam the message to echo (mandatory)
* @param message the message to echo (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns ByteOperationResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public ByteOperationResponseObject byteOperation (ExecutionContext ctx , Byte headerParam , Byte queryParam , BodyParamByteObject message , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.byteOperationKey),
new Object[] { headerParam , queryParam , message },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation byteOperation timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (ByteOperationResponseObject) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Takes one of each rest parameter type, that is a byte
* @param ctx the context of the request.
* @param headerParam the header parameter (mandatory)
* @param queryParam the message to echo (mandatory)
* @param message the message to echo (mandatory)
* @return returns ByteOperationResponseObject
*/
@Override
public ByteOperationResponseObject byteOperation (ExecutionContext ctx , Byte headerParam , Byte queryParam , BodyParamByteObject message ) throws SimpleException {
try {
return byteOperation(ctx,headerParam,queryParam,message, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation byteOperation was interrupted!");
}
return null;
}
/**
* Takes one of each rest parameter type, that is a Float. Calls floatOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param headerParam the header parameter (mandatory)
* @param queryParam the message to echo (mandatory)
* @param message the message to echo (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns FloatOperationResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public FloatOperationResponseObject floatOperation (ExecutionContext ctx , Float headerParam , Float queryParam , BodyParamFloatObject message , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return floatOperation(ctx,headerParam,queryParam,message, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Takes one of each rest parameter type, that is a Float. Calls floatOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param headerParam the header parameter (mandatory)
* @param queryParam the message to echo (mandatory)
* @param message the message to echo (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns FloatOperationResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public FloatOperationResponseObject floatOperation (ExecutionContext ctx , Float headerParam , Float queryParam , BodyParamFloatObject message , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.floatOperationKey),
new Object[] { headerParam , queryParam , message },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation floatOperation timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (FloatOperationResponseObject) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Takes one of each rest parameter type, that is a Float
* @param ctx the context of the request.
* @param headerParam the header parameter (mandatory)
* @param queryParam the message to echo (mandatory)
* @param message the message to echo (mandatory)
* @return returns FloatOperationResponseObject
*/
@Override
public FloatOperationResponseObject floatOperation (ExecutionContext ctx , Float headerParam , Float queryParam , BodyParamFloatObject message ) throws SimpleException {
try {
return floatOperation(ctx,headerParam,queryParam,message, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation floatOperation was interrupted!");
}
return null;
}
/**
* Takes one of each rest parameter type, that is a Double. Calls doubleOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param headerParam the header parameter (mandatory)
* @param queryParam the message to echo (mandatory)
* @param message the message to echo (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns DoubleOperationResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public DoubleOperationResponseObject doubleOperation (ExecutionContext ctx , Double headerParam , Double queryParam , BodyParamDoubleObject message , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return doubleOperation(ctx,headerParam,queryParam,message, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Takes one of each rest parameter type, that is a Double. Calls doubleOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param headerParam the header parameter (mandatory)
* @param queryParam the message to echo (mandatory)
* @param message the message to echo (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns DoubleOperationResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public DoubleOperationResponseObject doubleOperation (ExecutionContext ctx , Double headerParam , Double queryParam , BodyParamDoubleObject message , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.doubleOperationKey),
new Object[] { headerParam , queryParam , message },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation doubleOperation timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (DoubleOperationResponseObject) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Takes one of each rest parameter type, that is a Double
* @param ctx the context of the request.
* @param headerParam the header parameter (mandatory)
* @param queryParam the message to echo (mandatory)
* @param message the message to echo (mandatory)
* @return returns DoubleOperationResponseObject
*/
@Override
public DoubleOperationResponseObject doubleOperation (ExecutionContext ctx , Double headerParam , Double queryParam , BodyParamDoubleObject message ) throws SimpleException {
try {
return doubleOperation(ctx,headerParam,queryParam,message, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation doubleOperation was interrupted!");
}
return null;
}
/**
* Takes one of each rest parameter type, that is a Boolean. Calls boolOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param headerParam the header parameter (mandatory)
* @param queryParam the message to echo (mandatory)
* @param message the message to echo (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns BoolOperationResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public BoolOperationResponseObject boolOperation (ExecutionContext ctx , Boolean headerParam , Boolean queryParam , BodyParamBoolObject message , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return boolOperation(ctx,headerParam,queryParam,message, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Takes one of each rest parameter type, that is a Boolean. Calls boolOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param headerParam the header parameter (mandatory)
* @param queryParam the message to echo (mandatory)
* @param message the message to echo (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns BoolOperationResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public BoolOperationResponseObject boolOperation (ExecutionContext ctx , Boolean headerParam , Boolean queryParam , BodyParamBoolObject message , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.boolOperationKey),
new Object[] { headerParam , queryParam , message },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation boolOperation timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (BoolOperationResponseObject) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Takes one of each rest parameter type, that is a Boolean
* @param ctx the context of the request.
* @param headerParam the header parameter (mandatory)
* @param queryParam the message to echo (mandatory)
* @param message the message to echo (mandatory)
* @return returns BoolOperationResponseObject
*/
@Override
public BoolOperationResponseObject boolOperation (ExecutionContext ctx , Boolean headerParam , Boolean queryParam , BodyParamBoolObject message ) throws SimpleException {
try {
return boolOperation(ctx,headerParam,queryParam,message, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation boolOperation was interrupted!");
}
return null;
}
/**
* Takes one of each rest parameter type, but they are not mandatory (barring path which is always mandatory). Calls nonMandatoryParamsOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param queryParam the message to echo
* @param message the message to echo (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns NonMandatoryParamsOperationResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public NonMandatoryParamsOperationResponseObject nonMandatoryParamsOperation (ExecutionContext ctx , String queryParam , NonMandatoryParamsRequest message , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return nonMandatoryParamsOperation(ctx,queryParam,message, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Takes one of each rest parameter type, but they are not mandatory (barring path which is always mandatory). Calls nonMandatoryParamsOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param queryParam the message to echo
* @param message the message to echo (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns NonMandatoryParamsOperationResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public NonMandatoryParamsOperationResponseObject nonMandatoryParamsOperation (ExecutionContext ctx , String queryParam , NonMandatoryParamsRequest message , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.nonMandatoryParamsOperationKey),
new Object[] { queryParam , message },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation nonMandatoryParamsOperation timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (NonMandatoryParamsOperationResponseObject) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Takes one of each rest parameter type, but they are not mandatory (barring path which is always mandatory)
* @param ctx the context of the request.
* @param queryParam the message to echo
* @param message the message to echo (mandatory)
* @return returns NonMandatoryParamsOperationResponseObject
*/
@Override
public NonMandatoryParamsOperationResponseObject nonMandatoryParamsOperation (ExecutionContext ctx , String queryParam , NonMandatoryParamsRequest message ) throws SimpleException {
try {
return nonMandatoryParamsOperation(ctx,queryParam,message, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation nonMandatoryParamsOperation was interrupted!");
}
return null;
}
/**
* Takes one of each rest parameter type, but they are not mandatory (barring path which is always mandatory). Calls mandatoryParamsOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param headerParam the header parameter (mandatory)
* @param queryParam the message to echo (mandatory)
* @param message the message to echo (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns MandatoryParamsOperationResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public MandatoryParamsOperationResponseObject mandatoryParamsOperation (ExecutionContext ctx , String headerParam , String queryParam , MandatoryParamsRequest message , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return mandatoryParamsOperation(ctx,headerParam,queryParam,message, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Takes one of each rest parameter type, but they are not mandatory (barring path which is always mandatory). Calls mandatoryParamsOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param headerParam the header parameter (mandatory)
* @param queryParam the message to echo (mandatory)
* @param message the message to echo (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns MandatoryParamsOperationResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public MandatoryParamsOperationResponseObject mandatoryParamsOperation (ExecutionContext ctx , String headerParam , String queryParam , MandatoryParamsRequest message , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.mandatoryParamsOperationKey),
new Object[] { headerParam , queryParam , message },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation mandatoryParamsOperation timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (MandatoryParamsOperationResponseObject) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Takes one of each rest parameter type, but they are not mandatory (barring path which is always mandatory)
* @param ctx the context of the request.
* @param headerParam the header parameter (mandatory)
* @param queryParam the message to echo (mandatory)
* @param message the message to echo (mandatory)
* @return returns MandatoryParamsOperationResponseObject
*/
@Override
public MandatoryParamsOperationResponseObject mandatoryParamsOperation (ExecutionContext ctx , String headerParam , String queryParam , MandatoryParamsRequest message ) throws SimpleException {
try {
return mandatoryParamsOperation(ctx,headerParam,queryParam,message, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation mandatoryParamsOperation was interrupted!");
}
return null;
}
/**
* Sets the Baseline2 service's healthy status. Calls setHealthStatusInfo allowing you to specify a timeout
* @param ctx the context of the request.
* @param message the message to echo (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns SimpleResponse
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public SimpleResponse setHealthStatusInfo (ExecutionContext ctx , HealthStatusInfoRequest message , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return setHealthStatusInfo(ctx,message, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Sets the Baseline2 service's healthy status. Calls setHealthStatusInfo allowing you to specify a timeout
* @param ctx the context of the request.
* @param message the message to echo (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns SimpleResponse
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public SimpleResponse setHealthStatusInfo (ExecutionContext ctx , HealthStatusInfoRequest message , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.setHealthStatusInfoKey),
new Object[] { message },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation setHealthStatusInfo timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (SimpleResponse) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Sets the Baseline2 service's healthy status
* @param ctx the context of the request.
* @param message the message to echo (mandatory)
* @return returns SimpleResponse
*/
@Override
public SimpleResponse setHealthStatusInfo (ExecutionContext ctx , HealthStatusInfoRequest message ) throws SimpleException {
try {
return setHealthStatusInfo(ctx,message, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation setHealthStatusInfo was interrupted!");
}
return null;
}
/**
* Takes one of each rest parameter type, that is a dateTime. Calls dateTimeOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param bodyParamDateTimeObject the message to echo (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns DateTimeOperationResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public DateTimeOperationResponseObject dateTimeOperation (ExecutionContext ctx , BodyParamDateTimeObject bodyParamDateTimeObject , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return dateTimeOperation(ctx,bodyParamDateTimeObject, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Takes one of each rest parameter type, that is a dateTime. Calls dateTimeOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param bodyParamDateTimeObject the message to echo (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns DateTimeOperationResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public DateTimeOperationResponseObject dateTimeOperation (ExecutionContext ctx , BodyParamDateTimeObject bodyParamDateTimeObject , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.dateTimeOperationKey),
new Object[] { bodyParamDateTimeObject },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation dateTimeOperation timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (DateTimeOperationResponseObject) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Takes one of each rest parameter type, that is a dateTime
* @param ctx the context of the request.
* @param bodyParamDateTimeObject the message to echo (mandatory)
* @return returns DateTimeOperationResponseObject
*/
@Override
public DateTimeOperationResponseObject dateTimeOperation (ExecutionContext ctx , BodyParamDateTimeObject bodyParamDateTimeObject ) throws SimpleException {
try {
return dateTimeOperation(ctx,bodyParamDateTimeObject, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation dateTimeOperation was interrupted!");
}
return null;
}
/**
* Takes a post body that contains a simple (string, string) map. Calls simpleMapOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param message the message to echo (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns SimpleMapOperationResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public SimpleMapOperationResponseObject simpleMapOperation (ExecutionContext ctx , BodyParamSimpleMapObject message , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return simpleMapOperation(ctx,message, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Takes a post body that contains a simple (string, string) map. Calls simpleMapOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param message the message to echo (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns SimpleMapOperationResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public SimpleMapOperationResponseObject simpleMapOperation (ExecutionContext ctx , BodyParamSimpleMapObject message , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.simpleMapOperationKey),
new Object[] { message },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation simpleMapOperation timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (SimpleMapOperationResponseObject) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Takes a post body that contains a simple (string, string) map
* @param ctx the context of the request.
* @param message the message to echo (mandatory)
* @return returns SimpleMapOperationResponseObject
*/
@Override
public SimpleMapOperationResponseObject simpleMapOperation (ExecutionContext ctx , BodyParamSimpleMapObject message ) throws SimpleException {
try {
return simpleMapOperation(ctx,message, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation simpleMapOperation was interrupted!");
}
return null;
}
/**
* Takes a post body that contains a more complex (string, some complex object) map. Calls complexMapOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param message the message to echo (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns ComplexMapOperationResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public ComplexMapOperationResponseObject complexMapOperation (ExecutionContext ctx , BodyParamComplexMapObject message , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return complexMapOperation(ctx,message, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Takes a post body that contains a more complex (string, some complex object) map. Calls complexMapOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param message the message to echo (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns ComplexMapOperationResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public ComplexMapOperationResponseObject complexMapOperation (ExecutionContext ctx , BodyParamComplexMapObject message , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.complexMapOperationKey),
new Object[] { message },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation complexMapOperation timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (ComplexMapOperationResponseObject) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Takes a post body that contains a more complex (string, some complex object) map
* @param ctx the context of the request.
* @param message the message to echo (mandatory)
* @return returns ComplexMapOperationResponseObject
*/
@Override
public ComplexMapOperationResponseObject complexMapOperation (ExecutionContext ctx , BodyParamComplexMapObject message ) throws SimpleException {
try {
return complexMapOperation(ctx,message, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation complexMapOperation was interrupted!");
}
return null;
}
/**
* Takes a post body that contains a simple (string) set. Calls simpleSetOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param message the message to echo (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns SimpleSetOperationResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public SimpleSetOperationResponseObject simpleSetOperation (ExecutionContext ctx , BodyParamSimpleSetObject message , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return simpleSetOperation(ctx,message, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Takes a post body that contains a simple (string) set. Calls simpleSetOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param message the message to echo (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns SimpleSetOperationResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public SimpleSetOperationResponseObject simpleSetOperation (ExecutionContext ctx , BodyParamSimpleSetObject message , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.simpleSetOperationKey),
new Object[] { message },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation simpleSetOperation timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (SimpleSetOperationResponseObject) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Takes a post body that contains a simple (string) set
* @param ctx the context of the request.
* @param message the message to echo (mandatory)
* @return returns SimpleSetOperationResponseObject
*/
@Override
public SimpleSetOperationResponseObject simpleSetOperation (ExecutionContext ctx , BodyParamSimpleSetObject message ) throws SimpleException {
try {
return simpleSetOperation(ctx,message, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation simpleSetOperation was interrupted!");
}
return null;
}
/**
* Takes a post body that contains a more complex (some complex object) set. Calls complexSetOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param message the message to echo (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns ComplexSetOperationResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public ComplexSetOperationResponseObject complexSetOperation (ExecutionContext ctx , BodyParamComplexSetObject message , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return complexSetOperation(ctx,message, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Takes a post body that contains a more complex (some complex object) set. Calls complexSetOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param message the message to echo (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns ComplexSetOperationResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public ComplexSetOperationResponseObject complexSetOperation (ExecutionContext ctx , BodyParamComplexSetObject message , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.complexSetOperationKey),
new Object[] { message },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation complexSetOperation timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (ComplexSetOperationResponseObject) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Takes a post body that contains a more complex (some complex object) set
* @param ctx the context of the request.
* @param message the message to echo (mandatory)
* @return returns ComplexSetOperationResponseObject
*/
@Override
public ComplexSetOperationResponseObject complexSetOperation (ExecutionContext ctx , BodyParamComplexSetObject message ) throws SimpleException {
try {
return complexSetOperation(ctx,message, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation complexSetOperation was interrupted!");
}
return null;
}
/**
* Takes a post body that contains a more complex (dateTime object) set. Calls dateTimeSetOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param message the message to echo (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns DateTimeSetOperationResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public DateTimeSetOperationResponseObject dateTimeSetOperation (ExecutionContext ctx , BodyParamDateTimeSetObject message , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return dateTimeSetOperation(ctx,message, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Takes a post body that contains a more complex (dateTime object) set. Calls dateTimeSetOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param message the message to echo (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns DateTimeSetOperationResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public DateTimeSetOperationResponseObject dateTimeSetOperation (ExecutionContext ctx , BodyParamDateTimeSetObject message , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.dateTimeSetOperationKey),
new Object[] { message },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation dateTimeSetOperation timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (DateTimeSetOperationResponseObject) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Takes a post body that contains a more complex (dateTime object) set
* @param ctx the context of the request.
* @param message the message to echo (mandatory)
* @return returns DateTimeSetOperationResponseObject
*/
@Override
public DateTimeSetOperationResponseObject dateTimeSetOperation (ExecutionContext ctx , BodyParamDateTimeSetObject message ) throws SimpleException {
try {
return dateTimeSetOperation(ctx,message, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation dateTimeSetOperation was interrupted!");
}
return null;
}
/**
* Takes a post body that contains a date time list. Calls dateTimeListOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param message the message to echo (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns DateTimeListOperationResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public DateTimeListOperationResponseObject dateTimeListOperation (ExecutionContext ctx , BodyParamDateTimeListObject message , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return dateTimeListOperation(ctx,message, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Takes a post body that contains a date time list. Calls dateTimeListOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param message the message to echo (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns DateTimeListOperationResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public DateTimeListOperationResponseObject dateTimeListOperation (ExecutionContext ctx , BodyParamDateTimeListObject message , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.dateTimeListOperationKey),
new Object[] { message },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation dateTimeListOperation timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (DateTimeListOperationResponseObject) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Takes a post body that contains a date time list
* @param ctx the context of the request.
* @param message the message to echo (mandatory)
* @return returns DateTimeListOperationResponseObject
*/
@Override
public DateTimeListOperationResponseObject dateTimeListOperation (ExecutionContext ctx , BodyParamDateTimeListObject message ) throws SimpleException {
try {
return dateTimeListOperation(ctx,message, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation dateTimeListOperation was interrupted!");
}
return null;
}
/**
* Takes a post body that contains a date time map. Calls dateTimeMapOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param message the message to echo (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns DateTimeMapOperationResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public DateTimeMapOperationResponseObject dateTimeMapOperation (ExecutionContext ctx , BodyParamDateTimeMapObject message , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return dateTimeMapOperation(ctx,message, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Takes a post body that contains a date time map. Calls dateTimeMapOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param message the message to echo (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns DateTimeMapOperationResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public DateTimeMapOperationResponseObject dateTimeMapOperation (ExecutionContext ctx , BodyParamDateTimeMapObject message , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.dateTimeMapOperationKey),
new Object[] { message },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation dateTimeMapOperation timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (DateTimeMapOperationResponseObject) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Takes a post body that contains a date time map
* @param ctx the context of the request.
* @param message the message to echo (mandatory)
* @return returns DateTimeMapOperationResponseObject
*/
@Override
public DateTimeMapOperationResponseObject dateTimeMapOperation (ExecutionContext ctx , BodyParamDateTimeMapObject message ) throws SimpleException {
try {
return dateTimeMapOperation(ctx,message, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation dateTimeMapOperation was interrupted!");
}
return null;
}
/**
* Takes a post body that contains a map with a date time key. Calls mapDateTimeKeyOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param message the message to echo (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns MapDateTimeKeyOperationResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public MapDateTimeKeyOperationResponseObject mapDateTimeKeyOperation (ExecutionContext ctx , BodyParamMapDateTimeKeyObject message , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return mapDateTimeKeyOperation(ctx,message, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Takes a post body that contains a map with a date time key. Calls mapDateTimeKeyOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param message the message to echo (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns MapDateTimeKeyOperationResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public MapDateTimeKeyOperationResponseObject mapDateTimeKeyOperation (ExecutionContext ctx , BodyParamMapDateTimeKeyObject message , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.mapDateTimeKeyOperationKey),
new Object[] { message },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation mapDateTimeKeyOperation timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (MapDateTimeKeyOperationResponseObject) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Takes a post body that contains a map with a date time key
* @param ctx the context of the request.
* @param message the message to echo (mandatory)
* @return returns MapDateTimeKeyOperationResponseObject
*/
@Override
public MapDateTimeKeyOperationResponseObject mapDateTimeKeyOperation (ExecutionContext ctx , BodyParamMapDateTimeKeyObject message ) throws SimpleException {
try {
return mapDateTimeKeyOperation(ctx,message, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation mapDateTimeKeyOperation was interrupted!");
}
return null;
}
/**
* Takes one of each rest parameter type, that is an Integer. Calls i32SimpleTypeOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param headerParam the header parameter (mandatory)
* @param queryParam the message to echo (mandatory)
* @param message the message to echo (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns I32SimpleOperationResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public I32SimpleOperationResponseObject i32SimpleTypeOperation (ExecutionContext ctx , Integer headerParam , Integer queryParam , I32SimpleTypeRequestObject message , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return i32SimpleTypeOperation(ctx,headerParam,queryParam,message, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Takes one of each rest parameter type, that is an Integer. Calls i32SimpleTypeOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param headerParam the header parameter (mandatory)
* @param queryParam the message to echo (mandatory)
* @param message the message to echo (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns I32SimpleOperationResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public I32SimpleOperationResponseObject i32SimpleTypeOperation (ExecutionContext ctx , Integer headerParam , Integer queryParam , I32SimpleTypeRequestObject message , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.i32SimpleTypeOperationKey),
new Object[] { headerParam , queryParam , message },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation i32SimpleTypeOperation timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (I32SimpleOperationResponseObject) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Takes one of each rest parameter type, that is an Integer
* @param ctx the context of the request.
* @param headerParam the header parameter (mandatory)
* @param queryParam the message to echo (mandatory)
* @param message the message to echo (mandatory)
* @return returns I32SimpleOperationResponseObject
*/
@Override
public I32SimpleOperationResponseObject i32SimpleTypeOperation (ExecutionContext ctx , Integer headerParam , Integer queryParam , I32SimpleTypeRequestObject message ) throws SimpleException {
try {
return i32SimpleTypeOperation(ctx,headerParam,queryParam,message, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation i32SimpleTypeOperation was interrupted!");
}
return null;
}
/**
* Takes one of each rest parameter type, that is an enum. Calls enumSimpleOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param headerParam the header parameter (mandatory)
* @param queryParam the message to echo (mandatory)
* @param message the message to echo (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns EnumSimpleResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public EnumSimpleResponseObject enumSimpleOperation (ExecutionContext ctx , SimpleEnum headerParam , SimpleEnum queryParam , EnumSimpleRequestObject message , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return enumSimpleOperation(ctx,headerParam,queryParam,message, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Takes one of each rest parameter type, that is an enum. Calls enumSimpleOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param headerParam the header parameter (mandatory)
* @param queryParam the message to echo (mandatory)
* @param message the message to echo (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns EnumSimpleResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public EnumSimpleResponseObject enumSimpleOperation (ExecutionContext ctx , SimpleEnum headerParam , SimpleEnum queryParam , EnumSimpleRequestObject message , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.enumSimpleOperationKey),
new Object[] { headerParam , queryParam , message },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation enumSimpleOperation timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (EnumSimpleResponseObject) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Takes one of each rest parameter type, that is an enum
* @param ctx the context of the request.
* @param headerParam the header parameter (mandatory)
* @param queryParam the message to echo (mandatory)
* @param message the message to echo (mandatory)
* @return returns EnumSimpleResponseObject
*/
@Override
public EnumSimpleResponseObject enumSimpleOperation (ExecutionContext ctx , SimpleEnum headerParam , SimpleEnum queryParam , EnumSimpleRequestObject message ) throws SimpleException {
try {
return enumSimpleOperation(ctx,headerParam,queryParam,message, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation enumSimpleOperation was interrupted!");
}
return null;
}
/**
* Takes one of each rest parameter type, that is an list of strings. Calls stringListOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param headerParam list of strings (mandatory)
* @param queryParam list of strings (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns NonMandatoryParamsOperationResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public NonMandatoryParamsOperationResponseObject stringListOperation (ExecutionContext ctx , List < String > headerParam , List < String > queryParam , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return stringListOperation(ctx,headerParam,queryParam, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Takes one of each rest parameter type, that is an list of strings. Calls stringListOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param headerParam list of strings (mandatory)
* @param queryParam list of strings (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns NonMandatoryParamsOperationResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public NonMandatoryParamsOperationResponseObject stringListOperation (ExecutionContext ctx , List < String > headerParam , List < String > queryParam , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.stringListOperationKey),
new Object[] { headerParam , queryParam },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation stringListOperation timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (NonMandatoryParamsOperationResponseObject) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Takes one of each rest parameter type, that is an list of strings
* @param ctx the context of the request.
* @param headerParam list of strings (mandatory)
* @param queryParam list of strings (mandatory)
* @return returns NonMandatoryParamsOperationResponseObject
*/
@Override
public NonMandatoryParamsOperationResponseObject stringListOperation (ExecutionContext ctx , List < String > headerParam , List < String > queryParam ) throws SimpleException {
try {
return stringListOperation(ctx,headerParam,queryParam, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation stringListOperation was interrupted!");
}
return null;
}
/**
* Takes one of each rest parameter type, that is an set of strings. Calls stringSetOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param headerParam set of strings (mandatory)
* @param queryParam set of strings (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns NonMandatoryParamsOperationResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public NonMandatoryParamsOperationResponseObject stringSetOperation (ExecutionContext ctx , Set < String > headerParam , Set < String > queryParam , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return stringSetOperation(ctx,headerParam,queryParam, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Takes one of each rest parameter type, that is an set of strings. Calls stringSetOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param headerParam set of strings (mandatory)
* @param queryParam set of strings (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns NonMandatoryParamsOperationResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public NonMandatoryParamsOperationResponseObject stringSetOperation (ExecutionContext ctx , Set < String > headerParam , Set < String > queryParam , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.stringSetOperationKey),
new Object[] { headerParam , queryParam },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation stringSetOperation timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (NonMandatoryParamsOperationResponseObject) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Takes one of each rest parameter type, that is an set of strings
* @param ctx the context of the request.
* @param headerParam set of strings (mandatory)
* @param queryParam set of strings (mandatory)
* @return returns NonMandatoryParamsOperationResponseObject
*/
@Override
public NonMandatoryParamsOperationResponseObject stringSetOperation (ExecutionContext ctx , Set < String > headerParam , Set < String > queryParam ) throws SimpleException {
try {
return stringSetOperation(ctx,headerParam,queryParam, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation stringSetOperation was interrupted!");
}
return null;
}
/**
* Takes one of each rest parameter type, that is an list of SimpleEnums. Calls simpleEnumListOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param headerParam list of SimpleEnum (mandatory)
* @param queryParam list of SimpleEnum (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns NonMandatoryParamsOperationResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public NonMandatoryParamsOperationResponseObject simpleEnumListOperation (ExecutionContext ctx , List < SimpleEnum > headerParam , List < SimpleEnum > queryParam , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return simpleEnumListOperation(ctx,headerParam,queryParam, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Takes one of each rest parameter type, that is an list of SimpleEnums. Calls simpleEnumListOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param headerParam list of SimpleEnum (mandatory)
* @param queryParam list of SimpleEnum (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns NonMandatoryParamsOperationResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public NonMandatoryParamsOperationResponseObject simpleEnumListOperation (ExecutionContext ctx , List < SimpleEnum > headerParam , List < SimpleEnum > queryParam , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.simpleEnumListOperationKey),
new Object[] { headerParam , queryParam },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation simpleEnumListOperation timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (NonMandatoryParamsOperationResponseObject) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Takes one of each rest parameter type, that is an list of SimpleEnums
* @param ctx the context of the request.
* @param headerParam list of SimpleEnum (mandatory)
* @param queryParam list of SimpleEnum (mandatory)
* @return returns NonMandatoryParamsOperationResponseObject
*/
@Override
public NonMandatoryParamsOperationResponseObject simpleEnumListOperation (ExecutionContext ctx , List < SimpleEnum > headerParam , List < SimpleEnum > queryParam ) throws SimpleException {
try {
return simpleEnumListOperation(ctx,headerParam,queryParam, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation simpleEnumListOperation was interrupted!");
}
return null;
}
/**
* returns a valid from the valid set. Calls callWithEnumResponse allowing you to specify a timeout
* @param ctx the context of the request.
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns EnumWrapper<SimpleValidValue>
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public EnumWrapper<SimpleValidValue> callWithEnumResponse (ExecutionContext ctx , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return callWithEnumResponse(ctx, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* returns a valid from the valid set. Calls callWithEnumResponse allowing you to specify a timeout
* @param ctx the context of the request.
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns EnumWrapper<SimpleValidValue>
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public EnumWrapper<SimpleValidValue> callWithEnumResponse (ExecutionContext ctx , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.callWithEnumResponseKey),
new Object[] { },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation callWithEnumResponse timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (EnumWrapper<SimpleValidValue>) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* returns a valid from the valid set
* @param ctx the context of the request.
* @return returns EnumWrapper<SimpleValidValue>
*/
@Override
public EnumWrapper<SimpleValidValue> callWithEnumResponse (ExecutionContext ctx ) throws SimpleException {
try {
return callWithEnumResponse(ctx, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation callWithEnumResponse was interrupted!");
}
return null;
}
/**
* Takes one of each rest parameter type, that is an set of SimpleEnums. Calls simpleEnumSetOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param headerParam set of SimpleEnum (mandatory)
* @param queryParam set of SimpleEnum (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns NonMandatoryParamsOperationResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public NonMandatoryParamsOperationResponseObject simpleEnumSetOperation (ExecutionContext ctx , Set < SimpleEnum > headerParam , Set < SimpleEnum > queryParam , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return simpleEnumSetOperation(ctx,headerParam,queryParam, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Takes one of each rest parameter type, that is an set of SimpleEnums. Calls simpleEnumSetOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param headerParam set of SimpleEnum (mandatory)
* @param queryParam set of SimpleEnum (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns NonMandatoryParamsOperationResponseObject
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public NonMandatoryParamsOperationResponseObject simpleEnumSetOperation (ExecutionContext ctx , Set < SimpleEnum > headerParam , Set < SimpleEnum > queryParam , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.simpleEnumSetOperationKey),
new Object[] { headerParam , queryParam },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation simpleEnumSetOperation timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (NonMandatoryParamsOperationResponseObject) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Takes one of each rest parameter type, that is an set of SimpleEnums
* @param ctx the context of the request.
* @param headerParam set of SimpleEnum (mandatory)
* @param queryParam set of SimpleEnum (mandatory)
* @return returns NonMandatoryParamsOperationResponseObject
*/
@Override
public NonMandatoryParamsOperationResponseObject simpleEnumSetOperation (ExecutionContext ctx , Set < SimpleEnum > headerParam , Set < SimpleEnum > queryParam ) throws SimpleException {
try {
return simpleEnumSetOperation(ctx,headerParam,queryParam, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation simpleEnumSetOperation was interrupted!");
}
return null;
}
/**
* Operation with a void response type. Calls voidResponseOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param message message (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns void
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public void voidResponseOperation (ExecutionContext ctx , String message , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
voidResponseOperation(ctx,message, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Operation with a void response type. Calls voidResponseOperation allowing you to specify a timeout
* @param ctx the context of the request.
* @param message message (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns void
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public void voidResponseOperation (ExecutionContext ctx , String message , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.voidResponseOperationKey),
new Object[] { message },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation voidResponseOperation timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return;
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Operation with a void response type
* @param ctx the context of the request.
* @param message message (mandatory)
* @return returns void
*/
@Override
public void voidResponseOperation (ExecutionContext ctx , String message ) throws SimpleException {
try {
voidResponseOperation(ctx,message, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation voidResponseOperation was interrupted!");
}
}
/**
* Bridging call between a request based transport and an event based transport. This parameter will be published to an event destination. Calls simpleEventPublication allowing you to specify a timeout
* @param ctx the context of the request.
* @param time The time tick information to be forwarded (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns Boolean
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public Boolean simpleEventPublication (ExecutionContext ctx , TimeContainer time , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return simpleEventPublication(ctx,time, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Bridging call between a request based transport and an event based transport. This parameter will be published to an event destination. Calls simpleEventPublication allowing you to specify a timeout
* @param ctx the context of the request.
* @param time The time tick information to be forwarded (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns Boolean
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public Boolean simpleEventPublication (ExecutionContext ctx , TimeContainer time , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.simpleEventPublicationKey),
new Object[] { time },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation simpleEventPublication timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (Boolean) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Bridging call between a request based transport and an event based transport. This parameter will be published to an event destination
* @param ctx the context of the request.
* @param time The time tick information to be forwarded (mandatory)
* @return returns Boolean
*/
@Override
public Boolean simpleEventPublication (ExecutionContext ctx , TimeContainer time ) throws SimpleException {
try {
return simpleEventPublication(ctx,time, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation simpleEventPublication was interrupted!");
}
return null;
}
/**
* Publish the input bet to the message transport. Calls emitMatchedBet allowing you to specify a timeout
* @param ctx the context of the request.
* @param bet Details of the matched bet (mandatory)
* @param market details of the market (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns void
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public void emitMatchedBet (ExecutionContext ctx , MatchedBetStruct bet , MarketStruct market , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
emitMatchedBet(ctx,bet,market, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Publish the input bet to the message transport. Calls emitMatchedBet allowing you to specify a timeout
* @param ctx the context of the request.
* @param bet Details of the matched bet (mandatory)
* @param market details of the market (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns void
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public void emitMatchedBet (ExecutionContext ctx , MatchedBetStruct bet , MarketStruct market , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.emitMatchedBetKey),
new Object[] { bet , market },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation emitMatchedBet timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return;
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Publish the input bet to the message transport
* @param ctx the context of the request.
* @param bet Details of the matched bet (mandatory)
* @param market details of the market (mandatory)
* @return returns void
*/
@Override
public void emitMatchedBet (ExecutionContext ctx , MatchedBetStruct bet , MarketStruct market ) throws SimpleException {
try {
emitMatchedBet(ctx,bet,market, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation emitMatchedBet was interrupted!");
}
}
/**
* Publish the log message to the message transport. Calls emitLogMessage allowing you to specify a timeout
* @param ctx the context of the request.
* @param logString the message to log (mandatory)
* @param logLevel log level (mandatory)
* @param timeStamp timestamp to identify the event (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns void
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public void emitLogMessage (ExecutionContext ctx , String logString , String logLevel , Long timeStamp , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
emitLogMessage(ctx,logString,logLevel,timeStamp, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* Publish the log message to the message transport. Calls emitLogMessage allowing you to specify a timeout
* @param ctx the context of the request.
* @param logString the message to log (mandatory)
* @param logLevel log level (mandatory)
* @param timeStamp timestamp to identify the event (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns void
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public void emitLogMessage (ExecutionContext ctx , String logString , String logLevel , Long timeStamp , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.emitLogMessageKey),
new Object[] { logString , logLevel , timeStamp },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation emitLogMessage timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return;
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* Publish the log message to the message transport
* @param ctx the context of the request.
* @param logString the message to log (mandatory)
* @param logLevel log level (mandatory)
* @param timeStamp timestamp to identify the event (mandatory)
* @return returns void
*/
@Override
public void emitLogMessage (ExecutionContext ctx , String logString , String logLevel , Long timeStamp ) throws SimpleException {
try {
emitLogMessage(ctx,logString,logLevel,timeStamp, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation emitLogMessage was interrupted!");
}
}
/**
* An operation which echoes a bool. Calls boolSimpleTypeEcho allowing you to specify a timeout
* @param ctx the context of the request.
* @param msg The value to echo (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns Boolean
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public Boolean boolSimpleTypeEcho (ExecutionContext ctx , Boolean msg , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return boolSimpleTypeEcho(ctx,msg, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* An operation which echoes a bool. Calls boolSimpleTypeEcho allowing you to specify a timeout
* @param ctx the context of the request.
* @param msg The value to echo (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns Boolean
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public Boolean boolSimpleTypeEcho (ExecutionContext ctx , Boolean msg , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.boolSimpleTypeEchoKey),
new Object[] { msg },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation boolSimpleTypeEcho timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (Boolean) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* An operation which echoes a bool
* @param ctx the context of the request.
* @param msg The value to echo (mandatory)
* @return returns Boolean
*/
@Override
public Boolean boolSimpleTypeEcho (ExecutionContext ctx , Boolean msg ) throws SimpleException {
try {
return boolSimpleTypeEcho(ctx,msg, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation boolSimpleTypeEcho was interrupted!");
}
return null;
}
/**
* An operation which echoes a byte. Calls byteSimpleTypeEcho allowing you to specify a timeout
* @param ctx the context of the request.
* @param msg The value to echo (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns Byte
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public Byte byteSimpleTypeEcho (ExecutionContext ctx , Byte msg , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return byteSimpleTypeEcho(ctx,msg, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* An operation which echoes a byte. Calls byteSimpleTypeEcho allowing you to specify a timeout
* @param ctx the context of the request.
* @param msg The value to echo (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns Byte
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public Byte byteSimpleTypeEcho (ExecutionContext ctx , Byte msg , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.byteSimpleTypeEchoKey),
new Object[] { msg },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation byteSimpleTypeEcho timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (Byte) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* An operation which echoes a byte
* @param ctx the context of the request.
* @param msg The value to echo (mandatory)
* @return returns Byte
*/
@Override
public Byte byteSimpleTypeEcho (ExecutionContext ctx , Byte msg ) throws SimpleException {
try {
return byteSimpleTypeEcho(ctx,msg, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation byteSimpleTypeEcho was interrupted!");
}
return null;
}
/**
* An operation which echoes an i32. Calls i32SimpleTypeEcho allowing you to specify a timeout
* @param ctx the context of the request.
* @param msg The value to echo (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns Integer
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public Integer i32SimpleTypeEcho (ExecutionContext ctx , Integer msg , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return i32SimpleTypeEcho(ctx,msg, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* An operation which echoes an i32. Calls i32SimpleTypeEcho allowing you to specify a timeout
* @param ctx the context of the request.
* @param msg The value to echo (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns Integer
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public Integer i32SimpleTypeEcho (ExecutionContext ctx , Integer msg , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.i32SimpleTypeEchoKey),
new Object[] { msg },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation i32SimpleTypeEcho timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (Integer) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* An operation which echoes an i32
* @param ctx the context of the request.
* @param msg The value to echo (mandatory)
* @return returns Integer
*/
@Override
public Integer i32SimpleTypeEcho (ExecutionContext ctx , Integer msg ) throws SimpleException {
try {
return i32SimpleTypeEcho(ctx,msg, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation i32SimpleTypeEcho was interrupted!");
}
return null;
}
/**
* An operation which echoes an i64. Calls i64SimpleTypeEcho allowing you to specify a timeout
* @param ctx the context of the request.
* @param msg The value to echo (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns Long
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public Long i64SimpleTypeEcho (ExecutionContext ctx , Long msg , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return i64SimpleTypeEcho(ctx,msg, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* An operation which echoes an i64. Calls i64SimpleTypeEcho allowing you to specify a timeout
* @param ctx the context of the request.
* @param msg The value to echo (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns Long
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public Long i64SimpleTypeEcho (ExecutionContext ctx , Long msg , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.i64SimpleTypeEchoKey),
new Object[] { msg },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation i64SimpleTypeEcho timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (Long) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* An operation which echoes an i64
* @param ctx the context of the request.
* @param msg The value to echo (mandatory)
* @return returns Long
*/
@Override
public Long i64SimpleTypeEcho (ExecutionContext ctx , Long msg ) throws SimpleException {
try {
return i64SimpleTypeEcho(ctx,msg, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation i64SimpleTypeEcho was interrupted!");
}
return null;
}
/**
* An operation which echoes a float. Calls floatSimpleTypeEcho allowing you to specify a timeout
* @param ctx the context of the request.
* @param msg The value to echo (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns Float
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public Float floatSimpleTypeEcho (ExecutionContext ctx , Float msg , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return floatSimpleTypeEcho(ctx,msg, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* An operation which echoes a float. Calls floatSimpleTypeEcho allowing you to specify a timeout
* @param ctx the context of the request.
* @param msg The value to echo (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns Float
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public Float floatSimpleTypeEcho (ExecutionContext ctx , Float msg , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.floatSimpleTypeEchoKey),
new Object[] { msg },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation floatSimpleTypeEcho timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (Float) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* An operation which echoes a float
* @param ctx the context of the request.
* @param msg The value to echo (mandatory)
* @return returns Float
*/
@Override
public Float floatSimpleTypeEcho (ExecutionContext ctx , Float msg ) throws SimpleException {
try {
return floatSimpleTypeEcho(ctx,msg, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation floatSimpleTypeEcho was interrupted!");
}
return null;
}
/**
* An operation which echoes a double. Calls doubleSimpleTypeEcho allowing you to specify a timeout
* @param ctx the context of the request.
* @param msg The value to echo (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns Double
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public Double doubleSimpleTypeEcho (ExecutionContext ctx , Double msg , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return doubleSimpleTypeEcho(ctx,msg, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* An operation which echoes a double. Calls doubleSimpleTypeEcho allowing you to specify a timeout
* @param ctx the context of the request.
* @param msg The value to echo (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns Double
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public Double doubleSimpleTypeEcho (ExecutionContext ctx , Double msg , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.doubleSimpleTypeEchoKey),
new Object[] { msg },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation doubleSimpleTypeEcho timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (Double) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* An operation which echoes a double
* @param ctx the context of the request.
* @param msg The value to echo (mandatory)
* @return returns Double
*/
@Override
public Double doubleSimpleTypeEcho (ExecutionContext ctx , Double msg ) throws SimpleException {
try {
return doubleSimpleTypeEcho(ctx,msg, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation doubleSimpleTypeEcho was interrupted!");
}
return null;
}
/**
* An operation which echoes a string. Calls stringSimpleTypeEcho allowing you to specify a timeout
* @param ctx the context of the request.
* @param msg The value to echo (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns String
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public String stringSimpleTypeEcho (ExecutionContext ctx , String msg , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return stringSimpleTypeEcho(ctx,msg, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* An operation which echoes a string. Calls stringSimpleTypeEcho allowing you to specify a timeout
* @param ctx the context of the request.
* @param msg The value to echo (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns String
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public String stringSimpleTypeEcho (ExecutionContext ctx , String msg , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.stringSimpleTypeEchoKey),
new Object[] { msg },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation stringSimpleTypeEcho timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (String) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* An operation which echoes a string
* @param ctx the context of the request.
* @param msg The value to echo (mandatory)
* @return returns String
*/
@Override
public String stringSimpleTypeEcho (ExecutionContext ctx , String msg ) throws SimpleException {
try {
return stringSimpleTypeEcho(ctx,msg, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation stringSimpleTypeEcho was interrupted!");
}
return null;
}
/**
* An operation which echoes a dateTime. Calls dateTimeSimpleTypeEcho allowing you to specify a timeout
* @param ctx the context of the request.
* @param msg The value to echo (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns Date
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public Date dateTimeSimpleTypeEcho (ExecutionContext ctx , Date msg , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return dateTimeSimpleTypeEcho(ctx,msg, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* An operation which echoes a dateTime. Calls dateTimeSimpleTypeEcho allowing you to specify a timeout
* @param ctx the context of the request.
* @param msg The value to echo (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns Date
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public Date dateTimeSimpleTypeEcho (ExecutionContext ctx , Date msg , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.dateTimeSimpleTypeEchoKey),
new Object[] { msg },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation dateTimeSimpleTypeEcho timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (Date) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* An operation which echoes a dateTime
* @param ctx the context of the request.
* @param msg The value to echo (mandatory)
* @return returns Date
*/
@Override
public Date dateTimeSimpleTypeEcho (ExecutionContext ctx , Date msg ) throws SimpleException {
try {
return dateTimeSimpleTypeEcho(ctx,msg, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation dateTimeSimpleTypeEcho was interrupted!");
}
return null;
}
/**
* An operation which echoes a list(i32). Calls i32ListSimpleTypeEcho allowing you to specify a timeout
* @param ctx the context of the request.
* @param msg The value to echo (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns List<Integer>
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public List<Integer> i32ListSimpleTypeEcho (ExecutionContext ctx , List < Integer > msg , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return i32ListSimpleTypeEcho(ctx,msg, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* An operation which echoes a list(i32). Calls i32ListSimpleTypeEcho allowing you to specify a timeout
* @param ctx the context of the request.
* @param msg The value to echo (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns List<Integer>
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public List<Integer> i32ListSimpleTypeEcho (ExecutionContext ctx , List < Integer > msg , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.i32ListSimpleTypeEchoKey),
new Object[] { msg },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation i32ListSimpleTypeEcho timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (List<Integer>) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* An operation which echoes a list(i32)
* @param ctx the context of the request.
* @param msg The value to echo (mandatory)
* @return returns List<Integer>
*/
@Override
public List<Integer> i32ListSimpleTypeEcho (ExecutionContext ctx , List < Integer > msg ) throws SimpleException {
try {
return i32ListSimpleTypeEcho(ctx,msg, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation i32ListSimpleTypeEcho was interrupted!");
}
return null;
}
/**
* An operation which echoes a set(i32). Calls i32SetSimpleTypeEcho allowing you to specify a timeout
* @param ctx the context of the request.
* @param msg The value to echo (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns Set<Integer>
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public Set<Integer> i32SetSimpleTypeEcho (ExecutionContext ctx , Set < Integer > msg , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return i32SetSimpleTypeEcho(ctx,msg, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* An operation which echoes a set(i32). Calls i32SetSimpleTypeEcho allowing you to specify a timeout
* @param ctx the context of the request.
* @param msg The value to echo (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns Set<Integer>
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public Set<Integer> i32SetSimpleTypeEcho (ExecutionContext ctx , Set < Integer > msg , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.i32SetSimpleTypeEchoKey),
new Object[] { msg },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation i32SetSimpleTypeEcho timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (Set<Integer>) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* An operation which echoes a set(i32)
* @param ctx the context of the request.
* @param msg The value to echo (mandatory)
* @return returns Set<Integer>
*/
@Override
public Set<Integer> i32SetSimpleTypeEcho (ExecutionContext ctx , Set < Integer > msg ) throws SimpleException {
try {
return i32SetSimpleTypeEcho(ctx,msg, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation i32SetSimpleTypeEcho was interrupted!");
}
return null;
}
/**
* An operation which echoes a map(i32,i32). Calls i32MapSimpleTypeEcho allowing you to specify a timeout
* @param ctx the context of the request.
* @param msg The value to echo (mandatory)
* @param timeoutMillis - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
* @return returns Map<Integer,Integer>
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public Map<Integer,Integer> i32MapSimpleTypeEcho (ExecutionContext ctx , Map < Integer , Integer > msg , long timeoutMillis) throws TimeoutException, InterruptedException , SimpleException {
return i32MapSimpleTypeEcho(ctx,msg, timeoutMillis == 0 ? DefaultTimeConstraints.NO_CONSTRAINTS : DefaultTimeConstraints.fromTimeout(timeoutMillis));
}
/**
* An operation which echoes a map(i32,i32). Calls i32MapSimpleTypeEcho allowing you to specify a timeout
* @param ctx the context of the request.
* @param msg The value to echo (mandatory)
* @param timeConstraints - allows you to specify time constraints for this operation. If you want a blocking call,
* use DefaultTimeConstraints.NO_CONSTRAINTS, or call the overloading without the timeout argument
* @return returns Map<Integer,Integer>
* @throws TimeoutException if call does not complete in the specified time (providing timeout > 0)
* @throws InterruptedException if the blocking call thread was interrupted
* @throws SimpleException if the remote Application threw SimpleException
*/
public Map<Integer,Integer> i32MapSimpleTypeEcho (ExecutionContext ctx , Map < Integer , Integer > msg , TimeConstraints timeConstraints) throws TimeoutException, InterruptedException , SimpleException {
final WaitingObserver observer = new WaitingObserver();
ev.execute(ctx,
getOperationKey(BaselineServiceDefinition.i32MapSimpleTypeEchoKey),
new Object[] { msg },
observer,
timeConstraints);
if (!observer.await(timeConstraints)) {
throw new CougarClientException(ServerFaultCode.Timeout, "Operation i32MapSimpleTypeEcho timed out!");
}
final ExecutionResult er = observer.getExecutionResult();
switch (er.getResultType()) {
case Success:
return (Map<Integer,Integer>) er.getResult();
case Fault:
CougarException cex = er.getFault();
if (cex.getServerFaultCode() == ServerFaultCode.ServiceCheckedException) {
List<String[]> exceptionParams = cex.getFault().getDetail().getFaultMessages();
String className = cex.getFault().getDetail().getDetailMessage();
if (className.equals("SimpleException")) {
throw new SimpleException(
cex.getResponseCode(),
SimpleExceptionErrorCodeEnum.valueOf(exceptionParams.get(0)[1]),
(exceptionParams.get(1)[1])
);
}
else {
throw new IllegalArgumentException("An unanticipated exception was received of class [" + className + "]");
}
} else if (cex instanceof CougarFrameworkException) {
CougarFrameworkException cfe = (CougarFrameworkException) cex;
throw new CougarClientException(cfe.getServerFaultCode(), cfe.getMessage(), cfe.getCause());
} else {
throw cex;
}
default:
throw new IllegalArgumentException("The Server returned an illegal result type [" + er.getResultType() + "]");
}
}
/**
* An operation which echoes a map(i32,i32)
* @param ctx the context of the request.
* @param msg The value to echo (mandatory)
* @return returns Map<Integer,Integer>
*/
@Override
public Map<Integer,Integer> i32MapSimpleTypeEcho (ExecutionContext ctx , Map < Integer , Integer > msg ) throws SimpleException {
try {
return i32MapSimpleTypeEcho(ctx,msg, DefaultTimeConstraints.NO_CONSTRAINTS);
} catch (TimeoutException ex) {
//blocking call, so won't happen
} catch (InterruptedException interrupted) {
throw new RuntimeException("Operation i32MapSimpleTypeEcho was interrupted!");
}
return null;
}
/**
* This allows the execution venue to subscribe to your application to facilitate publication
* of TimeTick events. To publish an event, your application should hold on to the
* observer passed to you by this method, and by calling onResult on that observer, an event
* will be published.
* @param ctx the context of the event
* @param args the arguments passed with the subscription
* @param observer the observer to allow the application to publish events with
*/
public void subscribeToTimeTick (ExecutionContext ctx, Object[] args, ExecutionObserver observer) {
ev.execute(ctx, getOperationKey(BaselineServiceDefinition.subscribeToTimeTickOperationKey), args, observer, DefaultTimeConstraints.NO_CONSTRAINTS);
}
/**
* This allows the execution venue to subscribe to your application to facilitate publication
* of MatchedBet events. To publish an event, your application should hold on to the
* observer passed to you by this method, and by calling onResult on that observer, an event
* will be published.
* @param ctx the context of the event
* @param args the arguments passed with the subscription
* @param observer the observer to allow the application to publish events with
*/
public void subscribeToMatchedBet (ExecutionContext ctx, Object[] args, ExecutionObserver observer) {
ev.execute(ctx, getOperationKey(BaselineServiceDefinition.subscribeToMatchedBetOperationKey), args, observer, DefaultTimeConstraints.NO_CONSTRAINTS);
}
/**
* This allows the execution venue to subscribe to your application to facilitate publication
* of LogMessage events. To publish an event, your application should hold on to the
* observer passed to you by this method, and by calling onResult on that observer, an event
* will be published.
* @param ctx the context of the event
* @param args the arguments passed with the subscription
* @param observer the observer to allow the application to publish events with
*/
public void subscribeToLogMessage (ExecutionContext ctx, Object[] args, ExecutionObserver observer) {
ev.execute(ctx, getOperationKey(BaselineServiceDefinition.subscribeToLogMessageOperationKey), args, observer, DefaultTimeConstraints.NO_CONSTRAINTS);
}
public void init(ContainerContext cc) {
throw new UnsupportedOperationException("Not valid for CLIENT");
}
}