typedef int[0,4] Buffer_Implementation;
const Buffer_Implementation SET = 0;
const Buffer_Implementation BAG = 1;
const Buffer_Implementation STUTT_FIFO = 2;
const Buffer_Implementation FIFO = 3;
const Buffer_Implementation LOSSY_FIFO = 4;
// ****************************
// PROTOCOL CONFIGURATION START
// ****************************
// First choose a communication policy, possible values are: SET, BAG, STUTT_FIFO, FIFO, LOSSY_FIFO
Buffer_Implementation buffer_Implementation = STUTT_FIFO;
// Then set the maximum buffer capacity
const int BUFFER_CAPACITY = 4;
// Finally set the minimum delay and tire-outs for the retransmission of messages
// This is relevant only for the termination property and MIN_DELAY should be
// smaller or eqaul than TIRE_OUT
// For boundedness and correctness checks, the constants should be both set to 0
const int MIN_DELAY = 0;
const int TIRE_OUT = 0;
// **************************
// PROTOCOL CONFIGURATION END
// **************************
bool overflow = false;
typedef int[0,BUFFER_CAPACITY-1] BufferTc;
int [0,BUFFER_CAPACITY] bufferSizeTc;
typedef int[0,BUFFER_CAPACITY-1] BufferP;
int [0,BUFFER_CAPACITY] bufferSizeP;
/**Coordinator states*/
typedef int[0,11] StateTC;
const StateTC TC_ACTIVE = 0;
const StateTC TC_CANCELING_ACTIVE = 1;
const StateTC TC_CANCELING_COMPLETING = 2;
const StateTC TC_COMPLETING = 3;
const StateTC TC_COMPLETED = 4;
const StateTC TC_CLOSING = 5;
const StateTC TC_COMPENSATING = 6;
const StateTC TC_FAILING_ACC = 7; //failing Active/Canceling/Completing
const StateTC TC_FAILING_C = 8; //failing Compensating
const StateTC TC_NOT_COMPLETING = 9;
const StateTC TC_EXITING = 10;
const StateTC TC_ENDED = 11;
StateTC stTC = TC_ACTIVE;
/**States of the Participant.*/
typedef int[0,10] StateP;
const StateP P_ACTIVE = 0;
const StateP P_CANCELING = 1;
const StateP P_COMPLETING = 2;
const StateP P_COMPLETED = 3;
const StateP P_CLOSING = 4;
const StateP P_COMPENSATING = 5;
const StateP P_FAILING_ACC = 6; //failing Active/Canceling
const StateP P_FAILING_C = 7; //failing Compensating
const StateP P_NOT_COMPLETING = 8;
const StateP P_EXITING = 9;
const StateP P_ENDED = 10;
StateP stP = P_ACTIVE;
//Messages sent from TC to Participant.
typedef int[0,7] MsgsTC;
const MsgsTC CANCEL_TC = 0;
const MsgsTC COMPLETE_TC = 1;
const MsgsTC CLOSE_TC = 2;
const MsgsTC COMPENSATE_TC =3;
const MsgsTC FAILED_TC = 4;
const MsgsTC EXITED_TC = 5;
const MsgsTC NOT_COMPLETED_TC = 6;
const MsgsTC FAILED_EXITED_NOT_COMPLETED_TC = 7;
int msgTC_SET_BAG[MsgsTC];
MsgsTC msgTC_FIFO[BufferTc];
//Messages sent from Participant to TC.
typedef int[0,7] MsgsP;
const MsgsP EXIT_P = 0;
const MsgsP COMPLETED_P = 1;
const MsgsP FAIL_P = 2;
const MsgsP CANNOT_COMPLETE_P = 3;
const MsgsP CANCELED_P = 4;
const MsgsP CLOSED_P = 5;
const MsgsP COMPENSATED_P = 6;
const MsgsP CANCELED_CLOSED_COMPENSATED_P = 7;
int msgP_SET_BAG[MsgsP];
MsgsP msgP_FIFO[BufferP];Coordinatorclock x,y;
void Send_Msg(MsgsTC s) {
int i;
//SET construct
if (buffer_Implementation == SET) msgTC_SET_BAG[s] = true;
//BAG construct
if (buffer_Implementation == BAG) {
if (msgTC_SET_BAG[s] == BUFFER_CAPACITY) overflow = true;
else msgTC_SET_BAG[s]++; }
//STUTT_FIFO construct
if (buffer_Implementation == STUTT_FIFO) {
if (bufferSizeTc == BUFFER_CAPACITY) overflow = true;
else
{ if (msgTC_FIFO[0] != s and bufferSizeTc>0) {
for (i=bufferSizeTc-1; i>=0; i--) msgTC_FIFO[i+1] = msgTC_FIFO[i];
bufferSizeTc++; msgTC_FIFO[0] = s;
}
if (bufferSizeTc==0) { bufferSizeTc++; msgTC_FIFO[0] = s; }
}
}
//FIFO and LOSSY_FIFO construct
if (buffer_Implementation == FIFO || buffer_Implementation == LOSSY_FIFO) {
if (bufferSizeTc == BUFFER_CAPACITY) overflow = true;
else
{ for (i=bufferSizeTc-1; i>=0; i--) msgTC_FIFO[i+1] = msgTC_FIFO[i];
bufferSizeTc++;
msgTC_FIFO[0] = s;}
}
}
bool Receive_Msg(MsgsP r) {
int i;
//SET construct
if (buffer_Implementation == SET) return msgP_SET_BAG[r];
//BAG construct
if (buffer_Implementation == BAG) return(msgP_SET_BAG[r] >= 1);
//STUTT_FIFO construct
if (buffer_Implementation == STUTT_FIFO) {
for (i=bufferSizeP-1; i>=0; i--)
if (msgP_FIFO[i] == r) return true;
return false;}
//FIFO and LOSSY_FIFO construct
if (buffer_Implementation == FIFO || buffer_Implementation == LOSSY_FIFO) {
if (bufferSizeP==0) return false;
return (msgP_FIFO[bufferSizeP-1]==r); }
return false;
}
void Received_Msg(MsgsP r) {
int i;
//SET construct
//if (buffer_Implementation == SET) return ;
//BAG construct
if (buffer_Implementation == BAG) msgP_SET_BAG[r]--;
//STUTT_FIFO construct
if (buffer_Implementation == STUTT_FIFO) {
i = 0;
while (msgP_FIFO[i] != r) i++; // msgP_SEQ[0,i-1] != r
bufferSizeP--; }
//FIFO and LOSSY_FIFO construct
if (buffer_Implementation == FIFO || buffer_Implementation == LOSSY_FIFO) {
bufferSizeP--; }
}
//Messages transmitted by the TC
bool guard1() {
return stTC == TC_ACTIVE;
}
void action1() {
Send_Msg(CANCEL_TC);
stTC = TC_CANCELING_ACTIVE;
}
bool guard2() {
return stTC == TC_CANCELING_ACTIVE;
}
void action2() {
Send_Msg(CANCEL_TC);
}
bool guard3() {
return stTC == TC_CANCELING_COMPLETING;
}
void action3() {
Send_Msg(CANCEL_TC);
}
bool guard4() {
return stTC == TC_COMPLETING;
}
void action4() {
Send_Msg(CANCEL_TC);
stTC = TC_CANCELING_COMPLETING;
}
bool guard5() {
return stTC == TC_ACTIVE;
}
void action5() {
Send_Msg(COMPLETE_TC);
stTC = TC_COMPLETING;
}
bool guard6() {
return stTC == TC_COMPLETING;
}
void action6() {
Send_Msg(COMPLETE_TC);
}
bool guard7() {
return stTC == TC_COMPLETED;
}
void action7() {
Send_Msg(CLOSE_TC);
stTC = TC_CLOSING;
}
bool guard8() {
return stTC == TC_CLOSING;
}
void action8() {
Send_Msg(CLOSE_TC);
}
bool guard9() {
return stTC == TC_COMPLETED;
}
void action9() {
Send_Msg(COMPENSATE_TC);
stTC = TC_COMPENSATING;
}
bool guard10() {
return stTC == TC_COMPENSATING;
}
void action10() {
Send_Msg(COMPENSATE_TC);
}
bool guard11() {
return stTC == TC_FAILING_ACC || stTC == TC_FAILING_C;
}
void action11() {
Send_Msg(FAILED_TC);
stTC = TC_ENDED;
}
bool guard12() {
//return (msgTC_SET_BAG[FAILED_TC] || msgTC_SEQ[FAILED_TC]) && stTC == TC_ENDED;
return stTC == TC_ENDED;
}
void action12() {
Send_Msg(FAILED_TC);
}
bool guard13() {
return stTC == TC_EXITING;
}
void action13() {
Send_Msg(EXITED_TC);
stTC = TC_ENDED;
}
bool guard14() {
//return (msgTC_SET_BAG[EXITED_TC] || msgTC_SEQ[EXITED_TC]) && stTC == TC_ENDED;
return stTC == TC_ENDED;
}
void action14() {
Send_Msg(EXITED_TC);
}
bool guard15() {
return stTC == TC_NOT_COMPLETING;
}
void action15() {
Send_Msg(NOT_COMPLETED_TC);
stTC = TC_ENDED;
}
bool guard16() {
//return (msgTC_SET_BAG[NOT_COMPLETED_TC] || msgTC_SEQ[NOT_COMPLETED_TC]) && stTC == TC_ENDED;
return stTC == TC_ENDED;
}
void action16() {
Send_Msg(NOT_COMPLETED_TC);
}
//Messages received by the TC
bool guard17() {
return Receive_Msg(EXIT_P) && (stTC == TC_ACTIVE || stTC == TC_CANCELING_ACTIVE || stTC == TC_CANCELING_COMPLETING || stTC == TC_COMPLETING);
}
void action17() {
stTC = TC_EXITING;
Received_Msg(EXIT_P);
}
bool guard18() {
return Receive_Msg(EXIT_P) && stTC == TC_EXITING;
}
void action18() {
Received_Msg(EXIT_P);
}
bool guard19() {
return Receive_Msg(EXIT_P) && stTC == TC_ENDED;
}
void action19() {
Send_Msg(EXITED_TC);
Received_Msg(EXIT_P);
}
bool guard20() {
return Receive_Msg(COMPLETED_P) && (stTC == TC_CANCELING_COMPLETING || stTC == TC_COMPLETING);
}
void action20() {
stTC = TC_COMPLETED;
Received_Msg(COMPLETED_P);
}
bool guard21() {
return Receive_Msg(COMPLETED_P) && stTC == TC_COMPLETED;
}
void action21() {
Received_Msg(COMPLETED_P);
}
bool guard22() {
return Receive_Msg(COMPLETED_P) && stTC == TC_CLOSING;
}
void action22() {
Send_Msg(CLOSE_TC);
Received_Msg(COMPLETED_P);
}
bool guard23() {
return Receive_Msg(COMPLETED_P) && stTC == TC_COMPENSATING;
}
void action23() {
Send_Msg(COMPENSATE_TC);
Received_Msg(COMPLETED_P);
}
bool guard24() {
return Receive_Msg(COMPLETED_P) && stTC == TC_FAILING_C;
}
void action24() {
Received_Msg(COMPLETED_P);
}
bool guard25() {
return Receive_Msg(COMPLETED_P) && stTC == TC_ENDED;
}
void action25() {
Received_Msg(COMPLETED_P);
}
bool guard26() {
return Receive_Msg(FAIL_P) &&
(stTC == TC_ACTIVE || stTC == TC_CANCELING_ACTIVE || stTC == TC_CANCELING_COMPLETING || stTC == TC_COMPLETING);
}
void action26() {
stTC = TC_FAILING_ACC;
Received_Msg(FAIL_P);
}
bool guard27() {
return Receive_Msg(FAIL_P) && stTC == TC_COMPENSATING;
}
void action27() {
stTC = TC_FAILING_C;
Received_Msg(FAIL_P);
}
bool guard28() {
return Receive_Msg(FAIL_P) && stTC == TC_FAILING_ACC;
}
void action28() {
Received_Msg(FAIL_P);
}
bool guard29() {
return Receive_Msg(FAIL_P) && stTC == TC_FAILING_C;
}
void action29() {
Received_Msg(FAIL_P);
}
bool guard30() {
return Receive_Msg(FAIL_P) && stTC == TC_ENDED;
}
void action30() {
Send_Msg(FAILED_TC);
Received_Msg(FAIL_P);
}
bool guard31() {
return Receive_Msg(CANNOT_COMPLETE_P) &&
(stTC == TC_ACTIVE || stTC == TC_CANCELING_ACTIVE || stTC == TC_CANCELING_COMPLETING || stTC == TC_COMPLETING);
}
void action31() {
stTC = TC_NOT_COMPLETING;
Received_Msg(CANNOT_COMPLETE_P);
}
bool guard32() {
return Receive_Msg(CANNOT_COMPLETE_P) && stTC == TC_NOT_COMPLETING;
}
void action32() {
Received_Msg(CANNOT_COMPLETE_P);
}
bool guard33() {
return Receive_Msg(CANNOT_COMPLETE_P) && stTC == TC_ENDED;
}
void action33() {
Send_Msg(NOT_COMPLETED_TC);
Received_Msg(CANNOT_COMPLETE_P);
}
bool guard34() {
return Receive_Msg(CANCELED_P) && (stTC == TC_CANCELING_ACTIVE || stTC == TC_CANCELING_COMPLETING);
}
void action34() {
stTC = TC_ENDED;
Received_Msg(CANCELED_P);
}
bool guard35() {
return Receive_Msg(CANCELED_P) && stTC == TC_ENDED;
}
void action35() {
Received_Msg(CANCELED_P);
}
bool guard36() {
return Receive_Msg(CLOSED_P) && stTC == TC_CLOSING;
}
void action36() {
stTC = TC_ENDED;
Received_Msg(CLOSED_P);
}
bool guard37() {
return Receive_Msg(CLOSED_P) && stTC == TC_ENDED;
}
void action37() {
Received_Msg(CLOSED_P);
}
bool guard38() {
return Receive_Msg(COMPENSATED_P) && stTC == TC_COMPENSATING;
}
void action38() {
stTC = TC_ENDED;
Received_Msg(COMPENSATED_P);
}
bool guard39() {
return Receive_Msg(CANCELED_P) && stTC == TC_ENDED;
}
void action39() {
Received_Msg(CANCELED_P);
}
bool receive_msg_exit_In_456789() {
return (Receive_Msg(EXIT_P) && (stTC == TC_COMPLETED || stTC == TC_CLOSING || stTC == TC_COMPENSATING || stTC == TC_FAILING_ACC || stTC == TC_FAILING_C || stTC == TC_NOT_COMPLETING));
}
bool receive_msg_Completed_In_017910() {
return (Receive_Msg(COMPLETED_P) && (stTC == TC_ACTIVE || stTC == TC_CANCELING_ACTIVE || stTC == TC_FAILING_ACC || stTC == TC_NOT_COMPLETING || stTC == TC_EXITING));
}
bool receive_msg_fail_In_45910() {
return (Receive_Msg(FAIL_P) && (stTC == TC_COMPLETED || stTC == TC_CLOSING || stTC == TC_NOT_COMPLETING || stTC == TC_EXITING));
}
bool receive_msg_cannot_complete_In_4567810() {
return (Receive_Msg(CANNOT_COMPLETE_P) && (stTC == TC_COMPLETED || stTC == TC_CLOSING || stTC == TC_COMPENSATING || stTC == TC_FAILING_ACC || stTC == TC_FAILING_C || stTC == TC_EXITING));
}
bool receive_msg_canceled_In_0345678910() {
return (Receive_Msg(CANCELED_P) && (stTC == TC_ACTIVE || stTC == TC_COMPLETING || stTC == TC_COMPLETED || stTC == TC_CLOSING || stTC == TC_COMPENSATING ||
stTC == TC_FAILING_ACC || stTC == TC_FAILING_C || stTC == TC_NOT_COMPLETING || stTC == TC_EXITING));
}
bool receive_msg_closed_In_01234678910() {
return (Receive_Msg(CLOSED_P) && (stTC == TC_ACTIVE || stTC == TC_CANCELING_ACTIVE || stTC == TC_CANCELING_COMPLETING || stTC == TC_COMPLETING || stTC == TC_COMPLETED ||
stTC == TC_COMPENSATING || stTC == TC_FAILING_ACC || stTC == TC_FAILING_C || stTC == TC_NOT_COMPLETING || stTC == TC_EXITING));
}
bool receive_msg_compensated_In_01234578910() {
return (Receive_Msg(COMPENSATED_P) && (stTC == TC_ACTIVE || stTC == TC_CANCELING_ACTIVE || stTC == TC_CANCELING_COMPLETING || stTC == TC_COMPLETING || stTC == TC_COMPLETED ||
stTC == TC_CLOSING || stTC == TC_FAILING_ACC || stTC == TC_FAILING_C || stTC == TC_NOT_COMPLETING || stTC == TC_EXITING));
}INVALIDSTARTparclock x,y;
void Send_Msg(MsgsP s) {
int i;
//SET construct
if (buffer_Implementation == SET) msgP_SET_BAG[s] = true;
//BAG construct
if (buffer_Implementation == BAG) {
if (msgP_SET_BAG[s] == BUFFER_CAPACITY) overflow = true;
else msgP_SET_BAG[s]++; }
//STUTT_FIFO construct
if (buffer_Implementation == STUTT_FIFO) {
if (bufferSizeP == BUFFER_CAPACITY) overflow = true;
else
{
if (msgP_FIFO[0] != s and bufferSizeP>0) {
for (i = bufferSizeP-1; i>=0; i--) msgP_FIFO[i+1] = msgP_FIFO[i];
bufferSizeP++; msgP_FIFO[0] = s;
}
if (bufferSizeP==0) { bufferSizeP++; msgP_FIFO[0] = s;}
}
}
//FIFO and LOSSY_FIFO construct
if (buffer_Implementation == FIFO || buffer_Implementation == LOSSY_FIFO) {
if (bufferSizeP == BUFFER_CAPACITY) overflow = true;
else
{ for (i = bufferSizeP-1; i>=0; i--) msgP_FIFO[i+1] = msgP_FIFO[i];
bufferSizeP++;
msgP_FIFO[0] = s; }
}
}
bool Receive_Msg(MsgsTC r) {
int i;
//SET construct
if (buffer_Implementation == SET) return msgTC_SET_BAG[r];
//BAG construct
if (buffer_Implementation == BAG) return (msgTC_SET_BAG[r] >= 1);
//STUTT_FIFO construct
if (buffer_Implementation == STUTT_FIFO) {
for (i=bufferSizeTc-1; i>=0; i--)
if (msgTC_FIFO[i] == r) return true;
return false; }
//FIFO and LOSSY_FIFO construct
if (buffer_Implementation == FIFO || buffer_Implementation == LOSSY_FIFO) {
if (bufferSizeTc==0) return false;
return (msgTC_FIFO[bufferSizeTc-1] == r);
}
return false;
}
void Received_Msg(MsgsTC r) {
int i;
//SET construct
//if (buffer_Implementation == SET) return ;
//BAG construct
if (buffer_Implementation == BAG) msgTC_SET_BAG[r]--;
//STUTT_FIFO construct
if (buffer_Implementation == STUTT_FIFO) {
i = 0;
while (msgTC_FIFO[i] != r) i++; // msgTC_SEQ[0,i-1] != r
bufferSizeTc--; }
//FIFO and LOSSY_FIFO construct
if (buffer_Implementation == FIFO || buffer_Implementation == LOSSY_FIFO) {
bufferSizeTc--; }
}
//Messages transmitted by the Participant
bool guard40() {
return stP == P_ACTIVE || stP == P_COMPLETING;
}
void action40() {
Send_Msg(EXIT_P);
stP = P_EXITING;
}
bool guard41() {
return stP == P_EXITING;
}
void action41() {
Send_Msg(EXIT_P);
}
bool guard42() {
return stP == P_COMPLETING;
}
void action42() {
Send_Msg(COMPLETED_P);
stP = P_COMPLETED;
}
bool guard43() {
return stP == P_COMPLETED;
}
void action43() {
Send_Msg(COMPLETED_P);
}
bool guard44() {
return stP == P_ACTIVE || stP == P_CANCELING || stP == P_COMPLETING;
}
void action44() {
Send_Msg(FAIL_P);
stP = P_FAILING_ACC;
}
bool guard45() {
return stP == P_COMPENSATING;
}
void action45() {
Send_Msg(FAIL_P);
stP = P_FAILING_C;
}
bool guard46() {
return stP == P_FAILING_ACC || stP == P_FAILING_C;
}
void action46() {
Send_Msg(FAIL_P);
}
bool guard47() {
return stP == P_ACTIVE || stP == P_COMPLETING;
}
void action47() {
Send_Msg(CANNOT_COMPLETE_P);
stP = P_NOT_COMPLETING;
}
bool guard48() {
return stP == P_NOT_COMPLETING;
}
void action48() {
Send_Msg(CANNOT_COMPLETE_P);
}
bool guard49() {
return stP == P_CANCELING;
}
void action49() {
Send_Msg(CANCELED_P);
stP = P_ENDED;
}
bool guard50() {
return stP == P_ENDED;
}
void action50() {
Send_Msg(CANCELED_P);
}
bool guard51() {
return stP == P_CLOSING;
}
void action51() {
Send_Msg(CLOSED_P);
stP = P_ENDED;
}
bool guard52() {
return stP == P_ENDED;
}
void action52() {
Send_Msg(CLOSED_P);
}
bool guard53() {
return stP == P_COMPENSATING;
}
void action53() {
Send_Msg(COMPENSATED_P);
stP = P_ENDED;
}
bool guard54() {
return stP == P_ENDED;
}
void action54() {
Send_Msg(COMPENSATED_P);
}
//Messages received by the Participant
bool guard55() {
return Receive_Msg(CANCEL_TC) && (stP == P_ACTIVE || stP == P_COMPLETING);
}
void action55() {
stP = P_CANCELING;
Received_Msg(CANCEL_TC);
}
bool guard56() {
return Receive_Msg(CANCEL_TC) && stP == P_CANCELING;
}
void action56() {
Received_Msg(CANCEL_TC);
}
bool guard57() {
return Receive_Msg(CANCEL_TC) && stP == P_COMPLETED;
}
void action57() {
Send_Msg(COMPLETED_P);
Received_Msg(CANCEL_TC);
}
bool guard58() {
return Receive_Msg(CANCEL_TC) && stP == P_CLOSING;
}
void action58() {
Received_Msg(CANCEL_TC);
}
bool guard59() {
return Receive_Msg(CANCEL_TC) && stP == P_COMPENSATING;
}
void action59() {
Received_Msg(CANCEL_TC);
}
bool guard60() {
return Receive_Msg(CANCEL_TC) && stP == P_FAILING_ACC;
}
void action60() {
Send_Msg(FAIL_P);
Received_Msg(CANCEL_TC);
}
bool guard61() {
return Receive_Msg(CANCEL_TC) && stP == P_FAILING_C;
}
void action61() {
Received_Msg(CANCEL_TC);
}
bool guard62() {
return Receive_Msg(CANCEL_TC) && stP == P_NOT_COMPLETING;
}
void action62() {
Send_Msg(CANNOT_COMPLETE_P);
Received_Msg(CANCEL_TC);
}
bool guard63() {
return Receive_Msg(CANCEL_TC) && stP == P_EXITING;
}
void action63() {
Send_Msg(EXIT_P);
Received_Msg(CANCEL_TC);
}
bool guard64() {
return Receive_Msg(CANCEL_TC) && stP == P_ENDED;
}
void action64() {
Send_Msg(CANCELED_P);
Received_Msg(CANCEL_TC);
}
bool guard65() {
return Receive_Msg(COMPLETE_TC) && stP == P_ACTIVE;
}
void action65() {
stP = P_COMPLETING;
Received_Msg(COMPLETE_TC);
}
bool guard66() {
return Receive_Msg(COMPLETE_TC) && stP == P_CANCELING;
}
void action66() {
Received_Msg(COMPLETE_TC);
}
bool guard67() {
return Receive_Msg(COMPLETE_TC) && stP == P_COMPLETING;
}
void action67() {
Received_Msg(COMPLETE_TC);
}
bool guard68() {
return Receive_Msg(COMPLETE_TC) && stP == P_COMPLETED;
}
void action68() {
Send_Msg(COMPLETED_P);
Received_Msg(COMPLETE_TC);
}
bool guard69() {
return Receive_Msg(COMPLETE_TC) && stP == P_CLOSING;
}
void action69() {
Received_Msg(COMPLETE_TC);
}
bool guard70() {
return Receive_Msg(COMPLETE_TC) && stP == P_COMPENSATING;
}
void action70() {
Received_Msg(COMPLETE_TC);
}
bool guard71() {
return Receive_Msg(COMPLETE_TC) && stP == P_FAILING_ACC;
}
void action71() {
Send_Msg(FAIL_P);
Received_Msg(COMPLETE_TC);
}
bool guard72() {
return Receive_Msg(COMPLETE_TC) && stP == P_FAILING_C;
}
void action72() {
Received_Msg(COMPLETE_TC);
}
bool guard73() {
return Receive_Msg(COMPLETE_TC) && stP == P_NOT_COMPLETING;
}
void action73() {
Send_Msg(CANNOT_COMPLETE_P);
Received_Msg(COMPLETE_TC);
}
bool guard74() {
return Receive_Msg(COMPLETE_TC) && stP == P_EXITING;
}
void action74() {
Send_Msg(EXIT_P);
Received_Msg(COMPLETE_TC);
}
bool guard75() {
return Receive_Msg(COMPLETE_TC) && stP == P_ENDED;
}
void action75() {
Send_Msg(FAIL_P);
Received_Msg(COMPLETE_TC);
}
bool guard76() {
return Receive_Msg(CLOSE_TC) && stP == P_COMPLETED;
}
void action76() {
stP = P_CLOSING;
Received_Msg(CLOSE_TC);
}
bool guard77() {
return Receive_Msg(CLOSE_TC) && stP == P_CLOSING;
}
void action77() {
Received_Msg(CLOSE_TC);
}
bool guard78() {
return Receive_Msg(CLOSE_TC) && stP == P_ENDED;
}
void action78() {
Send_Msg(CLOSED_P);
Received_Msg(CLOSE_TC);
}
bool guard79() {
return Receive_Msg(COMPENSATE_TC) && stP == P_COMPLETED;
}
void action79() {
stP = P_COMPENSATING;
Received_Msg(COMPENSATE_TC);
}
bool guard80() {
return Receive_Msg(COMPENSATE_TC) && stP == P_COMPENSATING;
}
void action80() {
Received_Msg(COMPENSATE_TC);
}
bool guard81() {
return Receive_Msg(COMPENSATE_TC) && stP == P_FAILING_C;
}
void action81() {
Send_Msg(FAIL_P);
Received_Msg(COMPENSATE_TC);
}
bool guard82() {
return Receive_Msg(COMPENSATE_TC) && stP == P_ENDED;
}
void action82() {
Send_Msg(COMPENSATED_P);
Received_Msg(COMPENSATE_TC);
}
bool guard83() {
return Receive_Msg(FAILED_TC) && (stP == P_FAILING_ACC || stP == P_FAILING_C);
}
void action83() {
stP = P_ENDED;
Received_Msg(FAILED_TC);
}
bool guard84() {
return Receive_Msg(FAILED_TC) && stP == P_ENDED;
}
void action84() {
Received_Msg(FAILED_TC);
}
bool guard85() {
return Receive_Msg(EXITED_TC) && stP == P_EXITING;
}
void action85() {
stP = P_ENDED;
Received_Msg(EXITED_TC);
}
bool guard86() {
return Receive_Msg(EXITED_TC) && stP == P_ENDED;
}
void action86() {
Received_Msg(EXITED_TC);
}
bool guard87() {
return Receive_Msg(NOT_COMPLETED_TC) && stP == P_NOT_COMPLETING;
}
void action87() {
stP = P_ENDED;
Received_Msg(NOT_COMPLETED_TC);
}
bool guard88() {
return Receive_Msg(NOT_COMPLETED_TC) && stP == P_ENDED;
}
void action88() {
Received_Msg(NOT_COMPLETED_TC);
}
bool receive_close_In_01256789() {
return Receive_Msg(CLOSE_TC) && (stP == P_ACTIVE || stP == P_CANCELING || stP == P_COMPLETING || stP == P_COMPENSATING || stP == P_FAILING_ACC || stP == P_FAILING_C || stP == P_NOT_COMPLETING || stP == P_EXITING);
}
bool receive_compensate_In_0124689() {
return Receive_Msg(COMPENSATE_TC) && (stP == P_ACTIVE || stP == P_CANCELING || stP == P_COMPLETING || stP == P_CLOSING || stP == P_FAILING_ACC || stP == P_NOT_COMPLETING || stP == P_EXITING);
}
bool receive_failed_In_01234589() {
return Receive_Msg(FAILED_TC) && (stP == P_ACTIVE || stP == P_CANCELING || stP == P_COMPLETING || stP == P_COMPLETED || stP == P_CLOSING || stP == P_COMPENSATING || stP == P_NOT_COMPLETING || stP == P_EXITING);
}
bool receive_exited_In_012345678() {
return Receive_Msg(EXITED_TC) && (stP == P_ACTIVE || stP == P_CANCELING || stP == P_COMPLETING || stP == P_COMPLETED || stP == P_CLOSING || stP == P_COMPENSATING ||
stP == P_FAILING_ACC || stP == P_FAILING_C || stP == P_NOT_COMPLETING);
}
bool receive_NotCompleted_In_012345679() {
return Receive_Msg(NOT_COMPLETED_TC) && (stP == P_ACTIVE || stP == P_CANCELING || stP == P_COMPLETING || stP == P_COMPLETED || stP == P_CLOSING || stP == P_COMPENSATING ||
stP == P_FAILING_ACC || stP == P_FAILING_C || stP == P_EXITING);
}INVALIDSTARTtc = Coordinator();
//p = Participant_T();
system tc, par;