Main Page   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members   Related Pages  

VirtualCircuitTable.cpp

Go to the documentation of this file.
00001 #include "headers.h"
00002 
00008 
00009 
00010 VirtualCircuitTable::VirtualCircuitTable(Node* myself) 
00011 {
00012     Guard guard(&m_tableLock);
00013     m_table.reserve(20);
00014         m_myself = myself;
00015 } // constructor
00016 
00017 
00018 VirtualCircuitTable::~VirtualCircuitTable()
00019 {
00020         Guard guard(&m_tableLock);
00021     vector<VirtualCircuitTableEntry*>::iterator iter;
00022     for (iter = m_table.begin(); iter != m_table.end(); ++iter) {
00023         delete (*iter);
00024     }
00025     m_table.clear();
00026 } // destructor
00027 
00028 
00034 VirtualCircuitTableEntry*
00035 VirtualCircuitTable::add(Node* srcNode, int srcVcn,
00036                                                                 Node* destNode, int destVcn)
00037 {
00038         Guard guard(&m_tableLock);
00039     
00040     // create a new entry
00041     VirtualCircuitTableEntry* newEntry =
00042         new VirtualCircuitTableEntry(srcNode, srcVcn, 
00043         destNode, destVcn);
00044     MEMCHECK(newEntry);
00045     
00046 #ifdef DEBUG_ON
00047     stringstream s;
00048     s << *newEntry;
00049     debug(DEBUG_VCT, "Adding entry: %s", s.str());
00050 #endif
00051 
00052     m_table.push_back(newEntry);
00053 
00054     return newEntry;
00055 } // fn add
00056 
00057 
00067 VirtualCircuitTableEntry* 
00068 VirtualCircuitTable::findBySrc(Node* srcNode, int srcVcn)
00069 {
00070         Guard guard(&m_tableLock);
00071 
00072         debug(DEBUG_VCT, "Looking up node %s, source vcn %d", 
00073         srcNode->getSocketAddress()->toCStr(), srcVcn);
00074 
00075     vector<VirtualCircuitTableEntry*>::iterator iter;
00076     for (iter = m_table.begin(); iter != m_table.end(); ++iter) {
00077         if (srcNode->equals((*iter)->getSrcNode()) && (srcVcn == (*iter)->getSrcVcn())) {
00078             return (*iter);
00079         }
00080     }
00081 
00082         // if we get here we have gone through the entire list without finding
00083         // a match.
00084         return NULL;
00085 } // fn findBySrc
00086 
00087 
00097 VirtualCircuitTableEntry* 
00098 VirtualCircuitTable::findByDest(Node* destNode, int destVcn)
00099 {
00100         Guard guard(&m_tableLock);
00101 
00102         debug(DEBUG_VCT, "Looking up node %s, destination VCN %d", 
00103         destNode->getSocketAddress()->toCStr(), destVcn);
00104 
00105     vector<VirtualCircuitTableEntry*>::iterator iter;
00106     for (iter = m_table.begin(); iter != m_table.end(); ++iter) {
00107         if (destNode->equals((*iter)->getDestNode()) && (destVcn == (*iter)->getDestVcn())) {
00108             return (*iter);
00109         }
00110     }
00111 
00112         // if we get here we have gone through the entire list without finding
00113         // a match.
00114         return NULL;
00115 } // fn findByDest
00116 
00117 
00121 VirtualCircuitTableEntry* 
00122 VirtualCircuitTable::findNode(Node* node) {
00123         Guard guard(&m_tableLock);
00124 
00125         debug(DEBUG_VCT, "Looking up node %s", node->getSocketAddress()->toCStr());
00126 
00127     vector<VirtualCircuitTableEntry*>::iterator iter;
00128     for (iter = m_table.begin(); iter != m_table.end(); ++iter) {
00129         if (node->equals((*iter)->getSrcNode()) || (node->equals((*iter)->getDestNode()))) {
00130             return (*iter);
00131         }
00132     }
00133 
00134         // if we get here we have gone through the entire list without finding
00135         // a match.
00136         return NULL;    
00137 } // fn findNode
00138 
00139 
00145 bool 
00146 VirtualCircuitTable::remove(Node* srcNode, int srcVcn) 
00147 {
00148         Guard guard(&m_tableLock);
00149 
00150         debug(DEBUG_VCT, "Removing node %s, source VCN %d", 
00151         srcNode->getSocketAddress()->toCStr(), srcVcn);
00152 
00153 
00154     vector<VirtualCircuitTableEntry*>::iterator iter;
00155     for (iter = m_table.begin(); iter != m_table.end(); ++iter) {
00156                 if ((srcNode->equals((*iter)->getSrcNode())) &&
00157                         (srcVcn == (*iter)->getSrcVcn())) 
00158                 {
00159             delete (*iter);
00160             m_table.erase(iter);
00161             return true;
00162         }
00163     }
00164 
00165         // if we get here we have gone through the entire list without finding
00166         // a match.
00167         return false;
00168 } // fn remove
00169 
00170 
00174 /*
00175 int VirtualCircuitTable::generateVcn()
00176 {
00177         // Generate the next Vcn
00178         return Counter::incrementGlobalCount();
00179 } // fn generateVcn
00180 */
00181 
00182 
00187 bool 
00188 VirtualCircuitTable::isThisPacketForMe(Node* fromNode, NpPacket* packet) {
00189     VirtualCircuitTableEntry* e;
00190         e = findBySrc(fromNode, packet->getVcn());
00191         if ((e != NULL) && e->getDestNode()->equals(m_myself)) {
00192                 return true;
00193         } 
00194     else {
00195                 return false;
00196         }
00197 }  // fn isThisPacketForMe
00198 
00199 
00200 #ifdef INFO
00201 
00204 void 
00205 VirtualCircuitTable::incrementControlPackets(Node* srcNode, int srcVcn) 
00206 {
00207         VirtualCircuitTableEntry* entry;
00208         entry = findBySrc(srcNode, srcVcn);
00209         if (entry) {
00210                 entry->controlPackets++;
00211         }
00212         entry = findByDest(srcNode, srcVcn);
00213         if (entry) {
00214                 entry->controlPackets++;
00215         }
00216 } // fn incrementControlPackets
00217 
00218 
00222 void 
00223 VirtualCircuitTable::incrementDataPackets(Node* srcNode, int srcVcn)
00224 {
00225         VirtualCircuitTableEntry* entry;
00226         entry = findBySrc(srcNode, srcVcn);
00227         if (entry) {
00228                 entry->dataPackets++;
00229         }
00230         entry = findByDest(srcNode, srcVcn);
00231         if (entry) {
00232                 entry->dataPackets++;
00233         }
00234 } // fn incrementDataPackets
00235 #endif
00236 
00237 
00238 // ***********************************************************************
00239 // I/O Functions
00240 // ***********************************************************************
00241 
00246 std::ostream& operator <<(std::ostream& out, VirtualCircuitTable& vct) 
00247 {
00248     vct.toStream(out);
00249         return out;
00250 } // fn <<
00251 
00252 
00253 void 
00254 VirtualCircuitTable::toStream(std::ostream& out) {
00255         Guard guard(&m_tableLock);
00256 
00257     // Print out table header
00258     out << "-------------------------------------------------------------------------------\n";
00259     out << "Virtual Circuit Table (Node Addr: ";
00260     out << *GlobalObjects::instance()->getConfig()->getSelf()->getNode()->getSocketAddress();
00261     out << ")" << "\n";
00262     out << "-------------------------------------------------------------------------------\n";
00263     out.setf(ios::left);
00264     out << setw(IP_PORT_FIELD_LENGTH) << "SRC";
00265     out << setw(VCN_FIELD_LENGTH) << "SRC";
00266     out << setw(IP_PORT_FIELD_LENGTH) << "DEST" ;
00267     out << setw(VCN_FIELD_LENGTH) << "DEST";
00268 #ifdef INFO
00269     out << "    "; // to skip over the O and T
00270     out << setw(MAX_INT_LENGTH*2 + 4) << "    PACKETS";
00271 #endif
00272     out << "\n";
00273     out << setw(IP_PORT_FIELD_LENGTH) << "IP";
00274     out << setw(VCN_FIELD_LENGTH) << "VCN";
00275     out << setw(IP_PORT_FIELD_LENGTH) << "IP" ;
00276     out << setw(VCN_FIELD_LENGTH) << "VCN";
00277     out << setw(2) << "O";
00278     out << setw(2) << "T";
00279 #ifdef INFO
00280     out << setw(MAX_INT_LENGTH) << "CTRL";
00281     out << setw(MAX_INT_LENGTH) << "DATA";
00282 #endif
00283     out << "\n";
00284     out << "-------------------------------------------------------------------------------\n";
00285 
00286     // print table entries
00287     vector<VirtualCircuitTableEntry*>::iterator iter;
00288     for (iter = m_table.begin(); iter != m_table.end(); ++iter) {
00289         out << **iter;
00290     }
00291 } // fn toStream
00292 
00293 

Generated at Thu Jul 11 13:31:53 2002 for Peekabooty by doxygen1.2.9 written by Dimitri van Heesch, © 1997-2001