/************************************************************************ PhySciMsg.cpp - Copyright buret Here you can write a license for your code, some comments or any other information you want to have in your generated code. To to this simply configure the "headings" directory in uml to point to a directory where you have your heading files. or you can just replace the contents of this file with your own. If you want to do this, this file is located at /usr/share/apps/umbrello/headings/heading.cpp -->Code Generators searches for heading files based on the file extension i.e. it will look for a file name ending in ".h" to include in C++ header files, and for a file name ending in ".java" to include in all generated java code. If you name the file "heading.", Code Generator will always choose this file even if there are other files with the same extension in the directory. If you name the file something else, it must be the only one with that extension in the directory to guarantee that Code Generator will choose it. you can use variables in your heading files which are replaced at generation time. possible variables are : author, date, time, filename and filepath. just write %variable_name% This file was generated on %date% at %time% The original location of this file is /home/buret/eclipse/maximus/phy/src/PhySciMsg.cpp **************************************************************************/ #include "PhySciMsg.h" #include "IPhy.h" #include "Error.h" #include "Logger.h" #include "mac/common/tonemap.h" // for 'TONEMAP_INDEX_NB' #include // for 'setfill()' and 'setw()' #include // for 'ntohl()' and 'ntohs()' #include // for 'cout', 'cerr' and 'clog' #include // for 'ostringstream' #include // for 'memset()' and 'memcpy()' #include // for 'ReceiveFunction' using namespace std; typedef boost::function ReceiveFunction; ReceiveFunction receiveFunction[PHY_TYPE_NB] = { &IPhy::receiveInvalid, // NONE &IPhy::receivePre, // PREAMBLE &IPhy::receiveFc, // FC_HYBRID_MODE &IPhy::receiveFc, // FC_AV_ONLY_MODE &IPhy::receivePrs, // PRS &IPhy::receiveMpdu, // MPDU_PAYLOAD &IPhy::receiveTonemask, // TONEMASK &IPhy::receiveTonemap, // TONEMAP &IPhy::receiveInvalid, // NOISE &IPhy::receiveRx, // RX &IPhy::receiveInvalid }; // ZERO_CROSS // Constructors/Destructors // PhySciMsg::PhySciMsg ( IPhy * p_phy_processor ): mSpecializedSciMsgType(PHY_TYPE_NONE), mMpduFormat(PHY_MPDU_FORMAT_NONE), mNbOfPbs(0), mNbOfMsgs(1), mFcMode(PHY_FC_MODE_NONE), mShortPpdu(false), mMod(PHY_MOD_NONE), mFecrate(PHY_FEC_RATE_NONE), mGil(PHY_GIL_NONE), mTonemapIndex(0), mTxId(0), mFlags(PHY_FLAG_NONE), mIsEncrypted(false), mIsCrcOk(false), mPbSize(0), mReserved(0), mNbOfSymbols(0), mpPhyProcessor(NULL), mIsSent(false) { logFunction(); if (NULL != p_phy_processor) { mpPhyProcessor = p_phy_processor; } else { errno = EINVAL; throw Error(__PRETTY_FUNCTION__, "PHY processor pointer is NULL", errno); } initAttributes (); } void PhySciMsg::initAttributes ( ) { logFunction(); memset(mIvArray, '\0', 3*sizeof(uint32_t)); memset(mNekArray, '\0', 4*sizeof(uint32_t)); memset(mPbMeasurementArray, '\0', PHY_PB_MAX_NB*sizeof(uint32_t)); memset(mPbHeaderArray, '\0', PHY_PB_MAX_NB*sizeof(uint32_t)); mSpecializedSciMsgHeader.version = PHY_VERSION; mSpecializedSciMsgHeader.type = PHY_TYPE_NONE; mSpecializedSciMsgHeader.mpdu_format = PHY_MPDU_FORMAT_NONE; mSpecializedSciMsgHeader.pb_nb = 0x00; mSpecializedSciMsgHeader.msg_nb = 0x01; mSpecializedSciMsgHeader.fc_mode = PHY_FC_MODE_NONE; mSpecializedSciMsgHeader.short_ppdu = 0x00; mSpecializedSciMsgHeader.mod = PHY_MOD_NONE; mSpecializedSciMsgHeader.fecrate = PHY_FEC_RATE_NONE; mSpecializedSciMsgHeader.gil = PHY_GIL_NONE; mSpecializedSciMsgHeader.tonemap_index = 0x00; mSpecializedSciMsgHeader.reserved = 0x00; mSpecializedSciMsgHeader.tx_id = 0x0000; mSpecializedSciMsgHeader.flags = PHY_FLAG_NONE; mSpecializedSciMsgHeader.symbol_nb = 0x00000000; memset(mSpecializedSciMsgHeader.iv, '\0', 3*sizeof(uint32_t)); memset(mSpecializedSciMsgHeader.nek, '\0', 4*sizeof(uint32_t)); memset(mSpecializedSciMsgHeader.pb_measurement, '\0', PHY_PB_MAX_NB*sizeof(uint32_t)); memset(mSpecializedSciMsgHeader.pb_header, '\0', PHY_PB_MAX_NB*sizeof(uint32_t)); } PhySciMsg::~PhySciMsg ( ) { logFunction(); if (NULL != mpPhyProcessor) { mpPhyProcessor = NULL; } } // // Methods // // Other methods // // public methods // SciMsg * PhySciMsg::create ( ) const { logFunction(); return new PhySciMsg (getPhyProcessor()); } bool PhySciMsg::dispatchMsg ( ) { logFunction(); bool bDispatch = (receiveFunction[getSpecializedSciMsgType()])(getPhyProcessor(), *this); if (!bDispatch) { throw Error(__PRETTY_FUNCTION__, "error while receiving PHY SCI message"); } return bDispatch; } bool PhySciMsg::identifySpecializedSciMsgHeader ( ) { logFunction(); bool bIdentifyHeader = false; if (NULL != SciMsg::getSciMsgData()) { // Set specialized SCI msg header size // SciMsg::setSpecializedSciMsgHeaderSize((unsigned long)sizeof(struct Phy_Header)); // Get specialized SCI message header contents // if (SciMsg::getSciMsgDataLength() >= SciMsg::getSpecializedSciMsgHeaderSize()) // check that there are enough data to get the specialized SCI message header { bIdentifyHeader = setSpecializedSciMsgHeader(*((Phy_Header*)SciMsg::getSciMsgData())); } else { errno = ENODATA; throw Error(__PRETTY_FUNCTION__, "Not enough data to get the specialized SCI message header", errno); } } else { throw Error(__PRETTY_FUNCTION__, "SCI message data pointer is NULL"); } return bIdentifyHeader; } bool PhySciMsg::checkCompatibility ( ) const { logFunction(); bool bCheck = false; if (PHY_VERSION == getSpecializedSciMsgHeader().version) { bCheck = SciMsg::checkCompatibility(); } return bCheck; } bool PhySciMsg::checkValidity ( ) const { logFunction(); bool bCheck = false; // Check header values ranges // if ((PHY_TYPE_NB > getSpecializedSciMsgHeader().type) && (PHY_TYPE_NONE < getSpecializedSciMsgHeader().type) && (PHY_MPDU_FORMAT_NB > getSpecializedSciMsgHeader().mpdu_format) && (PHY_PB_MAX_NB >= getSpecializedSciMsgHeader().pb_nb) && (0 != getSpecializedSciMsgHeader().msg_nb) && (PHY_MSG_MAX_NB_PER_MPDU >= getSpecializedSciMsgHeader().msg_nb) && (PHY_FC_MODE_NONE >= getSpecializedSciMsgHeader().fc_mode) && ((0 == getSpecializedSciMsgHeader().short_ppdu) || (1 == getSpecializedSciMsgHeader().short_ppdu)) && (PHY_MOD_NONE >= getSpecializedSciMsgHeader().mod) && (PHY_FEC_RATE_NONE >= getSpecializedSciMsgHeader().fecrate) && (PHY_GIL_NONE >= getSpecializedSciMsgHeader().gil) && (TONEMAP_INDEX_NB > getSpecializedSciMsgHeader().tonemap_index) && (PHY_FLAG_MAX >= htons(getSpecializedSciMsgHeader().flags)) && (MAC_MAX_SYMB_PER_MPDU >= htonl(getSpecializedSciMsgHeader().symbol_nb)) && (NULL != getSpecializedSciMsgHeader().iv) && (NULL != getSpecializedSciMsgHeader().nek) && (NULL != getSpecializedSciMsgHeader().pb_measurement) && (NULL != getSpecializedSciMsgHeader().pb_header)) { // Check header coherence in case of MPDU payload // if (PHY_TYPE_MPDU_PAYLOAD == getSpecializedSciMsgHeader().type) { if ( ( ((PHY_MPDU_FORMAT_BEACON == getSpecializedSciMsgHeader().mpdu_format) || (PHY_MPDU_FORMAT_SOF == getSpecializedSciMsgHeader().mpdu_format) || (PHY_MPDU_FORMAT_SOUND == getSpecializedSciMsgHeader().mpdu_format) || (PHY_MPDU_FORMAT_RSOF == getSpecializedSciMsgHeader().mpdu_format)) && (0 != getSpecializedSciMsgHeader().pb_nb) ) || ( ((PHY_MPDU_FORMAT_SACK == getSpecializedSciMsgHeader().mpdu_format) || (PHY_MPDU_FORMAT_RTS_CTS == getSpecializedSciMsgHeader().mpdu_format)) && (0 == getSpecializedSciMsgHeader().pb_nb) ) ) { bCheck = SciMsg::checkValidity(); } } else { bCheck = SciMsg::checkValidity(); } } return bCheck; } void PhySciMsg::displaySpecializedSciMsgHeader ( ) const { logFunction(); clog << logger(LOG_INFO) << "PHY SCI msg header = " << endl; clog << logger(LOG_INFO) << "\tversion = 0x" << setfill('0') << setw(2) << uppercase << hex << static_cast(getSpecializedSciMsgHeader().version) << endl; displaySpecializedSciMsgType(LOG_INFO); clog << logger(LOG_INFO) << "\tmpdu format = 0x" << setfill('0') << setw(2) << uppercase << hex << static_cast(getSpecializedSciMsgHeader().mpdu_format) << endl; clog << logger(LOG_INFO) << "\tpb nb = " << dec << static_cast(getSpecializedSciMsgHeader().pb_nb) << endl; clog << logger(LOG_INFO) << "\tmsg nb = " << dec << static_cast(getSpecializedSciMsgHeader().msg_nb) << endl; clog << logger(LOG_INFO) << "\tfc mode = 0x" << setfill('0') << setw(2) << uppercase << hex << static_cast(getSpecializedSciMsgHeader().fc_mode) << endl; clog << logger(LOG_INFO) << "\tshort ppdu = 0x" << setfill('0') << setw(2) << uppercase << hex << static_cast(getSpecializedSciMsgHeader().short_ppdu) << endl; clog << logger(LOG_INFO) << "\tmod = 0x" << setfill('0') << setw(2) << uppercase << hex << static_cast(getSpecializedSciMsgHeader().mod) << endl; clog << logger(LOG_INFO) << "\tfecrate = 0x" << setfill('0') << setw(2) << uppercase << hex << static_cast(getSpecializedSciMsgHeader().fecrate) << endl; clog << logger(LOG_INFO) << "\tgil = 0x" << setfill('0') << setw(2) << uppercase << hex << static_cast(getSpecializedSciMsgHeader().gil) << endl; clog << logger(LOG_INFO) << "\ttonemap index = " << dec << static_cast(getSpecializedSciMsgHeader().tonemap_index) << endl; clog << logger(LOG_INFO) << "\treserved = 0x" << setfill('0') << setw(4) << uppercase << hex << ntohs(getSpecializedSciMsgHeader().reserved) << endl; clog << logger(LOG_INFO) << "\ttx id = " << dec << ntohs(getSpecializedSciMsgHeader().tx_id) << endl; clog << logger(LOG_INFO) << "\tflags = 0x" << setfill('0') << setw(4) << uppercase << hex << ntohs(getSpecializedSciMsgHeader().flags) << endl; clog << logger(LOG_INFO) << "\tsymbol nb = " << dec << ntohl(getSpecializedSciMsgHeader().symbol_nb) << endl; displayIv(); displayNek(); displayPbMeasurement(); displayPbHeader(); } bool PhySciMsg::prepare ( Network_Clock_Id clock_id ) { logFunction(); return false; } void PhySciMsg::displaySpecializedSciMsgType ( int log_level ) const { logFunction(); switch (getSpecializedSciMsgHeader().type) { case 0: clog << logger(log_level) << "\ttype = PHY_TYPE_NONE" << endl; break; case 1: clog << logger(log_level) << "\ttype = PHY_TYPE_PREAMBLE" << endl; break; case 2: clog << logger(log_level) << "\ttype = PHY_TYPE_FC_HYBRID_MODE" << endl; break; case 3: clog << logger(log_level) << "\ttype = PHY_TYPE_FC_AV_ONLY_MODE" << endl; break; case 4: clog << logger(log_level) << "\ttype = PHY_TYPE_PRS" << endl; break; case 5: clog << logger(log_level) << "\ttype = PHY_TYPE_MPDU_PAYLOAD" << endl; break; case 6: clog << logger(log_level) << "\ttype = PHY_TYPE_TONEMASK" << endl; break; case 7: clog << logger(log_level) << "\ttype = PHY_TYPE_TONEMAP" << endl; break; case 8: clog << logger(log_level) << "\ttype = PHY_TYPE_NOISE" << endl; break; case 9: clog << logger(log_level) << "\ttype = PHY_TYPE_RX" << endl; break; case 10: clog << logger(log_level) << "\ttype = PHY_TYPE_ZERO_CROSS" << endl; break; default: clog << logger(log_level) << "\ttype = unknown!" << endl; break; } } // private methods // void PhySciMsg::displayIv ( ) const { logFunction(); ostringstream oss; oss << "\tiv = 0x "; for (unsigned int i=0; i<3; i++) { oss << setfill('0') << setw(8) << uppercase << hex << htonl(getSpecializedSciMsgHeader().iv[i]) << " "; } oss << endl; oss.flush(); clog << logger(LOG_INFO) << oss.str(); } void PhySciMsg::displayNek ( ) const { logFunction(); ostringstream oss; oss << "\tnek = 0x "; for (unsigned int i=0; i<4; i++) { oss << setfill('0') << setw(8) << uppercase << hex << htonl(getSpecializedSciMsgHeader().nek[i]) << " "; } oss << endl; oss.flush(); clog << logger(LOG_INFO) << oss.str(); } void PhySciMsg::displayPbMeasurement ( ) const { logFunction(); ostringstream oss; oss << "\tpb_measurement = 0x "; for (unsigned int i=0; i(getSpecializedSciMsgHeader().type)); bSetHdr &= setMpduFormat (static_cast(getSpecializedSciMsgHeader().mpdu_format)); bSetHdr &= setNbOfPbs (static_cast(getSpecializedSciMsgHeader().pb_nb)); bSetHdr &= setNbOfMsgs (static_cast(getSpecializedSciMsgHeader().msg_nb)); bSetHdr &= setFcMode (static_cast(getSpecializedSciMsgHeader().fc_mode)); bSetHdr &= setShortPpdu (static_cast(getSpecializedSciMsgHeader().short_ppdu)); bSetHdr &= setMod (static_cast(getSpecializedSciMsgHeader().mod)); bSetHdr &= setFecrate (static_cast(getSpecializedSciMsgHeader().fecrate)); bSetHdr &= setGil (static_cast(getSpecializedSciMsgHeader().gil)); bSetHdr &= setTonemapIndex (static_cast(getSpecializedSciMsgHeader().tonemap_index)); bSetHdr &= setTxId (static_cast(ntohs(getSpecializedSciMsgHeader().tx_id))); bSetHdr &= setFlags (static_cast(ntohs(getSpecializedSciMsgHeader().flags))); bSetHdr &= setIsEncrypted (PHY_FLAG_ENCRYPTED == (getFlags() & PHY_FLAG_ENCRYPTED)); bSetHdr &= setIsCrcOk (PHY_FLAG_CRC_OK == (getFlags() & PHY_FLAG_CRC_OK)); bSetHdr &= setPbSize ((PHY_FLAG_PB512 == (getFlags() & PHY_FLAG_PB512)) ? 512 : 128); bSetHdr &= setReserved ((ntohs(getSpecializedSciMsgHeader().reserved))); bSetHdr &= setNbOfSymbols (static_cast(ntohl(getSpecializedSciMsgHeader().symbol_nb))); uint32_t iv[3]; for (unsigned int i=0; i<3; i++) { iv[i] = ntohl(getSpecializedSciMsgHeader().iv[i]); } bSetHdr &= setIv (iv); uint32_t nek[4]; for (unsigned int i=0; i<4; i++) { nek[i] = ntohl(getSpecializedSciMsgHeader().nek[i]); } bSetHdr &= setNek (nek); uint32_t pbMeasurement[PHY_PB_MAX_NB]; uint32_t pbHeader[PHY_PB_MAX_NB]; for (unsigned int i=0; i= type)) { errno = EINVAL; throw Error(__PRETTY_FUNCTION__, "PHY SCI message header type is out-of-range", errno); } else { mSpecializedSciMsgType = type; bSetType = true; } return bSetType; } Phy_Mpdu_Format PhySciMsg::getMpduFormat ( ) const { return mMpduFormat; } bool PhySciMsg::setMpduFormat ( const Phy_Mpdu_Format mpdu_format ) { bool bSetMpduFormat = false; if (PHY_MPDU_FORMAT_NB <= mpdu_format) { errno = EINVAL; throw Error(__PRETTY_FUNCTION__, "PHY SCI message header MPDU format is out-of-range", errno); } else { mMpduFormat = mpdu_format; bSetMpduFormat = true; } return bSetMpduFormat; } Phy_Nb_Of_Pbs PhySciMsg::getNbOfPbs ( ) const { return mNbOfPbs; } bool PhySciMsg::setNbOfPbs ( const Phy_Nb_Of_Pbs nb_of_pbs ) { bool bSetPbNb = false; if (PHY_PB_MAX_NB < nb_of_pbs) { errno = EINVAL; throw Error(__PRETTY_FUNCTION__, "PHY SCI message header PB number is out-of-range", errno); } else { mNbOfPbs = nb_of_pbs; bSetPbNb = true; } return bSetPbNb; } const unsigned short int PhySciMsg::getNbOfMsgs ( ) const { if ((0 == mNbOfMsgs) || (PHY_MSG_MAX_NB_PER_MPDU < mNbOfMsgs)) { throw Error(__PRETTY_FUNCTION__, "Number of PHY SCI messages is out-of-range"); } return mNbOfMsgs; } bool PhySciMsg::setNbOfMsgs ( const unsigned short int nb_of_msgs ) { if ( (0 == nb_of_msgs) || (PHY_MSG_MAX_NB_PER_MPDU < nb_of_msgs)) { throw Error(__PRETTY_FUNCTION__, "Number of PHY SCI messages is out-of-range"); } mNbOfMsgs = nb_of_msgs; return true; } Phy_Fc_Mode PhySciMsg::getFcMode ( ) const { return mFcMode; } bool PhySciMsg::setFcMode ( const Phy_Fc_Mode fc_mode ) { bool bSetFcMode = false; if (PHY_FC_MODE_NONE < fc_mode) { errno = EINVAL; throw Error(__PRETTY_FUNCTION__, "PHY SCI message header FC mode is out-of-range", errno); } else { mFcMode = fc_mode; bSetFcMode = true; } return bSetFcMode; } Phy_Short_Ppdu PhySciMsg::getShortPpdu ( ) const { return mShortPpdu; } bool PhySciMsg::setShortPpdu ( const Phy_Short_Ppdu short_ppdu ) { mShortPpdu = short_ppdu; return true; } Phy_Mod PhySciMsg::getMod ( ) const { return mMod; } bool PhySciMsg::setMod ( const Phy_Mod mod ) { bool bSetMod = false; if (PHY_MOD_NONE < mod) { errno = EINVAL; throw Error(__PRETTY_FUNCTION__, "PHY SCI message header modulation is out-of-range", errno); } else { mMod = mod; bSetMod = true; } return bSetMod; } Phy_Fecrate PhySciMsg::getFecrate ( ) const { return mFecrate; } bool PhySciMsg::setFecrate ( const Phy_Fecrate fecrate ) { bool bSetFecrate = false; if (PHY_FEC_RATE_NONE < fecrate) { errno = EINVAL; throw Error(__PRETTY_FUNCTION__, "PHY SCI message header FEC rate is out-of-range", errno); } else { mFecrate = fecrate; bSetFecrate = true; } return bSetFecrate; } Phy_Gil PhySciMsg::getGil ( ) const { return mGil; } bool PhySciMsg::setGil ( const Phy_Gil gil ) { bool bSetGil = false; if (PHY_GIL_NONE < gil) { errno = EINVAL; throw Error(__PRETTY_FUNCTION__, "PHY SCI message header Guard Interval is out-of-range", errno); } else { mGil = gil; bSetGil = true; } return bSetGil; } Phy_Tonemap_Index PhySciMsg::getTonemapIndex ( ) const { return mTonemapIndex; } bool PhySciMsg::setTonemapIndex ( const Phy_Tonemap_Index tonemap_index ) { bool bSetTonemapIndex = false; if (TONEMAP_INDEX_NB <= tonemap_index) { errno = EINVAL; throw Error(__PRETTY_FUNCTION__, "PHY SCI message header tonemap index is out-of-range", errno); } else { mTonemapIndex = tonemap_index; bSetTonemapIndex = true; } return bSetTonemapIndex; } Phy_Tx_Id PhySciMsg::getTxId ( ) const { return mTxId; } bool PhySciMsg::setTxId ( const Phy_Tx_Id tx_id ) { mTxId = tx_id; return true; } Phy_Flags PhySciMsg::getFlags ( ) const { return mFlags; } bool PhySciMsg::setFlags ( const Phy_Flags flags ) { bool bSetFlags = false; if (PHY_FLAG_MAX < flags) { errno = EINVAL; throw Error(__PRETTY_FUNCTION__, "PHY SCI message header flags is out-of-range", errno); } else { mFlags = flags; bSetFlags = true; } return bSetFlags; } bool PhySciMsg::isEncrypted ( ) const { return mIsEncrypted; } bool PhySciMsg::setIsEncrypted ( const bool is_encrypted ) { mIsEncrypted = is_encrypted; return true; } bool PhySciMsg::isCrcOk ( ) const { return mIsCrcOk; } bool PhySciMsg::setIsCrcOk ( const bool is_crc_ok ) { mIsCrcOk = is_crc_ok; return true; } unsigned short int PhySciMsg::getPbSize ( ) const { return mPbSize; } bool PhySciMsg::setPbSize ( const unsigned short int pb_size ) { bool bSetPbSize = false; if ( (MAC_PB136_BYTES != pb_size) && (MAC_PB520_BYTES != pb_size) ) { errno = EINVAL; throw Error(__PRETTY_FUNCTION__, "PB size is out-of-range", errno); } else { mPbSize = pb_size; bSetPbSize = true; } return bSetPbSize; } Phy_Nb_Of_Symbols PhySciMsg::getNbOfSymbols ( ) const { return mNbOfSymbols; } bool PhySciMsg::setNbOfSymbols ( const Phy_Nb_Of_Symbols nb_of_symbols ) { bool bSetSymbolNb = false; if (MAC_MAX_SYMB_PER_MPDU < nb_of_symbols) { errno = EINVAL; throw Error(__PRETTY_FUNCTION__, "PHY SCI message header symbol number is out-of-range", errno); } else { mNbOfSymbols = nb_of_symbols; bSetSymbolNb = true; } return bSetSymbolNb; } const uint32_t * PhySciMsg::getIv ( ) const { return mIvArray; } bool PhySciMsg::setIv ( const uint32_t iv[3] ) { return (NULL != memcpy(mIvArray, iv, 3*sizeof(uint32_t))); } const uint32_t * PhySciMsg::getNek ( ) const { return mNekArray; } bool PhySciMsg::setNek ( const uint32_t nek[4] ) { return (NULL != memcpy(mNekArray, nek, 4*sizeof(uint32_t))); } const uint32_t * PhySciMsg::getPbMeasurement ( ) const { return mPbMeasurementArray; } bool PhySciMsg::setPbMeasurement ( const uint32_t pb_measurement[PHY_PB_MAX_NB] ) { return (NULL != memcpy(mPbMeasurementArray, pb_measurement, PHY_PB_MAX_NB*sizeof(uint32_t))); } const uint32_t * PhySciMsg::getPbHeader ( ) const { return mPbHeaderArray; } bool PhySciMsg::setPbHeader ( const uint32_t pb_header[PHY_PB_MAX_NB] ) { return (NULL != memcpy(mPbHeaderArray, pb_header, PHY_PB_MAX_NB*sizeof(uint32_t))); } const bool PhySciMsg::isSent ( ) const { return mIsSent; } bool PhySciMsg::setIsSent ( const bool is_sent ) { logFunction(); mIsSent = is_sent; return true; } // protected attribute accessor methods //