// Network.cpp: The implementation of the Network class for this // application. The Network class, like the Transaction class, is // used on both sides of the application. It uses ATM_SIDE and // BANK_SIDE macros to distinguish which side is being compiled. // Each side of the network class has both a send and receive pair, // which match the formats of the corresponding application side. #include ''network.hpp'' #include ''trans.hpp'' // The send method, which takes a Transaction, is used by the ATM // side of the application to send a transaction to the Bank side of // the application. It asks the Transaction to packetize itself. // The Transaction will build a string in its argument address // which has the format of a four-character type field (first four // letters of the class's name, a seven-digit source account field, // a space, a four-digit PIN number, a space, a nine-digit // floating-point field (stored in ASCII), and a NULL terminator). // Some transactions may add additional info to the end of the // record, e.g., the Transfer transaction adds the target account // to the end of the string for later retrieval by the Network:: // receive() method below (which takes zero arguments). // In this simulation, the method simply prints the packet it would // send through the reader's favorite mechanism. #ifdef ATM_SIDE int Network::send(Transaction* t) { char buffer[large_string]; t->packetize(buffer); cout << ''@Network Simulation@ Sending from the ATM to the Bank: \'' '' << buffer; cout << ''\''\n''; // The reader would now send this string through there favorite // byte sending mechanism. return(0); } // The receive method for the Network class on the ATM side of the // application waits for a buffer to be sent from the Bank. This // buffer is expected to have the return status (0 or 1) in the first // four bytes, followed by any transaction-specific information in // the remaining characters. It is assumed that a space separates // the status from the additional info. If the fifth character is a // NULL terminator, then there is no additional info. The method // returns the number of bytes existing, aside from the status // field. int Network::receive(int& status, char* buf) { char buffer[large_string]; // The reader would place his or her favorite byte-exchange // mechanism here and ask it to receive a byte string from the Bank // side of the application. This byte string is assumed to be a // four-character status field followed by an indeterminant number // of transaction-specific information. In this simulation, the // balance of the account is passed as additional information. cout << ''@Network Simulation@ Enter Status (4 characters), a space, ''; cout << ''and the account balance: ''; cin.getline(buffer, large_string, '\n'); if (buffer[4] == ' // Network.cpp: The implementation of the Network class for this // application. The Network class, like the Transaction class, is // used on both sides of the application. It uses ATM_SIDE and // BANK_SIDE macros to distinguish which side is being compiled. // Each side of the network class has both a send and receive pair, // which match the formats of the corresponding application side. #include ''network.hpp'' #include ''trans.hpp'' // The send method, which takes a Transaction, is used by the ATM // side of the application to send a transaction to the Bank side of // the application. It asks the Transaction to packetize itself. // The Transaction will build a string in its argument address // which has the format of a four-character type field (first four // letters of the class's name , a seven-digit source account field, // a space, a four-digit PIN number, a space, a nine-digit // floating-point field (stored in ASCII), and a NULL terminator). // Some transactions may add additional info to the end of the // record, e.g., the Transfer transaction adds the target account // to the end of the string for later retrieval by the Network:: // receive() method below (which takes zero arguments). // In this simulation, the method simply prints the packet it would // send through the reader's favorite mechanism. #ifdef ATM_SIDE int Network::send(Transaction* t) { char buffer[large_string]; t->packetize(buffer); cout << ''@Network Simulation@ Sending from the ATM to the Bank: \'' '' << buffer; cout << ''\''\n''; // The reader would now send this string through there favorite // byte sending mechanism. return(0); } // The receive method for the Network class on the ATM side of the // application waits for a buffer to be sent from the Bank. This // buffer is expected to have the return status (0 or 1) in the first // four bytes, followed by any transaction-specific information in // the remaining characters . It is assumed that a space separates // the status from the additional info. If the fifth character is a // NULL terminator, then there is no additional info . The method // returns the number of bytes existing, aside from the status // field. int Network::receive(int& status, char* buf) { char buffer[large_string]; // The reader would place his or her favorite byte-exchange // mechanism here and ask it to receive a byte string from the Bank // side of the application. This byte string is assumed to be a // four-character status field followed by an indeterminant number // of transaction-specific information. In this simulation, the // balance of the account is passed as additional information. cout << ''@Network Simulation@ Enter Status (4 characters), a space, ''; cout << ''and the account balance: ''; cin.getline(buffer, large_string, '\n'); if (buffer[4] == '\0') { status = atoi(buffer); buf[0]= '\0'; return(0); } else if (buffer[4] == '') { buffer[4] = '\0'; status = atoi(buffer); strcpy (buf, &buffer[5]); return(strlen(&buffer[5])); } else { cout << ''@Network Simulation@ Bad packet received at the ATM!!!\n''; Status = 1; } return(0); } #endif #ifdef BANK_SIDE // The receive method on the Bank side of the application receives // a string of the byte-transfer mechanism (in this case, a string // typed by the user ). The string is then parsed by the Network // class, and an appropriate Transaction object is built. The // explicit case analysis on the type of the transaction is // necessary due to the absence of an object-oriented network. The // Network class provides the object-oriented interface so that // the rest of our model sees nothing but objects. The case analysis // is hidden within this method. Transaction* Network::receive() { char buffer[large_string]; // The reader may replace this call to getline with any // appropriate byte-transfer mechanism. cout << ''@Network Simulation@ Enter type (4 characters), ''; cout << ''an account (7 digits), \n''; cout << ''@Network Simulation@ a space, a pin (4 characters), a space, ''; cout << ''and an amount: \n''; cin.getline(buffer, large_string); // We parse the string by turning the whitespace into NULL // terminators. We then build the appropriate object denoted by // the first four characters of the buffer. This is the inverse // routine for the send method on the ATM side of the application. buffer[11] = buffer[16] = buffer[26] = '\0'; if (!strncmp(buffer, ''With'', 4)) { return(newWithdraw(&buffer[4], &buffer[12], atof (&buffer[17]))); } else if (!strncmp(buffer, ''Depo'', 4)) { return(new Deposit(&buffer[4], &buffer[12], atof (&buffer[17]))); } else if (!strncmp{buffer, ''Bala'', 4)) { return (new Balance(&buffer[4], &buffer[12])); } else if (! strncmp (buffer, ''Tran'', 4)) { return(newTransfer(&buffer[4], &buffer[12], &buffer [27], atof(&buffer[17]))); } else { cout << ''@Bank Application@ Unknown packet type!!!\n''; } return(NULL); } // The send method of the Bank side of the application uses the // transaction to packetize the data. The buffer created will be a // four-digit status field, followed by a space, and the amount of // the transaction. This amount is then given to the Balance // transaction on the other side of the application (the ATM side). void Network::send(int status, Transaction* t) { char buffer[large_string]; t->packetize(status, buffer); // The reader can replace this output with the appropriate // byte-transfer mechanism. cout << ''@Network Simulation@ Packet Sent to ATM: \'''' << buffer << ''\''\n"; } #endif ') { status = atoi(buffer); buf[0]= ' // Network.cpp: The implementation of the Network class for this // application. The Network class, like the Transaction class, is // used on both sides of the application. It uses ATM_SIDE and // BANK_SIDE macros to distinguish which side is being compiled. // Each side of the network class has both a send and receive pair, // which match the formats of the corresponding application side. #include ''network.hpp'' #include ''trans.hpp'' // The send method, which takes a Transaction, is used by the ATM // side of the application to send a transaction to the Bank side of // the application. It asks the Transaction to packetize itself. // The Transaction will build a string in its argument address // which has the format of a four-character type field (first four // letters of the class's name , a seven-digit source account field, // a space, a four-digit PIN number, a space, a nine-digit // floating-point field (stored in ASCII), and a NULL terminator). // Some transactions may add additional info to the end of the // record, e.g., the Transfer transaction adds the target account // to the end of the string for later retrieval by the Network:: // receive() method below (which takes zero arguments). // In this simulation, the method simply prints the packet it would // send through the reader's favorite mechanism. #ifdef ATM_SIDE int Network::send(Transaction* t) { char buffer[large_string]; t->packetize(buffer); cout << ''@Network Simulation@ Sending from the ATM to the Bank: \'' '' << buffer; cout << ''\''\n''; // The reader would now send this string through there favorite // byte sending mechanism. return(0); } // The receive method for the Network class on the ATM side of the // application waits for a buffer to be sent from the Bank. This // buffer is expected to have the return status (0 or 1) in the first // four bytes, followed by any transaction-specific information in // the remaining characters . It is assumed that a space separates // the status from the additional info. If the fifth character is a // NULL terminator, then there is no additional info . The method // returns the number of bytes existing, aside from the status // field. int Network::receive(int& status, char* buf) { char buffer[large_string]; // The reader would place his or her favorite byte-exchange // mechanism here and ask it to receive a byte string from the Bank // side of the application. This byte string is assumed to be a // four-character status field followed by an indeterminant number // of transaction-specific information. In this simulation, the // balance of the account is passed as additional information. cout << ''@Network Simulation@ Enter Status (4 characters), a space, ''; cout << ''and the account balance: ''; cin.getline(buffer, large_string, '\n'); if (buffer[4] == '\0') { status = atoi(buffer); buf[0]= '\0'; return(0); } else if (buffer[4] == '') { buffer[4] = '\0'; status = atoi(buffer); strcpy (buf, &buffer[5]); return(strlen(&buffer[5])); } else { cout << ''@Network Simulation@ Bad packet received at the ATM!!!\n''; Status = 1; } return(0); } #endif #ifdef BANK_SIDE // The receive method on the Bank side of the application receives // a string of the byte-transfer mechanism (in this case, a string // typed by the user ). The string is then parsed by the Network // class, and an appropriate Transaction object is built. The // explicit case analysis on the type of the transaction is // necessary due to the absence of an object-oriented network. The // Network class provides the object-oriented interface so that // the rest of our model sees nothing but objects. The case analysis // is hidden within this method. Transaction* Network::receive() { char buffer[large_string]; // The reader may replace this call to getline with any // appropriate byte-transfer mechanism. cout << ''@Network Simulation@ Enter type (4 characters), ''; cout << ''an account (7 digits), \n''; cout << ''@Network Simulation@ a space, a pin (4 characters), a space, ''; cout << ''and an amount: \n''; cin.getline(buffer, large_string); // We parse the string by turning the whitespace into NULL // terminators. We then build the appropriate object denoted by // the first four characters of the buffer. This is the inverse // routine for the send method on the ATM side of the application. buffer[11] = buffer[16] = buffer[26] = '\0'; if (!strncmp(buffer, ''With'', 4)) { return(newWithdraw(&buffer[4], &buffer[12], atof (&buffer[17]))); } else if (!strncmp(buffer, ''Depo'', 4)) { return(new Deposit(&buffer[4], &buffer[12], atof (&buffer[17]))); } else if (!strncmp{buffer, ''Bala'', 4)) { return (new Balance(&buffer[4], &buffer[12])); } else if (! strncmp (buffer, ''Tran'', 4)) { return(newTransfer(&buffer[4], &buffer[12], &buffer [27], atof(&buffer[17]))); } else { cout << ''@Bank Application@ Unknown packet type!!!\n''; } return(NULL); } // The send method of the Bank side of the application uses the // transaction to packetize the data. The buffer created will be a // four-digit status field, followed by a space, and the amount of // the transaction. This amount is then given to the Balance // transaction on the other side of the application (the ATM side). void Network::send(int status, Transaction* t) { char buffer[large_string]; t->packetize(status, buffer); // The reader can replace this output with the appropriate // byte-transfer mechanism. cout << ''@Network Simulation@ Packet Sent to ATM: \'''' << buffer << ''\''\n"; } #endif '; return(0); } else if (buffer[4] == '') { buffer[4] = ' // Network.cpp: The implementation of the Network class for this // application. The Network class, like the Transaction class, is // used on both sides of the application. It uses ATM_SIDE and // BANK_SIDE macros to distinguish which side is being compiled. // Each side of the network class has both a send and receive pair, // which match the formats of the corresponding application side. #include ''network.hpp'' #include ''trans.hpp'' // The send method, which takes a Transaction, is used by the ATM // side of the application to send a transaction to the Bank side of // the application. It asks the Transaction to packetize itself. // The Transaction will build a string in its argument address // which has the format of a four-character type field (first four // letters of the class's name , a seven-digit source account field, // a space, a four-digit PIN number, a space, a nine-digit // floating-point field (stored in ASCII), and a NULL terminator). // Some transactions may add additional info to the end of the // record, e.g., the Transfer transaction adds the target account // to the end of the string for later retrieval by the Network:: // receive() method below (which takes zero arguments). // In this simulation, the method simply prints the packet it would // send through the reader's favorite mechanism. #ifdef ATM_SIDE int Network::send(Transaction* t) { char buffer[large_string]; t->packetize(buffer); cout << ''@Network Simulation@ Sending from the ATM to the Bank: \'' '' << buffer; cout << ''\''\n''; // The reader would now send this string through there favorite // byte sending mechanism. return(0); } // The receive method for the Network class on the ATM side of the // application waits for a buffer to be sent from the Bank. This // buffer is expected to have the return status (0 or 1) in the first // four bytes, followed by any transaction-specific information in // the remaining characters . It is assumed that a space separates // the status from the additional info. If the fifth character is a // NULL terminator, then there is no additional info . The method // returns the number of bytes existing, aside from the status // field. int Network::receive(int& status, char* buf) { char buffer[large_string]; // The reader would place his or her favorite byte-exchange // mechanism here and ask it to receive a byte string from the Bank // side of the application. This byte string is assumed to be a // four-character status field followed by an indeterminant number // of transaction-specific information. In this simulation, the // balance of the account is passed as additional information. cout << ''@Network Simulation@ Enter Status (4 characters), a space, ''; cout << ''and the account balance: ''; cin.getline(buffer, large_string, '\n'); if (buffer[4] == '\0') { status = atoi(buffer); buf[0]= '\0'; return(0); } else if (buffer[4] == '') { buffer[4] = '\0'; status = atoi(buffer); strcpy (buf, &buffer[5]); return(strlen(&buffer[5])); } else { cout << ''@Network Simulation@ Bad packet received at the ATM!!!\n''; Status = 1; } return(0); } #endif #ifdef BANK_SIDE // The receive method on the Bank side of the application receives // a string of the byte-transfer mechanism (in this case, a string // typed by the user ). The string is then parsed by the Network // class, and an appropriate Transaction object is built. The // explicit case analysis on the type of the transaction is // necessary due to the absence of an object-oriented network. The // Network class provides the object-oriented interface so that // the rest of our model sees nothing but objects. The case analysis // is hidden within this method. Transaction* Network::receive() { char buffer[large_string]; // The reader may replace this call to getline with any // appropriate byte-transfer mechanism. cout << ''@Network Simulation@ Enter type (4 characters), ''; cout << ''an account (7 digits), \n''; cout << ''@Network Simulation@ a space, a pin (4 characters), a space, ''; cout << ''and an amount: \n''; cin.getline(buffer, large_string); // We parse the string by turning the whitespace into NULL // terminators. We then build the appropriate object denoted by // the first four characters of the buffer. This is the inverse // routine for the send method on the ATM side of the application. buffer[11] = buffer[16] = buffer[26] = '\0'; if (!strncmp(buffer, ''With'', 4)) { return(newWithdraw(&buffer[4], &buffer[12], atof (&buffer[17]))); } else if (!strncmp(buffer, ''Depo'', 4)) { return(new Deposit(&buffer[4], &buffer[12], atof (&buffer[17]))); } else if (!strncmp{buffer, ''Bala'', 4)) { return (new Balance(&buffer[4], &buffer[12])); } else if (! strncmp (buffer, ''Tran'', 4)) { return(newTransfer(&buffer[4], &buffer[12], &buffer [27], atof(&buffer[17]))); } else { cout << ''@Bank Application@ Unknown packet type!!!\n''; } return(NULL); } // The send method of the Bank side of the application uses the // transaction to packetize the data. The buffer created will be a // four-digit status field, followed by a space, and the amount of // the transaction. This amount is then given to the Balance // transaction on the other side of the application (the ATM side). void Network::send(int status, Transaction* t) { char buffer[large_string]; t->packetize(status, buffer); // The reader can replace this output with the appropriate // byte-transfer mechanism. cout << ''@Network Simulation@ Packet Sent to ATM: \'''' << buffer << ''\''\n"; } #endif '; status = atoi(buffer); strcpy(buf, &buffer[5]); return(strlen(&buffer[5])); } else { cout << ''@Network Simulation@ Bad packet received at the ATM!!!\n''; Status = 1; } return(0); } #endif #ifdef BANK_SIDE // The receive method on the Bank side of the application receives // a string of the byte-transfer mechanism (in this case, a string // typed by the user). The string is then parsed by the Network // class, and an appropriate Transaction object is built. The // explicit case analysis on the type of the transaction is // necessary due to the absence of an object-oriented network. The // Network class provides the object-oriented interface so that // the rest of our model sees nothing but objects. The case analysis // is hidden within this method. Transaction* Network::receive() { char buffer[large_string]; // The reader may replace this call to getline with any // appropriate byte-transfer mechanism. cout << ''@Network Simulation@ Enter type (4 characters), ''; cout << ''an account (7 digits), \n''; cout << ''@Network Simulation@ a space, a pin (4 characters), a space, ''; cout << ''and an amount: \n''; cin.getline(buffer, large_string); // We parse the string by turning the whitespace into NULL // terminators. We then build the appropriate object denoted by // the first four characters of the buffer. This is the inverse // routine for the send method on the ATM side of the application. buffer[11] = buffer[16] = buffer[26] = ' // Network.cpp: The implementation of the Network class for this // application. The Network class, like the Transaction class, is // used on both sides of the application. It uses ATM_SIDE and // BANK_SIDE macros to distinguish which side is being compiled. // Each side of the network class has both a send and receive pair, // which match the formats of the corresponding application side. #include ''network.hpp'' #include ''trans.hpp'' // The send method, which takes a Transaction, is used by the ATM // side of the application to send a transaction to the Bank side of // the application. It asks the Transaction to packetize itself. // The Transaction will build a string in its argument address // which has the format of a four-character type field (first four // letters of the class's name , a seven-digit source account field, // a space, a four-digit PIN number, a space, a nine-digit // floating-point field (stored in ASCII), and a NULL terminator). // Some transactions may add additional info to the end of the // record, e.g., the Transfer transaction adds the target account // to the end of the string for later retrieval by the Network:: // receive() method below (which takes zero arguments). // In this simulation, the method simply prints the packet it would // send through the reader's favorite mechanism. #ifdef ATM_SIDE int Network::send(Transaction* t) { char buffer[large_string]; t->packetize(buffer); cout << ''@Network Simulation@ Sending from the ATM to the Bank: \'' '' << buffer; cout << ''\''\n''; // The reader would now send this string through there favorite // byte sending mechanism. return(0); } // The receive method for the Network class on the ATM side of the // application waits for a buffer to be sent from the Bank. This // buffer is expected to have the return status (0 or 1) in the first // four bytes, followed by any transaction-specific information in // the remaining characters . It is assumed that a space separates // the status from the additional info. If the fifth character is a // NULL terminator, then there is no additional info . The method // returns the number of bytes existing, aside from the status // field. int Network::receive(int& status, char* buf) { char buffer[large_string]; // The reader would place his or her favorite byte-exchange // mechanism here and ask it to receive a byte string from the Bank // side of the application. This byte string is assumed to be a // four-character status field followed by an indeterminant number // of transaction-specific information. In this simulation, the // balance of the account is passed as additional information. cout << ''@Network Simulation@ Enter Status (4 characters), a space, ''; cout << ''and the account balance: ''; cin.getline(buffer, large_string, '\n'); if (buffer[4] == '\0') { status = atoi(buffer); buf[0]= '\0'; return(0); } else if (buffer[4] == '') { buffer[4] = '\0'; status = atoi(buffer); strcpy (buf, &buffer[5]); return(strlen(&buffer[5])); } else { cout << ''@Network Simulation@ Bad packet received at the ATM!!!\n''; Status = 1; } return(0); } #endif #ifdef BANK_SIDE // The receive method on the Bank side of the application receives // a string of the byte-transfer mechanism (in this case, a string // typed by the user ). The string is then parsed by the Network // class, and an appropriate Transaction object is built. The // explicit case analysis on the type of the transaction is // necessary due to the absence of an object-oriented network. The // Network class provides the object-oriented interface so that // the rest of our model sees nothing but objects. The case analysis // is hidden within this method. Transaction* Network::receive() { char buffer[large_string]; // The reader may replace this call to getline with any // appropriate byte-transfer mechanism. cout << ''@Network Simulation@ Enter type (4 characters), ''; cout << ''an account (7 digits), \n''; cout << ''@Network Simulation@ a space, a pin (4 characters), a space, ''; cout << ''and an amount: \n''; cin.getline(buffer, large_string); // We parse the string by turning the whitespace into NULL // terminators. We then build the appropriate object denoted by // the first four characters of the buffer. This is the inverse // routine for the send method on the ATM side of the application. buffer[11] = buffer[16] = buffer[26] = '\0'; if (!strncmp(buffer, ''With'', 4)) { return(newWithdraw(&buffer[4], &buffer[12], atof (&buffer[17]))); } else if (!strncmp(buffer, ''Depo'', 4)) { return(new Deposit(&buffer[4], &buffer[12], atof (&buffer[17]))); } else if (!strncmp{buffer, ''Bala'', 4)) { return (new Balance(&buffer[4], &buffer[12])); } else if (! strncmp (buffer, ''Tran'', 4)) { return(newTransfer(&buffer[4], &buffer[12], &buffer [27], atof(&buffer[17]))); } else { cout << ''@Bank Application@ Unknown packet type!!!\n''; } return(NULL); } // The send method of the Bank side of the application uses the // transaction to packetize the data. The buffer created will be a // four-digit status field, followed by a space, and the amount of // the transaction. This amount is then given to the Balance // transaction on the other side of the application (the ATM side). void Network::send(int status, Transaction* t) { char buffer[large_string]; t->packetize(status, buffer); // The reader can replace this output with the appropriate // byte-transfer mechanism. cout << ''@Network Simulation@ Packet Sent to ATM: \'''' << buffer << ''\''\n"; } #endif '; if (!strncmp(buffer, ''With'', 4)) { return(newWithdraw(&buffer[4], &buffer[12], atof (&buffer[17]))); } else if (!strncmp(buffer, ''Depo'', 4)) { return(new Deposit(&buffer[4], &buffer[12], atof (&buffer[17]))); } else if (!strncmp{buffer, ''Bala'', 4)) { return (new Balance(&buffer[4], &buffer[12])); } else if (!strncmp(buffer, ''Tran'', 4)) { return(newTransfer(&buffer[4], &buffer[12], &buffer [27], atof(&buffer[17]))); } else { cout << ''@Bank Application@ Unknown packet type!!!\n''; } return(NULL); } // The send method of the Bank side of the application uses the // transaction to packetize the data. The buffer created will be a // four-digit status field, followed by a space, and the amount of // the transaction. This amount is then given to the Balance // transaction on the other side of the application (the ATM side). void Network::send(int status, Transaction* t) { char buffer[large_string]; t->packetize(status, buffer); // The reader can replace this output with the appropriate // byte-transfer mechanism. cout << ''@Network Simulation@ Packet Sent to ATM: \'''' << buffer << ''\''\n"; } #endif |
