package ca.uhn.hl7v2.hoh.hapi.client;
import java.io.IOException;
import java.net.URL;
import java.nio.charset.Charset;
import ca.uhn.hl7v2.HL7Exception;
import ca.uhn.hl7v2.hoh.api.DecodeException;
import ca.uhn.hl7v2.hoh.api.EncodeException;
import ca.uhn.hl7v2.hoh.api.IAuthorizationClientCallback;
import ca.uhn.hl7v2.hoh.api.IClient;
import ca.uhn.hl7v2.hoh.api.IReceivable;
import ca.uhn.hl7v2.hoh.api.ISendable;
import ca.uhn.hl7v2.hoh.hapi.api.MessageReceivable;
import ca.uhn.hl7v2.hoh.hapi.api.MessageSendable;
import ca.uhn.hl7v2.hoh.raw.client.AbstractRawClient;
import ca.uhn.hl7v2.hoh.sign.ISigner;
import ca.uhn.hl7v2.hoh.sockets.ISocketFactory;
import ca.uhn.hl7v2.hoh.util.Validate;
import ca.uhn.hl7v2.model.Message;
import ca.uhn.hl7v2.parser.EncodingNotSupportedException;
import ca.uhn.hl7v2.parser.Parser;
public abstract class AbstractClient<T extends AbstractRawClient> implements IClient {
private Parser myParser;
private T myRawClient;
/**
* Constructor
*
* @param theRawClient
* The Raw client to wrap (may not be null)
*/
public AbstractClient(T theRawClient) {
this(theRawClient, null);
}
/**
* {@inheritDoc}
*/
public void setKeepAlive(boolean theKeepAlive) {
getRawClient().setKeepAlive(theKeepAlive);
}
/**
* {@inheritDoc}
*/
public boolean isKeepAlive() {
return getRawClient().isKeepAlive();
}
/**
* {@inheritDoc}
*/
public void setSoTimeout(int theSoTimeout) {
getRawClient().setSoTimeout(theSoTimeout);
}
/**
* {@inheritDoc}
*/
public int getSoTimeout() {
return getRawClient().getSoTimeout();
}
/**
* Constructor
*
* @param theRawClient
* The Raw client to wrap (may not be null)
* @param theParser
* The parser to use (may be null, in which case the parser
* contained within the sent message will be used
*/
protected AbstractClient(T theRawClient, Parser theParser) {
Validate.notNull(theRawClient, "rawClient");
myRawClient = theRawClient;
myParser = theParser;
}
public String getHost() {
return myRawClient.getHost();
}
/**
* Returns the {@link Parser} to use to parsing and encoding messages within
* this client (may return null)
*/
public Parser getParser() {
return myParser;
}
/**
* {@inheritDoc}
*/
public int getPort() {
return myRawClient.getPort();
}
/**
* {@inheritDoc}
*/
protected T getRawClient() {
return myRawClient;
}
/**
* {@inheritDoc}
*/
public ISocketFactory getSocketFactory() {
return myRawClient.getSocketFactory();
}
/**
* {@inheritDoc}
*/
public String getUriPath() {
return myRawClient.getUriPath();
}
/**
* {@inheritDoc}
*/
public URL getUrl() {
return myRawClient.getUrl();
}
/**
* {@inheritDoc}
*/
public String getUrlString() {
return myRawClient.getUrlString();
}
/**
* Sends a message, waits for the response, and then returns the response if
* any
*
* @param theMessageToSend
* The message to send
* @return The returned message, as well as associated metadata
* @throws DecodeException
* If a problem occurs (read error, socket disconnect, etc.)
* during communication, or the response is invalid in some way.
* Note that IO errors in trying to connect to the remote host
* or sending the message are thrown directly (i.e. as
* {@link IOException}), but IO errors in reading the response
* are thrown as DecodeException
* @throws IOException
* If the client is unable to connect to the remote host
* @throws EncodeException
* If a failure occurs while encoding the message into a
* sendable HTTP request
* @throws HL7Exception
* If the response can not be parsed
* @throws EncodingNotSupportedException
* If the encoding is not supported
*/
public IReceivable<Message> sendAndReceiveMessage(ISendable<Message> theMessageToSend) throws DecodeException, IOException, EncodeException, EncodingNotSupportedException, HL7Exception {
IReceivable<String> response = myRawClient.sendAndReceive(theMessageToSend);
Parser parser = myParser != null ? myParser : theMessageToSend.getMessage().getParser();
return new MessageReceivable(parser.parse(response.getMessage()));
}
/**
* Sends a message, waits for the response, and then returns the response if
* any (this method is a convenience method for {@link #sendAndReceiveMessage(ISendable)}
*
* @param theMessageToSend
* The message to send
* @return The returned message, as well as associated metadata
* @throws DecodeException
* If a problem occurs (read error, socket disconnect, etc.)
* during communication, or the response is invalid in some way.
* Note that IO errors in trying to connect to the remote host
* or sending the message are thrown directly (i.e. as
* {@link IOException}), but IO errors in reading the response
* are thrown as DecodeException
* @throws IOException
* If the client is unable to connect to the remote host
* @throws EncodeException
* If a failure occurs while encoding the message into a
* sendable HTTP request
* @throws HL7Exception
* If the response can not be parsed
* @throws EncodingNotSupportedException
* If the encoding is not supported
*/
public IReceivable<Message> sendAndReceiveMessage(Message theMessageToSend) throws DecodeException, IOException, EncodeException, EncodingNotSupportedException, HL7Exception {
MessageSendable sendable = new MessageSendable(theMessageToSend);
return sendAndReceiveMessage(sendable);
}
/**
* {@inheritDoc}
*/
public void setAuthorizationCallback(IAuthorizationClientCallback theAuthorizationCallback) {
myRawClient.setAuthorizationCallback(theAuthorizationCallback);
}
/**
* {@inheritDoc}
*/
public void setCharset(Charset theCharset) {
myRawClient.setCharset(theCharset);
}
/**
* {@inheritDoc}
*/
public void setHost(String theHost) {
myRawClient.setHost(theHost);
}
/**
* Sets the {@link Parser} to use to parsing and encoding messages within
* this client
*/
public void setParser(Parser theParser) {
Validate.notNull(theParser, "parser");
myParser = theParser;
}
/**
* {@inheritDoc}
*/
public void setUriPath(String thePath) {
myRawClient.setUriPath(thePath);
}
/**
* {@inheritDoc}
*/
public void setPort(int thePort) {
myRawClient.setPort(thePort);
}
/**
* {@inheritDoc}
*/
public void setResponseTimeout(long theResponseTimeout) {
myRawClient.setResponseTimeout(theResponseTimeout);
}
/**
* {@inheritDoc}
*/
public void setSigner(ISigner theSigner) {
myRawClient.setSigner(theSigner);
}
/**
* {@inheritDoc}
*/
public void setSocketFactory(ISocketFactory theSocketFactory) {
myRawClient.setSocketFactory(theSocketFactory);
}
/**
* {@inheritDoc}
*/
public void setUrl(URL theUrl) {
myRawClient.setUrl(theUrl);
}
/**
* {@inheritDoc}
*/
public void setUrlString(String theString) {
myRawClient.setUrlString(theString);
}
}