Changeset 2710 in ntrip

Timestamp:

Nov 18, 2010, 12:44:38 PM (13 years ago)

Author:

mervart

Message:

 

Location:

trunk/BNC

Files:

• GPSS/gpssDecoder.cpp (modified) (3 diffs)
• RTCM/GPSDecoder.h (modified) (3 diffs)
• RTCM/RTCM2Decoder.cpp (modified) (2 diffs)
• RTCM3/RTCM3Decoder.cpp (modified) (1 diff)
• RTIGS/RTIGSDecoder.cpp (modified) (1 diff)
• bnccaster.cpp (modified) (5 diffs)
• bnccaster.h (modified) (2 diffs)
• bncgetthread.cpp (modified) (2 diffs)
• bncgetthread.h (modified) (1 diff)
• bncpppclient.cpp (modified) (1 diff)
• bncpppclient.h (modified) (1 diff)
• bncrinex.cpp (modified) (6 diffs)
• bncrinex.h (modified) (2 diffs)
• latencychecker.cpp (modified) (1 diff)
• latencychecker.h (modified) (1 diff)

trunk/BNC/GPSS/gpssDecoder.cpp

@@ -21 +21 @@
 using namespace std;
 
-typedef struct epochHeader {
+struct t_epochHeader {
   double t_epoch;
   int    n_svs;
-} EPOCHHEADER;
+};
 
 // Cyclic Redundancy Check
@@ -80 +80 @@
     if      (_buffer.length() > 0 && char(_buffer[1]) == 0x00) {
 
-      int reqLength = 2 + sizeof(recordSize) + sizeof(EPOCHHEADER);
+      int reqLength = 2 + sizeof(recordSize) + sizeof(t_epochHeader);
 
       if (_buffer.length() >= reqLength) {
-        EPOCHHEADER epochHdr;
+        t_epochHeader epochHdr;
         memcpy(&epochHdr, _buffer.data() + 2 + sizeof(recordSize), 
                sizeof(epochHdr));
@@ -91 +91 @@
         if (_buffer.length() >= reqLength) {
 
-          int checkLen = 2 + sizeof(recordSize) + sizeof(EPOCHHEADER) + 
+          int checkLen = 2 + sizeof(recordSize) + sizeof(t_epochHeader) + 
                          epochHdr.n_svs * sizeof(t_obs);
           memcpy(&crc, _buffer.data() + checkLen, sizeof(crc));

trunk/BNC/RTCM/GPSDecoder.h

@@ -114 +114 @@
 };
 
-typedef t_obs* p_obs;
-
 class GPSDecoder {
  public:
@@ -121 +119 @@
 
   virtual ~GPSDecoder() {
-    QListIterator<p_obs> it(_obsList);
+    QListIterator<t_obs*> it(_obsList);
     while (it.hasNext()) {
-      p_obs obs = it.next();
+      t_obs* obs = it.next();
       if (obs && obs->_status == t_obs::initial) {
         delete obs;
@@ -151 +149 @@
   };
 
-  QList<p_obs>     _obsList;
+  QList<t_obs*>    _obsList;
   QList<int>       _typeList;  // RTCM   message types
   QStringList      _antType;   // RTCM   antenna descriptor

trunk/BNC/RTCM/RTCM2Decoder.cpp

@@ -140 +140 @@
           
         for (int iSat=0; iSat < _ObsBlock.nSat; iSat++) {
-          p_obs obs = new t_obs();
+          t_obs* obs = new t_obs();
           _obsList.push_back(obs);
           if (_ObsBlock.PRN[iSat] > 100) {
@@ -314 +314 @@
 
     // new observation
-    p_obs new_obs = 0;
+    t_obs* new_obs = 0;
 
     // missing IOD

trunk/BNC/RTCM3/RTCM3Decoder.cpp

@@ -237 +237 @@
             for (int iSat = 0; iSat < gnssData.numsats; iSat++) {
 
-              p_obs obs   = new t_obs();
-              int   satID = gnssData.satellites[iSat];
+              t_obs* obs   = new t_obs();
+              int    satID = gnssData.satellites[iSat];
 
               // GPS

trunk/BNC/RTIGS/RTIGSDecoder.cpp

@@ -116 +116 @@
 
     for (short ii = 0; ii < numObs; ii++) {
-      p_obs obs = new t_obs();
+      t_obs* obs = new t_obs();
       _obsList.push_back(obs);
       obs->satSys   = 'G';

trunk/BNC/bnccaster.cpp

@@ -171 +171 @@
   }
 
-  _epochs = new QMultiMap<long, p_obs>;
+  _epochs = new QMultiMap<long, t_obs*>;
 
   _lastDumpSec   = 0; 
@@ -198 +198 @@
   delete _nmeaSockets;
   if (_epochs) {
-    QListIterator<p_obs> it(_epochs->values());
+    QListIterator<t_obs*> it(_epochs->values());
     while (it.hasNext()) {
       delete it.next();
@@ -208 +208 @@
 // New Observations
 ////////////////////////////////////////////////////////////////////////////
-void bncCaster::newObs(const QByteArray staID, bool firstObs, p_obs obs) {
+void bncCaster::newObs(const QByteArray staID, bool firstObs, t_obs* obs) {
 
   QMutexLocker locker(&_mutex);
@@ -323 +323 @@
 void bncCaster::addGetThread(bncGetThread* getThread, bool noNewThread) {
 
-  qRegisterMetaType<p_obs>("p_obs");
+  ////  qRegisterMetaType<t_obs*>("p_obs");
   qRegisterMetaType<gpsephemeris>("gpsephemeris");
   qRegisterMetaType<glonassephemeris>("glonassephemeris");
 
-  connect(getThread, SIGNAL(newObs(QByteArray, bool, p_obs)),
-          this,      SLOT(newObs(QByteArray, bool, p_obs))); /// Qt::DirectConnection);
+  connect(getThread, SIGNAL(newObs(QByteArray, bool, t_obs*)),
+          this,      SLOT(newObs(QByteArray, bool, t_obs*))); /// Qt::DirectConnection);
 
   connect(getThread, SIGNAL(getThreadFinished(QByteArray)), 
@@ -385 +385 @@
 
     bool first = true;
-    QList<p_obs> allObs = _epochs->values(sec);
-
-    QListIterator<p_obs> it(allObs);
+    QList<t_obs*> allObs = _epochs->values(sec);
+
+    QListIterator<t_obs*> it(allObs);
     while (it.hasNext()) {
-      p_obs obs = it.next();
+      t_obs* obs = it.next();
 
       if (_samplingRate == 0 || sec % _samplingRate == 0) {

trunk/BNC/bnccaster.h

@@ -44 +44 @@
 
  public slots:
-   void newObs(QByteArray staID, bool firstObs, p_obs obs);
+   void newObs(QByteArray staID, bool firstObs, t_obs* obs);
    void slotReadMountPoints();
    void slotNewNMEAstr(QByteArray str);
@@ -63 +63 @@
    static int myWrite(QTcpSocket* sock, const char* buf, int bufLen);
 
-   QFile*                  _outFile;
-   int                     _port;
-   QTextStream*            _out;
-   QMultiMap<long, p_obs>* _epochs;
-   long                    _lastDumpSec;
-   QTcpServer*             _server;
-   QTcpServer*             _uServer;
-   QTcpServer*             _nmeaServer;
-   QList<QTcpSocket*>*     _sockets;
-   QList<QTcpSocket*>*     _uSockets;
-   QList<QTcpSocket*>*     _nmeaSockets;
-   QList<QByteArray>       _staIDs;
-   QList<bncGetThread*>    _threads;
-   int                     _samplingRate;
-   long                    _waitTime;
-   QMutex                  _mutex;
-   int                     _confInterval;
+   QFile*                   _outFile;
+   int                      _port;
+   QTextStream*             _out;
+   QMultiMap<long, t_obs*>* _epochs;
+   long                     _lastDumpSec;
+   QTcpServer*              _server;
+   QTcpServer*              _uServer;
+   QTcpServer*              _nmeaServer;
+   QList<QTcpSocket*>*      _sockets;
+   QList<QTcpSocket*>*      _uSockets;
+   QList<QTcpSocket*>*      _nmeaSockets;
+   QList<QByteArray>        _staIDs;
+   QList<bncGetThread*>     _threads;
+   int                      _samplingRate;
+   long                     _waitTime;
+   QMutex                   _mutex;
+   int                      _confInterval;
 };
 

trunk/BNC/bncgetthread.cpp

@@ -374 +374 @@
       // Delete old observations
       // -----------------------
-      QListIterator<p_obs> itOld(_decoder->_obsList);
+      QListIterator<t_obs*> itOld(_decoder->_obsList);
       while (itOld.hasNext()) {
         delete itOld.next();
@@ -439 +439 @@
       // Loop over all observations (observations output)
       // ------------------------------------------------
-      QListIterator<p_obs> it(_decoder->_obsList);
+      QListIterator<t_obs*> it(_decoder->_obsList);
       while (it.hasNext()) {
-        p_obs obs = it.next();
+        t_obs* obs = it.next();
       
         // Check observation epoch

trunk/BNC/bncgetthread.h

@@ -79 +79 @@
    void newBytes(QByteArray staID, double nbyte);
    void newLatency(QByteArray staID, double clate);
-   void newObs(QByteArray staID, bool firstObs, p_obs obs);
+   void newObs(QByteArray staID, bool firstObs, t_obs* obs);
    void newAntCrd(QByteArray staID, double xx, double yy, double zz, QByteArray antType);
    void newMessage(QByteArray msg, bool showOnScreen);

trunk/BNC/bncpppclient.cpp

@@ -119 +119 @@
 //
 ////////////////////////////////////////////////////////////////////////////
-void bncPPPclient::putNewObs(p_obs obs) {
+void bncPPPclient::putNewObs(t_obs* obs) {
   QMutexLocker locker(&_mutex);
 

trunk/BNC/bncpppclient.h

@@ -120 +120 @@
   bncPPPclient(QByteArray staID);
   ~bncPPPclient();
-  void putNewObs(p_obs pp);
+  void putNewObs(t_obs* pp);
 
  public slots:

trunk/BNC/bncrinex.cpp

@@ -107 +107 @@
 ////////////////////////////////////////////////////////////////////////////
 bncRinex::~bncRinex() {
-  QListIterator<p_obs> it(_obs);
+  QListIterator<t_obs*> it(_obs);
   while (it.hasNext()) {
     delete it.next();
@@ -518 +518 @@
 // Stores Observation into Internal Array
 ////////////////////////////////////////////////////////////////////////////
-void bncRinex::deepCopy(const p_obs obs) {
-  p_obs newObs = new t_obs();
+void bncRinex::deepCopy(const t_obs* obs) {
+  t_obs* newObs = new t_obs();
   memcpy(newObs, obs, sizeof(t_obs));
   _obs.push_back(newObs);
@@ -530 +530 @@
   // Select observations older than maxTime
   // --------------------------------------
-  QList<p_obs> dumpList;
-  QMutableListIterator<p_obs> mIt(_obs);
+  QList<t_obs*> dumpList;
+  QMutableListIterator<t_obs*> mIt(_obs);
   while (mIt.hasNext()) {
-    p_obs obs = mIt.next();
+    t_obs* obs = mIt.next();
     if (obs->GPSWeek * 7*24*3600 + obs->GPSWeeks < maxTime - 0.05) {
       dumpList.push_back(obs);
@@ -548 +548 @@
   // Time of Epoch
   // -------------
-  p_obs fObs = *dumpList.begin();
+  t_obs* fObs = *dumpList.begin();
   QDateTime datTim    = dateAndTimeFromGPSweek(fObs->GPSWeek, fObs->GPSWeeks);
   QDateTime datTimNom = dateAndTimeFromGPSweek(fObs->GPSWeek, 
@@ -582 +582 @@
          << "  " << 0 << setw(3)  << dumpList.size();
 
-    QListIterator<p_obs> it(dumpList); int iSat = 0;
+    QListIterator<t_obs*> it(dumpList); int iSat = 0;
     while (it.hasNext()) {
       iSat++;
-      p_obs obs = it.next();
+      t_obs* obs = it.next();
       _out << obs->satSys << setw(2) << obs->satNum;
       if (iSat == 12 && it.hasNext()) {
@@ -595 +595 @@
   }
 
-  QListIterator<p_obs> it(dumpList);
+  QListIterator<t_obs*> it(dumpList);
   while (it.hasNext()) {
-    p_obs obs = it.next();
+    t_obs* obs = it.next();
 
     // Cycle slips detection

trunk/BNC/bncrinex.h

@@ -42 +42 @@
             const QByteArray& ntripVersion); 
    ~bncRinex();
-   void deepCopy(const p_obs obs);
+   void deepCopy(const t_obs* obs);
    void dumpEpoch(long maxTime);
    void setReconnectFlag(bool flag){_reconnectFlag = flag;}
@@ -67 +67 @@
    QByteArray    _statID;
    QByteArray    _fName;
-   QList<p_obs>  _obs;
+   QList<t_obs*> _obs;
    std::ofstream _out;
    QStringList   _headerLines;

trunk/BNC/latencychecker.cpp

@@ -307 +307 @@
 // Perform latency checks (observations)
 //////////////////////////////////////////////////////////////////////////////
-void latencyChecker::checkObsLatency(const QList<p_obs>& obsList) {
+void latencyChecker::checkObsLatency(const QList<t_obs*>& obsList) {
 
   if (_perfIntr > 0 ) {
 
-    QListIterator<p_obs> it(obsList);
+    QListIterator<t_obs*> it(obsList);
     while (it.hasNext()) {
-      p_obs obs = it.next();
+      t_obs* obs = it.next();
       
       _newSecGPS = static_cast<int>(obs->GPSWeeks);

trunk/BNC/latencychecker.h

@@ -38 +38 @@
   void checkReconnect();
   void checkOutage(bool decoded);
-  void checkObsLatency(const QList<p_obs>& obsList);
+  void checkObsLatency(const QList<t_obs*>& obsList);
   void checkCorrLatency(int corrGPSEpochTime);
   double currentLatency() const {return _curLat;}