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.



18822
18823
18824
18825
18826
18827
18828
18829
18830
18831
18832
18833
18834
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 18822

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;
  }
  result = (SBAS_SpaceNode< double > *)new SBAS_SpaceNode< double >();
  DATA_PTR(self) = result;
  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.



18697
18698
18699
18700
18701
18702
18703
18704
18705
18706
18707
18708
18709
18710
18711
18712
18713
18714
18715
18716
18717
18718
18719
18720
18721
18722
18723
18724
18725
18726
18727
18728
18729
18730
18731
18732
18733
18734
18735
18736
18737
18738
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 18697

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));
    }
  }
  result = (SBAS_SpaceNode< double >::float_t)SBAS_SpaceNode< double >::SWIGTEMPLATEDISAMBIGUATOR sagnac_correction(arg1,arg2);
  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.



18750
18751
18752
18753
18754
18755
18756
18757
18758
18759
18760
18761
18762
18763
18764
18765
18766
18767
18768
18769
18770
18771
18772
18773
18774
18775
18776
18777
18778
18779
18780
18781
18782
18783
18784
18785
18786
18787
18788
18789
18790
18791
18792
18793
18794
18795
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 18750

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);
  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);
  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.



18936
18937
18938
18939
18940
18941
18942
18943
18944
18945
18946
18947
18948
18949
18950
18951
18952
18953
18954
18955
18956
18957
18958
18959
18960
18961
18962
18963
18964
18965
18966
18967
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 18936

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;
  result = ((SBAS_SpaceNode< double > const *)arg1)->available_satellites((SBAS_SpaceNode< double >::float_t const &)*arg2);
  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.



19364
19365
19366
19367
19368
19369
19370
19371
19372
19373
19374
19375
19376
19377
19378
19379
19380
19381
19382
19383
19384
19385
19386
19387
19388
19389
19390
19391
19392
19393
19394
19395
19396
19397
19398
19399
19400
19401
19402
19403
19404
19405
19406
19407
19408
19409
19410
19411
19412
19413
19414
19415
19416
19417
19418
19419
19420
19421
19422
19423
19424
19425
19426
19427
19428
19429
19430
19431
19432
19433
19434
19435
19436
19437
19438
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 19364

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.



19150
19151
19152
19153
19154
19155
19156
19157
19158
19159
19160
19161
19162
19163
19164
19165
19166
19167
19168
19169
19170
19171
19172
19173
19174
19175
19176
19177
19178
19179
19180
19181
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 19150

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;
  result = SBAS_SpaceNode_Sl_double_Sg__ephemeris((SBAS_SpaceNode< double > const *)arg1,(int const &)*arg2);
  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.



18852
18853
18854
18855
18856
18857
18858
18859
18860
18861
18862
18863
18864
18865
18866
18867
18868
18869
18870
18871
18872
18873
18874
18875
18876
18877
18878
18879
18880
18881
18882
18883
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 18852

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;
  result = (bool)((SBAS_SpaceNode< double > const *)arg1)->has_satellite((int const &)*arg2);
  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.



19450
19451
19452
19453
19454
19455
19456
19457
19458
19459
19460
19461
19462
19463
19464
19465
19466
19467
19468
19469
19470
19471
19472
19473
19474
19475
19476
19477
19478
19479
19480
19481
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 19450

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;
  result = SBAS_SpaceNode_Sl_double_Sg__ionospheric_grid_points((SBAS_SpaceNode< double > const *)arg1,(int const &)*arg2);
  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.



19193
19194
19195
19196
19197
19198
19199
19200
19201
19202
19203
19204
19205
19206
19207
19208
19209
19210
19211
19212
19213
19214
19215
19216
19217
19218
19219
19220
19221
19222
19223
19224
19225
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 19193

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);
  result = (int)SBAS_SpaceNode_Sl_double_Sg__read(arg1,(char const *)arg2);
  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.



19074
19075
19076
19077
19078
19079
19080
19081
19082
19083
19084
19085
19086
19087
19088
19089
19090
19091
19092
19093
19094
19095
19096
19097
19098
19099
19100
19101
19102
19103
19104
19105
19106
19107
19108
19109
19110
19111
19112
19113
19114
19115
19116
19117
19118
19119
19120
19121
19122
19123
19124
19125
19126
19127
19128
19129
19130
19131
19132
19133
19134
19135
19136
19137
19138
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 19074

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.



18895
18896
18897
18898
18899
18900
18901
18902
18903
18904
18905
18906
18907
18908
18909
18910
18911
18912
18913
18914
18915
18916
18917
18918
18919
18920
18921
18922
18923
18924
 
# File 'ext/gps_pvt/GPS/GPS_wrap.cxx', line 18895

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);
  (arg1)->update_all_ephemeris((SBAS_SpaceNode< double >::gps_time_t const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}