You are viewing a plain text version of this content. The canonical link for it is here.
Posted to sandesha-dev@ws.apache.org by da...@apache.org on 2006/07/11 14:42:27 UTC
svn commit: r420822 [2/4] - in /webservices/sandesha/trunk/c: include/
include/sandesha2/ src/client/ src/msgprocessors/ src/storage/beans/
src/storage/inmemory/ src/transport/ src/util/ src/workers/ src/wsrm/
Modified: webservices/sandesha/trunk/c/src/client/sandesha_client.c
URL: http://svn.apache.org/viewvc/webservices/sandesha/trunk/c/src/client/sandesha_client.c?rev=420822&r1=420821&r2=420822&view=diff
==============================================================================
--- webservices/sandesha/trunk/c/src/client/sandesha_client.c (original)
+++ webservices/sandesha/trunk/c/src/client/sandesha_client.c Tue Jul 11 05:42:25 2006
@@ -15,7 +15,7 @@
*/
#include <sandesha2_client.h>
-#include <sandesha2_sequence_report.h>
+#include <sandesha2_seq_report.h>
#include <sandesha2_client_constants.h>
#include <axis2_svc_client.h>
#include <axis2_svc_ctx.h>
@@ -98,14 +98,14 @@
}
/**
- * Users can get a sequence_report of the sequence defined by the information
+ * Users can get a seq_report of the seq defined by the information
* given from the passed svc_client object.
*
* @param service_client
* @return
*/
-sandesha2_sequence_report_t *AXIS2_CALL
-sandesha2_client_get_outgoing_sequence_report_with_svc_client(
+sandesha2_seq_report_t *AXIS2_CALL
+sandesha2_client_get_outgoing_seq_report_with_svc_client(
sandesha2_client_t *sandesha2_client,
const axis2_env_t *env,
axis2_svc_client_t *svc_client)
@@ -114,7 +114,7 @@
axis2_options_t *options = NULL;
axis2_endpoint_ref_t *to_epr = NULL;
axis2_char_t *to = NULL;
- axis2_char_t *sequence_key = NULL;
+ axis2_char_t *seq_key = NULL;
axis2_svc_ctx_t *svc_ctx = NULL;
axis2_conf_ctx_t *conf_ctx = NULL;
@@ -140,8 +140,8 @@
"To address is not set.");
}
to = AXIS2_ENDPOINT_REF_GET_ADDRESS(to_epr, env);
- sequence_key = (axis2_char_t *) AXIS2_OPTIONS_GET_PROPERTY(options, env,
- SANDESHA2_CLIENT_SEQUENCE_KEY);
+ seq_key = (axis2_char_t *) AXIS2_OPTIONS_GET_PROPERTY(options, env,
+ SANDESHA2_CLIENT_SEQ_KEY);
svc_ctx = AXIS2_SVC_CLIET_GET_SVC_CTX(svc_client, env);
if(svc_ctx == NULL)
{
@@ -152,57 +152,57 @@
}
conf_ctx = AXIS2_SVC_CTX_GET_CONF_CTX(svc_ctx, env);
- internal_sequence_id = sandesha2_client_get_internal_sequence_id(
- sandesha2_client, env, to, sequence_key);
+ internal_seq_id = sandesha2_client_get_internal_seq_id(
+ sandesha2_client, env, to, seq_key);
return
- sandesha2_client_get_outgoing_sequence_report_with_internal_sequence_id(
- sandesha2_client, env, internal_sequence_id, conf_ctx);
+ sandesha2_client_get_outgoing_seq_report_with_internal_seq_id(
+ sandesha2_client, env, internal_seq_id, conf_ctx);
}
-sandesha2_sequence_report_t *AXIS2_CALL
-sandesha2_client_get_outgoing_sequence_report_with_sequence_key(
+sandesha2_seq_report_t *AXIS2_CALL
+sandesha2_client_get_outgoing_seq_report_with_seq_key(
sandesha2_client_t *sandesha2_client,
const axis2_env_t *env,
axis2_char_t *to,
- axis2_char_t *sequence_key,
+ axis2_char_t *seq_key,
axis2_conf_ctx_t *conf_ctx)
{
sandesha2_client_impl_t *schema_impl = NULL;
- axis2_char_t *internal_sequence_id = NULL;
+ axis2_char_t *internal_seq_id = NULL;
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error, to, NULL);
- AXIS2_PARAM_CHECK(env->error, sequence_key, NULL);
+ AXIS2_PARAM_CHECK(env->error, seq_key, NULL);
AXIS2_PARAM_CHECK(env->error, conf_ctx, NULL);
schema_impl = SANDESHA2_INTF_TO_IMPL(schema);
- internal_sequence_id = SANDESHA2_UTIL_GET_INTERNAL_SEQUENCE_ID(to,
- sequence_key);
- return sandesha2_client_get_outgoing_sequence_report(sandesha2_client, env,
- internal_sequence_id, conf_ctx);
+ internal_seq_id = SANDESHA2_UTIL_GET_INTERNAL_SEQ_ID(to,
+ seq_key);
+ return sandesha2_client_get_outgoing_seq_report(sandesha2_client, env,
+ internal_seq_id, conf_ctx);
}
-sandesha2_sequence_report_t *AXIS2_CALL
-sandesha2_client_get_outgoing_sequence_report_with_sequence_key(
+sandesha2_seq_report_t *AXIS2_CALL
+sandesha2_client_get_outgoing_seq_report_with_seq_key(
sandesha2_client_t *sandesha2_client,
const axis2_env_t *env,
- axis2_char_t *internal_sequence_id,
+ axis2_char_t *internal_seq_id,
axis2_conf_ctx_t *conf_ctx)
{
sandesha2_client_impl_t *schema_impl = NULL;
- sandesha2_sequence_report_t *sequence_report = NULL;
+ sandesha2_seq_report_t *seq_report = NULL;
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error, to, NULL);
- AXIS2_PARAM_CHECK(env->error, sequence_key, NULL);
+ AXIS2_PARAM_CHECK(env->error, seq_key, NULL);
AXIS2_PARAM_CHECK(env->error, conf_ctx, NULL);
schema_impl = SANDESHA2_INTF_TO_IMPL(schema);
- sequence_report = sandesha2_sequence_report_create(env);
- SANDESHSA2_SEQUENCE_REPORT_SET_SEQUENCE_DIRECTION(sequence_report, env,
- SANDESHA2_SEQUENCE_DIRECTION_OUT);
+ seq_report = sandesha2_seq_report_create(env);
+ SANDESHSA2_SEQ_REPORT_SET_SEQ_DIRECTION(seq_report, env,
+ SANDESHA2_SEQ_DIRECTION_OUT);
@@ -212,8 +212,8 @@
public static SequenceReport getOutgoingSequenceReport(String internalSequenceID,
ConfigurationContext configurationContext) throws SandeshaException {
- SequenceReport sequenceReport = new SequenceReport();
- sequenceReport.setSequenceDirection(SequenceReport.SEQUENCE_DIRECTION_OUT);
+ SequenceReport seqReport = new SequenceReport();
+ seqReport.setSequenceDirection(SequenceReport.SEQ_DIRECTION_OUT);
StorageManager storageManager = SandeshaUtil.getSandeshaStorageManager(configurationContext,configurationContext.getAxisConfiguration());
SequencePropertyBeanMgr seqPropMgr = storageManager.getSequencePropertyBeanMgr();
@@ -232,55 +232,55 @@
try {
- sequenceReport.setInternalSequenceID(internalSequenceID);
+ seqReport.setInternalSequenceID(internalSequenceID);
CreateSeqBean createSeqFindBean = new CreateSeqBean();
createSeqFindBean.setInternalSequenceID(internalSequenceID);
CreateSeqBean createSeqBean = createSeqMgr.findUnique(createSeqFindBean);
- // if data not is available sequence has to be terminated or
+ // if data not is available seq has to be terminated or
// timedOut.
if (createSeqBean == null) {
- // check weather this is an terminated sequence.
+ // check weather this is an terminated seq.
if (isSequenceTerminated(internalSequenceID, seqPropMgr)) {
- fillTerminatedOutgoingSequenceInfo(sequenceReport, internalSequenceID, seqPropMgr);
+ fillTerminatedOutgoingSequenceInfo(seqReport, internalSequenceID, seqPropMgr);
- return sequenceReport;
+ return seqReport;
}
if (isSequenceTimedout(internalSequenceID, seqPropMgr)) {
- fillTimedoutOutgoingSequenceInfo(sequenceReport, internalSequenceID, seqPropMgr);
+ fillTimedoutOutgoingSequenceInfo(seqReport, internalSequenceID, seqPropMgr);
- return sequenceReport;
+ return seqReport;
}
- // sequence must hv been timed out before establiching. No other
+ // seq must hv been timed out before establiching. No other
// posibility I can think of.
// this does not get recorded since there is no key (which is
- // normally the sequenceID) to store it.
+ // normally the seqID) to store it.
// (properties with key as the internalSequenceID get deleted in
// timing out)
- // so, setting the sequence status to INITIAL
- sequenceReport.setSequenceStatus(SequenceReport.SEQUENCE_STATUS_INITIAL);
+ // so, setting the seq status to INITIAL
+ seqReport.setSequenceStatus(SequenceReport.SEQ_STATUS_INITIAL);
- // returning the current sequence report.
- return sequenceReport;
+ // returning the current seq report.
+ return seqReport;
}
String outSequenceID = createSeqBean.getSequenceID();
if (outSequenceID == null) {
- sequenceReport.setInternalSequenceID(internalSequenceID);
- sequenceReport.setSequenceStatus(SequenceReport.SEQUENCE_STATUS_INITIAL);
- sequenceReport.setSequenceDirection(SequenceReport.SEQUENCE_DIRECTION_OUT);
+ seqReport.setInternalSequenceID(internalSequenceID);
+ seqReport.setSequenceStatus(SequenceReport.SEQ_STATUS_INITIAL);
+ seqReport.setSequenceDirection(SequenceReport.SEQ_DIRECTION_OUT);
- return sequenceReport;
+ return seqReport;
}
- sequenceReport.setSequenceStatus(SequenceReport.SEQUENCE_STATUS_ESTABLISHED);
- fillOutgoingSequenceInfo(sequenceReport, outSequenceID, seqPropMgr);
+ seqReport.setSequenceStatus(SequenceReport.SEQ_STATUS_ESTABLISHED);
+ fillOutgoingSequenceInfo(seqReport, outSequenceID, seqPropMgr);
} catch (Exception e) {
if (!withinTransaction && reportTransaction!=null) {
@@ -295,12 +295,12 @@
}
}
- return sequenceReport;
+ return seqReport;
}
/**
- * Users can get a list of sequenceReports each describing a incoming
- * sequence, which are the sequences the client work as a RMD.
+ * Users can get a list of seqReports each describing a incoming
+ * seq, which are the seqs the client work as a RMD.
*
* @param configCtx
* @return
@@ -318,7 +318,7 @@
String sequnceID = (String) incomingSequenceIDIter.next();
SequenceReport incomingSequenceReport = getIncomingSequenceReport(sequnceID, configCtx);
if (incomingSequenceReport == null) {
- throw new SandeshaException("An incoming sequence report is not present for the given sequenceID");
+ throw new SandeshaException("An incoming seq report is not present for the given seqID");
}
incomingSequenceReports.add(incomingSequenceReport);
}
@@ -327,8 +327,8 @@
}
/**
- * SandeshaReport gives the details of all incoming and outgoing sequences.
- * The outgoing sequence have to pass the initial state (CS/CSR exchange) to
+ * SandeshaReport gives the details of all incoming and outgoing seqs.
+ * The outgoing seq have to pass the initial state (CS/CSR exchange) to
* be included in a SandeshaReport
*
* @param configurationContext
@@ -355,22 +355,22 @@
try {
- internalSequenceFindBean.setName(Sandesha2Constants.SequenceProperties.INTERNAL_SEQUENCE_ID);
+ internalSequenceFindBean.setName(Sandesha2Constants.SequenceProperties.INTERNAL_SEQ_ID);
Collection collection = seqPropMgr.find(internalSequenceFindBean);
Iterator iterator = collection.iterator();
while (iterator.hasNext()) {
SequencePropertyBean bean = (SequencePropertyBean) iterator.next();
- String sequenceID = bean.getSequenceID();
- sandesha2Report.addToOutgoingSequenceList(sequenceID);
- sandesha2Report.addToOutgoingInternalSequenceMap(sequenceID, bean.getValue());
+ String seqID = bean.getSequenceID();
+ sandesha2Report.addToOutgoingSequenceList(seqID);
+ sandesha2Report.addToOutgoingInternalSequenceMap(seqID, bean.getValue());
SequenceReport report = getOutgoingSequenceReport(bean.getValue(), configurationContext);
- sandesha2Report.addToNoOfCompletedMessagesMap(sequenceID, report.getCompletedMessages().size());
- sandesha2Report.addToSequenceStatusMap(sequenceID, report.getSequenceStatus());
+ sandesha2Report.addToNoOfCompletedMessagesMap(seqID, report.getCompletedMessages().size());
+ sandesha2Report.addToSequenceStatusMap(seqID, report.getSequenceStatus());
}
- // incoming sequences
+ // incoming seqs
SequencePropertyBean serverCompletedMsgsFindBean = new SequencePropertyBean();
serverCompletedMsgsFindBean.setName(Sandesha2Constants.SequenceProperties.SERVER_COMPLETED_MESSAGES);
@@ -378,13 +378,13 @@
Iterator iter = serverCompletedMsgsBeans.iterator();
while (iter.hasNext()) {
SequencePropertyBean serverCompletedMsgsBean = (SequencePropertyBean) iter.next();
- String sequenceID = serverCompletedMsgsBean.getSequenceID();
- sandesha2Report.addToIncomingSequenceList(sequenceID);
+ String seqID = serverCompletedMsgsBean.getSequenceID();
+ sandesha2Report.addToIncomingSequenceList(seqID);
- SequenceReport sequenceReport = getIncomingSequenceReport(sequenceID, configurationContext);
+ SequenceReport seqReport = getIncomingSequenceReport(seqID, configurationContext);
- sandesha2Report.addToNoOfCompletedMessagesMap(sequenceID, sequenceReport.getCompletedMessages().size());
- sandesha2Report.addToSequenceStatusMap(sequenceID, sequenceReport.getSequenceStatus());
+ sandesha2Report.addToNoOfCompletedMessagesMap(seqID, seqReport.getCompletedMessages().size());
+ sandesha2Report.addToSequenceStatusMap(seqID, seqReport.getSequenceStatus());
}
} catch (Exception e) {
@@ -416,14 +416,14 @@
if (offer) {
String offeredSequenceID = SandeshaUtil.getUUID();
- options.setProperty(SandeshaClientConstants.OFFERED_SEQUENCE_ID, offeredSequenceID);
+ options.setProperty(SandeshaClientConstants.OFFERED_SEQ_ID, offeredSequenceID);
}
// setting a new squenceKey if not already set.
- String sequenceKey = (String) options.getProperty(SandeshaClientConstants.SEQUENCE_KEY);
- if (sequenceKey == null) {
- sequenceKey = SandeshaUtil.getUUID();
- options.setProperty(SandeshaClientConstants.SEQUENCE_KEY, sequenceKey);
+ String seqKey = (String) options.getProperty(SandeshaClientConstants.SEQ_KEY);
+ if (seqKey == null) {
+ seqKey = SandeshaUtil.getUUID();
+ options.setProperty(SandeshaClientConstants.SEQ_KEY, seqKey);
}
options.setProperty(SandeshaClientConstants.DUMMY_MESSAGE, Sandesha2Constants.VALUE_TRUE);
@@ -438,33 +438,33 @@
}
- public static void createSequence(ServiceClient serviceClient, boolean offer, String sequenceKey)
+ public static void createSequence(ServiceClient serviceClient, boolean offer, String seqKey)
throws SandeshaException {
Options options = serviceClient.getOptions();
if (options == null)
throw new SandeshaException("Options object is not set");
- String oldSequenceKey = (String) options.getProperty(SandeshaClientConstants.SEQUENCE_KEY);
- options.setProperty(SandeshaClientConstants.SEQUENCE_KEY, sequenceKey);
+ String oldSequenceKey = (String) options.getProperty(SandeshaClientConstants.SEQ_KEY);
+ options.setProperty(SandeshaClientConstants.SEQ_KEY, seqKey);
createSequence(serviceClient, offer);
- options.setProperty(SandeshaClientConstants.SEQUENCE_KEY, oldSequenceKey);
+ options.setProperty(SandeshaClientConstants.SEQ_KEY, oldSequenceKey);
}
/**
- * User can terminate the sequence defined by the passed serviceClient.
+ * User can terminate the seq defined by the passed serviceClient.
*
* @deprecated
*/
- public static void createSequnce(ServiceClient serviceClient, boolean offer, String sequenceKey)
+ public static void createSequnce(ServiceClient serviceClient, boolean offer, String seqKey)
throws SandeshaException {
- createSequence(serviceClient,offer,sequenceKey);
+ createSequence(serviceClient,offer,seqKey);
}
/**
- * User can terminate the sequence defined by the passed serviceClient.
+ * User can terminate the seq defined by the passed serviceClient.
*
* @param serviceClient
* @throws SandeshaException
@@ -487,7 +487,7 @@
SOAPEnvelope terminateEnvelope = configureTerminateSequence(options, serviceContext.getConfigurationContext());
OMElement terminateBody = terminateEnvelope.getBody().getFirstChildWithName(
- new QName(rmNamespaceValue, Sandesha2Constants.WSRM_COMMON.TERMINATE_SEQUENCE));
+ new QName(rmNamespaceValue, Sandesha2Constants.WSRM_COMMON.TERMINATE_SEQ));
String oldAction = options.getAction();
options.setAction(SpecSpecificConstants.getTerminateSequenceAction(rmSpecVersion));
@@ -502,20 +502,20 @@
}
}
- public static void terminateSequence(ServiceClient serviceClient, String sequenceKey) throws SandeshaException {
+ public static void terminateSequence(ServiceClient serviceClient, String seqKey) throws SandeshaException {
Options options = serviceClient.getOptions();
if (options == null)
throw new SandeshaException("Options object is not set");
- String oldSequenceKey = (String) options.getProperty(SandeshaClientConstants.SEQUENCE_KEY);
- options.setProperty(SandeshaClientConstants.SEQUENCE_KEY, sequenceKey);
+ String oldSequenceKey = (String) options.getProperty(SandeshaClientConstants.SEQ_KEY);
+ options.setProperty(SandeshaClientConstants.SEQ_KEY, seqKey);
terminateSequence(serviceClient);
- options.setProperty(SandeshaClientConstants.SEQUENCE_KEY, oldSequenceKey);
+ options.setProperty(SandeshaClientConstants.SEQ_KEY, oldSequenceKey);
}
/**
- * User can close the sequence defined by the passed serviceClient.
+ * User can close the seq defined by the passed serviceClient.
*
* @param serviceClient
* @throws SandeshaException
@@ -538,21 +538,21 @@
SOAPEnvelope closeSequnceEnvelope = configureCloseSequence(options, serviceContext.getConfigurationContext());
OMElement closeSequenceBody = closeSequnceEnvelope.getBody().getFirstChildWithName(
- new QName(rmNamespaceValue, Sandesha2Constants.WSRM_COMMON.CLOSE_SEQUENCE));
+ new QName(rmNamespaceValue, Sandesha2Constants.WSRM_COMMON.CLOSE_SEQ));
String oldAction = options.getAction();
options.setAction(SpecSpecificConstants.getCloseSequenceAction(rmSpecVersion));
try {
serviceClient.fireAndForget(closeSequenceBody);
} catch (AxisFault e) {
- String message = "Could not send the close sequence message";
+ String message = "Could not send the close seq message";
throw new SandeshaException(message, e);
} finally {
options.setAction(oldAction);
}
}
- public static void closeSequence(ServiceClient serviceClient, String sequenceKey) throws SandeshaException {
+ public static void closeSequence(ServiceClient serviceClient, String seqKey) throws SandeshaException {
// TODO test
Options options = serviceClient.getOptions();
@@ -565,11 +565,11 @@
throw new SandeshaException (message);
}
- String oldSequenceKey = (String) options.getProperty(SandeshaClientConstants.SEQUENCE_KEY);
- options.setProperty(SandeshaClientConstants.SEQUENCE_KEY, sequenceKey);
+ String oldSequenceKey = (String) options.getProperty(SandeshaClientConstants.SEQ_KEY);
+ options.setProperty(SandeshaClientConstants.SEQ_KEY, seqKey);
closeSequence(serviceClient);
- options.setProperty(SandeshaClientConstants.SEQUENCE_KEY, oldSequenceKey);
+ options.setProperty(SandeshaClientConstants.SEQ_KEY, oldSequenceKey);
}
/**
@@ -581,17 +581,17 @@
waitUntilSequenceCompleted(serviceClient, -1);
}
- public static void waitUntilSequenceCompleted(ServiceClient serviceClient, String sequenceKey)
+ public static void waitUntilSequenceCompleted(ServiceClient serviceClient, String seqKey)
throws SandeshaException {
Options options = serviceClient.getOptions();
if (options == null)
throw new SandeshaException("Options object is not set");
- String oldSequenceKey = (String) options.getProperty(SandeshaClientConstants.SEQUENCE_KEY);
- options.setProperty(SandeshaClientConstants.SEQUENCE_KEY, sequenceKey);
+ String oldSequenceKey = (String) options.getProperty(SandeshaClientConstants.SEQ_KEY);
+ options.setProperty(SandeshaClientConstants.SEQ_KEY, seqKey);
waitUntilSequenceCompleted(serviceClient);
- options.setProperty(SandeshaClientConstants.SEQUENCE_KEY, oldSequenceKey);
+ options.setProperty(SandeshaClientConstants.SEQ_KEY, oldSequenceKey);
}
/**
@@ -606,18 +606,18 @@
long startTime = System.currentTimeMillis();
- SequenceReport sequenceReport = getOutgoingSequenceReport(serviceClient);
- if (sequenceReport == null) {
- throw new SandeshaException("Cannnot find a sequence report for the given data");
+ SequenceReport seqReport = getOutgoingSequenceReport(serviceClient);
+ if (seqReport == null) {
+ throw new SandeshaException("Cannnot find a seq report for the given data");
}
boolean done = false;
while (!done) {
- sequenceReport = getOutgoingSequenceReport(serviceClient);
- int status = sequenceReport.getSequenceStatus();
- if (status == SequenceReport.SEQUENCE_STATUS_TERMINATED)
+ seqReport = getOutgoingSequenceReport(serviceClient);
+ int status = seqReport.getSequenceStatus();
+ if (status == SequenceReport.SEQ_STATUS_TERMINATED)
done = true;
- if (status == SequenceReport.SEQUENCE_STATUS_TIMED_OUT)
+ if (status == SequenceReport.SEQ_STATUS_TIMED_OUT)
done = true;
if (maxWaitingTime >= 0) {
@@ -628,20 +628,20 @@
}
}
- public static void waitUntilSequenceCompleted(ServiceClient serviceClient, long maxWaitingTime, String sequenceKey)
+ public static void waitUntilSequenceCompleted(ServiceClient serviceClient, long maxWaitingTime, String seqKey)
throws SandeshaException {
Options options = serviceClient.getOptions();
if (options == null)
throw new SandeshaException("Options object is not set");
- String oldSequenceKey = (String) options.getProperty(SandeshaClientConstants.SEQUENCE_KEY);
- options.setProperty(SandeshaClientConstants.SEQUENCE_KEY, sequenceKey);
+ String oldSequenceKey = (String) options.getProperty(SandeshaClientConstants.SEQ_KEY);
+ options.setProperty(SandeshaClientConstants.SEQ_KEY, seqKey);
waitUntilSequenceCompleted(serviceClient, maxWaitingTime);
- options.setProperty(SandeshaClientConstants.SEQUENCE_KEY, oldSequenceKey);
+ options.setProperty(SandeshaClientConstants.SEQ_KEY, oldSequenceKey);
}
- // gives the out sequenceID if CS/CSR exchange is done. Otherwise a
+ // gives the out seqID if CS/CSR exchange is done. Otherwise a
// SandeshaException
public static String getSequenceID(ServiceClient serviceClient) throws SandeshaException {
@@ -654,7 +654,7 @@
throw new SandeshaException("To EPR is not set");
String to = toEPR.getAddress();
- String sequenceKey = (String) options.getProperty(SandeshaClientConstants.SEQUENCE_KEY);
+ String seqKey = (String) options.getProperty(SandeshaClientConstants.SEQ_KEY);
ServiceContext serviceContext = serviceClient.getServiceContext();
if (serviceContext == null)
@@ -662,28 +662,28 @@
ConfigurationContext configurationContext = serviceContext.getConfigurationContext();
- String internalSequenceID = generateInternalSequenceIDForTheClientSide(to, sequenceKey);
+ String internalSequenceID = generateInternalSequenceIDForTheClientSide(to, seqKey);
- SequenceReport sequenceReport = SandeshaClient.getOutgoingSequenceReport(serviceClient);
- if (sequenceReport == null)
- throw new SandeshaException("Cannot get a sequence report from the given data");
+ SequenceReport seqReport = SandeshaClient.getOutgoingSequenceReport(serviceClient);
+ if (seqReport == null)
+ throw new SandeshaException("Cannot get a seq report from the given data");
- if (sequenceReport.getSequenceStatus() != SequenceReport.SEQUENCE_STATUS_ESTABLISHED) {
+ if (seqReport.getSequenceStatus() != SequenceReport.SEQ_STATUS_ESTABLISHED) {
throw new SandeshaException(
- "Sequence is not in a active state. Either create sequence response has not being received or sequence has been terminated,"
- + " cannot get sequenceID");
+ "Sequence is not in a active state. Either create seq response has not being received or seq has been terminated,"
+ + " cannot get seqID");
}
StorageManager storageManager = SandeshaUtil.getSandeshaStorageManager(configurationContext,configurationContext.getAxisConfiguration());
SequencePropertyBeanMgr seqPropMgr = storageManager.getSequencePropertyBeanMgr();
- SequencePropertyBean sequenceIDBean = seqPropMgr.retrieve(internalSequenceID,
- Sandesha2Constants.SequenceProperties.OUT_SEQUENCE_ID);
- if (sequenceIDBean == null)
+ SequencePropertyBean seqIDBean = seqPropMgr.retrieve(internalSequenceID,
+ Sandesha2Constants.SequenceProperties.OUT_SEQ_ID);
+ if (seqIDBean == null)
throw new SandeshaException("SequenceIdBean is not set");
- String sequenceID = sequenceIDBean.getValue();
- return sequenceID;
+ String seqID = seqIDBean.getValue();
+ return seqID;
}
public static void sendAckRequest(ServiceClient serviceClient) throws SandeshaException {
@@ -704,7 +704,7 @@
String to = toEPR.getAddress();
- String sequenceKey = (String) options.getProperty(SandeshaClientConstants.SEQUENCE_KEY);
+ String seqKey = (String) options.getProperty(SandeshaClientConstants.SEQ_KEY);
String rmSpecVersion = (String) options.getProperty(SandeshaClientConstants.RM_SPEC_VERSION);
if (rmSpecVersion == null)
@@ -714,12 +714,12 @@
throw new SandeshaException("Empty AckRequest messages can only be sent with the v1_1 spec");
}
- String internalSequenceID = getInternalSequenceID(to, sequenceKey);
+ String internalSequenceID = getInternalSequenceID(to, seqKey);
- SequenceReport sequenceReport = SandeshaClient.getOutgoingSequenceReport(internalSequenceID, configContext);
- if (sequenceReport == null)
- throw new SandeshaException("Cannot generate the sequence report for the given internalSequenceID");
- if (sequenceReport.getSequenceStatus() != SequenceReport.SEQUENCE_STATUS_ESTABLISHED)
+ SequenceReport seqReport = SandeshaClient.getOutgoingSequenceReport(internalSequenceID, configContext);
+ if (seqReport == null)
+ throw new SandeshaException("Cannot generate the seq report for the given internalSequenceID");
+ if (seqReport.getSequenceStatus() != SequenceReport.SEQ_STATUS_ESTABLISHED)
throw new SandeshaException("Canot send the ackRequest message since it is not active");
String outSequenceID = getSequenceID(serviceClient);
@@ -764,20 +764,20 @@
options.setAction(oldAction);
}
- public static void sendAckRequest(ServiceClient serviceClient, String sequenceKey) throws SandeshaException {
+ public static void sendAckRequest(ServiceClient serviceClient, String seqKey) throws SandeshaException {
Options options = serviceClient.getOptions();
if (options == null)
throw new SandeshaException("Options object is not set");
- String oldSequenceKey = (String) options.getProperty(SandeshaClientConstants.SEQUENCE_KEY);
- options.setProperty(SandeshaClientConstants.SEQUENCE_KEY, sequenceKey);
+ String oldSequenceKey = (String) options.getProperty(SandeshaClientConstants.SEQ_KEY);
+ options.setProperty(SandeshaClientConstants.SEQ_KEY, seqKey);
sendAckRequest(serviceClient);
- options.setProperty(SandeshaClientConstants.SEQUENCE_KEY, oldSequenceKey);
+ options.setProperty(SandeshaClientConstants.SEQ_KEY, oldSequenceKey);
}
- private static String getInternalSequenceID(String to, String sequenceKey) {
- return SandeshaUtil.getInternalSequenceID(to, sequenceKey);
+ private static String getInternalSequenceID(String to, String seqKey) {
+ return SandeshaUtil.getInternalSequenceID(to, seqKey);
}
private static SOAPEnvelope configureCloseSequence(Options options, ConfigurationContext configurationContext)
@@ -791,28 +791,28 @@
throw new SandeshaException("You must set the toEPR before calling this method");
String to = epr.getAddress();
- String sequenceKey = (String) options.getProperty(SandeshaClientConstants.SEQUENCE_KEY);
+ String seqKey = (String) options.getProperty(SandeshaClientConstants.SEQ_KEY);
- String internalSequenceID = SandeshaUtil.getInternalSequenceID(to, sequenceKey);
+ String internalSequenceID = SandeshaUtil.getInternalSequenceID(to, seqKey);
- SequenceReport sequenceReport = SandeshaClient.getOutgoingSequenceReport(internalSequenceID,
+ SequenceReport seqReport = SandeshaClient.getOutgoingSequenceReport(internalSequenceID,
configurationContext);
- if (sequenceReport == null)
- throw new SandeshaException("Cannot generate the sequence report for the given internalSequenceID");
- if (sequenceReport.getSequenceStatus() != SequenceReport.SEQUENCE_STATUS_ESTABLISHED)
- throw new SandeshaException("Canot close the sequence since it is not active");
+ if (seqReport == null)
+ throw new SandeshaException("Cannot generate the seq report for the given internalSequenceID");
+ if (seqReport.getSequenceStatus() != SequenceReport.SEQ_STATUS_ESTABLISHED)
+ throw new SandeshaException("Canot close the seq since it is not active");
StorageManager storageManager = SandeshaUtil.getSandeshaStorageManager(configurationContext,configurationContext.getAxisConfiguration());
SequencePropertyBeanMgr seqPropMgr = storageManager.getSequencePropertyBeanMgr();
- SequencePropertyBean sequenceIDBean = seqPropMgr.retrieve(internalSequenceID,
- Sandesha2Constants.SequenceProperties.OUT_SEQUENCE_ID);
- if (sequenceIDBean == null)
+ SequencePropertyBean seqIDBean = seqPropMgr.retrieve(internalSequenceID,
+ Sandesha2Constants.SequenceProperties.OUT_SEQ_ID);
+ if (seqIDBean == null)
throw new SandeshaException("SequenceIdBean is not set");
- String sequenceID = sequenceIDBean.getValue();
+ String seqID = seqIDBean.getValue();
- if (sequenceID == null)
- throw new SandeshaException("Cannot find the sequenceID");
+ if (seqID == null)
+ throw new SandeshaException("Cannot find the seqID");
String rmSpecVersion = (String) options.getProperty(SandeshaClientConstants.RM_SPEC_VERSION);
@@ -820,7 +820,7 @@
rmSpecVersion = SpecSpecificConstants.getDefaultSpecVersion();
if (!SpecSpecificConstants.isSequenceClosingAllowed(rmSpecVersion))
- throw new SandeshaException("This rm version does not allow sequence closing");
+ throw new SandeshaException("This rm version does not allow seq closing");
SOAPEnvelope dummyEnvelope = null;
SOAPFactory factory = null;
@@ -837,7 +837,7 @@
CloseSequence closeSequence = new CloseSequence(factory, rmNamespaceValue);
Identifier identifier = new Identifier(factory, rmNamespaceValue);
- identifier.setIndentifer(sequenceID);
+ identifier.setIndentifer(seqID);
closeSequence.setIdentifier(identifier);
closeSequence.toSOAPEnvelope(dummyEnvelope);
@@ -849,11 +849,11 @@
throws SandeshaException {
SequencePropertyBean internalSequenceFindBean = new SequencePropertyBean();
internalSequenceFindBean.setValue(internalSequenceID);
- internalSequenceFindBean.setName(Sandesha2Constants.SequenceProperties.INTERNAL_SEQUENCE_ID);
+ internalSequenceFindBean.setName(Sandesha2Constants.SequenceProperties.INTERNAL_SEQ_ID);
SequencePropertyBean internalSequenceBean = seqPropMgr.findUnique(internalSequenceFindBean);
if (internalSequenceBean == null) {
- String message = "Internal sequence Bean is not available for the given sequence";
+ String message = "Internal seq Bean is not available for the given seq";
log.debug(message);
return false;
@@ -861,9 +861,9 @@
String outSequenceID = internalSequenceBean.getSequenceID();
- SequencePropertyBean sequenceTerminatedBean = seqPropMgr.retrieve(outSequenceID,
- Sandesha2Constants.SequenceProperties.SEQUENCE_TERMINATED);
- if (sequenceTerminatedBean != null && Sandesha2Constants.VALUE_TRUE.equals(sequenceTerminatedBean.getValue())) {
+ SequencePropertyBean seqTerminatedBean = seqPropMgr.retrieve(outSequenceID,
+ Sandesha2Constants.SequenceProperties.SEQ_TERMINATED);
+ if (seqTerminatedBean != null && Sandesha2Constants.VALUE_TRUE.equals(seqTerminatedBean.getValue())) {
return true;
}
@@ -874,20 +874,20 @@
throws SandeshaException {
SequencePropertyBean internalSequenceFindBean = new SequencePropertyBean();
internalSequenceFindBean.setValue(internalSequenceID);
- internalSequenceFindBean.setName(Sandesha2Constants.SequenceProperties.INTERNAL_SEQUENCE_ID);
+ internalSequenceFindBean.setName(Sandesha2Constants.SequenceProperties.INTERNAL_SEQ_ID);
SequencePropertyBean internalSequenceBean = seqPropMgr.findUnique(internalSequenceFindBean);
if (internalSequenceBean == null) {
- String message = "Internal sequence Bean is not available for the given sequence";
+ String message = "Internal seq Bean is not available for the given seq";
log.debug(message);
return false;
}
String outSequenceID = internalSequenceBean.getSequenceID();
- SequencePropertyBean sequenceTerminatedBean = seqPropMgr.retrieve(outSequenceID,
- Sandesha2Constants.SequenceProperties.SEQUENCE_TIMED_OUT);
- if (sequenceTerminatedBean != null && Sandesha2Constants.VALUE_TRUE.equals(sequenceTerminatedBean.getValue())) {
+ SequencePropertyBean seqTerminatedBean = seqPropMgr.retrieve(outSequenceID,
+ Sandesha2Constants.SequenceProperties.SEQ_TIMED_OUT);
+ if (seqTerminatedBean != null && Sandesha2Constants.VALUE_TRUE.equals(seqTerminatedBean.getValue())) {
return true;
}
@@ -898,17 +898,17 @@
SequencePropertyBeanMgr seqPropMgr) throws SandeshaException {
SequencePropertyBean internalSequenceFindBean = new SequencePropertyBean();
internalSequenceFindBean.setValue(internalSequenceID);
- internalSequenceFindBean.setName(Sandesha2Constants.SequenceProperties.INTERNAL_SEQUENCE_ID);
+ internalSequenceFindBean.setName(Sandesha2Constants.SequenceProperties.INTERNAL_SEQ_ID);
SequencePropertyBean internalSequenceBean = seqPropMgr.findUnique(internalSequenceFindBean);
if (internalSequenceBean == null) {
- String message = "Not a valid terminated sequence. Internal sequence Bean is not available for the given sequence";
+ String message = "Not a valid terminated seq. Internal seq Bean is not available for the given seq";
log.debug(message);
throw new SandeshaException(message);
}
- report.setSequenceStatus(SequenceReport.SEQUENCE_STATUS_TERMINATED);
+ report.setSequenceStatus(SequenceReport.SEQ_STATUS_TERMINATED);
String outSequenceID = internalSequenceBean.getSequenceID();
fillOutgoingSequenceInfo(report, outSequenceID, seqPropMgr);
@@ -918,17 +918,17 @@
SequencePropertyBeanMgr seqPropMgr) throws SandeshaException {
SequencePropertyBean internalSequenceFindBean = new SequencePropertyBean();
internalSequenceFindBean.setValue(internalSequenceID);
- internalSequenceFindBean.setName(Sandesha2Constants.SequenceProperties.INTERNAL_SEQUENCE_ID);
+ internalSequenceFindBean.setName(Sandesha2Constants.SequenceProperties.INTERNAL_SEQ_ID);
SequencePropertyBean internalSequenceBean = seqPropMgr.findUnique(internalSequenceFindBean);
if (internalSequenceBean == null) {
- String message = "Not a valid timedOut sequence. Internal sequence Bean is not available for the given sequence";
+ String message = "Not a valid timedOut seq. Internal seq Bean is not available for the given seq";
log.debug(message);
throw new SandeshaException(message);
}
- report.setSequenceStatus(SequenceReport.SEQUENCE_STATUS_TIMED_OUT);
+ report.setSequenceStatus(SequenceReport.SEQ_STATUS_TIMED_OUT);
String outSequenceID = internalSequenceBean.getSequenceID();
fillOutgoingSequenceInfo(report, outSequenceID, seqPropMgr);
}
@@ -947,31 +947,31 @@
}
}
- private static byte getServerSequenceStatus(String sequenceID, StorageManager storageManager)
+ private static byte getServerSequenceStatus(String seqID, StorageManager storageManager)
throws SandeshaException {
SequencePropertyBeanMgr seqPropMgr = storageManager.getSequencePropertyBeanMgr();
- SequencePropertyBean terminatedBean = seqPropMgr.retrieve(sequenceID,
- Sandesha2Constants.SequenceProperties.SEQUENCE_TERMINATED);
+ SequencePropertyBean terminatedBean = seqPropMgr.retrieve(seqID,
+ Sandesha2Constants.SequenceProperties.SEQ_TERMINATED);
if (terminatedBean != null) {
- return SequenceReport.SEQUENCE_STATUS_TERMINATED;
+ return SequenceReport.SEQ_STATUS_TERMINATED;
}
- SequencePropertyBean timedOutBean = seqPropMgr.retrieve(sequenceID,
- Sandesha2Constants.SequenceProperties.SEQUENCE_TIMED_OUT);
+ SequencePropertyBean timedOutBean = seqPropMgr.retrieve(seqID,
+ Sandesha2Constants.SequenceProperties.SEQ_TIMED_OUT);
if (timedOutBean != null) {
- return SequenceReport.SEQUENCE_STATUS_TIMED_OUT;
+ return SequenceReport.SEQ_STATUS_TIMED_OUT;
}
NextMsgBeanMgr nextMsgMgr = storageManager.getNextMsgBeanMgr();
- NextMsgBean nextMsgBean = nextMsgMgr.retrieve(sequenceID);
+ NextMsgBean nextMsgBean = nextMsgMgr.retrieve(seqID);
if (nextMsgBean != null) {
- return SequenceReport.SEQUENCE_STATUS_ESTABLISHED;
+ return SequenceReport.SEQ_STATUS_ESTABLISHED;
}
- throw new SandeshaException("Unrecorded sequenceID");
+ throw new SandeshaException("Unrecorded seqID");
}
private class DummyCallback extends Callback {
@@ -989,11 +989,11 @@
}
- private static String generateInternalSequenceIDForTheClientSide(String toEPR, String sequenceKey) {
- return SandeshaUtil.getInternalSequenceID(toEPR, sequenceKey);
+ private static String generateInternalSequenceIDForTheClientSide(String toEPR, String seqKey) {
+ return SandeshaUtil.getInternalSequenceID(toEPR, seqKey);
}
- private static SequenceReport getIncomingSequenceReport(String sequenceID, ConfigurationContext configCtx)
+ private static SequenceReport getIncomingSequenceReport(String seqID, ConfigurationContext configCtx)
throws SandeshaException {
StorageManager storageManager = SandeshaUtil.getSandeshaStorageManager(configCtx,configCtx.getAxisConfiguration());
@@ -1012,26 +1012,26 @@
try {
- SequenceReport sequenceReport = new SequenceReport();
+ SequenceReport seqReport = new SequenceReport();
- ArrayList completedMessageList = AcknowledgementManager.getServerCompletedMessagesList(sequenceID,
+ ArrayList completedMessageList = AcknowledgementManager.getServerCompletedMessagesList(seqID,
seqPropMgr);
Iterator iter = completedMessageList.iterator();
while (iter.hasNext()) {
;
- sequenceReport.addCompletedMessage((Long) iter.next());
+ seqReport.addCompletedMessage((Long) iter.next());
}
- sequenceReport.setSequenceID(sequenceID);
- sequenceReport.setInternalSequenceID(sequenceID); // for the
+ seqReport.setSequenceID(seqID);
+ seqReport.setInternalSequenceID(seqID); // for the
// incoming side
- // internalSequenceID=sequenceID
- sequenceReport.setSequenceDirection(SequenceReport.SEQUENCE_DIRECTION_IN);
+ // internalSequenceID=seqID
+ seqReport.setSequenceDirection(SequenceReport.SEQ_DIRECTION_IN);
- sequenceReport.setSequenceStatus(getServerSequenceStatus(sequenceID, storageManager));
+ seqReport.setSequenceStatus(getServerSequenceStatus(seqID, storageManager));
- return sequenceReport;
+ return seqReport;
} catch (Exception e) {
if (!withinTransaction && reportTransaction!=null) {
@@ -1060,26 +1060,26 @@
throw new SandeshaException("You must set the toEPR before calling this method");
String to = epr.getAddress();
- String sequenceKey = (String) options.getProperty(SandeshaClientConstants.SEQUENCE_KEY);
- String internalSequenceID = SandeshaUtil.getInternalSequenceID(to, sequenceKey);
- SequenceReport sequenceReport = SandeshaClient.getOutgoingSequenceReport(internalSequenceID,
+ String seqKey = (String) options.getProperty(SandeshaClientConstants.SEQ_KEY);
+ String internalSequenceID = SandeshaUtil.getInternalSequenceID(to, seqKey);
+ SequenceReport seqReport = SandeshaClient.getOutgoingSequenceReport(internalSequenceID,
configurationContext);
- if (sequenceReport == null)
- throw new SandeshaException("Cannot generate the sequence report for the given internalSequenceID");
- if (sequenceReport.getSequenceStatus() != SequenceReport.SEQUENCE_STATUS_ESTABLISHED)
- throw new SandeshaException("Canot terminate the sequence since it is not active");
+ if (seqReport == null)
+ throw new SandeshaException("Cannot generate the seq report for the given internalSequenceID");
+ if (seqReport.getSequenceStatus() != SequenceReport.SEQ_STATUS_ESTABLISHED)
+ throw new SandeshaException("Canot terminate the seq since it is not active");
StorageManager storageManager = SandeshaUtil.getSandeshaStorageManager(configurationContext,configurationContext.getAxisConfiguration());
SequencePropertyBeanMgr seqPropMgr = storageManager.getSequencePropertyBeanMgr();
- SequencePropertyBean sequenceIDBean = seqPropMgr.retrieve(internalSequenceID,
- Sandesha2Constants.SequenceProperties.OUT_SEQUENCE_ID);
- if (sequenceIDBean == null)
+ SequencePropertyBean seqIDBean = seqPropMgr.retrieve(internalSequenceID,
+ Sandesha2Constants.SequenceProperties.OUT_SEQ_ID);
+ if (seqIDBean == null)
throw new SandeshaException("SequenceIdBean is not set");
- String sequenceID = sequenceIDBean.getValue();
+ String seqID = seqIDBean.getValue();
- if (sequenceID == null)
- throw new SandeshaException("Cannot find the sequenceID");
+ if (seqID == null)
+ throw new SandeshaException("Cannot find the seqID");
String rmSpecVersion = (String) options.getProperty(SandeshaClientConstants.RM_SPEC_VERSION);
if (rmSpecVersion == null)
@@ -1100,7 +1100,7 @@
String rmNamespaceValue = SpecSpecificConstants.getRMNamespaceValue(rmSpecVersion);
TerminateSequence terminateSequence = new TerminateSequence(factory, rmNamespaceValue);
Identifier identifier = new Identifier(factory, rmNamespaceValue);
- identifier.setIndentifer(sequenceID);
+ identifier.setIndentifer(seqID);
terminateSequence.setIdentifier(identifier);
terminateSequence.toSOAPEnvelope(dummyEnvelope);
Modified: webservices/sandesha/trunk/c/src/client/sequence_report.c
URL: http://svn.apache.org/viewvc/webservices/sandesha/trunk/c/src/client/sequence_report.c?rev=420822&r1=420821&r2=420822&view=diff
==============================================================================
--- webservices/sandesha/trunk/c/src/client/sequence_report.c (original)
+++ webservices/sandesha/trunk/c/src/client/sequence_report.c Tue Jul 11 05:42:25 2006
@@ -14,111 +14,111 @@
* limitations under the License.
*/
-#include <sandesha2_sequence_report.h>
+#include <sandesha2_seq_report.h>
#include <axis2_log.h>
-typedef struct sandesha2_sequence_report_impl sandesha2_sequence_report_impl_t;
+typedef struct sandesha2_seq_report_impl sandesha2_seq_report_impl_t;
/**
* @brief Sandesha Sequence Report Struct Impl
* Sandesha Sequence Report
*/
-struct sandesha2_sequence_report_impl
+struct sandesha2_seq_report_impl
{
- sandesha2_sequence_report_t report;
+ sandesha2_seq_report_t report;
- axis2_char_t sequence_status;
- axis2_char_t sequence_direction;
- axis2_char_t *sequence_id;
- axis2_char_t *internal_sequence_id; /* only for outgoing sequences */
+ axis2_char_t seq_status;
+ axis2_char_t seq_direction;
+ axis2_char_t *seq_id;
+ axis2_char_t *internal_seq_id; /* only for outgoing seqs */
axis2_array_list_t *completed_msgs; /* no of messages acked (both for incoming and outgoing)*/
};
-#define SANDESHA2_INTF_TO_IMPL(report) ((sandesha2_sequence_report_impl_t *) report)
+#define SANDESHA2_INTF_TO_IMPL(report) ((sandesha2_seq_report_impl_t *) report)
axis2_status_t AXIS2_CALL
-sandesha2_sequence_report_free(
+sandesha2_seq_report_free(
void *report,
const axis2_env_t *envv);
axis2_status_t AXIS2_CALL
-sandesha2_sequence_report_set_sequence_status(
- sandesha2_sequence_report_t *report,
+sandesha2_seq_report_set_seq_status(
+ sandesha2_seq_report_t *report,
const axis2_env_t *env,
- axis2_char_t sequence_status);
+ axis2_char_t seq_status);
axis2_status_t AXIS2_CALL
-sandesha2_sequence_report_set_sequence_direction(
- sandesha2_sequence_report_t *report,
+sandesha2_seq_report_set_seq_direction(
+ sandesha2_seq_report_t *report,
const axis2_env_t *env,
- axis2_char_t sequence_direction);
+ axis2_char_t seq_direction);
axis2_char_t AXIS2_CALL
-sandesha2_sequence_report_get_sequence_status(
- sandesha2_sequence_report_t *report,
+sandesha2_seq_report_get_seq_status(
+ sandesha2_seq_report_t *report,
const axis2_env_t *env);
axis2_char_t AXIS2_CALL
-sandesha2_sequence_report_get_sequence_direction(
- sandesha2_sequence_report_t *report,
+sandesha2_seq_report_get_seq_direction(
+ sandesha2_seq_report_t *report,
const axis2_env_t *env);
axis2_char_t *AXIS2_CALL
-sandesha2_sequence_report_get_sequence_id(
- sandesha2_sequence_report_t *report,
+sandesha2_seq_report_get_seq_id(
+ sandesha2_seq_report_t *report,
const axis2_env_t *env);
axis2_status_t AXIS2_CALL
-sandesha2_sequence_report_set_sequence_id(
- sandesha2_sequence_report_t *report,
+sandesha2_seq_report_set_seq_id(
+ sandesha2_seq_report_t *report,
const axis2_env_t *env,
- axis2_char_t *sequence_id);
+ axis2_char_t *seq_id);
axis2_array_list_t *AXIS2_CALL
-sandesha2_sequence_report_get_completed_msgs(
- sandesha2_sequence_report_t *report,
+sandesha2_seq_report_get_completed_msgs(
+ sandesha2_seq_report_t *report,
const axis2_env_t *env);
axis2_status_t AXIS2_CALL
-sandesha2_sequence_report_add_completed_msg(
- sandesha2_sequence_report_t *report,
+sandesha2_seq_report_add_completed_msg(
+ sandesha2_seq_report_t *report,
const axis2_env_t *env,
long *msg_no);
axis2_status_t AXIS2_CALL
-sandesha2_sequence_report_set_completed_msgs(
- sandesha2_sequence_report_t *report,
+sandesha2_seq_report_set_completed_msgs(
+ sandesha2_seq_report_t *report,
const axis2_env_t *env,
axis2_array_list_t *completed_msgs);
axis2_char_t *AXIS2_CALL
-sandesha2_sequence_report_get_internal_sequence_id(
- sandesha2_sequence_report_t *report,
+sandesha2_seq_report_get_internal_seq_id(
+ sandesha2_seq_report_t *report,
const axis2_env_t *env,
long *msg_no);
axis2_status_t AXIS2_CALL
-sandesha2_sequence_report_set_internal_sequence_id(
- sandesha2_sequence_report_t *report,
+sandesha2_seq_report_set_internal_seq_id(
+ sandesha2_seq_report_t *report,
const axis2_env_t *env,
- axis2_char_t *internal_sequence_id);
+ axis2_char_t *internal_seq_id);
-AXIS2_EXTERN sandesha2_sequence_report_t * AXIS2_CALL
-sandesha2_sequence_report_create(
+AXIS2_EXTERN sandesha2_seq_report_t * AXIS2_CALL
+sandesha2_seq_report_create(
const axis2_env_t *env)
{
- sandesha2_sequence_report_impl_t *report_impl = NULL;
+ sandesha2_seq_report_impl_t *report_impl = NULL;
AXIS2_ENV_CHECK(env, NULL);
report_impl = AXIS2_MALLOC(env->allocator,
- sizeof(sandesha2_sequence_report_impl_t));
+ sizeof(sandesha2_seq_report_impl_t));
report_impl->completed_msgs = NULL;
- report_impl->sequence_status = SEQUENCE_STATUS_UNKNOWN;
- report_impl->sequence_direction = SEQUENCE_DIRECTION_UNKNOWN;
+ report_impl->seq_status = SEQ_STATUS_UNKNOWN;
+ report_impl->seq_direction = SEQ_DIRECTION_UNKNOWN;
report_impl->report.ops = AXIS2_MALLOC(env->allocator,
- sizeof(sandesha2_sequence_report_ops_t));
+ sizeof(sandesha2_seq_report_ops_t));
report_impl->completed_msgs = axis2_array_list_create(env, 0);
if(!report_impl->completed_msgs)
@@ -126,39 +126,39 @@
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
- report_impl->report.ops->free = sandesha2_sequence_report_free;
- report_impl->report.ops->set_sequence_status =
- sandesha2_sequence_report_set_sequence_status;
- report_impl->report.ops->set_sequence_direction =
- sandesha2_sequence_report_set_sequence_direction;
- report_impl->report.ops->get_sequence_status =
- sandesha2_sequence_report_get_sequence_status;
- report_impl->report.ops->get_sequence_direction =
- sandesha2_sequence_report_get_sequence_direction;
- report_impl->report.ops->get_sequence_id =
- sandesha2_sequence_report_get_sequence_id;
- report_impl->report.ops->set_sequence_id =
- sandesha2_sequence_report_set_sequence_id;
+ report_impl->report.ops->free = sandesha2_seq_report_free;
+ report_impl->report.ops->set_seq_status =
+ sandesha2_seq_report_set_seq_status;
+ report_impl->report.ops->set_seq_direction =
+ sandesha2_seq_report_set_seq_direction;
+ report_impl->report.ops->get_seq_status =
+ sandesha2_seq_report_get_seq_status;
+ report_impl->report.ops->get_seq_direction =
+ sandesha2_seq_report_get_seq_direction;
+ report_impl->report.ops->get_seq_id =
+ sandesha2_seq_report_get_seq_id;
+ report_impl->report.ops->set_seq_id =
+ sandesha2_seq_report_set_seq_id;
report_impl->report.ops->get_completed_msgs =
- sandesha2_sequence_report_get_completed_msgs;
+ sandesha2_seq_report_get_completed_msgs;
report_impl->report.ops->add_completed_msg =
- sandesha2_sequence_report_add_completed_msg;
+ sandesha2_seq_report_add_completed_msg;
report_impl->report.ops->set_completed_msgs =
- sandesha2_sequence_report_set_completed_msgs;
- report_impl->report.ops->get_internal_sequence_id =
- sandesha2_sequence_report_get_internal_sequence_id;
- report_impl->report.ops->set_internal_sequence_id =
- sandesha2_sequence_report_set_internal_sequence_id;
+ sandesha2_seq_report_set_completed_msgs;
+ report_impl->report.ops->get_internal_seq_id =
+ sandesha2_seq_report_get_internal_seq_id;
+ report_impl->report.ops->set_internal_seq_id =
+ sandesha2_seq_report_set_internal_seq_id;
return &(report_impl->report);
}
axis2_status_t AXIS2_CALL
-sandesha2_sequence_report_free(
+sandesha2_seq_report_free(
void *report,
const axis2_env_t *env)
{
- sandesha2_sequence_report_impl_t *report_impl = NULL;
+ sandesha2_seq_report_impl_t *report_impl = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
report_impl = SANDESHA2_INTF_TO_IMPL(report);
@@ -169,10 +169,10 @@
report_impl->completed_msgs = NULL;
}
- if(report_impl->sequence_id)
+ if(report_impl->seq_id)
{
- AXIS2_FREE(env->allocator, report_impl->sequence_id);
- report_impl->sequence_id = NULL;
+ AXIS2_FREE(env->allocator, report_impl->seq_id);
+ report_impl->seq_id = NULL;
}
if((&(report_impl->report))->ops)
@@ -190,100 +190,100 @@
}
axis2_status_t AXIS2_CALL
-sandesha2_sequence_report_set_sequence_status(
- sandesha2_sequence_report_t *report,
+sandesha2_seq_report_set_seq_status(
+ sandesha2_seq_report_t *report,
const axis2_env_t *env,
- axis2_char_t sequence_status)
+ axis2_char_t seq_status)
{
- sandesha2_sequence_report_impl_t *report_impl = NULL;
+ sandesha2_seq_report_impl_t *report_impl = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
report_impl = SANDESHA2_INTF_TO_IMPL(report);
- if (sequence_status >= SEQUENCE_STATUS_UNKNOWN &&
- sequence_status <= MAX_SEQUENCE_STATUS)
+ if (seq_status >= SEQ_STATUS_UNKNOWN &&
+ seq_status <= MAX_SEQ_STATUS)
{
- report_impl->sequence_status = sequence_status;
+ report_impl->seq_status = seq_status;
}
return AXIS2_SUCCESS;
}
axis2_status_t AXIS2_CALL
-sandesha2_sequence_report_set_sequence_direction(
- sandesha2_sequence_report_t *report,
+sandesha2_seq_report_set_seq_direction(
+ sandesha2_seq_report_t *report,
const axis2_env_t *env,
- axis2_char_t sequence_direction)
+ axis2_char_t seq_direction)
{
- sandesha2_sequence_report_impl_t *report_impl = NULL;
+ sandesha2_seq_report_impl_t *report_impl = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
report_impl = SANDESHA2_INTF_TO_IMPL(report);
- if (sequence_direction >= SEQUENCE_DIRECTION_UNKNOWN &&
- sequence_direction <= MAX_SEQUENCE_DIRECTION)
+ if (seq_direction >= SEQ_DIRECTION_UNKNOWN &&
+ seq_direction <= MAX_SEQ_DIRECTION)
{
- report_impl->sequence_direction = sequence_direction;
+ report_impl->seq_direction = seq_direction;
}
return AXIS2_SUCCESS;
}
axis2_char_t AXIS2_CALL
-sandesha2_sequence_report_get_sequence_status(
- sandesha2_sequence_report_t *report,
+sandesha2_seq_report_get_seq_status(
+ sandesha2_seq_report_t *report,
const axis2_env_t *env)
{
- sandesha2_sequence_report_impl_t *report_impl = NULL;
+ sandesha2_seq_report_impl_t *report_impl = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
report_impl = SANDESHA2_INTF_TO_IMPL(report);
- return report_impl->sequence_status;
+ return report_impl->seq_status;
}
axis2_char_t AXIS2_CALL
-sandesha2_sequence_report_get_sequence_direction(
- sandesha2_sequence_report_t *report,
+sandesha2_seq_report_get_seq_direction(
+ sandesha2_seq_report_t *report,
const axis2_env_t *env)
{
- sandesha2_sequence_report_impl_t *report_impl = NULL;
+ sandesha2_seq_report_impl_t *report_impl = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
report_impl = SANDESHA2_INTF_TO_IMPL(report);
- return report_impl->sequence_direction;
+ return report_impl->seq_direction;
}
axis2_char_t *AXIS2_CALL
-sandesha2_sequence_report_get_sequence_id(
- sandesha2_sequence_report_t *report,
+sandesha2_seq_report_get_seq_id(
+ sandesha2_seq_report_t *report,
const axis2_env_t *env)
{
- sandesha2_sequence_report_impl_t *report_impl = NULL;
+ sandesha2_seq_report_impl_t *report_impl = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
report_impl = SANDESHA2_INTF_TO_IMPL(report);
- return report_impl->sequence_id;
+ return report_impl->seq_id;
}
axis2_status_t AXIS2_CALL
-sandesha2_sequence_report_set_sequence_id(
- sandesha2_sequence_report_t *report,
+sandesha2_seq_report_set_seq_id(
+ sandesha2_seq_report_t *report,
const axis2_env_t *env,
- axis2_char_t *sequence_id)
+ axis2_char_t *seq_id)
{
- sandesha2_sequence_report_impl_t *report_impl = NULL;
+ sandesha2_seq_report_impl_t *report_impl = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
report_impl = SANDESHA2_INTF_TO_IMPL(report);
- if(report_impl->sequence_id)
+ if(report_impl->seq_id)
{
- AXIS2_FREE(env->allocator, report_impl->sequence_id);
- report_impl->sequence_id = NULL;
+ AXIS2_FREE(env->allocator, report_impl->seq_id);
+ report_impl->seq_id = NULL;
}
- report_impl->sequence_id = AXIS2_STRDUP(sequence_id, env);
- if(!report_impl->sequence_id)
+ report_impl->seq_id = AXIS2_STRDUP(seq_id, env);
+ if(!report_impl->seq_id)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return AXIS2_FAILURE;
@@ -292,11 +292,11 @@
}
axis2_array_list_t *AXIS2_CALL
-sandesha2_sequence_report_get_completed_msgs(
- sandesha2_sequence_report_t *report,
+sandesha2_seq_report_get_completed_msgs(
+ sandesha2_seq_report_t *report,
const axis2_env_t *env)
{
- sandesha2_sequence_report_impl_t *report_impl = NULL;
+ sandesha2_seq_report_impl_t *report_impl = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
report_impl = SANDESHA2_INTF_TO_IMPL(report);
@@ -305,12 +305,12 @@
}
axis2_status_t AXIS2_CALL
-sandesha2_sequence_report_add_completed_msg(
- sandesha2_sequence_report_t *report,
+sandesha2_seq_report_add_completed_msg(
+ sandesha2_seq_report_t *report,
const axis2_env_t *env,
long *msg_no)
{
- sandesha2_sequence_report_impl_t *report_impl = NULL;
+ sandesha2_seq_report_impl_t *report_impl = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
report_impl = SANDESHA2_INTF_TO_IMPL(report);
@@ -320,12 +320,12 @@
}
axis2_status_t AXIS2_CALL
-sandesha2_sequence_report_set_completed_msgs(
- sandesha2_sequence_report_t *report,
+sandesha2_seq_report_set_completed_msgs(
+ sandesha2_seq_report_t *report,
const axis2_env_t *env,
axis2_array_list_t *completed_msgs)
{
- sandesha2_sequence_report_impl_t *report_impl = NULL;
+ sandesha2_seq_report_impl_t *report_impl = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
report_impl = SANDESHA2_INTF_TO_IMPL(report);
@@ -350,37 +350,37 @@
}
axis2_char_t *AXIS2_CALL
-sandesha2_sequence_report_get_internal_sequence_id(
- sandesha2_sequence_report_t *report,
+sandesha2_seq_report_get_internal_seq_id(
+ sandesha2_seq_report_t *report,
const axis2_env_t *env,
long *msg_no)
{
- sandesha2_sequence_report_impl_t *report_impl = NULL;
+ sandesha2_seq_report_impl_t *report_impl = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
report_impl = SANDESHA2_INTF_TO_IMPL(report);
- return report_impl->internal_sequence_id;
+ return report_impl->internal_seq_id;
}
axis2_status_t AXIS2_CALL
-sandesha2_sequence_report_set_internal_sequence_id(
- sandesha2_sequence_report_t *report,
+sandesha2_seq_report_set_internal_seq_id(
+ sandesha2_seq_report_t *report,
const axis2_env_t *env,
- axis2_char_t *internal_sequence_id)
+ axis2_char_t *internal_seq_id)
{
- sandesha2_sequence_report_impl_t *report_impl = NULL;
+ sandesha2_seq_report_impl_t *report_impl = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
report_impl = SANDESHA2_INTF_TO_IMPL(report);
- if(report_impl->internal_sequence_id)
+ if(report_impl->internal_seq_id)
{
- AXIS2_FREE(env->allocator, report_impl->internal_sequence_id);
- report_impl->internal_sequence_id = NULL;
+ AXIS2_FREE(env->allocator, report_impl->internal_seq_id);
+ report_impl->internal_seq_id = NULL;
}
- report_impl->internal_sequence_id = AXIS2_STRDUP(internal_sequence_id, env);
- if(!report_impl->internal_sequence_id)
+ report_impl->internal_seq_id = AXIS2_STRDUP(internal_seq_id, env);
+ if(!report_impl->internal_seq_id)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return AXIS2_FAILURE;
---------------------------------------------------------------------
To unsubscribe, e-mail: sandesha-dev-unsubscribe@ws.apache.org
For additional commands, e-mail: sandesha-dev-help@ws.apache.org