ccl » source

CigiIncomingMsg.cpp

Go to the documentation of this file.
00001 
00092 #define _EXPORT_CCL_
00093 
00094 #include "CigiIncomingMsg.h"
00095 #include "CigiExceptions.h"
00096 #include "CigiAllPackets.h"
00097 
00098 #include "CigiVersionID.h"
00099 #include "CigiSignalType.h"
00100 #include "CigiDefaultPacket.h"
00101 #include "CigiSession.h"
00102 
00103 
00104 // ====================================================================
00105 // Construction/Destruction
00106 // ====================================================================
00107 
00108 // ================================================
00109 // CigiIncomingMsg
00110 // vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
00111 CigiIncomingMsg::CigiIncomingMsg()
00112 : Iteration(false)
00113 , CrntPacket(NULL)
00114 , ReadBufferPos(0)
00115 , Swap(false)
00116 , DefaultPckt(NULL)
00117 {
00118    DefaultPckt = new CigiDefaultPacket;
00119 
00120    for(int ndx=0;ndx<256;ndx++)
00121       IncomingHandlerTbl[ndx] = NULL;
00122 
00123    ClearTbls(true);
00124 
00125    for(int ndx=0;ndx<256;ndx++)
00126       SignalTbl[ndx] = CigiSignalType::SigNone;
00127 
00128    ReaderVersion.SetCigiVersion(0,0);
00129    ProcessingVersion.SetCigiVersion(0,0);
00130    MostMatureCigiVersionReceived.SetCigiVersion(0,0);
00131 }
00132 
00133 // ================================================
00134 // ~CigiIncomingMsg
00135 // vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
00136 CigiIncomingMsg::~CigiIncomingMsg()
00137 {
00138    int ndx;
00139 
00140    ClearTbls(false);
00141 
00142    for(ndx=0;ndx<257;ndx++)
00143    {
00144       // Events
00145       EventList[ndx].clear();
00146 
00147       // Call Backs
00148       CallBackList[ndx].clear();
00149    }
00150 
00151    // Signals
00152    SignalList.clear();
00153 
00154    // Default Packet
00155    if(DefaultPckt != NULL)
00156       delete DefaultPckt;
00157 }
00158 
00159 
00160 // ====================================================================
00161 // Processing
00162 // ====================================================================
00163 
00164 // ================================================
00165 // ProcessIncomingMsg
00166 // vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
00167 int CigiIncomingMsg::ProcessIncomingMsg(Cigi_uint8 *Buff, int Size)
00168 {
00169    if(Iteration)
00170    {
00171 #ifndef CIGI_NO_EXCEPT
00172       throw CigiCalledOutOfSequenceException();
00173 #endif
00174       return(CIGI_ERROR_CALLED_OUT_OF_SEQUENCE);
00175    }
00176 
00177    if(Size < 12)
00178    {
00179 #ifndef CIGI_NO_EXCEPT
00180       throw CigiImproperPacketException();
00181 #endif
00182       return(CIGI_ERROR_IMPROPER_PACKET);
00183    }
00184 
00185    int stat = CheckFirstPacket(Buff);
00186    if(stat != CIGI_SUCCESS)
00187       return(stat);
00188 
00189    Cigi_uint8 *Dta = Buff;
00190    int ReadCnt = 0;
00191    Swap = false;
00192 
00193    // Process the message
00194    while(ReadCnt < Size)
00195    {
00196       Cigi_uint8 PacketID = *Dta;
00197       Cigi_uint8 PacketSize = *(Dta+1);
00198 
00199       if(PacketSize == 0)
00200          break;
00201 
00202       CigiBasePacket *tPckt = IncomingHandlerTbl[PacketID];
00203 
00204       CigiCnvtInfoType::Type CnvtDta;
00205       tPckt->GetCnvt(ReaderVersion,CnvtDta);
00206 
00207       switch(CnvtDta.ProcID)
00208       {
00209       case CigiProcessType::ProcStd:   // Most Packets
00210       case CigiProcessType::ProcVarSize:
00211          tPckt->Unpack(Dta,Swap,NULL);
00212          ProcessPacket(CnvtDta.CnvtPacketID,tPckt);
00213          break;
00214 
00215       case CigiProcessType::ProcEntity:  // Entity Control Packets
00216          tPckt->Unpack(Dta,Swap,ATbl);
00217          ProcessPacket(CnvtDta.CnvtPacketID,tPckt);
00218          break;
00219 
00220       case CigiProcessType::ProcEnvCtrl:
00221          {
00222             // Environment Control Packets
00223             // Atmosphere Control Packets
00224             // & Celestial Sphere Control Packets
00225             tPckt->Unpack(Dta,Swap,&EnvHoldObj);
00226             CigiBaseEnvCtrl *pEnv = (CigiBaseEnvCtrl *)tPckt;
00227             pEnv->FillHold(&EnvHoldObj);
00228 
00229             if(ProcessingVersion.CigiMajorVersion >= 3)
00230             {
00231                // From V3 or above
00232                if(ReaderVersion.CigiMajorVersion >= 3)
00233                {
00234                   // To V3 or above
00235                   ProcessPacket(tPckt->GetPacketID(),tPckt);
00236                }
00237                else
00238                {
00239                   // To V1 or V2
00240                   // V1 Env Ctrl & V2 Env Ctrl have the same ID number
00241                   ProcessPacket(CIGI_ENV_CTRL_PACKET_ID_V2,&EnvHoldObj);
00242                }
00243             }
00244             else  // V1 or V2
00245             {
00246                if(ReaderVersion.CigiMajorVersion >= 3)
00247                {
00248                   // To V3 or above
00249                   ProcessPacket(CIGI_ATMOS_CTRL_PACKET_ID_V3,&EnvHoldObj);
00250                   ProcessPacket(CIGI_CELESTIAL_CTRL_PACKET_ID_V3,&EnvHoldObj);
00251                }
00252                else
00253                {
00254                   // To V1 or V2
00255                   // V1 Env Ctrl & V2 Env Ctrl have the same ID number
00256                   ProcessPacket(CIGI_ENV_CTRL_PACKET_ID_V2,tPckt);
00257                }
00258             }
00259          }
00260 
00261          break;
00262 
00263       case CigiProcessType::ProcShortArtPartToArtPart:
00264          {
00265             // A special case of CIGI version 3 and later
00266             //  Short Articulated Part being converted
00267             //  to a CIGI Version 1 or 2 Articulated Part
00268             tPckt->Unpack(Dta,Swap,&EnvHoldObj);
00269             CigiBaseShortArtPartCtrl *pSArtPart = (CigiBaseShortArtPartCtrl *)tPckt;
00270             Cigi_uint8 ArtPartID1 = pSArtPart->GetArtPart1();
00271             Cigi_uint8 ArtPartID2 = pSArtPart->GetArtPart2();
00272             CigiArtPartCtrlV3 tArtPart;
00273             pSArtPart->SpecialConversion(ReaderVersion,ArtPartID1,&tArtPart);
00274             ProcessPacket(CnvtDta.CnvtPacketID,&tArtPart);
00275             if(ArtPartID2 != ArtPartID1)
00276             {
00277                CigiArtPartCtrlV3 tArtPart2;
00278                pSArtPart->SpecialConversion(ReaderVersion,ArtPartID2,&tArtPart2);
00279                ProcessPacket(CnvtDta.CnvtPacketID,&tArtPart2);
00280             }
00281          }
00282 
00283          break;
00284 
00285       case CigiProcessType::ProcIGCtrl:
00286          // IG Control Packets
00287          // If the Session is a Host session or
00288          //  this is not the first packet to be
00289          //  processed, an IG Control packet
00290          //  should not be here and will skipped
00291          //  and not processed.
00292          if(Session->IsIG() && (ReadCnt == 0))
00293          {
00294             tPckt->Unpack(Dta,false,NULL);
00295 
00296             CigiBaseIGCtrl *tIGCtrl = (CigiBaseIGCtrl *)tPckt;
00297             Swap = tIGCtrl->GetSwap();
00298 
00299             ProcessPacket(CnvtDta.CnvtPacketID,tPckt);
00300          }
00301          break;
00302 
00303       case CigiProcessType::ProcSOF:
00304          // Start Of Frame Packets
00305          // If the Session is an IG session or
00306          //  this is not the first packet to be
00307          //  processed, a Start-Of-Frame packet
00308          //  should not be here and will skipped
00309          //  and not processed.
00310          if(Session->IsHost() && (ReadCnt == 0))
00311          {
00312             tPckt->Unpack(Dta,false,NULL);
00313 
00314             CigiBaseSOF *tSOF = (CigiBaseSOF *)tPckt;
00315             Swap = tSOF->GetSwap();
00316 
00317             ProcessPacket(CnvtDta.CnvtPacketID,tPckt);
00318          }
00319          break;
00320 
00321       case CigiProcessType::TwoPassCnvtProcNone:
00322       case CigiProcessType::TwoPassCnvtProcStd:
00323          // Packets requiring unpacking to determine
00324          //  final conversion method
00325          tPckt->Unpack(Dta,Swap,NULL);
00326 
00327          tPckt->GetCnvt(ReaderVersion,CnvtDta);
00328 
00329          if(CnvtDta.ProcID == CigiProcessType::TwoPassCnvtProcStd)
00330             ProcessPacket(CnvtDta.CnvtPacketID,tPckt);
00331 
00332          break;
00333       default:
00334          break;
00335       }
00336 
00337       // Go to the next packet
00338       Dta += PacketSize;
00339       ReadCnt += PacketSize;
00340    }
00341 
00342    return(CIGI_SUCCESS);
00343 
00344 }
00345 
00346 
00347 // ================================================
00348 // CheckFirstPacket
00349 // vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
00350 int CigiIncomingMsg::CheckFirstPacket(Cigi_uint8 *Buff)
00351 {
00352    // IG Ctrl for IGs & SOF or Hosts
00353    // Get version
00354    //   verify valid version
00355    //   switch version if needed
00356    //   switch MostMatureCigiVersionReceived if needed
00357 
00358    Cigi_uint8 PacketID = *Buff;
00359 
00360    bool IsSOF = false;
00361 
00362    // Verify that this is a valid packet to receive
00363    if(Session->IsHost())
00364    {
00365       if(PacketID != 101)
00366       {
00367          // A host must receive a SOF Packet
00368 #ifndef CIGI_NO_EXCEPT
00369          throw CigiMissingStartOfFrameException();
00370 #endif
00371          return(CIGI_ERROR_MISSING_SOF_PACKET);
00372       }
00373 
00374       IsSOF = true;
00375    }
00376    else
00377    {
00378       if(PacketID != 1)
00379       {
00380          // An IG must receive an IG Control Packet
00381 #ifndef CIGI_NO_EXCEPT
00382          throw CigiMissingIgControlException();
00383 #endif
00384          return(CIGI_ERROR_MISSING_IG_CONTROL_PACKET);
00385       }
00386    }
00387 
00388    // Get the CIGI version used by the message
00389    CigiVersionID tVer;
00390 
00391    // Get the Major CIGI version used by the message
00392    //  The version ID is in the same location in all
00393    //    IGCtrl & SOF packets.
00394    tVer.CigiMajorVersion = (int) *(Buff + 2);
00395 
00396    // CIGI versions 1 & 2 have minor versions of 0
00397    // If the CIGI Major version is 3 or later, the
00398    //   Minor version must be determined.
00399    if(tVer.CigiMajorVersion >= 3)
00400    {
00401       //  Unfortunately The minor version ID is in different locations
00402       int Minor = 0;
00403       if(IsSOF)
00404          Minor = (int) *(Buff + 5);
00405       else
00406          Minor = (int) *(Buff + 4);
00407 
00408       tVer.CigiMinorVersion = (Minor >> 4) & 0x0000000f;
00409    }
00410 
00411    // Verify that the version is a known version
00412    bool ValidVer = tVer.IsKnownCigiVersion();
00413 
00414    // if not valid determine best match version
00415    if(!ValidVer)
00416       tVer.BestCigiVersion();
00417 
00418    // Check the version against the current processing version
00419    if(tVer != ProcessingVersion)
00420    {
00421       // Change processing to the new version
00422       ProcessingVersion = tVer;
00423       ClearTbls(false);
00424 
00425       if(Session->IsHost())
00426       {
00427          if(tVer.CigiMajorVersion == 3)
00428             SetIncomingHostV3Tbls();
00429          else if(tVer.CigiMajorVersion == 2)
00430             SetIncomingHostV2Tbls();
00431          else if(tVer.CigiMajorVersion == 1)
00432             SetIncomingHostV1Tbls();
00433       }
00434       else
00435       {
00436          if(tVer.CigiMajorVersion == 3)
00437             SetIncomingIGV3Tbls();
00438          else if(tVer.CigiMajorVersion == 2)
00439             SetIncomingIGV2Tbls();
00440          else if(tVer.CigiMajorVersion == 1)
00441             SetIncomingIGV1Tbls();
00442       }
00443 
00444    }
00445 
00446    if(tVer.GetCombinedCigiVersion() >
00447       MostMatureCigiVersionReceived.GetCombinedCigiVersion())
00448    {
00449       MostMatureCigiVersionReceived = tVer;
00450       Session->SetMostMatureReceivedCigiVersion(tVer);
00451    }
00452 
00453    return(CIGI_SUCCESS);
00454 }
00455 
00456 
00457 // ================================================
00458 // ProcessPacket
00459 // vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
00460 void CigiIncomingMsg::ProcessPacket(int PcktId, CigiBasePacket *Pckt)
00461 {
00462 
00463 #ifndef CIGI_NO_EVENT_PROCESSING
00464    // Process all Event handlers for this packet
00465    if(!EventList[PcktId].empty())
00466    {
00467       list<CigiBaseEventProcessor *>::iterator iEvent =
00468          EventList[PcktId].begin();
00469       while(iEvent != EventList[PcktId].end())
00470       {
00471          (*iEvent)->OnPacketReceived(Pckt);
00472          iEvent++;
00473       }
00474    }
00475 #endif
00476 
00477 #ifndef CIGI_NO_CALLBACK
00478    // Process all Callbacks for this packet
00479    if(!CallBackList[PcktId].empty())
00480    {
00481       list<CigiCBProcessor>::iterator iCB =
00482          CallBackList[PcktId].begin();
00483       while(iCB != CallBackList[PcktId].end())
00484       {
00485          (*iCB)(Pckt);
00486          iCB++;
00487       }
00488    }
00489 #endif
00490 
00491 #ifndef CIGI_NO_SIGNAL_PROCESSING
00492    // Process all Signal handlers
00493    SignalJump(PcktId,Pckt);
00494 #endif
00495 
00496 }
00497 
00498 
00499 // ================================================
00500 // SignalJump
00501 // vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
00502 bool CigiIncomingMsg::SignalJump(const Cigi_uint8 PacketID, CigiBasePacket *Packet)
00503 {
00504 
00505    CigiSignalType::Type SignalId = SignalTbl[PacketID];
00506 
00507    bool Processed = false;
00508 
00509    list<CigiBaseSignalProcessing *>::iterator iSig;
00510 
00511    for(iSig=SignalList.begin();iSig!=SignalList.end();iSig++)
00512    {
00513 
00514       Processed = true;
00515 
00516       switch(SignalId)
00517       {
00518       case CigiSignalType::SigIGCtrl:
00519          (*iSig)->OnIGCtrl(Packet);
00520          break;
00521       case CigiSignalType::SigEntityCtrl:
00522          (*iSig)->OnEntityCtrl(Packet);
00523          break;
00524       case CigiSignalType::SigViewDef:
00525          (*iSig)->OnViewDef(Packet);
00526          break;
00527       case CigiSignalType::SigViewCtrl:
00528          (*iSig)->OnViewCtrl(Packet);
00529          break;
00530       case CigiSignalType::SigRateCtrl:
00531          (*iSig)->OnRateCtrl(Packet);
00532          break;
00533       case CigiSignalType::SigSensorCtrl:
00534          (*iSig)->OnSensorCtrl(Packet);
00535          break;
00536       case CigiSignalType::SigTrajectory:
00537          (*iSig)->OnTrajectory(Packet);
00538          break;
00539       case CigiSignalType::SigWeatherCtrl:
00540          (*iSig)->OnWeatherCtrl(Packet);
00541          break;
00542       case CigiSignalType::SigCollDetSegDef:
00543          (*iSig)->OnCollDetSegDef(Packet);
00544          break;
00545       case CigiSignalType::SigLosSegReq:
00546          (*iSig)->OnLosSegReq(Packet);
00547          break;
00548       case CigiSignalType::SigLosVectReq:
00549          (*iSig)->OnLosVectReq(Packet);
00550          break;
00551       case CigiSignalType::SigHatReq:
00552          (*iSig)->OnHatReq(Packet);
00553          break;
00554       case CigiSignalType::SigHotReq:
00555          (*iSig)->OnHotReq(Packet);
00556          break;
00557       case CigiSignalType::SigHatHotReq:
00558          (*iSig)->OnHatHotReq(Packet);
00559          break;
00560       case CigiSignalType::SigEnvCtrl:
00561          (*iSig)->OnEnvCtrl(Packet);
00562          break;
00563       case CigiSignalType::SigSpecEffDef:
00564          (*iSig)->OnSpecEffDef(Packet);
00565          break;
00566       case CigiSignalType::SigArtPartCtrl:
00567          (*iSig)->OnArtPartCtrl(Packet);
00568          break;
00569       case CigiSignalType::SigCollDetVolDef:
00570          (*iSig)->OnCollDetVolDef(Packet);
00571          break;
00572       case CigiSignalType::SigShortArtPartCtrl:
00573          (*iSig)->OnShortArtPartCtrl(Packet);
00574          break;
00575       case CigiSignalType::SigConfClampEntityCtrl:
00576          (*iSig)->OnConfClampEntityCtrl(Packet);
00577          break;
00578       case CigiSignalType::SigMaritimeSurfaceCtrl:
00579          (*iSig)->OnMaritimeSurfaceCtrl(Packet);
00580          break;
00581       case CigiSignalType::SigEnvRgnCtrl:
00582          (*iSig)->OnEnvRgnCtrl(Packet);
00583          break;
00584       case CigiSignalType::SigTerrestrialSurfaceCtrl:
00585          (*iSig)->OnTerrestrialSurfaceCtrl(Packet);
00586          break;
00587       case CigiSignalType::SigMotionTrackCtrl:
00588          (*iSig)->OnMotionTrackCtrl(Packet);
00589          break;
00590       case CigiSignalType::SigEarthModelDef:
00591          (*iSig)->OnEarthModelDef(Packet);
00592          break;
00593       case CigiSignalType::SigPostionReq:
00594          (*iSig)->OnPostionReq(Packet);
00595          break;
00596       case CigiSignalType::SigEnvCondReq:
00597          (*iSig)->OnEnvCondReq(Packet);
00598          break;
00599       case CigiSignalType::SigWaveCtrl:
00600          (*iSig)->OnWaveCtrl(Packet);
00601          break;
00602       case CigiSignalType::SigCompCtrl:
00603          (*iSig)->OnCompCtrl(Packet);
00604          break;
00605       case CigiSignalType::SigShortCompCtrl:
00606          (*iSig)->OnShortCompCtrl(Packet);
00607          break;
00608       case CigiSignalType::SigSOF:
00609          (*iSig)->OnSOF(Packet);
00610          break;
00611       case CigiSignalType::SigCollDetSegResp:
00612          (*iSig)->OnCollDetSegResp(Packet);
00613          break;
00614       case CigiSignalType::SigSensorResp:
00615          (*iSig)->OnSensorResp(Packet);
00616          break;
00617       case CigiSignalType::SigSensorXResp:
00618          (*iSig)->OnSensorXResp(Packet);
00619          break;
00620       case CigiSignalType::SigLosResp:
00621          (*iSig)->OnLosResp(Packet);
00622          break;
00623       case CigiSignalType::SigLosXResp:
00624          (*iSig)->OnLosXResp(Packet);
00625          break;
00626       case CigiSignalType::SigHatResp:
00627          (*iSig)->OnHatResp(Packet);
00628          break;
00629       case CigiSignalType::SigHotResp:
00630          (*iSig)->OnHotResp(Packet);
00631          break;
00632       case CigiSignalType::SigHatHotResp:
00633          (*iSig)->OnHatHotResp(Packet);
00634          break;
00635       case CigiSignalType::SigHatHotXResp:
00636          (*iSig)->OnHatHotXResp(Packet);
00637          break;
00638       case CigiSignalType::SigCollDetVolResp:
00639          (*iSig)->OnCollDetVolResp(Packet);
00640          break;
00641       case CigiSignalType::SigPositionResp:
00642          (*iSig)->OnPositionResp(Packet);
00643          break;
00644       case CigiSignalType::SigWeatherCondResp:
00645          (*iSig)->OnWeatherCondResp(Packet);
00646          break;
00647       case CigiSignalType::SigAerosolResp:
00648          (*iSig)->OnAerosolResp(Packet);
00649          break;
00650       case CigiSignalType::SigMaritimeSurfaceResp:
00651          (*iSig)->OnMaritimeSurfaceResp(Packet);
00652          break;
00653       case CigiSignalType::SigTerrestrialSurfaceResp:
00654          (*iSig)->OnTerrestrialSurfaceResp(Packet);
00655          break;
00656       case CigiSignalType::SigAnimationStop:
00657          (*iSig)->OnAnimationStop(Packet);
00658          break;
00659       case CigiSignalType::SigEventNotification:
00660          (*iSig)->OnEventNotification(Packet);
00661          break;
00662       case CigiSignalType::SigIGMsg:
00663          (*iSig)->OnIGMsg(Packet);
00664          break;
00665       case CigiSignalType::SigAtmosCtrl:
00666          (*iSig)->OnAtmosCtrl(Packet);
00667          break;
00668       case CigiSignalType::SigCelestialCtrl:
00669          (*iSig)->OnCelestialCtrl(Packet);
00670          break;
00671       case CigiSignalType::SigSymbolSurfaceDef:
00672          (*iSig)->OnSymbolSurfaceDef(Packet);
00673          break;
00674       case CigiSignalType::SigSymbolCtrl:
00675          (*iSig)->OnSymbolCtrl(Packet);
00676          break;
00677       case CigiSignalType::SigShortSymbolCtrl:
00678          (*iSig)->OnShortSymbolCtrl(Packet);
00679          break;
00680       case CigiSignalType::SigSymbolTextDef:
00681          (*iSig)->OnSymbolTextDef(Packet);
00682          break;
00683       case CigiSignalType::SigSymbolCircleDef:
00684          (*iSig)->OnSymbolCircleDef(Packet);
00685          break;
00686       case CigiSignalType::SigSymbolLineDef:
00687          (*iSig)->OnSymbolLineDef(Packet);
00688          break;
00689       case CigiSignalType::SigSymbolClone:
00690          (*iSig)->OnSymbolClone(Packet);
00691          break;
00692       default:
00693          (*iSig)->OnUnrecognized(Packet);
00694          break;
00695       }
00696    }
00697 
00698    return(Processed);
00699 
00700 }
00701 
00702 
00703 
00704 // ====================================================================
00705 // Accessors
00706 // ====================================================================
00707 
00708 
00709 
00710 // ================================================
00711 // GetNextBuffToLoad
00712 // vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
00713 Cigi_uint8 *CigiIncomingMsg::GetNextBuffToLoad(void)
00714 {
00715    if(AvailBuff.empty())
00716    {
00717       CrntFillBuf = new CigiMessageBuffer(BufferSize);
00718    }
00719    else
00720    {
00721       CrntFillBuf = (*AvailBuff.begin());
00722       AvailBuff.pop_front();
00723    }
00724 
00725    if(CrntFillBuf != NULL)
00726    {
00727       Buffers.push_back(CrntFillBuf);
00728       CrntFillBuf->Active = true;
00729       CrntFillBuf->BufferFillCnt = 0;
00730       CrntFillBuf->DataPresent = false;
00731       CrntFillBuf->FillBufferPos = CrntFillBuf->Buffer;
00732       CrntFillBuf->Locked = false;
00733       CrntFillBuf->ValidIGCtrlSOF = false;
00734    }
00735 
00736    return(CrntFillBuf->Buffer);
00737 
00738 }
00739 
00740 
00741 // ================================================
00742 // AdvanceCrntBuffer
00743 // vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
00744 void CigiIncomingMsg::AdvanceCrntBuffer(void)
00745 {
00746 
00747    if(CrntMsgBuf != NULL)
00748    {
00749       if(!Buffers.empty())
00750       {
00751          list<CigiMessageBuffer *>::iterator iBuf = Buffers.begin();
00752          while(iBuf!=Buffers.end())
00753          {
00754             if(CrntMsgBuf == (*iBuf))
00755             {
00756                AvailBuff.push_back(CrntMsgBuf);
00757                iBuf = Buffers.erase(iBuf);
00758                break;
00759             }
00760             iBuf++;
00761          }
00762       }
00763    }
00764 
00765    if(Buffers.empty())
00766    {
00767       GetNextBuffToLoad();
00768    }
00769 
00770    CrntMsgBuf = (*Buffers.begin());
00771 
00772 }
00773 
00774 
00775 // ================================================
00776 // GetFirstPacket
00777 // vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
00778 CigiBasePacket * CigiIncomingMsg::GetFirstPacket()
00779 {
00780    bool Valid = true;
00781    CigiBasePacket *FirstPacket = NULL;
00782 
00783    if(!Iteration)
00784    {
00785 #ifndef CIGI_NO_EXCEPT
00786       throw CigiCalledOutOfSequenceException();
00787 #endif
00788       Valid = false;
00789    }
00790 
00791    int Size = CrntMsgBuf->BufferFillCnt;
00792 
00793    if((CrntMsgBuf == NULL) || (Size < 12))
00794    {
00795 #ifndef CIGI_NO_EXCEPT
00796       throw CigiImproperPacketException();
00797 #endif
00798       Valid = false;
00799    }
00800 
00801    if(Valid)
00802    {
00803       int stat = CheckFirstPacket(CrntMsgBuf->Buffer);
00804       if(stat != CIGI_SUCCESS)
00805          Valid = false;
00806    }
00807 
00808    Cigi_uint8 PacketID = 0;
00809    Cigi_uint8 PacketSize = 0;
00810 
00811    if(Valid)
00812    {
00813       CrntPacket = CrntMsgBuf->Buffer;
00814       ReadBufferPos = 0;
00815       PacketID = *CrntPacket;
00816       PacketSize = *(CrntPacket+1);
00817       Swap = false;
00818 
00819       FirstPacket = IncomingHandlerTbl[PacketID];
00820 
00821       CigiCnvtInfoType::Type CnvtDta;
00822       FirstPacket->GetCnvt(ReaderVersion,CnvtDta);
00823 
00824       if(Session->IsHost())
00825       {
00826          if(CnvtDta.ProcID == CigiProcessType::ProcSOF)
00827          {
00828             FirstPacket->Unpack(CrntPacket,false,NULL);
00829             Swap = ((CigiBaseSOF *)FirstPacket)->GetSwap();
00830          }
00831          else
00832          {
00833 #ifndef CIGI_NO_EXCEPT
00834             throw CigiImproperPacketException();
00835 #endif
00836             Valid = false;
00837          }
00838       }
00839       else
00840       {
00841          if(CnvtDta.ProcID == CigiProcessType::ProcIGCtrl)
00842          {
00843             FirstPacket->Unpack(CrntPacket,false,NULL);
00844             Swap = ((CigiBaseIGCtrl *)FirstPacket)->GetSwap();
00845          }
00846          else
00847          {
00848 #ifndef CIGI_NO_EXCEPT
00849             throw CigiImproperPacketException();
00850 #endif
00851             Valid = false;
00852          }
00853       }
00854    }
00855 
00856    if(Valid)
00857    {
00858       CrntPacket += PacketSize;
00859       ReadBufferPos += PacketSize;
00860    }
00861    else
00862       FirstPacket = NULL;
00863 
00864    return(FirstPacket);
00865 
00866 }
00867 
00868 // ================================================
00869 // GetNextPacket
00870 // vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
00871 CigiBasePacket * CigiIncomingMsg::GetNextPacket()
00872 {
00873    CigiBasePacket *tPckt = NULL;
00874    bool Valid = true;
00875 
00876    if((!Iteration) || (ReadBufferPos <= 0))
00877    {
00878 #ifndef CIGI_NO_EXCEPT
00879       throw CigiCalledOutOfSequenceException();
00880 #endif
00881       Valid = false;
00882    }
00883 
00884    if(CrntMsgBuf == NULL)
00885    {
00886 #ifndef CIGI_NO_EXCEPT
00887       throw CigiImproperPacketException();
00888 #endif
00889       Valid = false;
00890    }
00891 
00892    while((Valid) && (tPckt == NULL))
00893    {
00894       if(ReadBufferPos < CrntMsgBuf->BufferFillCnt)
00895       {
00896          Cigi_uint8 PacketID = *CrntPacket;
00897          Cigi_uint8 PacketSize = *(CrntPacket+1);
00898 
00899          CigiBasePacket *tPckt = IncomingHandlerTbl[PacketID];
00900 
00901          CigiCnvtInfoType::Type CnvtDta;
00902          tPckt->GetCnvt(ReaderVersion,CnvtDta);
00903 
00904          switch(CnvtDta.ProcID)
00905          {
00906          case CigiProcessType::ProcStd:   // Most Packets
00907          case CigiProcessType::ProcVarSize:
00908             tPckt->Unpack(CrntPacket,Swap,NULL);
00909             break;
00910 
00911          case CigiProcessType::ProcEntity:  // Entity Control Packets
00912             tPckt->Unpack(CrntPacket,Swap,ATbl);
00913             break;
00914 
00915          case CigiProcessType::ProcEnvCtrl:
00916             {
00917                // Environment Control Packets
00918                // Atmosphere Control Packets
00919                // & Celestial Sphere Control Packets
00920                // This will fill the Environment Control
00921                //   Hold Ojbect and pass that as the packet
00922                // The user will have to process that to get
00923                //   the needed data
00924                tPckt->Unpack(CrntPacket,Swap,&EnvHoldObj);
00925                CigiBaseEnvCtrl *pEnv = (CigiBaseEnvCtrl *)tPckt;
00926                pEnv->FillHold(&EnvHoldObj);
00927                tPckt = &EnvHoldObj;
00928             }
00929             break;
00930 
00931          case CigiProcessType::TwoPassCnvtProcNone:
00932          case CigiProcessType::TwoPassCnvtProcStd:
00933             // Packets requiring unpacking to determine
00934             //  final conversion method
00935             tPckt->Unpack(CrntPacket,Swap,NULL);
00936 
00937             tPckt->GetCnvt(ReaderVersion,CnvtDta);
00938 
00939             if(CnvtDta.ProcID != CigiProcessType::TwoPassCnvtProcStd)
00940                tPckt = NULL;
00941 
00942             break;
00943 
00944          default:
00945             tPckt = NULL;
00946             break;
00947          }
00948 
00949          // Go to the next packet
00950          CrntPacket += PacketSize;
00951          ReadBufferPos += PacketSize;
00952       }
00953       else
00954          Valid = false;
00955    }
00956 
00957 
00958    return(tPckt);
00959 
00960 }
00961 
00962 // ================================================
00963 // RegisterEventProcessor
00964 // vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
00965 int CigiIncomingMsg::RegisterEventProcessor(int PacketID, CigiBaseEventProcessor *EventMgr)
00966 {
00967 
00968    if((PacketID < 0)||(PacketID > 256))
00969    {
00970 #ifndef CIGI_NO_EXCEPT
00971       throw CigiValueOutOfRangeException("PacketID",PacketID,0,256);
00972 #endif
00973       return(CIGI_ERROR_VALUE_OUT_OF_RANGE);
00974    }
00975 
00976    if(EventMgr == NULL)
00977    {
00978 #ifndef CIGI_NO_EXCEPT
00979       throw CigiNullPointerException();
00980 #endif
00981       return(CIGI_ERROR_UNEXPECTED_NULL);
00982    }
00983 
00984    EventList[PacketID].push_back(EventMgr);
00985 
00986    return(CIGI_SUCCESS);
00987 
00988 }
00989 
00990 // ================================================
00991 // UnregisterEventProcessor
00992 // vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
00993 int CigiIncomingMsg::UnregisterEventProcessor(int PacketID, CigiBaseEventProcessor *EventMgr)
00994 {
00995 
00996    if((PacketID < 0)||(PacketID > 256))
00997    {
00998 #ifndef CIGI_NO_EXCEPT
00999       throw CigiValueOutOfRangeException("PacketID",PacketID,0,256);
01000 #endif
01001       return(CIGI_ERROR_VALUE_OUT_OF_RANGE);
01002    }
01003 
01004    if(EventMgr == NULL)
01005    {
01006 #ifndef CIGI_NO_EXCEPT
01007       throw CigiNullPointerException();
01008 #endif
01009       return(CIGI_ERROR_UNEXPECTED_NULL);
01010    }
01011 
01012    list<CigiBaseEventProcessor *>::iterator iEvent = EventList[PacketID].begin();
01013 
01014    while(iEvent != EventList[PacketID].end())
01015    {
01016       if((*iEvent) == EventMgr)
01017       {
01018          iEvent = EventList[PacketID].erase(iEvent);
01019          break;
01020       }
01021    }
01022 
01023    return(CIGI_SUCCESS);
01024 
01025 }
01026 
01027 // ================================================
01028 // RegisterCallBack
01029 // vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
01030 int CigiIncomingMsg::RegisterCallBack(int PacketID, CigiCBProcessor CallBack)
01031 {
01032 
01033    if((PacketID < 0)||(PacketID > 256))
01034    {
01035 #ifndef CIGI_NO_EXCEPT
01036       throw CigiValueOutOfRangeException("PacketID",PacketID,0,256);
01037 #endif
01038       return(CIGI_ERROR_VALUE_OUT_OF_RANGE);
01039    }
01040 
01041    if(CallBack == NULL)
01042    {
01043 #ifndef CIGI_NO_EXCEPT
01044       throw CigiNullPointerException();
01045 #endif
01046       return(CIGI_ERROR_UNEXPECTED_NULL);
01047    }
01048 
01049    CallBackList[PacketID].push_back(CallBack);
01050 
01051    return(CIGI_SUCCESS);
01052 
01053 }
01054 
01055 // ================================================
01056 // UnregisterCallBack
01057 // vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
01058 int CigiIncomingMsg::UnregisterCallBack(int PacketID, CigiCBProcessor CallBack)
01059 {
01060 
01061    if((PacketID < 0)||(PacketID > 256))
01062    {
01063 #ifndef CIGI_NO_EXCEPT
01064       throw CigiValueOutOfRangeException("PacketID",PacketID,0,256);
01065 #endif
01066       return(CIGI_ERROR_VALUE_OUT_OF_RANGE);
01067    }
01068 
01069    if(CallBack == NULL)
01070    {
01071 #ifndef CIGI_NO_EXCEPT
01072       throw CigiNullPointerException();
01073 #endif
01074       return(CIGI_ERROR_UNEXPECTED_NULL);
01075    }
01076 
01077    list<CigiCBProcessor>::iterator iCB = CallBackList[PacketID].begin();
01078 
01079    while(iCB != CallBackList[PacketID].end())
01080    {
01081       if((*iCB) == CallBack)
01082       {
01083          iCB = CallBackList[PacketID].erase(iCB);
01084          break;
01085       }
01086    }
01087 
01088    return(CIGI_SUCCESS);
01089 
01090 }
01091 
01092 // ================================================
01093 // RegisterSignalProcessor
01094 // vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
01095 int CigiIncomingMsg::RegisterSignalProcessor(CigiBaseSignalProcessing *SignalMgr)
01096 {
01097    if(SignalMgr == NULL)
01098    {
01099 #ifndef CIGI_NO_EXCEPT
01100       throw CigiNullPointerException();
01101 #endif
01102       return(CIGI_ERROR_UNEXPECTED_NULL);
01103    }
01104 
01105    SignalList.push_back(SignalMgr);
01106 
01107    return(CIGI_SUCCESS);
01108 
01109 }
01110 
01111 // ================================================
01112 // UnregisterSignalProcessor
01113 // vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
01114 int CigiIncomingMsg::UnregisterSignalProcessor(CigiBaseSignalProcessing *SignalMgr)
01115 {
01116    if(SignalMgr == NULL)
01117    {
01118 #ifndef CIGI_NO_EXCEPT
01119       throw CigiNullPointerException();
01120 #endif
01121       return(CIGI_ERROR_UNEXPECTED_NULL);
01122    }
01123 
01124    list<CigiBaseSignalProcessing *>::iterator iSig = SignalList.begin();
01125 
01126    while(iSig != SignalList.end())
01127    {
01128       if((*iSig) == SignalMgr)
01129       {
01130          iSig = SignalList.erase(iSig);
01131          break;
01132       }
01133    }
01134 
01135    return(CIGI_SUCCESS);
01136 
01137 }
01138 
01139 
01140 // ================================================
01141 // RegisterUserPacket
01142 // vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
01143 int CigiIncomingMsg::RegisterUserPacket(CigiBasePacket *Packet,
01144                                         Cigi_uint8 PacketID,
01145                                         bool HostSend,
01146                                         bool IGSend)
01147 {
01148    int stat = CIGI_ERROR_INVALID_USER_PACKET;
01149    if(((PacketID > 199) && (PacketID <= 255)) &&
01150       (Packet != NULL) &&
01151       ((HostSend && Session->IsIG()) ||
01152       (IGSend && Session->IsHost())))
01153    {
01154       IncomingHandlerTbl[PacketID] = Packet;
01155       stat = CIGI_SUCCESS;
01156    }
01157 
01158    return(stat);
01159 }
01160 
01161 
01162 // ================================================
01163 // Clear Tables
01164 // vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
01165 void CigiIncomingMsg::ClearTbls(bool Complete)
01166 {
01167    int ndx = 0;
01168 
01169    for(ndx=0;ndx<200;ndx++)
01170    {
01171       if(IncomingHandlerTbl[ndx] != (CigiBasePacket *)DefaultPckt)
01172       {
01173          delete IncomingHandlerTbl[ndx];
01174          IncomingHandlerTbl[ndx] = (CigiBasePacket *)DefaultPckt;
01175       }
01176    }
01177 
01178    if(Complete)
01179    {
01180       for(ndx=200;ndx<256;ndx++)
01181       {
01182          if(IncomingHandlerTbl[ndx] != (CigiBasePacket *)DefaultPckt)
01183          {
01184             delete IncomingHandlerTbl[ndx];
01185             IncomingHandlerTbl[ndx] = (CigiBasePacket *)DefaultPckt;
01186          }
01187       }
01188    }
01189 }
01190 
01191 
01192 // ================================================
01193 // SetIncomingV1Tbls
01194 // vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
01195 void CigiIncomingMsg::SetIncomingIGV1Tbls(void)
01196 {
01197 
01198    IncomingHandlerTbl[CIGI_IG_CTRL_PACKET_ID_V1] = (CigiBasePacket *) new CigiIGCtrlV1;
01199    IncomingHandlerTbl[CIGI_ENTITY_CTRL_PACKET_ID_V1] = (CigiBasePacket *) new CigiEntityCtrlV1;
01200    IncomingHandlerTbl[CIGI_VIEW_DEF_PACKET_ID_V1] = (CigiBasePacket *) new CigiViewDefV1;
01201    IncomingHandlerTbl[CIGI_VIEW_CTRL_PACKET_ID_V1] = (CigiBasePacket *) new CigiViewCtrlV1;
01202    IncomingHandlerTbl[CIGI_RATE_CTRL_PACKET_ID_V1] = (CigiBasePacket *) new CigiRateCtrlV1;
01203    IncomingHandlerTbl[CIGI_SENSOR_CTRL_PACKET_ID_V1] = (CigiBasePacket *) new CigiSensorCtrlV1;
01204    IncomingHandlerTbl[CIGI_TRAJECTORY_DEF_PACKET_ID_V1] = (CigiBasePacket *) new CigiTrajectoryDefV1;
01205    IncomingHandlerTbl[CIGI_WEATHER_CTRL_PACKET_ID_V1] = (CigiBasePacket *) new CigiWeatherCtrlV1;
01206    IncomingHandlerTbl[CIGI_COLL_DET_SEG_DEF_PACKET_ID_V1] = (CigiBasePacket *) new CigiCollDetSegDefV1;
01207    IncomingHandlerTbl[CIGI_LOS_SEG_REQ_PACKET_ID_V1] = (CigiBasePacket *) new CigiLosSegReqV1;
01208    IncomingHandlerTbl[CIGI_LOS_VECT_REQ_PACKET_ID_V1] = (CigiBasePacket *) new CigiLosVectReqV1;
01209    IncomingHandlerTbl[CIGI_HAT_REQ_PACKET_ID_V1] = (CigiBasePacket *) new CigiHatReqV1;
01210    IncomingHandlerTbl[CIGI_ENV_CTRL_PACKET_ID_V1] = (CigiBasePacket *) new CigiEnvCtrlV1;
01211    IncomingHandlerTbl[CIGI_SPEC_EFF_DEF_PACKET_ID_V1] = (CigiBasePacket *) new CigiSpecEffDefV1;
01212    IncomingHandlerTbl[CIGI_ART_PART_CTRL_PACKET_ID_V1] = (CigiBasePacket *) new CigiArtPartCtrlV1;
01213    IncomingHandlerTbl[CIGI_COMP_CTRL_PACKET_ID_V1] = (CigiBasePacket *) new CigiCompCtrlV1;
01214 
01215 }
01216 
01217 
01218 // ================================================
01219 // SetIncomingV1Tbls
01220 // vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
01221 void CigiIncomingMsg::SetIncomingHostV1Tbls(void)
01222 {
01223 
01224    IncomingHandlerTbl[CIGI_SOF_PACKET_ID_V1] = (CigiBasePacket *) new CigiSOFV1;
01225    IncomingHandlerTbl[CIGI_COLL_DET_SEG_RESP_PACKET_ID_V1] = (CigiBasePacket *) new CigiCollDetSegRespV1;
01226    IncomingHandlerTbl[CIGI_SENSOR_RESP_PACKET_ID_V1] = (CigiBasePacket *) new CigiSensorRespV1;
01227    IncomingHandlerTbl[CIGI_LOS_RESP_PACKET_ID_V1] = (CigiBasePacket *) new CigiLosRespV1;
01228    IncomingHandlerTbl[CIGI_HAT_RESP_PACKET_ID_V1] = (CigiBasePacket *) new CigiHatRespV1;
01229 
01230 }
01231 
01232 
01233 // ================================================
01234 // SetIncomingV2Tbls
01235 // vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
01236 void CigiIncomingMsg::SetIncomingIGV2Tbls(void)
01237 {
01238 
01239    IncomingHandlerTbl[CIGI_IG_CTRL_PACKET_ID_V2] = (CigiBasePacket *) new CigiIGCtrlV2;
01240    IncomingHandlerTbl[CIGI_ENTITY_CTRL_PACKET_ID_V2] = (CigiBasePacket *) new CigiEntityCtrlV2;
01241    IncomingHandlerTbl[CIGI_VIEW_DEF_PACKET_ID_V2] = (CigiBasePacket *) new CigiViewDefV2;
01242    IncomingHandlerTbl[CIGI_VIEW_CTRL_PACKET_ID_V2] = (CigiBasePacket *) new CigiViewCtrlV2;
01243    IncomingHandlerTbl[CIGI_RATE_CTRL_PACKET_ID_V2] = (CigiBasePacket *) new CigiRateCtrlV2;
01244    IncomingHandlerTbl[CIGI_SENSOR_CTRL_PACKET_ID_V2] = (CigiBasePacket *) new CigiSensorCtrlV2;
01245    IncomingHandlerTbl[CIGI_TRAJECTORY_DEF_PACKET_ID_V2] = (CigiBasePacket *) new CigiTrajectoryDefV2;
01246    IncomingHandlerTbl[CIGI_WEATHER_CTRL_PACKET_ID_V2] = (CigiBasePacket *) new CigiWeatherCtrlV2;
01247    IncomingHandlerTbl[CIGI_COLL_DET_SEG_DEF_PACKET_ID_V2] = (CigiBasePacket *) new CigiCollDetSegDefV2;
01248    IncomingHandlerTbl[CIGI_LOS_SEG_REQ_PACKET_ID_V2] = (CigiBasePacket *) new CigiLosSegReqV2;
01249    IncomingHandlerTbl[CIGI_LOS_VECT_REQ_PACKET_ID_V2] = (CigiBasePacket *) new CigiLosVectReqV2;
01250    IncomingHandlerTbl[CIGI_HAT_REQ_PACKET_ID_V2] = (CigiBasePacket *) new CigiHatReqV2;
01251    IncomingHandlerTbl[CIGI_HOT_REQ_PACKET_ID_V2] = (CigiBasePacket *) new CigiHotReqV2;
01252    IncomingHandlerTbl[CIGI_ENV_CTRL_PACKET_ID_V2] = (CigiBasePacket *) new CigiEnvCtrlV2;
01253    IncomingHandlerTbl[CIGI_SPEC_EFF_DEF_PACKET_ID_V2] = (CigiBasePacket *) new CigiSpecEffDefV2;
01254    IncomingHandlerTbl[CIGI_ART_PART_CTRL_PACKET_ID_V2] = (CigiBasePacket *) new CigiArtPartCtrlV2;
01255    IncomingHandlerTbl[CIGI_COLL_DET_VOL_DEF_PACKET_ID_V2] = (CigiBasePacket *) new CigiCollDetVolDefV2;
01256    IncomingHandlerTbl[CIGI_COMP_CTRL_PACKET_ID_V2] = (CigiBasePacket *) new CigiCompCtrlV2;
01257 
01258 }
01259 
01260 
01261 // ================================================
01262 // SetIncomingV2Tbls
01263 // vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
01264 void CigiIncomingMsg::SetIncomingHostV2Tbls(void)
01265 {
01266 
01267    IncomingHandlerTbl[CIGI_SOF_PACKET_ID_V2] = (CigiBasePacket *) new CigiSOFV2;
01268    IncomingHandlerTbl[CIGI_COLL_DET_SEG_RESP_PACKET_ID_V2] = (CigiBasePacket *) new CigiCollDetSegRespV2;
01269    IncomingHandlerTbl[CIGI_SENSOR_RESP_PACKET_ID_V2] = (CigiBasePacket *) new CigiSensorRespV2;
01270    IncomingHandlerTbl[CIGI_LOS_RESP_PACKET_ID_V2] = (CigiBasePacket *) new CigiLosRespV2;
01271    IncomingHandlerTbl[CIGI_HAT_RESP_PACKET_ID_V2] = (CigiBasePacket *) new CigiHatRespV2;
01272    IncomingHandlerTbl[CIGI_HOT_RESP_PACKET_ID_V2] = (CigiBasePacket *) new CigiHotRespV2;
01273    IncomingHandlerTbl[CIGI_COLL_DET_VOL_RESP_PACKET_ID_V2] = (CigiBasePacket *) new CigiCollDetVolRespV2;
01274    IncomingHandlerTbl[CIGI_IG_MSG_PACKET_ID_V2] = (CigiBasePacket *) new CigiIGMsgV2;
01275 
01276 }
01277 
01278 
01279 // ================================================
01280 // SetIncomingV3Tbls
01281 // vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
01282 void CigiIncomingMsg::SetIncomingIGV3Tbls(void)
01283 {
01284 
01285    if(ProcessingVersion.CigiMinorVersion >= 2)
01286    {
01287       if(ProcessingVersion.CigiMinorVersion >= 3)
01288       {
01289          IncomingHandlerTbl[CIGI_IG_CTRL_PACKET_ID_V3_3] = (CigiBasePacket *) new CigiIGCtrlV3_3;
01290          IncomingHandlerTbl[CIGI_ENTITY_CTRL_PACKET_ID_V3_3] = (CigiBasePacket *) new CigiEntityCtrlV3_3;
01291          IncomingHandlerTbl[CIGI_SYMBOL_SURFACE_DEF_PACKET_ID_V3_3] = (CigiBasePacket *) new CigiSymbolSurfaceDefV3_3;
01292          IncomingHandlerTbl[CIGI_SYMBOL_CONTROL_PACKET_ID_V3_3] = (CigiBasePacket *) new CigiSymbolCtrlV3_3;
01293          IncomingHandlerTbl[CIGI_SHORT_SYMBOL_CONTROL_PACKET_ID_V3_3] = (CigiBasePacket *) new CigiShortSymbolCtrlV3_3;
01294          IncomingHandlerTbl[CIGI_SYMBOL_TEXT_DEFINITION_PACKET_ID_V3_3] = (CigiBasePacket *) new CigiSymbolTextDefV3_3;
01295          IncomingHandlerTbl[CIGI_SYMBOL_CIRCLE_DEFINITION_PACKET_ID_V3_3] = (CigiBasePacket *) new CigiSymbolCircleDefV3_3;
01296          IncomingHandlerTbl[CIGI_SYMBOL_LINE_DEFINITION_PACKET_ID_V3_3] = (CigiBasePacket *) new CigiSymbolLineDefV3_3;
01297          IncomingHandlerTbl[CIGI_SYMBOL_CLONE_PACKET_ID_V3_3] = (CigiBasePacket *) new CigiSymbolCloneV3_3;
01298          IncomingHandlerTbl[CIGI_COMP_CTRL_PACKET_ID_V3_3] = (CigiBasePacket *) new CigiCompCtrlV3_3;
01299          IncomingHandlerTbl[CIGI_SHORT_COMP_CTRL_PACKET_ID_V3_3] = (CigiBasePacket *) new CigiShortCompCtrlV3_3;
01300       }
01301       else
01302       {
01303          IncomingHandlerTbl[CIGI_IG_CTRL_PACKET_ID_V3_2] = (CigiBasePacket *) new CigiIGCtrlV3_2;
01304          IncomingHandlerTbl[CIGI_ENTITY_CTRL_PACKET_ID_V3] = (CigiBasePacket *) new CigiEntityCtrlV3;
01305          IncomingHandlerTbl[CIGI_COMP_CTRL_PACKET_ID_V3] = (CigiBasePacket *) new CigiCompCtrlV3;
01306          IncomingHandlerTbl[CIGI_SHORT_COMP_CTRL_PACKET_ID_V3] = (CigiBasePacket *) new CigiShortCompCtrlV3;
01307       }
01308       IncomingHandlerTbl[CIGI_RATE_CTRL_PACKET_ID_V3] = (CigiBasePacket *) new CigiRateCtrlV3_2;
01309       IncomingHandlerTbl[CIGI_HAT_HOT_REQ_PACKET_ID_V3] = (CigiBasePacket *) new CigiHatHotReqV3_2;
01310       IncomingHandlerTbl[CIGI_LOS_SEG_REQ_PACKET_ID_V3] = (CigiBasePacket *) new CigiLosSegReqV3_2;
01311       IncomingHandlerTbl[CIGI_LOS_VECT_REQ_PACKET_ID_V3] = (CigiBasePacket *) new CigiLosVectReqV3_2;
01312    }
01313    else
01314    {
01315       IncomingHandlerTbl[CIGI_IG_CTRL_PACKET_ID_V3] = (CigiBasePacket *) new CigiIGCtrlV3;
01316       IncomingHandlerTbl[CIGI_ENTITY_CTRL_PACKET_ID_V3] = (CigiBasePacket *) new CigiEntityCtrlV3;
01317       IncomingHandlerTbl[CIGI_RATE_CTRL_PACKET_ID_V3] = (CigiBasePacket *) new CigiRateCtrlV3;
01318       IncomingHandlerTbl[CIGI_HAT_HOT_REQ_PACKET_ID_V3] = (CigiBasePacket *) new CigiHatHotReqV3;
01319       IncomingHandlerTbl[CIGI_LOS_SEG_REQ_PACKET_ID_V3] = (CigiBasePacket *) new CigiLosSegReqV3;
01320       IncomingHandlerTbl[CIGI_LOS_VECT_REQ_PACKET_ID_V3] = (CigiBasePacket *) new CigiLosVectReqV3;
01321       IncomingHandlerTbl[CIGI_COMP_CTRL_PACKET_ID_V3] = (CigiBasePacket *) new CigiCompCtrlV3;
01322       IncomingHandlerTbl[CIGI_SHORT_COMP_CTRL_PACKET_ID_V3] = (CigiBasePacket *) new CigiShortCompCtrlV3;
01323    }
01324 
01325    IncomingHandlerTbl[CIGI_VIEW_DEF_PACKET_ID_V3] = (CigiBasePacket *) new CigiViewDefV3;
01326    IncomingHandlerTbl[CIGI_VIEW_CTRL_PACKET_ID_V3] = (CigiBasePacket *) new CigiViewCtrlV3;
01327    IncomingHandlerTbl[CIGI_SENSOR_CTRL_PACKET_ID_V3] = (CigiBasePacket *) new CigiSensorCtrlV3;
01328    IncomingHandlerTbl[CIGI_TRAJECTORY_DEF_PACKET_ID_V3] = (CigiBasePacket *) new CigiTrajectoryDefV3;
01329    IncomingHandlerTbl[CIGI_WEATHER_CTRL_PACKET_ID_V3] = (CigiBasePacket *) new CigiWeatherCtrlV3;
01330    IncomingHandlerTbl[CIGI_COLL_DET_SEG_DEF_PACKET_ID_V3] = (CigiBasePacket *) new CigiCollDetSegDefV3;
01331    IncomingHandlerTbl[CIGI_ATMOS_CTRL_PACKET_ID_V3] = (CigiBasePacket *) new CigiAtmosCtrlV3;
01332    IncomingHandlerTbl[CIGI_CELESTIAL_CTRL_PACKET_ID_V3] = (CigiBasePacket *) new CigiCelestialCtrlV3;
01333    IncomingHandlerTbl[CIGI_ART_PART_CTRL_PACKET_ID_V3] = (CigiBasePacket *) new CigiArtPartCtrlV3;
01334    IncomingHandlerTbl[CIGI_COLL_DET_VOL_DEF_PACKET_ID_V3] = (CigiBasePacket *) new CigiCollDetVolDefV3;
01335    IncomingHandlerTbl[CIGI_SHORT_ART_PART_CTRL_PACKET_ID_V3] = (CigiBasePacket *) new CigiShortArtPartCtrlV3;
01336    IncomingHandlerTbl[CIGI_CONF_CLAMP_ENTITY_CTRL_PACKET_ID_V3] = (CigiBasePacket *) new CigiConfClampEntityCtrlV3;
01337    IncomingHandlerTbl[CIGI_MARITIME_SURFACE_CTRL_PACKET_ID_V3] = (CigiBasePacket *) new CigiMaritimeSurfaceCtrlV3;
01338    IncomingHandlerTbl[CIGI_ENV_RGN_CTRL_PACKET_ID_V3] = (CigiBasePacket *) new CigiEnvRgnCtrlV3;
01339    IncomingHandlerTbl[CIGI_TERRESTRIAL_SURFACE_CTRL_PACKET_ID_V3] = (CigiBasePacket *) new CigiTerrestrialSurfaceCtrlV3;
01340    IncomingHandlerTbl[CIGI_MOTION_TRACK_CTRL_PACKET_ID_V3] = (CigiBasePacket *) new CigiMotionTrackCtrlV3;
01341    IncomingHandlerTbl[CIGI_EARTH_MODEL_DEF_PACKET_ID_V3] = (CigiBasePacket *) new CigiEarthModelDefV3;
01342    IncomingHandlerTbl[CIGI_POSITION_REQ_PACKET_ID_V3] = (CigiBasePacket *) new CigiPositionReqV3;
01343    IncomingHandlerTbl[CIGI_ENV_COND_REQ_PACKET_ID_V3] = (CigiBasePacket *) new CigiEnvCondReqV3;
01344    IncomingHandlerTbl[CIGI_WAVE_CTRL_PACKET_ID_V3] = (CigiBasePacket *) new CigiWaveCtrlV3;
01345 
01346 }
01347 
01348 
01349 // ================================================
01350 // SetIncomingV3Tbls
01351 // vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
01352 void CigiIncomingMsg::SetIncomingHostV3Tbls(void)
01353 {
01354 
01355    if(ProcessingVersion.CigiMinorVersion >= 2)
01356    {
01357       IncomingHandlerTbl[CIGI_SOF_PACKET_ID_V3] = (CigiBasePacket *) new CigiSOFV3_2;
01358       IncomingHandlerTbl[CIGI_LOS_RESP_PACKET_ID_V3] = (CigiBasePacket *) new CigiLosRespV3_2;
01359       IncomingHandlerTbl[CIGI_LOS_XRESP_PACKET_ID_V3] = (CigiBasePacket *) new CigiLosXRespV3_2;
01360       IncomingHandlerTbl[CIGI_HAT_HOT_RESP_PACKET_ID_V3] = (CigiBasePacket *) new CigiHatHotRespV3_2;
01361       IncomingHandlerTbl[CIGI_HAT_HOT_XRESP_PACKET_ID_V3] = (CigiBasePacket *) new CigiHatHotXRespV3_2;
01362    }
01363    else
01364    {
01365       IncomingHandlerTbl[CIGI_SOF_PACKET_ID_V3] = (CigiBasePacket *) new CigiSOFV3;
01366       IncomingHandlerTbl[CIGI_LOS_RESP_PACKET_ID_V3] = (CigiBasePacket *) new CigiLosRespV3;
01367       IncomingHandlerTbl[CIGI_LOS_XRESP_PACKET_ID_V3] = (CigiBasePacket *) new CigiLosXRespV3;
01368       IncomingHandlerTbl[CIGI_HAT_HOT_RESP_PACKET_ID_V3] = (CigiBasePacket *) new CigiHatHotRespV3;
01369       IncomingHandlerTbl[CIGI_HAT_HOT_XRESP_PACKET_ID_V3] = (CigiBasePacket *) new CigiHatHotXRespV3;
01370    }
01371 
01372    IncomingHandlerTbl[CIGI_COLL_DET_SEG_RESP_PACKET_ID_V3] = (CigiBasePacket *) new CigiCollDetSegRespV3;
01373    IncomingHandlerTbl[CIGI_SENSOR_RESP_PACKET_ID_V3] = (CigiBasePacket *) new CigiSensorRespV3;
01374    IncomingHandlerTbl[CIGI_SENSOR_XRESP_PACKET_ID_V3] = (CigiBasePacket *) new CigiSensorXRespV3;
01375    IncomingHandlerTbl[CIGI_COLL_DET_VOL_RESP_PACKET_ID_V3] = (CigiBasePacket *) new CigiCollDetVolRespV3;
01376    IncomingHandlerTbl[CIGI_POSITION_RESP_PACKET_ID_V3] = (CigiBasePacket *) new CigiPositionRespV3;
01377    IncomingHandlerTbl[CIGI_WEATHER_COND_RESP_PACKET_ID_V3] = (CigiBasePacket *) new CigiWeatherCondRespV3;
01378    IncomingHandlerTbl[CIGI_AEROSOL_RESP_PACKET_ID_V3] = (CigiBasePacket *) new CigiAerosolRespV3;
01379    IncomingHandlerTbl[CIGI_MARITIME_SURFACE_RESP_PACKET_ID_V3] = (CigiBasePacket *) new CigiMaritimeSurfaceRespV3;
01380    IncomingHandlerTbl[CIGI_TERRESTRIAL_SURFACE_RESP_PACKET_ID_V3] = (CigiBasePacket *) new CigiTerrestrialSurfaceRespV3;
01381    IncomingHandlerTbl[CIGI_ANIMATION_STOP_PACKET_ID_V3] = (CigiBasePacket *) new CigiAnimationStopV3;
01382    IncomingHandlerTbl[CIGI_EVENT_NOTIFICATION_PACKET_ID_V3] = (CigiBasePacket *) new CigiEventNotificationV3;
01383    IncomingHandlerTbl[CIGI_IG_MSG_PACKET_ID_V3] = (CigiBasePacket *) new CigiIGMsgV3;
01384 
01385 }
01386 
01387 
01388 // ================================================
01389 // SetReaderVersion
01390 // vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
01391 void CigiIncomingMsg::SetReaderVersion(CigiVersionID &Version)
01392 {
01393 
01394    bool ChangeTbl = false;
01395 
01396    if((Version.CigiMajorVersion != ReaderVersion.CigiMajorVersion) ||
01397       (Version.CigiMinorVersion != ReaderVersion.CigiMinorVersion))
01398    {
01399       if(Version.IsKnownCigiVersion())
01400       {
01401          // Due to the way the system is organized at this time,
01402          // the tables only need to change if the major version
01403          // is changed.
01404          if(Version.CigiMajorVersion != ReaderVersion.CigiMajorVersion)
01405             ChangeTbl = true;
01406 
01407          ReaderVersion = Version;
01408       }
01409    }
01410 
01411    if(ChangeTbl)
01412    {
01413       // Clear the Signal Table
01414       for(int ndx=0;ndx<256;ndx++)
01415       {
01416          SignalTbl[ndx] = CigiSignalType::SigNone;
01417       }
01418 
01419       // Set the correct table values
01420       if(ReaderVersion.CigiMajorVersion >= 3)
01421       {
01422          if(Session->IsHost())
01423          {
01424             SignalTbl[CIGI_SOF_PACKET_ID_V3] = CigiSignalType::SigSOF;
01425             SignalTbl[CIGI_LOS_RESP_PACKET_ID_V3] = CigiSignalType::SigLosResp;
01426             SignalTbl[CIGI_LOS_XRESP_PACKET_ID_V3] = CigiSignalType::SigLosXResp;
01427             SignalTbl[CIGI_HAT_HOT_RESP_PACKET_ID_V3] = CigiSignalType::SigHatHotResp;
01428             SignalTbl[CIGI_HAT_HOT_XRESP_PACKET_ID_V3] = CigiSignalType::SigHatHotXResp;
01429             SignalTbl[CIGI_COLL_DET_SEG_RESP_PACKET_ID_V3] = CigiSignalType::SigCollDetSegResp;
01430             SignalTbl[CIGI_SENSOR_RESP_PACKET_ID_V3] = CigiSignalType::SigSensorResp;
01431             SignalTbl[CIGI_SENSOR_XRESP_PACKET_ID_V3] = CigiSignalType::SigSensorXResp;
01432             SignalTbl[CIGI_COLL_DET_VOL_RESP_PACKET_ID_V3] = CigiSignalType::SigCollDetVolResp;
01433             SignalTbl[CIGI_POSITION_RESP_PACKET_ID_V3] = CigiSignalType::SigPositionResp;
01434             SignalTbl[CIGI_WEATHER_COND_RESP_PACKET_ID_V3] = CigiSignalType::SigWeatherCondResp;
01435             SignalTbl[CIGI_AEROSOL_RESP_PACKET_ID_V3] = CigiSignalType::SigAerosolResp;
01436             SignalTbl[CIGI_MARITIME_SURFACE_RESP_PACKET_ID_V3] = CigiSignalType::SigMaritimeSurfaceResp;
01437             SignalTbl[CIGI_TERRESTRIAL_SURFACE_RESP_PACKET_ID_V3] = CigiSignalType::SigTerrestrialSurfaceResp;
01438             SignalTbl[CIGI_ANIMATION_STOP_PACKET_ID_V3] = CigiSignalType::SigAnimationStop;
01439             SignalTbl[CIGI_EVENT_NOTIFICATION_PACKET_ID_V3] = CigiSignalType::SigEventNotification;
01440             SignalTbl[CIGI_IG_MSG_PACKET_ID_V3] = CigiSignalType::SigIGMsg;
01441          }
01442          else
01443          {
01444             SignalTbl[CIGI_IG_CTRL_PACKET_ID_V3] = CigiSignalType::SigIGCtrl;
01445             SignalTbl[CIGI_RATE_CTRL_PACKET_ID_V3] = CigiSignalType::SigRateCtrl;
01446             SignalTbl[CIGI_HAT_HOT_REQ_PACKET_ID_V3] = CigiSignalType::SigHatHotReq;
01447             SignalTbl[CIGI_LOS_SEG_REQ_PACKET_ID_V3] = CigiSignalType::SigLosSegReq;
01448             SignalTbl[CIGI_LOS_VECT_REQ_PACKET_ID_V3] = CigiSignalType::SigLosVectReq;
01449 
01450             SignalTbl[CIGI_ENTITY_CTRL_PACKET_ID_V3] = CigiSignalType::SigEntityCtrl;
01451             SignalTbl[CIGI_VIEW_DEF_PACKET_ID_V3] = CigiSignalType::SigViewDef;
01452             SignalTbl[CIGI_VIEW_CTRL_PACKET_ID_V3] = CigiSignalType::SigViewCtrl;
01453             SignalTbl[CIGI_SENSOR_CTRL_PACKET_ID_V3] = CigiSignalType::SigSensorCtrl;
01454             SignalTbl[CIGI_TRAJECTORY_DEF_PACKET_ID_V3] = CigiSignalType::SigTrajectory;
01455             SignalTbl[CIGI_WEATHER_CTRL_PACKET_ID_V3] = CigiSignalType::SigWeatherCtrl;
01456             SignalTbl[CIGI_COLL_DET_SEG_DEF_PACKET_ID_V3] = CigiSignalType::SigCollDetSegDef;
01457             SignalTbl[CIGI_ATMOS_CTRL_PACKET_ID_V3] = CigiSignalType::SigAtmosCtrl;
01458             SignalTbl[CIGI_CELESTIAL_CTRL_PACKET_ID_V3] = CigiSignalType::SigCelestialCtrl;
01459             SignalTbl[CIGI_ART_PART_CTRL_PACKET_ID_V3] = CigiSignalType::SigArtPartCtrl;
01460             SignalTbl[CIGI_COLL_DET_VOL_DEF_PACKET_ID_V3] = CigiSignalType::SigCollDetVolDef;
01461             SignalTbl[CIGI_SHORT_ART_PART_CTRL_PACKET_ID_V3] = CigiSignalType::SigShortArtPartCtrl;
01462             SignalTbl[CIGI_CONF_CLAMP_ENTITY_CTRL_PACKET_ID_V3] = CigiSignalType::SigConfClampEntityCtrl;
01463             SignalTbl[CIGI_MARITIME_SURFACE_CTRL_PACKET_ID_V3] = CigiSignalType::SigMaritimeSurfaceCtrl;
01464             SignalTbl[CIGI_ENV_RGN_CTRL_PACKET_ID_V3] = CigiSignalType::SigEnvRgnCtrl;
01465             SignalTbl[CIGI_TERRESTRIAL_SURFACE_CTRL_PACKET_ID_V3] = CigiSignalType::SigTerrestrialSurfaceCtrl;
01466             SignalTbl[CIGI_MOTION_TRACK_CTRL_PACKET_ID_V3] = CigiSignalType::SigMotionTrackCtrl;
01467             SignalTbl[CIGI_EARTH_MODEL_DEF_PACKET_ID_V3] = CigiSignalType::SigEarthModelDef;
01468             SignalTbl[CIGI_POSITION_REQ_PACKET_ID_V3] = CigiSignalType::SigPostionReq;
01469             SignalTbl[CIGI_ENV_COND_REQ_PACKET_ID_V3] = CigiSignalType::SigEnvCondReq;
01470             SignalTbl[CIGI_WAVE_CTRL_PACKET_ID_V3] = CigiSignalType::SigWaveCtrl;
01471             SignalTbl[CIGI_COMP_CTRL_PACKET_ID_V3] = CigiSignalType::SigCompCtrl;
01472             SignalTbl[CIGI_SHORT_COMP_CTRL_PACKET_ID_V3] = CigiSignalType::SigShortCompCtrl;
01473 
01474             SignalTbl[CIGI_SYMBOL_SURFACE_DEF_PACKET_ID_V3_3] = CigiSignalType::SigSymbolSurfaceDef;
01475             SignalTbl[CIGI_SYMBOL_CONTROL_PACKET_ID_V3_3] = CigiSignalType::SigSymbolCtrl;
01476             SignalTbl[CIGI_SHORT_SYMBOL_CONTROL_PACKET_ID_V3_3] = CigiSignalType::SigShortSymbolCtrl;
01477             SignalTbl[CIGI_SYMBOL_TEXT_DEFINITION_PACKET_ID_V3_3] = CigiSignalType::SigSymbolTextDef;
01478             SignalTbl[CIGI_SYMBOL_CIRCLE_DEFINITION_PACKET_ID_V3_3] = CigiSignalType::SigSymbolCircleDef;
01479             SignalTbl[CIGI_SYMBOL_LINE_DEFINITION_PACKET_ID_V3_3] = CigiSignalType::SigSymbolLineDef;
01480             SignalTbl[CIGI_SYMBOL_CLONE_PACKET_ID_V3_3] = CigiSignalType::SigSymbolClone;
01481 
01482          }
01483       }
01484       else if(ReaderVersion.CigiMajorVersion == 2)
01485       {
01486          if(Session->IsHost())
01487          {
01488             SignalTbl[CIGI_SOF_PACKET_ID_V2] = CigiSignalType::SigSOF;
01489             SignalTbl[CIGI_COLL_DET_SEG_RESP_PACKET_ID_V2] = CigiSignalType::SigCollDetSegResp;
01490             SignalTbl[CIGI_SENSOR_RESP_PACKET_ID_V2] = CigiSignalType::SigSensorResp;
01491             SignalTbl[CIGI_LOS_RESP_PACKET_ID_V2] = CigiSignalType::SigLosResp;
01492             SignalTbl[CIGI_HAT_RESP_PACKET_ID_V2] = CigiSignalType::SigHatResp;
01493             SignalTbl[CIGI_HOT_RESP_PACKET_ID_V2] = CigiSignalType::SigHotResp;
01494             SignalTbl[CIGI_COLL_DET_VOL_RESP_PACKET_ID_V2] = CigiSignalType::SigCollDetVolResp;
01495             SignalTbl[CIGI_IG_MSG_PACKET_ID_V2] = CigiSignalType::SigIGMsg;
01496          }
01497          else
01498          {
01499             SignalTbl[CIGI_IG_CTRL_PACKET_ID_V1] = CigiSignalType::SigIGCtrl;
01500             SignalTbl[CIGI_ENTITY_CTRL_PACKET_ID_V2] = CigiSignalType::SigEntityCtrl;
01501             SignalTbl[CIGI_VIEW_DEF_PACKET_ID_V2] = CigiSignalType::SigViewDef;
01502             SignalTbl[CIGI_VIEW_CTRL_PACKET_ID_V2] = CigiSignalType::SigViewCtrl;
01503             SignalTbl[CIGI_RATE_CTRL_PACKET_ID_V2] = CigiSignalType::SigRateCtrl;
01504             SignalTbl[CIGI_SENSOR_CTRL_PACKET_ID_V2] = CigiSignalType::SigSensorCtrl;
01505             SignalTbl[CIGI_TRAJECTORY_DEF_PACKET_ID_V2] = CigiSignalType::SigTrajectory;
01506             SignalTbl[CIGI_WEATHER_CTRL_PACKET_ID_V2] = CigiSignalType::SigWeatherCtrl;
01507             SignalTbl[CIGI_COLL_DET_SEG_DEF_PACKET_ID_V2] = CigiSignalType::SigCollDetSegDef;
01508             SignalTbl[CIGI_LOS_SEG_REQ_PACKET_ID_V2] = CigiSignalType::SigLosSegReq;
01509             SignalTbl[CIGI_LOS_VECT_REQ_PACKET_ID_V2] = CigiSignalType::SigLosVectReq;
01510             SignalTbl[CIGI_HAT_REQ_PACKET_ID_V2] = CigiSignalType::SigHatReq;
01511             SignalTbl[CIGI_HOT_REQ_PACKET_ID_V2] = CigiSignalType::SigHotReq;
01512             SignalTbl[CIGI_ENV_CTRL_PACKET_ID_V2] = CigiSignalType::SigEnvCtrl;
01513             SignalTbl[CIGI_SPEC_EFF_DEF_PACKET_ID_V2] = CigiSignalType::SigSpecEffDef;
01514             SignalTbl[CIGI_ART_PART_CTRL_PACKET_ID_V2] = CigiSignalType::SigArtPartCtrl;
01515             SignalTbl[CIGI_COLL_DET_VOL_DEF_PACKET_ID_V2] = CigiSignalType::SigCollDetVolDef;
01516             SignalTbl[CIGI_COMP_CTRL_PACKET_ID_V2] = CigiSignalType::SigCompCtrl;
01517          }
01518       }
01519       else if(ReaderVersion.CigiMajorVersion == 1)
01520       {
01521          if(Session->IsHost())
01522          {
01523             SignalTbl[CIGI_SOF_PACKET_ID_V1] = CigiSignalType::SigSOF;
01524             SignalTbl[CIGI_COLL_DET_SEG_RESP_PACKET_ID_V1] = CigiSignalType::SigCollDetSegResp;
01525             SignalTbl[CIGI_SENSOR_RESP_PACKET_ID_V1] = CigiSignalType::SigSensorResp;
01526             SignalTbl[CIGI_LOS_RESP_PACKET_ID_V1] = CigiSignalType::SigLosResp;
01527             SignalTbl[CIGI_HAT_RESP_PACKET_ID_V1] = CigiSignalType::SigHatResp;
01528          }
01529          else
01530          {
01531             SignalTbl[CIGI_IG_CTRL_PACKET_ID_V1] = CigiSignalType::SigIGCtrl;
01532             SignalTbl[CIGI_ENTITY_CTRL_PACKET_ID_V1] = CigiSignalType::SigEntityCtrl;
01533             SignalTbl[CIGI_VIEW_DEF_PACKET_ID_V1] = CigiSignalType::SigViewDef;
01534             SignalTbl[CIGI_VIEW_CTRL_PACKET_ID_V1] = CigiSignalType::SigViewCtrl;
01535             SignalTbl[CIGI_RATE_CTRL_PACKET_ID_V1] = CigiSignalType::SigRateCtrl;
01536             SignalTbl[CIGI_SENSOR_CTRL_PACKET_ID_V1] = CigiSignalType::SigSensorCtrl;
01537             SignalTbl[CIGI_TRAJECTORY_DEF_PACKET_ID_V1] = CigiSignalType::SigTrajectory;
01538             SignalTbl[CIGI_WEATHER_CTRL_PACKET_ID_V1] = CigiSignalType::SigWeatherCtrl;
01539             SignalTbl[CIGI_COLL_DET_SEG_DEF_PACKET_ID_V1] = CigiSignalType::SigCollDetSegDef;
01540             SignalTbl[CIGI_LOS_SEG_REQ_PACKET_ID_V1] = CigiSignalType::SigLosSegReq;
01541             SignalTbl[CIGI_LOS_VECT_REQ_PACKET_ID_V1] = CigiSignalType::SigLosVectReq;
01542             SignalTbl[CIGI_HAT_REQ_PACKET_ID_V1] = CigiSignalType::SigHatReq;
01543             SignalTbl[CIGI_ENV_CTRL_PACKET_ID_V1] = CigiSignalType::SigEnvCtrl;
01544             SignalTbl[CIGI_SPEC_EFF_DEF_PACKET_ID_V1] = CigiSignalType::SigSpecEffDef;
01545             SignalTbl[CIGI_ART_PART_CTRL_PACKET_ID_V1] = CigiSignalType::SigArtPartCtrl;
01546             SignalTbl[CIGI_COMP_CTRL_PACKET_ID_V1] = CigiSignalType::SigCompCtrl;
01547          }
01548       }
01549    }
01550 }
01551 
01552 
01553
Generated on Wed Apr 29 08:59:58 2009 for CCL by  doxygen 1.4.7