You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
336 lines
8.8 KiB
336 lines
8.8 KiB
/*
|
|
* REVISIONS:
|
|
* jod30NOV92 Changes made due to GCIP stuff
|
|
* ane16DEC92 Added cdefine.h
|
|
* pcy02Feb93: AddEvent must return a value. Changed to return ErrNO_ERROR
|
|
* cad29Oct93: added get next attr
|
|
* cad08Dec93: added extended get/set types
|
|
* mwh05May94: #include file madness , part 2
|
|
* mwh07Jun94: port for NCR
|
|
* jbc07Nov96: added check to only allow one transaction per code
|
|
* mds10Jul97: modified Transaction Item Equal() function
|
|
* mds10Jul97: changed GetFirstAttribute() to const to work with Equal()
|
|
* mds14Jul97: StrIntCmpI was renamed to ApcStrIntCmpI
|
|
*/
|
|
|
|
#define INCL_BASE
|
|
#define INCL_NOPM
|
|
|
|
#include "cdefine.h"
|
|
|
|
#include "_defs.h"
|
|
extern "C" {
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
}
|
|
|
|
#include "trans.h"
|
|
#include "apc.h"
|
|
#include "err.h"
|
|
#include "event.h"
|
|
#include "list.h"
|
|
#include "message.h"
|
|
#include "utils.h"
|
|
|
|
#if (C_OS & C_NCR)
|
|
# include "incfix.h"
|
|
#endif
|
|
|
|
|
|
TransactionObject::TransactionObject(Type type, INT anId)
|
|
: theType(type),
|
|
theId(anId),
|
|
theProtocolMessageList((List*)NULL),
|
|
thePMIterator((ListIterator*)NULL)
|
|
{
|
|
theProtocolMessageList = new List();
|
|
if (theProtocolMessageList)
|
|
thePMIterator = &(RListIterator)(theProtocolMessageList->InitIterator());
|
|
else
|
|
SetObjectStatus(ErrMEMORY);
|
|
}
|
|
|
|
TransactionObject:: ~TransactionObject()
|
|
{
|
|
if (theProtocolMessageList)
|
|
theProtocolMessageList->FlushAll();
|
|
delete theProtocolMessageList;
|
|
theProtocolMessageList = (List*)NULL;
|
|
delete thePMIterator;
|
|
thePMIterator = NULL;
|
|
}
|
|
|
|
VOID TransactionObject::AddMessage(PMessage aMessage)
|
|
{
|
|
theProtocolMessageList->Append(aMessage);
|
|
}
|
|
|
|
|
|
INT TransactionItem::transactionItemCount = 0;
|
|
|
|
TransactionItem::TransactionItem(Type aType, INT aCode, CHAR* aValue)
|
|
: TransactionObject(aType, transactionItemCount++),
|
|
theCode(aCode),
|
|
theErrorCode(0),
|
|
theValue((CHAR*)NULL),
|
|
theAttributeList((List*)NULL),
|
|
theAttribIterator((ListIterator*)NULL)
|
|
{
|
|
SetValue(aValue);
|
|
theAttributeList = new List();
|
|
if (theAttributeList)
|
|
theAttribIterator = &(RListIterator)(theAttributeList->InitIterator());
|
|
}
|
|
|
|
TransactionItem::~TransactionItem()
|
|
{
|
|
if (theValue)
|
|
free(theValue);
|
|
theValue = (CHAR*)NULL;
|
|
|
|
if (theAttributeList)
|
|
theAttributeList->FlushAll();
|
|
delete theAttributeList;
|
|
theAttributeList = (List*)NULL;
|
|
delete theAttribIterator;
|
|
theAttribIterator = (ListIterator*)NULL;
|
|
}
|
|
|
|
VOID TransactionItem::SetValue(CHAR* aValue)
|
|
{
|
|
if (theValue != (CHAR*)NULL)
|
|
{
|
|
free(theValue);
|
|
theValue = (CHAR*)NULL;
|
|
}
|
|
if (aValue != (CHAR*)NULL)
|
|
theValue = _strdup(aValue);
|
|
}
|
|
|
|
|
|
VOID TransactionItem::AddAttribute(PAttribute anAttribute)
|
|
{
|
|
theAttributeList->Append(anAttribute);
|
|
}
|
|
|
|
VOID TransactionItem::AddAttribute(INT aCode, CHAR* aValue)
|
|
{
|
|
PAttribute attribute = new Attribute(aCode, aValue);
|
|
AddAttribute(attribute);
|
|
}
|
|
|
|
PAttribute TransactionItem:: GetFirstAttribute() const
|
|
{
|
|
theAttribIterator->Reset();
|
|
return (Attribute*)theAttributeList->GetHead();
|
|
}
|
|
|
|
PAttribute TransactionItem:: GetNextAttribute()
|
|
{
|
|
PAttribute ret = (PAttribute)(theAttribIterator->Next());
|
|
|
|
return ret;
|
|
}
|
|
|
|
INT TransactionItem:: Equal(RObj obj) const
|
|
{
|
|
INT ret_value = FALSE;
|
|
|
|
RTransactionItem trans_item = (RTransactionItem) obj;
|
|
|
|
if (trans_item.GetCode() == GetCode()){
|
|
ret_value = TRUE;
|
|
|
|
// if the code values are the same, this does not
|
|
// necessarily mean that the transaction items are equal
|
|
// A transaction item contains a list of attributes, and
|
|
// if the first attributes of each transaction item are
|
|
// not equal, then the transaction items are not equal.
|
|
|
|
// get first attributes from the attribute list
|
|
PAttribute attrib1 = trans_item.GetFirstAttribute();
|
|
PAttribute attrib2 = GetFirstAttribute();
|
|
|
|
// if both attributes are present
|
|
if(attrib1 && attrib2){
|
|
|
|
// get actual attribute values
|
|
PCHAR attrib_str1 = attrib1->GetValue();
|
|
PCHAR attrib_str2 = attrib2->GetValue();
|
|
|
|
// check to make sure that attribute values are not NULL
|
|
if(attrib_str1 != NULL && attrib_str2 != NULL){
|
|
if(attrib_str1[0] != NULL && attrib_str2[0] != NULL){
|
|
|
|
// if both of the attribute strings are not equal to
|
|
// one another, then return false
|
|
if(ApcStrIntCmpI(attrib_str1,attrib_str2) != EQUAL){
|
|
ret_value = FALSE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return ret_value;
|
|
}
|
|
|
|
INT TransactionGroup::transactionGroupCount = 0;
|
|
|
|
TransactionGroup::TransactionGroup(Type aType) :
|
|
TransactionObject(aType, transactionGroupCount++),
|
|
theAuthenticationString((CHAR*)NULL),
|
|
theResponse((CHAR*)NULL),
|
|
theEventList((List*)NULL),
|
|
theEventIterator((ListIterator*)NULL),
|
|
theTransactionList((List*)NULL),
|
|
theTransactionIterator((ListIterator*)NULL),
|
|
InitialSetResponseRepeated(0),
|
|
InitialSetResponse((CHAR*)NULL),
|
|
theErrorCode(0),
|
|
theErrorIndex(0)
|
|
{
|
|
theEventList = new List();
|
|
theEventIterator = &(RListIterator)(theEventList->InitIterator());
|
|
theTransactionList = new List();
|
|
theTransactionIterator = &(RListIterator)(theTransactionList->InitIterator());
|
|
}
|
|
|
|
TransactionGroup:: ~TransactionGroup()
|
|
{
|
|
if (theAuthenticationString)
|
|
free (theAuthenticationString);
|
|
theAuthenticationString =(CHAR*)NULL;
|
|
|
|
if (theResponse)
|
|
free( theResponse);
|
|
theResponse =(CHAR*)NULL;
|
|
|
|
if (InitialSetResponse)
|
|
free(InitialSetResponse);
|
|
InitialSetResponse = (CHAR*)NULL;
|
|
|
|
theEventList->FlushAll();
|
|
delete theEventList;
|
|
theEventList = (List*)NULL;
|
|
delete theEventIterator;
|
|
theEventIterator = NULL;
|
|
theTransactionList->FlushAll();
|
|
delete theTransactionList;
|
|
theTransactionList = (List*)NULL;
|
|
delete theTransactionIterator;
|
|
theTransactionIterator = NULL;
|
|
}
|
|
|
|
|
|
|
|
INT TransactionGroup:: Equal(RObj obj) const
|
|
{
|
|
// if (strcmp(obj.IsA(), IsA()))
|
|
// return FALSE;
|
|
|
|
RTransactionGroup tg = (RTransactionGroup)obj;
|
|
if (tg.GetId() == GetId())
|
|
return TRUE;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
VOID TransactionGroup::SetAuthentication(CHAR* aString)
|
|
{
|
|
if (theAuthenticationString != (CHAR*)NULL)
|
|
{
|
|
free(theAuthenticationString);
|
|
theAuthenticationString = (CHAR*)NULL;
|
|
}
|
|
if (aString != (CHAR*)NULL)
|
|
theAuthenticationString = _strdup(aString);
|
|
}
|
|
|
|
VOID TransactionGroup::SetResponse(CHAR* aString)
|
|
{
|
|
if (theResponse != (CHAR*)NULL)
|
|
{
|
|
free(theResponse);
|
|
theResponse = (CHAR*)NULL;
|
|
}
|
|
if (aString != (CHAR*)NULL)
|
|
theResponse = _strdup(aString);
|
|
}
|
|
|
|
VOID TransactionGroup:: SetInitialSetResponseRepeated(INT repeat)
|
|
{
|
|
InitialSetResponseRepeated = repeat;
|
|
}
|
|
|
|
VOID TransactionGroup:: SetErrorIndex(INT index)
|
|
{
|
|
theErrorIndex = index;
|
|
}
|
|
|
|
VOID TransactionGroup:: SetInitialSetResponse(CHAR* initialResponse)
|
|
{
|
|
InitialSetResponse = _strdup(initialResponse);
|
|
}
|
|
|
|
INT TransactionGroup::AddTransactionItem(PTransactionItem aTransactionItem)
|
|
{
|
|
int err = ErrNO_ERROR;
|
|
Type addType = aTransactionItem->GetType();
|
|
|
|
// simple transactions types can be added to complex groups, but
|
|
// not vice-versa. This is a completely arbitrary exclusion,
|
|
// and could be changed if needed. For now it save a couple
|
|
// of lines of code.
|
|
//
|
|
if ((addType == theType) ||
|
|
((theType == EXTENDED_GET) && (addType == GET)) ||
|
|
((theType == EXTENDED_SET) && (addType == SET)))
|
|
{
|
|
// Check to see if transaction already exists.
|
|
PTransactionItem trans_item = (PTransactionItem)NULL;
|
|
trans_item = (PTransactionItem)theTransactionList->Find(aTransactionItem);
|
|
|
|
// If the transaction was not found, then add it to theTransactionList
|
|
if (trans_item==NULL)
|
|
{
|
|
theTransactionList->Append(aTransactionItem);
|
|
}
|
|
|
|
if (theTransactionIterator == (ListIterator*)NULL) {
|
|
theTransactionIterator =
|
|
&(RListIterator)(theTransactionList->InitIterator());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
aTransactionItem->SetErrorCode(ErrTYPE_COMBINATION);
|
|
err = ErrTYPE_COMBINATION;
|
|
}
|
|
return err;
|
|
}
|
|
|
|
INT TransactionGroup::AddEvent(PEvent aEvent)
|
|
{
|
|
// theEventList->Add(*aEvent);
|
|
return ErrNO_ERROR;
|
|
}
|
|
|
|
PTransactionItem TransactionGroup::GetCurrentTransaction()
|
|
{
|
|
return (PTransactionItem)(& (theTransactionIterator->Current()));
|
|
}
|
|
|
|
PTransactionItem TransactionGroup::GetFirstTransactionItem()
|
|
{
|
|
theTransactionIterator->Reset();
|
|
return (PTransactionItem) theTransactionList->GetHead();
|
|
}
|
|
|
|
PTransactionItem TransactionGroup::GetNextTransactionItem()
|
|
{
|
|
return (PTransactionItem) theTransactionIterator->Next();
|
|
}
|
|
|
|
|
|
|