Class: GPS_PVT::GPS::SpaceNode_SBAS

Inherits:
Object
  • Object
show all
Defined in:
ext/gps_pvt/GPS/GPS_wrap.cxx,
ext/gps_pvt/GPS/GPS_wrap.cxx

Overview

Proxy of C++ GPS_PVT::GPS::SpaceNode_SBAS class

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object

call-seq:

SpaceNode_SBAS.new

Class constructor.



17870
17871
17872
17873
17874
17875
17876
17877
17878
17879
17880
17881
17882
17883
17884
17885
17886
17887
17888
17889
17890
17891
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 17870

SWIGINTERN VALUE
_wrap_new_SpaceNode_SBAS(int argc, VALUE *argv, VALUE self) {
  SBAS_SpaceNode< double > *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (SBAS_SpaceNode< double > *)new SBAS_SpaceNode< double >();
      DATA_PTR(self) = result;
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}

Class Method Details

.sagnac_correction(*args) ⇒ Object

call-seq:

sagnac_correction(XYZ sat_pos, XYZ usr_pos) -> SBAS_SpaceNode< double >::float_t

A class method.



17727
17728
17729
17730
17731
17732
17733
17734
17735
17736
17737
17738
17739
17740
17741
17742
17743
17744
17745
17746
17747
17748
17749
17750
17751
17752
17753
17754
17755
17756
17757
17758
17759
17760
17761
17762
17763
17764
17765
17766
17767
17768
17769
17770
17771
17772
17773
17774
17775
17776
17777
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 17727

SWIGINTERN VALUE
_wrap_SpaceNode_SBAS_sagnac_correction(int argc, VALUE *argv, VALUE self) {
  SBAS_SpaceNode< double >::xyz_t arg1 ;
  SBAS_SpaceNode< double >::xyz_t arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  SBAS_SpaceNode< double >::float_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  {
    res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_System_XYZT_double_WGS84_t,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SBAS_SpaceNode< double >::xyz_t const","SBAS_SpaceNode<(double)>::sagnac_correction", 1, argv[0] )); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "SBAS_SpaceNode< double >::xyz_t const","SBAS_SpaceNode<(double)>::sagnac_correction", 1, argv[0]));
    } else {
      arg1 = *(reinterpret_cast< SBAS_SpaceNode< double >::xyz_t * >(argp1));
    }
  }
  {
    res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_System_XYZT_double_WGS84_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "SBAS_SpaceNode< double >::xyz_t const","SBAS_SpaceNode<(double)>::sagnac_correction", 2, argv[1] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "SBAS_SpaceNode< double >::xyz_t const","SBAS_SpaceNode<(double)>::sagnac_correction", 2, argv[1]));
    } else {
      arg2 = *(reinterpret_cast< SBAS_SpaceNode< double >::xyz_t * >(argp2));
    }
  }
  {
    try {
      result = (SBAS_SpaceNode< double >::float_t)SBAS_SpaceNode< double >::SWIGTEMPLATEDISAMBIGUATOR sagnac_correction(arg1,arg2);
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

.tropo_correction(*args) ⇒ Object

call-seq:

tropo_correction(SBAS_SpaceNode< double >::float_t const & year_utc, ENU relative_pos, LLH usrllh) -> SBAS_SpaceNode< double >::float_t

A class method.



17789
17790
17791
17792
17793
17794
17795
17796
17797
17798
17799
17800
17801
17802
17803
17804
17805
17806
17807
17808
17809
17810
17811
17812
17813
17814
17815
17816
17817
17818
17819
17820
17821
17822
17823
17824
17825
17826
17827
17828
17829
17830
17831
17832
17833
17834
17835
17836
17837
17838
17839
17840
17841
17842
17843
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 17789

SWIGINTERN VALUE
_wrap_SpaceNode_SBAS_tropo_correction(int argc, VALUE *argv, VALUE self) {
  SBAS_SpaceNode< double >::float_t *arg1 = 0 ;
  SBAS_SpaceNode< double >::enu_t *arg2 = 0 ;
  SBAS_SpaceNode< double >::llh_t *arg3 = 0 ;
  SBAS_SpaceNode< double >::float_t temp1 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  SBAS_SpaceNode< double >::float_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_double(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "SBAS_SpaceNode< double >::float_t","SBAS_SpaceNode<(double)>::tropo_correction", 1, argv[0] ));
  } 
  temp1 = static_cast< SBAS_SpaceNode< double >::float_t >(val1);
  arg1 = &temp1;
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_System_ENUT_double_WGS84_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "SBAS_SpaceNode< double >::enu_t const &","SBAS_SpaceNode<(double)>::tropo_correction", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "SBAS_SpaceNode< double >::enu_t const &","SBAS_SpaceNode<(double)>::tropo_correction", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< SBAS_SpaceNode< double >::enu_t * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_System_LLHT_double_WGS84_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "SBAS_SpaceNode< double >::llh_t const &","SBAS_SpaceNode<(double)>::tropo_correction", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "SBAS_SpaceNode< double >::llh_t const &","SBAS_SpaceNode<(double)>::tropo_correction", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< SBAS_SpaceNode< double >::llh_t * >(argp3);
  {
    try {
      result = (SBAS_SpaceNode< double >::float_t)SBAS_SpaceNode< double >::SWIGTEMPLATEDISAMBIGUATOR tropo_correction((double const &)*arg1,(System_ENU< double,WGS84 > const &)*arg2,(System_LLH< double,WGS84 > const &)*arg3);
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

Instance Method Details

#available_satellites(*args) ⇒ Object

call-seq:

available_satellites(SBAS_SpaceNode< double >::float_t const & lng_deg) -> SBAS_SpaceNode< double >::available_satellites_t

An instance method.



18011
18012
18013
18014
18015
18016
18017
18018
18019
18020
18021
18022
18023
18024
18025
18026
18027
18028
18029
18030
18031
18032
18033
18034
18035
18036
18037
18038
18039
18040
18041
18042
18043
18044
18045
18046
18047
18048
18049
18050
18051
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 18011

SWIGINTERN VALUE
_wrap_SpaceNode_SBAS_available_satellites(int argc, VALUE *argv, VALUE self) {
  SBAS_SpaceNode< double > *arg1 = (SBAS_SpaceNode< double > *) 0 ;
  SBAS_SpaceNode< double >::float_t *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SBAS_SpaceNode< double >::float_t temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  SwigValueWrapper< std::vector< std::pair< int,SBAS_SpaceNode< double >::Satellite const * > > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SBAS_SpaceNodeT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SBAS_SpaceNode< double > const *","available_satellites", 1, self )); 
  }
  arg1 = reinterpret_cast< SBAS_SpaceNode< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "SBAS_SpaceNode< double >::float_t","available_satellites", 2, argv[0] ));
  } 
  temp2 = static_cast< SBAS_SpaceNode< double >::float_t >(val2);
  arg2 = &temp2;
  {
    try {
      result = ((SBAS_SpaceNode< double > const *)arg1)->available_satellites((SBAS_SpaceNode< double >::float_t const &)*arg2);
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  vresult = SWIG_NewPointerObj((new SBAS_SpaceNode< double >::available_satellites_t(static_cast< const SBAS_SpaceNode< double >::available_satellites_t& >(result))), SWIGTYPE_p_std__vectorT_std__pairT_int_SBAS_SpaceNodeT_double_t__Satellite_const_p_t_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#decode_message(*args, self) ⇒ Object

call-seq:

decode_message(unsigned int const [8] buf, int const & prn, Time t_reception, bool const & LNAV_VNAV_LP_LPV_approach=False) -> int
decode_message(unsigned int const [8] buf, int const & prn, Time t_reception) -> int

An instance method.



18502
18503
18504
18505
18506
18507
18508
18509
18510
18511
18512
18513
18514
18515
18516
18517
18518
18519
18520
18521
18522
18523
18524
18525
18526
18527
18528
18529
18530
18531
18532
18533
18534
18535
18536
18537
18538
18539
18540
18541
18542
18543
18544
18545
18546
18547
18548
18549
18550
18551
18552
18553
18554
18555
18556
18557
18558
18559
18560
18561
18562
18563
18564
18565
18566
18567
18568
18569
18570
18571
18572
18573
18574
18575
18576
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 18502

SWIGINTERN VALUE _wrap_SpaceNode_SBAS_decode_message(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[6];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 6) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBAS_SpaceNodeT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = RB_TYPE_P(argv[1], T_ARRAY) ? 1 : 0;
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_GPS_TimeT_double_t, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SpaceNode_SBAS_decode_message__SWIG_3(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBAS_SpaceNodeT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = RB_TYPE_P(argv[1], T_ARRAY) ? 1 : 0;
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_GPS_TimeT_double_t, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SpaceNode_SBAS_decode_message__SWIG_2(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "decode_message", 
    "    int decode_message(unsigned int const buf[8], int const &prn, GPS_Time< double > const &t_reception, bool const &LNAV_VNAV_LP_LPV_approach)\n"
    "    int decode_message(unsigned int const buf[8], int const &prn, GPS_Time< double > const &t_reception)\n");
  
  return Qnil;
}

#ephemeris(*args) ⇒ Object

call-seq:

ephemeris(int const & prn) -> Ephemeris_SBAS

An instance method.



18252
18253
18254
18255
18256
18257
18258
18259
18260
18261
18262
18263
18264
18265
18266
18267
18268
18269
18270
18271
18272
18273
18274
18275
18276
18277
18278
18279
18280
18281
18282
18283
18284
18285
18286
18287
18288
18289
18290
18291
18292
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 18252

SWIGINTERN VALUE
_wrap_SpaceNode_SBAS_ephemeris(int argc, VALUE *argv, VALUE self) {
  SBAS_SpaceNode< double > *arg1 = (SBAS_SpaceNode< double > *) 0 ;
  int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int val2 ;
  int ecode2 = 0 ;
  SBAS_Ephemeris< double > result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SBAS_SpaceNodeT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SBAS_SpaceNode< double > const *","ephemeris", 1, self )); 
  }
  arg1 = reinterpret_cast< SBAS_SpaceNode< double > * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","ephemeris", 2, argv[0] ));
  } 
  temp2 = static_cast< int >(val2);
  arg2 = &temp2;
  {
    try {
      result = SBAS_SpaceNode_Sl_double_Sg__ephemeris((SBAS_SpaceNode< double > const *)arg1,(int const &)*arg2);
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  vresult = SWIG_NewPointerObj((new SBAS_Ephemeris< double >(static_cast< const SBAS_Ephemeris< double >& >(result))), SWIGTYPE_p_SBAS_EphemerisT_double_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#has_satellite(*args) ⇒ Object

call-seq:

has_satellite(int const & prn) -> bool

An instance method.



17909
17910
17911
17912
17913
17914
17915
17916
17917
17918
17919
17920
17921
17922
17923
17924
17925
17926
17927
17928
17929
17930
17931
17932
17933
17934
17935
17936
17937
17938
17939
17940
17941
17942
17943
17944
17945
17946
17947
17948
17949
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 17909

SWIGINTERN VALUE
_wrap_SpaceNode_SBAS_has_satellite(int argc, VALUE *argv, VALUE self) {
  SBAS_SpaceNode< double > *arg1 = (SBAS_SpaceNode< double > *) 0 ;
  int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int val2 ;
  int ecode2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SBAS_SpaceNodeT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SBAS_SpaceNode< double > const *","has_satellite", 1, self )); 
  }
  arg1 = reinterpret_cast< SBAS_SpaceNode< double > * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","has_satellite", 2, argv[0] ));
  } 
  temp2 = static_cast< int >(val2);
  arg2 = &temp2;
  {
    try {
      result = (bool)((SBAS_SpaceNode< double > const *)arg1)->has_satellite((int const &)*arg2);
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

#ionospheric_grid_points(*args) ⇒ Object

call-seq:

ionospheric_grid_points(int const & prn) -> std::string

An instance method.



18588
18589
18590
18591
18592
18593
18594
18595
18596
18597
18598
18599
18600
18601
18602
18603
18604
18605
18606
18607
18608
18609
18610
18611
18612
18613
18614
18615
18616
18617
18618
18619
18620
18621
18622
18623
18624
18625
18626
18627
18628
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 18588

SWIGINTERN VALUE
_wrap_SpaceNode_SBAS_ionospheric_grid_points(int argc, VALUE *argv, VALUE self) {
  SBAS_SpaceNode< double > *arg1 = (SBAS_SpaceNode< double > *) 0 ;
  int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int val2 ;
  int ecode2 = 0 ;
  std::string result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SBAS_SpaceNodeT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SBAS_SpaceNode< double > const *","ionospheric_grid_points", 1, self )); 
  }
  arg1 = reinterpret_cast< SBAS_SpaceNode< double > * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","ionospheric_grid_points", 2, argv[0] ));
  } 
  temp2 = static_cast< int >(val2);
  arg2 = &temp2;
  {
    try {
      result = SBAS_SpaceNode_Sl_double_Sg__ionospheric_grid_points((SBAS_SpaceNode< double > const *)arg1,(int const &)*arg2);
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}

#read(*args) ⇒ Object

call-seq:

read(char const * fname) -> int

An instance method.



18304
18305
18306
18307
18308
18309
18310
18311
18312
18313
18314
18315
18316
18317
18318
18319
18320
18321
18322
18323
18324
18325
18326
18327
18328
18329
18330
18331
18332
18333
18334
18335
18336
18337
18338
18339
18340
18341
18342
18343
18344
18345
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 18304

SWIGINTERN VALUE
_wrap_SpaceNode_SBAS_read(int argc, VALUE *argv, VALUE self) {
  SBAS_SpaceNode< double > *arg1 = (SBAS_SpaceNode< double > *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SBAS_SpaceNodeT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SBAS_SpaceNode< double > *","read", 1, self )); 
  }
  arg1 = reinterpret_cast< SBAS_SpaceNode< double > * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","read", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (int)SBAS_SpaceNode_Sl_double_Sg__read(arg1,(char const *)arg2);
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}

#register_ephemeris(*args, self) ⇒ Object

call-seq:

register_ephemeris(int const & prn, Ephemeris_SBAS eph, int const & priority_delta=1)
register_ephemeris(int const & prn, Ephemeris_SBAS eph)

An instance method.



18176
18177
18178
18179
18180
18181
18182
18183
18184
18185
18186
18187
18188
18189
18190
18191
18192
18193
18194
18195
18196
18197
18198
18199
18200
18201
18202
18203
18204
18205
18206
18207
18208
18209
18210
18211
18212
18213
18214
18215
18216
18217
18218
18219
18220
18221
18222
18223
18224
18225
18226
18227
18228
18229
18230
18231
18232
18233
18234
18235
18236
18237
18238
18239
18240
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 18176

SWIGINTERN VALUE _wrap_SpaceNode_SBAS_register_ephemeris(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBAS_SpaceNodeT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SBAS_EphemerisT_double_t, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SpaceNode_SBAS_register_ephemeris__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBAS_SpaceNodeT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SBAS_EphemerisT_double_t, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SpaceNode_SBAS_register_ephemeris__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "register_ephemeris", 
    "    void register_ephemeris(int const &prn, SBAS_Ephemeris< double > const &eph, int const &priority_delta)\n"
    "    void register_ephemeris(int const &prn, SBAS_Ephemeris< double > const &eph)\n");
  
  return Qnil;
}

#update_all_ephemeris(*args) ⇒ Object

call-seq:

update_all_ephemeris(Time target_time)

An instance method.



17961
17962
17963
17964
17965
17966
17967
17968
17969
17970
17971
17972
17973
17974
17975
17976
17977
17978
17979
17980
17981
17982
17983
17984
17985
17986
17987
17988
17989
17990
17991
17992
17993
17994
17995
17996
17997
17998
17999
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 17961

SWIGINTERN VALUE
_wrap_SpaceNode_SBAS_update_all_ephemeris(int argc, VALUE *argv, VALUE self) {
  SBAS_SpaceNode< double > *arg1 = (SBAS_SpaceNode< double > *) 0 ;
  SBAS_SpaceNode< double >::gps_time_t *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SBAS_SpaceNodeT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SBAS_SpaceNode< double > *","update_all_ephemeris", 1, self )); 
  }
  arg1 = reinterpret_cast< SBAS_SpaceNode< double > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_GPS_TimeT_double_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "SBAS_SpaceNode< double >::gps_time_t const &","update_all_ephemeris", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "SBAS_SpaceNode< double >::gps_time_t const &","update_all_ephemeris", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< SBAS_SpaceNode< double >::gps_time_t * >(argp2);
  {
    try {
      (arg1)->update_all_ephemeris((SBAS_SpaceNode< double >::gps_time_t const &)*arg2);
    } catch (const native_exception &e) {
      e.regenerate();
      SWIG_fail;
    } catch (const std::exception& e) {
      SWIG_exception_fail(SWIG_RuntimeError, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}