Changeset 10791 in ntrip for trunk/BNC/src/pppInclude.h


Ignore:
Timestamp:
Dec 3, 2025, 5:37:16 PM (3 days ago)
Author:
mervart
Message:

BNC Multifrequency and PPPAR Client (initial version)

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/BNC/src/pppInclude.h

    r10409 r10791  
    55#include <vector>
    66#include <newmat.h>
     7#include <sstream>
    78
    89#include "bncconst.h"
    … …  
    1415namespace BNC_PPP {
    1516
     17const double ZEROVALUE = 1e-100;
     18 
    1619class t_except {
    1720 public:
    … …  
    4043};
    4144
     45class t_lc {
     46public:
     47  enum type {dummy = 0, code, phase, codeIF, phaseIF,  MW, CL, GIM, maxLc};
    4248
    43 class t_frqBand {
    44 public:
    45   static t_frequency::type toFreq(char sys, char bb) {
    46     switch (bb) {
    47     case '1':
    48       if      (sys == 'G') return t_frequency::G1;
    49       else if (sys == 'R') return t_frequency::R1;
    50       else if (sys == 'E') return t_frequency::E1;
    51       else if (sys == 'C') return t_frequency::C1;
    52       else                 return t_frequency::dummy;
    53     case '2':
    54       if      (sys == 'G') return t_frequency::G2;
    55       else if (sys == 'R') return t_frequency::R2;
    56       else if (sys == 'C') return t_frequency::C2;
    57       else                 return t_frequency::dummy;
    58     case '5':
    59       if      (sys == 'G') return t_frequency::G5;
    60       else if (sys == 'E') return t_frequency::E5;
    61       else if (sys == 'C') return t_frequency::C5;
    62       else                 return t_frequency::dummy;
    63     case '6':
    64       if      (sys == 'E') return t_frequency::E6;
    65       else if (sys == 'C') return t_frequency::C6;
    66       else                 return t_frequency::dummy;
    67     case '7':
    68       if      (sys == 'E') return t_frequency::E7;
    69       else if (sys == 'C') return t_frequency::C7;
    70       else                 return t_frequency::dummy;
    71     case '8':
    72       if      (sys == 'E') return t_frequency::E8;
    73       else if (sys == 'C') return t_frequency::C8;
    74       else                 return t_frequency::dummy;
    75     }
    76     return t_frequency::dummy;
     49  t_lc() : _type(dummy), _frq1(t_frequency::dummy), _frq2(t_frequency::dummy) {}
     50 
     51  t_lc(type tt, t_frequency::type frq1, t_frequency::type frq2 = t_frequency::dummy)
     52    : _type(tt), _frq1(frq1), _frq2(frq2) {
    7753  }
    78 };
    7954
    80 class t_lc {
    81  public:
    82   enum type {dummy = 0, c1, c2, cIF, l1, l2, lIF,  MW, CL, GIM, maxLc};
    83 
    84   static bool includesPhase(type tt) {
    85     switch (tt) {
    86     case l1:
    87     case l2:
    88     case lIF:
    89     case MW:
    90     case CL:
    91       return true;
    92     case c1:
    93     case c2:
    94     case cIF:
    95       return false;
    96     case dummy:
    97     case maxLc:
    98     case GIM:
     55  bool valid() const {
     56    if      (_type == dummy) {
    9957      return false;
    10058    }
    101     return false;
     59    else if (_type == GIM) {
     60      return true;
     61    }
     62    else {
     63      if (_frq1 == t_frequency::dummy) {
     64        return false;
     65      }
     66      if (t_lc::needs2ndFrq(_type) && _frq2 == t_frequency::dummy) {
     67        return false;
     68      }
     69      return true;
     70    }
    10271  }
    10372
    104   static bool includesCode(type tt) {
    105     switch (tt) {
    106     case c1:
    107     case c2:
    108     case cIF:
    109     case MW:
    110     case CL:
     73  char system() const {
     74    return t_frequency::toSystem(_frq1);
     75  }
     76
     77  static bool needs2ndFrq(type tt) {
     78    if (tt == codeIF || tt == phaseIF || tt == MW) {
    11179      return true;
    112     case l1:
    113     case l2:
    114     case lIF:
    115       return false;
    116     case dummy:
    117     case maxLc:
    118     case GIM:
     80    }
     81    else {
    11982      return false;
    12083    }
    121     return false;
     84  }
     85 
     86  bool includesPhase() const {
     87    if (_type == phase || _type == phaseIF || _type == MW || _type == CL) {
     88      return true;
     89    }
     90    else {
     91      return false;
     92    }
    12293  }
    12394
    124   static t_frequency::type toFreq(char sys, type tt) {
    125     switch (tt) {
    126     case l1: case c1:
    127       if      (sys == 'G') return t_frequency::G1;
    128       else if (sys == 'R') return t_frequency::R1;
    129       else if (sys == 'E') return t_frequency::E1;
    130       else if (sys == 'C') return t_frequency::C2;
    131       else                 return t_frequency::dummy;
    132     case l2: case c2:
    133       if      (sys == 'G') return t_frequency::G2;
    134       else if (sys == 'R') return t_frequency::R2;
    135       else if (sys == 'E') return t_frequency::E5;
    136       else if (sys == 'C') return t_frequency::C6;
    137       else                 return t_frequency::dummy;
    138     case lIF: case cIF: case MW: case CL:
    139       return t_frequency::dummy;
    140     case dummy:
    141     case maxLc:
    142     case GIM:
     95  bool includesCode() const {
     96    if (_type == code || _type == codeIF || _type == MW || _type == CL) {
     97      return true;
     98    }
     99    else {
     100      return false;
     101    }
     102  }
     103
     104  bool isIonoFree() const {
     105    if (_type == codeIF || _type == phaseIF || _type == MW || _type == CL) {
     106      return true;
     107    }
     108    else {
     109      return false;
     110    }
     111  }
     112 
     113  bool isGeometryFree() const {
     114    if (_type == MW || _type == CL || _type == GIM) {
     115      return true;
     116    }
     117    else {
     118      return false;
     119    }
     120  }
     121 
     122  t_frequency::type toFreq() const {
     123    if (_frq2 != t_frequency::dummy) {
    143124      return t_frequency::dummy;
    144125    }
    145     return t_frequency::dummy;
     126    else {
     127      return _frq1;
     128    }
    146129  }
    147130
    148   static std::string toString(type tt) {
    149     switch (tt) {
    150     case l1:  return "l1";
    151     case l2:  return "l2";
    152     case lIF: return "lIF";
    153     case MW:  return "MW";
    154     case CL:  return "CL";
    155     case c1:  return "c1";
    156     case c2:  return "c2";
    157     case cIF: return "cIF";
    158     case GIM: return "GIM";
    159     case dummy:
    160     case maxLc:
    161       return "";
     131  std::string toString() const {
     132    std::stringstream out;
     133    if      (_type == code) {
     134      out << 'c' << t_frequency::toString(_frq1);
    162135    }
    163     return "";
     136    else if (_type == phase) {
     137      out << 'l' << t_frequency::toString(_frq1);
     138    }
     139    else if (_type == codeIF) {
     140      out << 'c' << t_frequency::toSystem(_frq1) << "IF" ;
     141    }
     142    else if (_type == phaseIF) {
     143      out << 'l' << t_frequency::toSystem(_frq1) << "IF" ;
     144    }
     145    else if (_type == MW) {
     146      out << t_frequency::toSystem(_frq1) << "MW" ;
     147    }
     148    else if (_type == CL) {
     149      out << t_frequency::toSystem(_frq1) << "CL" ;
     150    }
     151    else if (_type == GIM) {
     152      out << t_frequency::toSystem(_frq1) << "GIM" ;
     153    }
     154    return out.str();
    164155  }
     156
     157  bool operator==(const t_lc& other) const {
     158    if (_type == other._type && _frq1 == other._frq1 && _frq2 == other._frq2) {
     159      return true;
     160    }
     161    else {
     162      return false;
     163    }
     164  }
     165
     166  bool operator!=(const t_lc& other) const {
     167    return !(*this == other);
     168  }
     169
     170  bool operator <(const t_lc& other) const {
     171    if      (_type != other._type) {
     172      return _type < other._type;
     173    }
     174    else if (_frq1 != other._frq1) {
     175      return _frq1 < other._frq1;
     176    }
     177    else {
     178      return _frq2 < other._frq2;
     179    }
     180  }
     181
     182  type              _type;
     183  t_frequency::type _frq1;
     184  t_frequency::type _frq2;
    165185};
    166186
Note: See TracChangeset for help on using the changeset viewer.