Hauptseite   Klassenhierarchie   Datenstrukturen   Auflistung der Dateien   Datenstruktur-Elemente   Datei-Elemente  

Receiver Klassenreferenz

Receiver ist der Empfänger. Mehr...

#include <Receiver.h>


Öffentliche Datenelemente

 Receiver (int iPort)
 ~Receiver (void)
void run (void)

Private Datenelemente

int findPacketNr (FragVec &pmcfvecSrc, DWORD dwPacketNr)
void showFrags (FragVec &pmcfvecSrc, bool bShow=true)
RNPRESULT MessageHandler (void *pvoidPacket, WORD wSize)

Private, statische Datenelemente

RNPRESULT StaticMessageHandler (void *pvoidUserContext, void *pvoidPacket, WORD wSize)

Private Attribute

FragVec m_pmcfvecNew
 Buffer für alle neu erhaltenen Textfragmente. Mehr...

FragVec m_pmcfvecOrdered
 Buffer für die bereits geordneten Textfragmente. Mehr...

int m_iPort
 Port, das für die Verbindung genutzt wird. Mehr...


Ausführliche Beschreibung

Receiver ist der Empfänger.

Diese Klasse empfängt die CharFragments und setzt sie wieder zu einem gesamten Text zusammen. Dieser wird dann natürlich ausgegeben.


Beschreibung der Konstruktoren und Destruktoren

Receiver::Receiver int    iPort
 

Konstruktor, Port merken

00026 {
00027         m_iPort=iPort;
00028 }

Receiver::~Receiver void   
 

Destruktor, Vektorinhalte löschen

00037 {
00038     showFrags(m_pmcfvecNew,false);
00039     showFrags(m_pmcfvecOrdered,false);
00040 }


Dokumentation der Elementfunktionen

int Receiver::findPacketNr FragVec   pmcfvecSrc,
DWORD    dwPacketNr
[private]
 

Sucht in einen Vektor aus CharFragmenten, nach einem Packet mit einer bestimmten PacketNr. Dessen Position wird zurückgegeben, wird keines gefunden, wird -1 zurückgegeben.

00149 {
00150     int iCount;
00151             
00152     for (iCount=0; iCount<pmcfvecSrc.size();iCount++)
00153     {
00154         // hat dieses Packet die Nummer?
00155         if (pmcfvecSrc[iCount]->m_dwPacketNr==dwPacketNr)
00156         {
00157             // ja, Nummer zurück
00158             return iCount;
00159         }
00160     }
00161 
00162     // nicht gefunden, -1 zurück
00163     return -1;
00164 }

RNPRESULT Receiver::MessageHandler void *    pvoidPacket,
WORD    wSize
[private]
 

Empfängt und verarbeitet die Nachrichten. Dafür wird zunächst der Nachrichtentyp anhand von MessageGeneric::m_Type erkannt, und dann der void* entsprechend gecasted.

00227 {
00228     MessageGeneric* pmsgTmp= (MessageGeneric*)pvoidPacket;
00229 
00230     switch (pmsgTmp->m_Type)
00231     {
00232     case MSGID_CHARFRAGMENT:
00233         {
00234             MessageCharFragment* pmsgcfTmp= (MessageCharFragment*)pmsgTmp;
00235             m_pmcfvecNew.push_back(pmsgcfTmp);
00236             
00237             int iPos;
00238             DWORD dwFind=c_dwFirstCharFragment;
00239 
00240             do
00241             {
00242                 if (m_pmcfvecOrdered.size()>0)
00243                 {
00244                     dwFind=(*(m_pmcfvecOrdered.end()-1))->m_dwNextPacketNr;
00245                 }
00246 
00247                 iPos=findPacketNr(m_pmcfvecNew,dwFind);
00248 
00249                 if (iPos!=-1)
00250                 {
00251                     m_pmcfvecOrdered.push_back(m_pmcfvecNew[iPos]);
00252                     m_pmcfvecNew.erase(m_pmcfvecNew.begin()+iPos);
00253                 }
00254 
00255             } while (iPos!=-1);
00256 
00257             if ((*(m_pmcfvecOrdered.end()-1))->m_dwNextPacketNr==c_dwLastCharFragment)
00258             {
00259                 showFrags(m_pmcfvecOrdered);
00260             }
00261         }
00262         return RNP_BUFFER_IN_USE;
00263         break;
00264 
00265     default:
00266         return RNP_BUFFER_RETURNED;
00267     }
00268 
00269     return RNP_BUFFER_RETURNED;
00270 }

void Receiver::run void   
 

Diese Methode lässt das Empfangen ablaufen.

00048 {
00049     RNPRESULT rnprTmp;
00050     RNPacket rnpRecv;
00051     RNSocket rnsListener;
00052 
00053     // MessageHandler initialisieren
00054     if(rnpRecv.initMessageCallBack(this,StaticMessageHandler) == RNP_OK)
00055     {
00056         printf("MessageHandler inited.\n");
00057     }
00058     else
00059     {
00060         return;
00061     }
00062 
00063     // Socket zum lauschen erzeugen
00064     if (!rnsListener.create())
00065     {
00066         printf("Could not create Socket to listen.\n");
00067         return;
00068     }
00069 
00070     // Socket an Port binden
00071     if (!rnsListener.bind(NULL,m_iPort))
00072     {
00073         printf("Could not bind Socket to listen.\n");
00074         
00075         return;
00076     }
00077 
00078     // Start des Lauschens
00079     if (!rnsListener.listen())
00080     {
00081         printf("Could not listen, Socket Error.\n");
00082         return;
00083     }
00084 
00085     printf("Listening...");
00086 
00087     // Abwarten, bist jemand einen Connect auf den Port versucht
00088     do
00089     {
00090         rnprTmp=rnpRecv.socketAccept(&rnsListener);
00091 
00092         if (kbhit())
00093         {
00094             printf("\nUser aborted.\n");
00095             getch();
00096             return;
00097         }
00098         
00099         Sleep(100);
00100         printf(".");
00101     } while (rnprTmp == RNP_SOCKET_NOT_CONNECTED);
00102 
00103     printf("\n");
00104 
00105     // Überprüfen, ob Verbindung erfolgreich zustande kam
00106     if (rnprTmp != RNP_OK)
00107     {
00108         printf("Error occured.\n");
00109         return;
00110     }
00111 
00112     // es hat funktioniert!
00113     printf("Connection established.\n");
00114     
00115     // empfangen bis disonnection auftritt
00116     do
00117     {
00118         rnprTmp=rnpRecv.recvMessage();
00119 
00120         if (kbhit())
00121         {
00122             printf("User aborted.\n");
00123             getch();
00124             return;
00125         }
00126     } while (rnprTmp != RNP_SOCKET_NOT_CONNECTED);
00127 
00128     printf("Connection closed.\n");
00129 
00130     // eigenen Socket auch schliessen
00131     if(rnpRecv.socketClose() == RNP_OK)
00132     {
00133         printf("Socket closed.\n");
00134     }
00135     else
00136     {
00137         printf("Error occured while closing Socket.\n");
00138     }
00139 }

void Receiver::showFrags FragVec   pmcfvecSrc,
bool    bShow = true
[private]
 

geht die Fragmente des Vektors alle durch und löscht diese. Falls bShow true sein sollte, werden die Textstücke angezeigt.

00173 {
00174     MessageCharFragment* pmcfTmp;
00175     char pcBuffer[c_dwSizeCharFragment+1];
00176     int iCount=0;
00177             
00178     while (pmcfvecSrc.size()>0)
00179     {
00180         pmcfTmp=*(pmcfvecSrc.begin());
00181 
00182         if (pmcfTmp != NULL)
00183         {
00184             if (bShow==true)
00185             {
00186                 strncpy(pcBuffer,pmcfTmp->m_cBuffer,c_dwSizeCharFragment);
00187                 pcBuffer[c_dwSizeCharFragment]=0;
00188                 printf("%s",pcBuffer);
00189                 iCount++;
00190             }
00191             
00192             delete pmcfTmp;     
00193         }
00194 
00195         pmcfvecSrc.erase(pmcfvecSrc.begin());
00196     }
00197 
00198     if (iCount>0)
00199     {
00200         printf("\n%i Fragments showed.\n",iCount);
00201     }
00202 }

RNPRESULT Receiver::StaticMessageHandler void *    pvoidUserContext,
void *    pvoidPacket,
WORD    wSize
[static, private]
 

Ruft den eigentlichen (nicht static definierten) MessageHandler auf.

00213 {
00214     Receiver* pThisObject = (Receiver*) pvoidUserContext;
00215 
00216     return pThisObject->MessageHandler(pvoidPacket,wSize);
00217 }


Dokumentation der Datenelemente

int Receiver::m_iPort [private]
 

Port, das für die Verbindung genutzt wird.

FragVec Receiver::m_pmcfvecNew [private]
 

Buffer für alle neu erhaltenen Textfragmente.

FragVec Receiver::m_pmcfvecOrdered [private]
 

Buffer für die bereits geordneten Textfragmente.


Die Dokumentation für diese Klasse wurde erzeugt aufgrund der Dateien:
Erzeugt am Thu Apr 4 19:23:30 2002 für Rechnernetze-Aufgabe1 von doxygen1.2.13.1 geschrieben von Dimitri van Heesch, © 1997-2001