core
/
eccodes
mirror of https://github.com/ecmwf/eccodes.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'feature/ECC-1903-tablesVersion-switch-with-chem-param-split' into feature/mtg2_switch_paramtype_timeproc

This commit is contained in:
Robert Osinski 2024-12-09 15:04:33 +00:00
parent 8e0b929ac7 473517435d
commit 9c5870e5f5
284 changed files with 169739 additions and 84118 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40812
definitions/grib2/localConcepts/ecmf/name.33.def
View File

File diff suppressed because it is too large Load Diff

41142
definitions/grib2/localConcepts/ecmf/paramId.33.def
View File

File diff suppressed because it is too large Load Diff

41298
definitions/grib2/localConcepts/ecmf/shortName.33.def
View File

File diff suppressed because it is too large Load Diff

40930
definitions/grib2/localConcepts/ecmf/units.33.def
View File

File diff suppressed because it is too large Load Diff

20404
definitions/grib2/name.33.def Normal file
View File

File diff suppressed because it is too large Load Diff

20404
definitions/grib2/paramId.33.def Normal file
View File

File diff suppressed because it is too large Load Diff

20404
definitions/grib2/shortName.33.def Normal file
View File

File diff suppressed because it is too large Load Diff

20404
definitions/grib2/units.33.def Normal file
View File

File diff suppressed because it is too large Load Diff

2
examples/F90/CMakeLists.txt
View File

@ -18,6 +18,7 @@ if( HAVE_BUILD_TOOLS )
bufr_ecc-1284
bufr_ecc-1019
get_native_type
key_is_computed
grib_ecc-671 )
list( APPEND tests_extra
grib_index
@ -81,6 +82,7 @@ else()
codes_set_paths
codes_f90_misc
get_native_type
key_is_computed
grib_ecc-671 )
list( APPEND tests_extra
grib_index

38
examples/F90/key_is_computed.f90 Normal file
View File

@ -0,0 +1,38 @@
! (C) Copyright 2005- ECMWF.
!
! This software is licensed under the terms of the Apache Licence Version 2.0
! which can be obtained at http://www.apache.org/licenses/LICENSECODES_INTERNAL_ERROR.0.
!
! In applying this licence, ECMWF does not waive the privileges and immunities granted to it by
! virtue of its status as an intergovernmental organisation nor does it submit to any jurisdiction.
!
program key_is_computed
use eccodes
implicit none
integer :: ihandle, is_computed=0
CALL codes_grib_new_from_samples(ihandle, "regular_ll_sfc_grib2")
CALL codes_key_is_computed(ihandle, 'edition', is_computed)
IF (is_computed /= 0) THEN
call codes_check(CODES_INTERNAL_ERROR, 'Error', 'key edition is coded')
END IF
CALL codes_key_is_computed(ihandle, 'longitudeOfLastGridPoint', is_computed)
IF (is_computed /= 0) THEN
call codes_check(CODES_INTERNAL_ERROR, 'Error', 'key longitudeOfLastGridPoint is coded')
END IF
CALL codes_key_is_computed(ihandle, 'longitudeOfLastGridPointInDegrees', is_computed)
IF (is_computed /= 1) THEN
call codes_check(CODES_INTERNAL_ERROR, 'Error', 'key longitudeOfLastGridPointInDegrees is computed')
END IF
CALL codes_key_is_computed(ihandle, 'gridType', is_computed)
IF (is_computed /= 1) THEN
call codes_check(CODES_INTERNAL_ERROR, 'Error', 'key gridType is computed')
END IF
CALL codes_release(ihandle)
end program key_is_computed

16
examples/F90/key_is_computed.sh Executable file
View File

@ -0,0 +1,16 @@
#!/bin/sh
# (C) Copyright 2005- ECMWF.
#
# This software is licensed under the terms of the Apache Licence Version 2.0
# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
#
# In applying this licence, ECMWF does not waive the privileges and immunities granted to it by
# virtue of its status as an intergovernmental organisation nor does it submit to any jurisdiction.
#
. ./include.ctest.sh
label="f_key_is_computed"
${examples_dir}/eccodes_f_key_is_computed

30
fortran/eccodes_f90_tail.f90
View File

@ -1710,6 +1710,36 @@
call grib_is_defined(msgid, key, is_defined, status)
end subroutine codes_is_defined
!!!
!> Check if a key is computed(virtual) or coded
!>
!> In case of error, if the status parameter (optional) is not given, the program will
!> exit with an error message.\n Otherwise the error message can be
!> gathered with @ref codes_get_error_string.
!>
!> @param msgid id of the message loaded in memory
!> @param key key name
!> @param is_computed 0->coded, 1->computed
!> @param status CODES_SUCCESS if OK, integer value on error
subroutine codes_key_is_computed(msgid, key, is_computed, status)
integer(kind=kindOfInt), intent(in) :: msgid
character(len=*), intent(in) :: key
integer(kind=kindOfInt), intent(out) :: is_computed
integer(kind=kindOfInt), optional, intent(out) :: status
integer(kind=kindOfInt) :: iret
iret = grib_f_key_is_computed(msgid, key, is_computed)
if (iret /= 0) then
call grib_f_write_on_fail(msgid)
end if
if (present(status)) then
status = iret
else
call grib_check(iret, 'key_is_computed', key)
end if
end subroutine codes_key_is_computed
!!!
!> Get the real(4) value of a key from a message.
!>
!> In case of error, if the status parameter (optional) is not given, the program will

2
fortran/eccodes_visibility.h
View File

@ -1,4 +1,4 @@
public :: codes_get, codes_set, codes_set_force, codes_grib_get_data, codes_is_missing, codes_is_defined
public :: codes_get, codes_set, codes_set_force, codes_grib_get_data, codes_is_missing, codes_is_defined, codes_key_is_computed
public :: codes_open_file, codes_close_file,codes_read_bytes,codes_write_bytes
public :: codes_grib_multi_support_on, codes_grib_multi_support_off
public :: codes_keys_iterator_new, &

2
fortran/grib_api_externals.h
View File

@ -48,7 +48,7 @@ integer, external :: grib_f_get_int, grib_f_get_long,grib_f_get_int_array, &
grib_f_get_real4_elements, grib_f_get_real8_elements, &
grib_f_get_string,grib_f_get_string_array, &
codes_f_bufr_copy_data, &
grib_f_is_missing,grib_f_is_defined
grib_f_is_missing, grib_f_is_defined, grib_f_key_is_computed
integer, external :: grib_f_new_from_index, &
grib_f_index_new_from_file, &
grib_f_index_add_file, &

14
fortran/grib_fortran.cc
View File

@ -2223,7 +2223,7 @@ int grib_f_is_missing_(int* gid, char* key,int* isMissing,int len)
int err=0;
grib_handle *h = get_handle(*gid);
char buf[1024];
if(!h) return GRIB_INVALID_GRIB;
if (!h) return GRIB_INVALID_GRIB;
*isMissing=grib_is_missing(h, cast_char(buf,key,len),&err);
return err;
@ -2240,6 +2240,18 @@ int grib_f_is_defined_(int* gid, char* key,int* isDefined,int len)
return GRIB_SUCCESS;
}
/*****************************************************************************/
int grib_f_key_is_computed_(int* gid, char* key,int* isComputed,int len)
{
int err = 0;
grib_handle *h = get_handle(*gid);
char buf[1024];
if (!h) return GRIB_INVALID_GRIB;
*isComputed = codes_key_is_computed(h, cast_char(buf,key,len), &err);
return err;
}
/*****************************************************************************/
int grib_f_set_real4_(int* gid, char* key, float* val, int len)
{

1
fortran/grib_fortran_prototypes.h
View File

@ -327,6 +327,7 @@ int grib_f_datetime_to_julian_(long* year,long* month,long* day, long* hour,long
int grib_f_set_string_array_(int* gid, char* key, char* val,int* nvals,int* slen, int len);
int codes_f_bufr_keys_iterator_get_name_(int* iterid, char* name, int len);
int codes_f_bufr_multi_element_constant_arrays_off_();
int grib_f_key_is_computed_(int *gid, char *key, int *isComputed, int len);
#ifdef __cplusplus

40
src/CMakeLists.txt
View File

@ -310,22 +310,27 @@ list( APPEND eccodes_src_files
grib_dependency.cc
grib_value.cc
grib_errors.cc
grib_expression_class_binop.cc
grib_expression_class_logical_and.cc
grib_expression_class_logical_or.cc
grib_expression_class_is_in_dict.cc
grib_expression_class_true.cc
grib_expression_class_string_compare.cc
grib_expression_class_unop.cc
grib_expression_class_functor.cc
grib_expression_class_accessor.cc
grib_expression_class_is_in_list.cc
grib_expression_class_is_integer.cc
grib_expression_class_length.cc
grib_expression_class_long.cc
grib_expression_class_double.cc
grib_expression_class_string.cc
grib_expression_class_sub_string.cc
expression/grib_arguments.cc
expression/grib_expression.cc
expression/grib_expression_class_binop.cc
expression/grib_expression_class_logical_and.cc
expression/grib_expression_class_logical_or.cc
expression/grib_expression_class_is_in_dict.cc
expression/grib_expression_class_true.cc
expression/grib_expression_class_string_compare.cc
expression/grib_expression_class_unop.cc
expression/grib_expression_class_functor.cc
expression/grib_expression_class_accessor.cc
expression/grib_expression_class_is_in_list.cc
expression/grib_expression_class_is_integer.cc
expression/grib_expression_class_length.cc
expression/grib_expression_class_long.cc
expression/grib_expression_class_double.cc
expression/grib_expression_class_string.cc
expression/grib_expression_class_sub_string.cc
geo_nearest/grib_nearest.cc
geo_nearest/grib_nearest_class_gen.cc
geo_nearest/grib_nearest_class_healpix.cc
@ -337,6 +342,7 @@ list( APPEND eccodes_src_files
geo_nearest/grib_nearest_class_reduced.cc
geo_nearest/grib_nearest_class_regular.cc
geo_nearest/grib_nearest_class_space_view.cc
geo_iterator/grib_iterator.cc
geo_iterator/grib_iterator_class_gaussian.cc
geo_iterator/grib_iterator_class_gaussian_reduced.cc
@ -351,7 +357,7 @@ list( APPEND eccodes_src_files
geo_iterator/grib_iterator_class_regular.cc
geo_iterator/grib_iterator_class_space_view.cc
geo_iterator/grib_iterator_class_unstructured.cc
grib_expression.cc
codes_util.cc
grib_util.cc
bufr_util.cc

4
src/accessor/grib_accessor_class_bit.cc
View File

@ -17,8 +17,8 @@ void grib_accessor_bit_t::init(const long len, grib_arguments* arg)
{
grib_accessor_long_t::init(len, arg);
length_ = 0;
owner_ = grib_arguments_get_name(grib_handle_of_accessor(this), arg, 0);
bit_index_ = grib_arguments_get_long(grib_handle_of_accessor(this), arg, 1);
owner_ = arg->get_name(grib_handle_of_accessor(this), 0);
bit_index_ = arg->get_long(grib_handle_of_accessor(this), 1);
}
int grib_accessor_bit_t::unpack_long(long* val, size_t* len)

8
src/accessor/grib_accessor_class_bitmap.cc
View File

@ -54,10 +54,10 @@ void grib_accessor_bitmap_t::init(const long len, grib_arguments* arg)
grib_handle* hand = grib_handle_of_accessor(this);
int n = 0;
tableReference_ = grib_arguments_get_name(hand, arg, n++);
missing_value_ = grib_arguments_get_name(hand, arg, n++);
offsetbsec_ = grib_arguments_get_name(hand, arg, n++);
sLength_ = grib_arguments_get_name(hand, arg, n++);
tableReference_ = arg->get_name(hand, n++);
missing_value_ = arg->get_name(hand, n++);
offsetbsec_ = arg->get_name(hand, n++);
sLength_ = arg->get_name(hand, n++);
compute_size();
}

12
src/accessor/grib_accessor_class_bits.cc
View File

@ -23,12 +23,12 @@ void grib_accessor_bits_t::init(const long l, grib_arguments* c)
int n = 0;
referenceValue_ = 0;
argument_ = grib_arguments_get_name(hand, c, n++);
start_ = grib_arguments_get_long(hand, c, n++);
len_ = grib_arguments_get_long(hand, c, n++);
e = grib_arguments_get_expression(hand, c, n++);
argument_ = c->get_name(hand, n++);
start_ = c->get_long(hand, n++);
len_ = c->get_long(hand, n++);
e = c->get_expression(hand, n++);
if (e) {
grib_expression_evaluate_double(hand, e, &(referenceValue_));
e->evaluate_double(hand, &(referenceValue_));
referenceValuePresent_ = 1;
}
else {
@ -36,7 +36,7 @@ void grib_accessor_bits_t::init(const long l, grib_arguments* c)
}
scale_ = 1;
if (referenceValuePresent_) {
scale_ = grib_arguments_get_double(hand, c, n++);
scale_ = c->get_double(hand, n++);
}
Assert(len_ <= sizeof(long) * 8);

4
src/accessor/grib_accessor_class_bits_per_value.cc
View File

@ -17,8 +17,8 @@ void grib_accessor_bits_per_value_t::init(const long l, grib_arguments* args)
{
grib_accessor_long_t::init(l, args);
int n = 0;
values_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, n++);
bits_per_value_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, n++);
values_ = args->get_name(grib_handle_of_accessor(this), n++);
bits_per_value_ = args->get_name(grib_handle_of_accessor(this), n++);
flags_ |= GRIB_ACCESSOR_FLAG_FUNCTION;
length_ = 0;
}

2
src/accessor/grib_accessor_class_blob.cc
View File

@ -17,7 +17,7 @@ void grib_accessor_blob_t::init(const long len, grib_arguments* arg)
{
grib_accessor_gen_t::init(len, arg);
grib_get_long_internal(grib_handle_of_accessor(this),
grib_arguments_get_name(parent_->h, arg, 0), &length_);
arg->get_name(parent_->h, 0), &length_);
Assert(length_ >= 0);
}

6
src/accessor/grib_accessor_class_budgdate.cc
View File

@ -18,9 +18,9 @@ void grib_accessor_budgdate_t::init(const long l, grib_arguments* c)
grib_accessor_long_t::init(l, c);
int n = 0;
year_ = grib_arguments_get_name(grib_handle_of_accessor(this), c, n++);
month_ = grib_arguments_get_name(grib_handle_of_accessor(this), c, n++);
day_ = grib_arguments_get_name(grib_handle_of_accessor(this), c, n++);
year_ = c->get_name(grib_handle_of_accessor(this), n++);
month_ = c->get_name(grib_handle_of_accessor(this), n++);
day_ = c->get_name(grib_handle_of_accessor(this), n++);
}
int grib_accessor_budgdate_t::unpack_long(long* val, size_t* len)

14
src/accessor/grib_accessor_class_bufr_data_array.cc
View File

@ -195,13 +195,13 @@ void grib_accessor_bufr_data_array_t::init(const long v, grib_arguments* params)
tempStrings_ = NULL;
bufrDataEncodedName_ = grib_arguments_get_name(grib_handle_of_accessor(this), params, n++);
numberOfSubsetsName_ = grib_arguments_get_name(grib_handle_of_accessor(this), params, n++);
expandedDescriptorsName_ = grib_arguments_get_name(grib_handle_of_accessor(this), params, n++);
flagsName_ = grib_arguments_get_name(grib_handle_of_accessor(this), params, n++);
elementsDescriptorsIndexName_ = grib_arguments_get_name(grib_handle_of_accessor(this), params, n++);
compressedDataName_ = grib_arguments_get_name(grib_handle_of_accessor(this), params, n++);
dataKeysName = grib_arguments_get_name(grib_handle_of_accessor(this), params, n++);
bufrDataEncodedName_ = params->get_name(grib_handle_of_accessor(this), n++);
numberOfSubsetsName_ = params->get_name(grib_handle_of_accessor(this), n++);
expandedDescriptorsName_ = params->get_name(grib_handle_of_accessor(this), n++);
flagsName_ = params->get_name(grib_handle_of_accessor(this), n++);
elementsDescriptorsIndexName_ = params->get_name(grib_handle_of_accessor(this), n++);
compressedDataName_ = params->get_name(grib_handle_of_accessor(this), n++);
dataKeysName = params->get_name(grib_handle_of_accessor(this), n++);
dataKeysAcc = grib_find_accessor(grib_handle_of_accessor(this), dataKeysName);
dataKeys_ = dataKeysAcc->parent_;

6
src/accessor/grib_accessor_class_bufr_elements_table.cc
View File

@ -47,9 +47,9 @@ void grib_accessor_bufr_elements_table_t::init(const long len, grib_arguments* p
grib_accessor_gen_t::init(len, params);
int n = 0;
dictionary_ = grib_arguments_get_string(grib_handle_of_accessor(this), params, n++);
masterDir_ = grib_arguments_get_name(grib_handle_of_accessor(this), params, n++);
localDir_ = grib_arguments_get_name(grib_handle_of_accessor(this), params, n++);
dictionary_ = params->get_string(grib_handle_of_accessor(this), n++);
masterDir_ = params->get_name(grib_handle_of_accessor(this), n++);
localDir_ = params->get_name(grib_handle_of_accessor(this), n++);
length_ = 0;
flags_ |= GRIB_ACCESSOR_FLAG_READ_ONLY;

20
src/accessor/grib_accessor_class_bufr_extract_area_subsets.cc
View File

@ -20,16 +20,16 @@ void grib_accessor_bufr_extract_area_subsets_t::init(const long len, grib_argume
int n = 0;
length_ = 0;
doExtractSubsets_ = grib_arguments_get_name(h, arg, n++);
numberOfSubsets_ = grib_arguments_get_name(h, arg, n++);
extractSubsetList_ = grib_arguments_get_name(h, arg, n++);
extractAreaWestLongitude_ = grib_arguments_get_name(h, arg, n++);
extractAreaEastLongitude_ = grib_arguments_get_name(h, arg, n++);
extractAreaNorthLatitude_ = grib_arguments_get_name(h, arg, n++);
extractAreaSouthLatitude_ = grib_arguments_get_name(h, arg, n++);
extractAreaLongitudeRank_ = grib_arguments_get_name(h, arg, n++);
extractAreaLatitudeRank_ = grib_arguments_get_name(h, arg, n++);
extractedAreaNumberOfSubsets_ = grib_arguments_get_name(h, arg, n++);
doExtractSubsets_ = arg->get_name(h, n++);
numberOfSubsets_ = arg->get_name(h, n++);
extractSubsetList_ = arg->get_name(h, n++);
extractAreaWestLongitude_ = arg->get_name(h, n++);
extractAreaEastLongitude_ = arg->get_name(h, n++);
extractAreaNorthLatitude_ = arg->get_name(h, n++);
extractAreaSouthLatitude_ = arg->get_name(h, n++);
extractAreaLongitudeRank_ = arg->get_name(h, n++);
extractAreaLatitudeRank_ = arg->get_name(h, n++);
extractedAreaNumberOfSubsets_ = arg->get_name(h, n++);
flags_ |= GRIB_ACCESSOR_FLAG_FUNCTION;
}

6
src/accessor/grib_accessor_class_bufr_extract_datetime_subsets.cc
View File

@ -19,9 +19,9 @@ void grib_accessor_bufr_extract_datetime_subsets_t::init(const long len, grib_ar
int n = 0;
length_ = 0;
doExtractSubsets_ = grib_arguments_get_name(grib_handle_of_accessor(this), arg, n++);
numberOfSubsets_ = grib_arguments_get_name(grib_handle_of_accessor(this), arg, n++);
extractSubsetList_ = grib_arguments_get_name(grib_handle_of_accessor(this), arg, n++);
doExtractSubsets_ = arg->get_name(grib_handle_of_accessor(this), n++);
numberOfSubsets_ = arg->get_name(grib_handle_of_accessor(this), n++);
extractSubsetList_ = arg->get_name(grib_handle_of_accessor(this), n++);
flags_ |= GRIB_ACCESSOR_FLAG_FUNCTION;
}

4
src/accessor/grib_accessor_class_bufr_extract_subsets.cc
View File

@ -29,8 +29,8 @@ void grib_accessor_bufr_extract_subsets_t::init(const long len, grib_arguments*
int n = 0;
length_ = 0;
numericValues_ = grib_arguments_get_name(grib_handle_of_accessor(this), arg, n++);
pack_ = grib_arguments_get_name(grib_handle_of_accessor(this), arg, n++);
numericValues_ = arg->get_name(grib_handle_of_accessor(this), n++);
pack_ = arg->get_name(grib_handle_of_accessor(this), n++);
flags_ |= GRIB_ACCESSOR_FLAG_FUNCTION;
numericValuesAccessor_ = NULL;

12
src/accessor/grib_accessor_class_bufr_simple_thinning.cc
View File

@ -20,12 +20,12 @@ void grib_accessor_bufr_simple_thinning_t::init(const long len, grib_arguments*
int n = 0;
length_ = 0;
doExtractSubsets_ = grib_arguments_get_name(h, arg, n++);
numberOfSubsets_ = grib_arguments_get_name(h, arg, n++);
extractSubsetList_ = grib_arguments_get_name(h, arg, n++);
simpleThinningStart_ = grib_arguments_get_name(h, arg, n++);
simpleThinningMissingRadius_ = grib_arguments_get_name(h, arg, n++);
simpleThinningSkip_ = grib_arguments_get_name(h, arg, n++);
doExtractSubsets_ = arg->get_name(h, n++);
numberOfSubsets_ = arg->get_name(h, n++);
extractSubsetList_ = arg->get_name(h, n++);
simpleThinningStart_ = arg->get_name(h, n++);
simpleThinningMissingRadius_ = arg->get_name(h, n++);
simpleThinningSkip_ = arg->get_name(h, n++);
flags_ |= GRIB_ACCESSOR_FLAG_FUNCTION;
}

2
src/accessor/grib_accessor_class_bufr_string_values.cc
View File

@ -18,7 +18,7 @@ void grib_accessor_bufr_string_values_t::init(const long len, grib_arguments* ar
{
grib_accessor_ascii_t::init(len, args);
int n = 0;
dataAccessorName_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, n++);
dataAccessorName_ = args->get_name(grib_handle_of_accessor(this), n++);
dataAccessor_ = NULL;
length_ = 0;
flags_ |= GRIB_ACCESSOR_FLAG_READ_ONLY;

2
src/accessor/grib_accessor_class_bufrdc_expanded_descriptors.cc
View File

@ -17,7 +17,7 @@ void grib_accessor_bufrdc_expanded_descriptors_t::init(const long len, grib_argu
{
grib_accessor_long_t::init(len, args);
int n = 0;
expandedDescriptors_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, n++);
expandedDescriptors_ = args->get_name(grib_handle_of_accessor(this), n++);
expandedDescriptorsAccessor_ = 0;
length_ = 0;
flags_ |= GRIB_ACCESSOR_FLAG_READ_ONLY;

2
src/accessor/grib_accessor_class_cf_var_name.cc
View File

@ -17,7 +17,7 @@ void grib_accessor_cf_var_name_t::init(const long l, grib_arguments* arg)
{
grib_accessor_ascii_t::init(l, arg);
grib_handle* h = grib_handle_of_accessor(this);
defaultKey_ = grib_arguments_get_name(h, arg, 0);
defaultKey_ = arg->get_name(h, 0);
}
int grib_accessor_cf_var_name_t::unpack_string(char* val, size_t* len)

8
src/accessor/grib_accessor_class_change_alternative_row_scanning.cc
View File

@ -18,10 +18,10 @@ void grib_accessor_change_alternative_row_scanning_t::init(const long len, grib_
grib_accessor_gen_t::init(len, args);
int n = 0;
values_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, n++);
Ni_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, n++);
Nj_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, n++);
alternativeRowScanning_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, n++);
values_ = args->get_name(grib_handle_of_accessor(this), n++);
Ni_ = args->get_name(grib_handle_of_accessor(this), n++);
Nj_ = args->get_name(grib_handle_of_accessor(this), n++);
alternativeRowScanning_ = args->get_name(grib_handle_of_accessor(this), n++);
flags_ |= GRIB_ACCESSOR_FLAG_FUNCTION;
length_ = 0;

16
src/accessor/grib_accessor_class_change_scanning_direction.cc
View File

@ -19,14 +19,14 @@ void grib_accessor_change_scanning_direction_t::init(const long len, grib_argume
grib_handle* h = grib_handle_of_accessor(this);
int n = 0;
values_ = grib_arguments_get_name(h, args, n++);
Ni_ = grib_arguments_get_name(h, args, n++);
Nj_ = grib_arguments_get_name(h, args, n++);
i_scans_negatively_ = grib_arguments_get_name(h, args, n++);
j_scans_positively_ = grib_arguments_get_name(h, args, n++);
first_ = grib_arguments_get_name(h, args, n++);
last_ = grib_arguments_get_name(h, args, n++);
axis_ = grib_arguments_get_name(h, args, n++);
values_ = args->get_name(h, n++);
Ni_ = args->get_name(h, n++);
Nj_ = args->get_name(h, n++);
i_scans_negatively_ = args->get_name(h, n++);
j_scans_positively_ = args->get_name(h, n++);
first_ = args->get_name(h, n++);
last_ = args->get_name(h, n++);
axis_ = args->get_name(h, n++);
flags_ |= GRIB_ACCESSOR_FLAG_FUNCTION;
length_ = 0;

2
src/accessor/grib_accessor_class_check_internal_version.cc
View File

@ -25,7 +25,7 @@ void grib_accessor_check_internal_version_t::init(const long l, grib_arguments*
int err = 0;
long defs_file_version = 0;
grib_handle* h = grib_handle_of_accessor(this);
const char* s_defn_version = grib_arguments_get_name(h, args, 0);
const char* s_defn_version = args->get_name(h, 0);
Assert(s_defn_version);
err = grib_get_long_internal(h, s_defn_version, &defs_file_version);

18
src/accessor/grib_accessor_class_closest_date.cc
View File

@ -20,15 +20,15 @@ void grib_accessor_closest_date_t::init(const long l, grib_arguments* c)
grib_handle* h = grib_handle_of_accessor(this);
int n = 0;
dateLocal_ = grib_arguments_get_name(h, c, n++);
timeLocal_ = grib_arguments_get_name(h, c, n++);
numForecasts_ = grib_arguments_get_name(h, c, n++);
year_ = grib_arguments_get_name(h, c, n++);
month_ = grib_arguments_get_name(h, c, n++);
day_ = grib_arguments_get_name(h, c, n++);
hour_ = grib_arguments_get_name(h, c, n++);
minute_ = grib_arguments_get_name(h, c, n++);
second_ = grib_arguments_get_name(h, c, n++);
dateLocal_ = c->get_name(h, n++);
timeLocal_ = c->get_name(h, n++);
numForecasts_ = c->get_name(h, n++);
year_ = c->get_name(h, n++);
month_ = c->get_name(h, n++);
day_ = c->get_name(h, n++);
hour_ = c->get_name(h, n++);
minute_ = c->get_name(h, n++);
second_ = c->get_name(h, n++);
length_ = 0;
}

2
src/accessor/grib_accessor_class_codeflag.cc
View File

@ -17,7 +17,7 @@ void grib_accessor_codeflag_t::init(const long len, grib_arguments* param)
{
grib_accessor_unsigned_t::init(len, param);
length_ = len;
tablename_ = grib_arguments_get_string(grib_handle_of_accessor(this), param, 0);
tablename_ = param->get_string(grib_handle_of_accessor(this), 0);
Assert(length_ >= 0);
}

36
src/accessor/grib_accessor_class_codetable.cc
View File

@ -61,19 +61,19 @@ void grib_accessor_codetable_t::init(const long len, grib_arguments* params)
* its length as an identifier not an integer. This identifier is
* added to the argument list (at the beginning)
*/
new_len = grib_arguments_get_long(hand, params, n++);
new_len = params->get_long(hand, n++);
if (new_len <= 0) {
grib_context_log(context_, GRIB_LOG_FATAL, "%s: codetable length must be a positive integer", name_);
}
nbytes_ = new_len;
}
tablename_ = grib_arguments_get_string(hand, params, n++);
tablename_ = params->get_string(hand, n++);
if (tablename_ == NULL) {
grib_context_log(context_, GRIB_LOG_FATAL, "%s: codetable table is invalid", name_);
}
masterDir_ = grib_arguments_get_name(hand, params, n++); /* can be NULL */
localDir_ = grib_arguments_get_name(hand, params, n++); /* can be NULL */
masterDir_ = params->get_name(hand, n++); /* can be NULL */
localDir_ = params->get_name(hand, n++); /* can be NULL */
/*if (flags_ & GRIB_ACCESSOR_FLAG_STRING_TYPE)
printf("-------- %s type string (%ld)\n",a->name,flags_ );*/
@ -97,22 +97,22 @@ void grib_accessor_codetable_t::init(const long len, grib_arguments* params)
int ret = 0;
double d;
char tmp[1024];
grib_expression* expression = grib_arguments_get_expression(hand, act->default_value, 0);
int type = grib_expression_native_type(hand, expression);
grib_expression* expression = act->default_value->get_expression(hand, 0);
int type = expression->native_type(hand);
switch (type) {
case GRIB_TYPE_DOUBLE:
grib_expression_evaluate_double(hand, expression, &d);
expression->evaluate_double(hand, &d);
pack_double(&d, &s_len);
break;
case GRIB_TYPE_LONG:
grib_expression_evaluate_long(grib_handle_of_accessor(this), expression, &l);
expression->evaluate_long(grib_handle_of_accessor(this), &l);
pack_long(&l, &s_len);
break;
default:
s_len = sizeof(tmp);
p = grib_expression_evaluate_string(grib_handle_of_accessor(this), expression, tmp, &s_len, &ret);
p = expression->evaluate_string(grib_handle_of_accessor(this), tmp, &s_len, &ret);
if (ret != GRIB_SUCCESS) {
grib_context_log(context_, GRIB_LOG_FATAL,
"Unable to evaluate %s as string", name_);
@ -683,22 +683,22 @@ int grib_accessor_codetable_t::pack_string(const char* buffer, size_t* len)
int ret = 0;
double d = 0;
char tmp[1024] = {0,};
grib_expression* expression = grib_arguments_get_expression(grib_handle_of_accessor(this), act->default_value, 0);
int type = grib_expression_native_type(grib_handle_of_accessor(this), expression);
grib_expression* expression = act->default_value->get_expression(grib_handle_of_accessor(this), 0);
int type = expression->native_type(grib_handle_of_accessor(this));
switch (type) {
case GRIB_TYPE_DOUBLE:
grib_expression_evaluate_double(grib_handle_of_accessor(this), expression, &d);
expression->evaluate_double(grib_handle_of_accessor(this), &d);
pack_double(&d, &s_len);
break;
case GRIB_TYPE_LONG:
grib_expression_evaluate_long(grib_handle_of_accessor(this), expression, &l);
expression->evaluate_long(grib_handle_of_accessor(this), &l);
pack_long(&l, &s_len);
break;
default:
s_len = sizeof(tmp);
p = grib_expression_evaluate_string(grib_handle_of_accessor(this), expression, tmp, &s_len, &ret);
p = expression->evaluate_string(grib_handle_of_accessor(this), tmp, &s_len, &ret);
if (ret != GRIB_SUCCESS) {
grib_context_log(context_, GRIB_LOG_ERROR,
"%s: Unable to evaluate default value of %s as string expression", __func__, name_);
@ -735,19 +735,19 @@ int grib_accessor_codetable_t::pack_expression(grib_expression* e)
size_t len = 1;
grib_handle* hand = grib_handle_of_accessor(this);
if (strcmp(e->cclass->name, "long") == 0) {
grib_expression_evaluate_long(hand, e, &lval); /* TODO: check return value */
if (strcmp(e->class_name(), "long") == 0) {
e->evaluate_long(hand, &lval); /* TODO: check return value */
// if (hand->context->debug) printf("ECCODES DEBUG grib_accessor_codetable::pack_expression %s %ld\n", name_ ,lval);
ret = pack_long(&lval, &len);
}
else {
char tmp[1024];
len = sizeof(tmp);
cval = grib_expression_evaluate_string(hand, e, tmp, &len, &ret);
cval = e->evaluate_string(hand, tmp, &len, &ret);
if (ret != GRIB_SUCCESS) {
grib_context_log(context_, GRIB_LOG_ERROR,
"grib_accessor_codetable.%s: Unable to evaluate string %s to be set in %s",
__func__, grib_expression_get_name(e), name_);
__func__, e->get_name(), name_);
return ret;
}
len = strlen(cval) + 1;

2
src/accessor/grib_accessor_class_codetable_title.cc
View File

@ -18,7 +18,7 @@ void grib_accessor_codetable_title_t::init(const long len, grib_arguments* param
{
grib_accessor_gen_t::init(len, params);
int n = 0;
codetable_ = grib_arguments_get_name(grib_handle_of_accessor(this), params, n++);
codetable_ = params->get_name(grib_handle_of_accessor(this), n++);
length_ = 0;
flags_ |= GRIB_ACCESSOR_FLAG_READ_ONLY;
}

2
src/accessor/grib_accessor_class_codetable_units.cc
View File

@ -19,7 +19,7 @@ void grib_accessor_codetable_units_t::init(const long len, grib_arguments* param
grib_accessor_gen_t::init(len, params);
int n = 0;
codetable_ = grib_arguments_get_name(grib_handle_of_accessor(this), params, n++);
codetable_ = params->get_name(grib_handle_of_accessor(this), n++);
length_ = 0;
flags_ |= GRIB_ACCESSOR_FLAG_READ_ONLY;
}

16
src/accessor/grib_accessor_class_concept.cc
View File

@ -72,11 +72,11 @@ static int concept_condition_expression_true(
long lres = 0;
int ok = FALSE; // Boolean
int err = 0;
const int type = grib_expression_native_type(h, c->expression);
const int type = c->expression->native_type(h);
switch (type) {
case GRIB_TYPE_LONG:
grib_expression_evaluate_long(h, c->expression, &lres);
c->expression->evaluate_long(h, &lres);
// Use memoization for the most common type (integer keys)
ok = (grib_get_long_memoize(h, c->name, &lval, memo) == GRIB_SUCCESS) &&
(lval == lres);
@ -86,7 +86,7 @@ static int concept_condition_expression_true(
case GRIB_TYPE_DOUBLE: {
double dval;
double dres = 0.0;
grib_expression_evaluate_double(h, c->expression, &dres);
c->expression->evaluate_double(h, &dres);
ok = (grib_get_double(h, c->name, &dval) == GRIB_SUCCESS) &&
(dval == dres);
break;
@ -100,7 +100,7 @@ static int concept_condition_expression_true(
size_t size = sizeof(tmp);
ok = (grib_get_string(h, c->name, buf, &len) == GRIB_SUCCESS) &&
((cval = grib_expression_evaluate_string(h, c->expression, tmp, &size, &err)) != NULL) &&
((cval = c->expression->evaluate_string(h, tmp, &size, &err)) != NULL) &&
(err == 0) && (grib_inline_strcmp(buf, cval) == 0);
break;
}
@ -203,19 +203,19 @@ static int concept_conditions_expression_apply(grib_handle* h, grib_concept_cond
Assert(count < 1024);
values[count].name = e->name;
values[count].type = grib_expression_native_type(h, e->expression);
values[count].type = e->expression->native_type(h);
switch (values[count].type) {
case GRIB_TYPE_LONG:
grib_expression_evaluate_long(h, e->expression, &lres);
e->expression->evaluate_long(h, &lres);
values[count].long_value = lres;
break;
case GRIB_TYPE_DOUBLE:
grib_expression_evaluate_double(h, e->expression, &dres);
e->expression->evaluate_double(h, &dres);
values[count].double_value = dres;
break;
case GRIB_TYPE_STRING:
size = sizeof(sa->v[count]);
values[count].string_value = grib_expression_evaluate_string(h, e->expression, sa->v[count], &size, &err);
values[count].string_value = e->expression->evaluate_string(h, sa->v[count], &size, &err);
break;
default:
return GRIB_NOT_IMPLEMENTED;

8
src/accessor/grib_accessor_class_count_missing.cc
View File

@ -39,10 +39,10 @@ void grib_accessor_count_missing_t::init(const long len, grib_arguments* arg)
grib_handle* h = grib_handle_of_accessor(this);
length_ = 0;
flags_ |= GRIB_ACCESSOR_FLAG_READ_ONLY;
bitmap_ = grib_arguments_get_name(h, arg, n++);
unusedBitsInBitmap_ = grib_arguments_get_name(h, arg, n++);
numberOfDataPoints_ = grib_arguments_get_name(h, arg, n++);
missingValueManagementUsed_ = grib_arguments_get_name(h, arg, n++); /* Can be NULL */
bitmap_ = arg->get_name(h, n++);
unusedBitsInBitmap_ = arg->get_name(h, n++);
numberOfDataPoints_ = arg->get_name(h, n++);
missingValueManagementUsed_ = arg->get_name(h, n++); /* Can be NULL */
}
static const int used[] = { 0, 1, 3, 7, 15, 31, 63, 127, 255 };

12
src/accessor/grib_accessor_class_data_apply_bitmap.cc
View File

@ -18,12 +18,12 @@ void grib_accessor_data_apply_bitmap_t::init(const long v, grib_arguments* args)
grib_accessor_gen_t::init(v, args);
int n = 0;
coded_values_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, n++);
bitmap_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, n++);
missing_value_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, n++);
binary_scale_factor_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, n++);
number_of_data_points_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, n++);
number_of_values_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, n++);
coded_values_ = args->get_name(grib_handle_of_accessor(this), n++);
bitmap_ = args->get_name(grib_handle_of_accessor(this), n++);
missing_value_ = args->get_name(grib_handle_of_accessor(this), n++);
binary_scale_factor_ = args->get_name(grib_handle_of_accessor(this), n++);
number_of_data_points_ = args->get_name(grib_handle_of_accessor(this), n++);
number_of_values_ = args->get_name(grib_handle_of_accessor(this), n++);
length_ = 0;
}

10
src/accessor/grib_accessor_class_data_apply_boustrophedonic.cc
View File

@ -18,11 +18,11 @@ void grib_accessor_data_apply_boustrophedonic_t::init(const long v, grib_argumen
grib_accessor_gen_t::init(v, args);
int n = 0;
values_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, n++);
numberOfRows_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, n++);
numberOfColumns_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, n++);
numberOfPoints_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, n++);
pl_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, n++);
values_ = args->get_name(grib_handle_of_accessor(this), n++);
numberOfRows_ = args->get_name(grib_handle_of_accessor(this), n++);
numberOfColumns_ = args->get_name(grib_handle_of_accessor(this), n++);
numberOfPoints_ = args->get_name(grib_handle_of_accessor(this), n++);
pl_ = args->get_name(grib_handle_of_accessor(this), n++);
length_ = 0;
}

14
src/accessor/grib_accessor_class_data_apply_boustrophedonic_bitmap.cc
View File

@ -19,14 +19,14 @@ void grib_accessor_data_apply_boustrophedonic_bitmap_t::init(const long v, grib_
int n = 0;
grib_handle* gh = grib_handle_of_accessor(this);
coded_values_ = grib_arguments_get_name(gh, args, n++);
bitmap_ = grib_arguments_get_name(gh, args, n++);
missing_value_ = grib_arguments_get_name(gh, args, n++);
binary_scale_factor_ = grib_arguments_get_name(gh, args, n++);
coded_values_ = args->get_name(gh, n++);
bitmap_ = args->get_name(gh, n++);
missing_value_ = args->get_name(gh, n++);
binary_scale_factor_ = args->get_name(gh, n++);
numberOfRows_ = grib_arguments_get_name(gh, args, n++);
numberOfColumns_ = grib_arguments_get_name(gh, args, n++);
numberOfPoints_ = grib_arguments_get_name(gh, args, n++);
numberOfRows_ = args->get_name(gh, n++);
numberOfColumns_ = args->get_name(gh, n++);
numberOfPoints_ = args->get_name(gh, n++);
length_ = 0;
}

20
src/accessor/grib_accessor_class_data_ccsds_packing.cc
View File

@ -25,16 +25,16 @@ void grib_accessor_data_ccsds_packing_t::init(const long v, grib_arguments* args
grib_accessor_values_t::init(v, args);
grib_handle* h = grib_handle_of_accessor(this);
number_of_values_ = grib_arguments_get_name(h, args, carg_++);
reference_value_ = grib_arguments_get_name(h, args, carg_++);
binary_scale_factor_ = grib_arguments_get_name(h, args, carg_++);
decimal_scale_factor_ = grib_arguments_get_name(h, args, carg_++);
optimize_scaling_factor_ = grib_arguments_get_name(h, args, carg_++);
bits_per_value_ = grib_arguments_get_name(h, args, carg_++);
number_of_data_points_ = grib_arguments_get_name(h, args, carg_++);
ccsds_flags_ = grib_arguments_get_name(h, args, carg_++);
ccsds_block_size_ = grib_arguments_get_name(h, args, carg_++);
ccsds_rsi_ = grib_arguments_get_name(h, args, carg_++);
number_of_values_ = args->get_name(h, carg_++);
reference_value_ = args->get_name(h, carg_++);
binary_scale_factor_ = args->get_name(h, carg_++);
decimal_scale_factor_ = args->get_name(h, carg_++);
optimize_scaling_factor_ = args->get_name(h, carg_++);
bits_per_value_ = args->get_name(h, carg_++);
number_of_data_points_ = args->get_name(h, carg_++);
ccsds_flags_ = args->get_name(h, carg_++);
ccsds_block_size_ = args->get_name(h, carg_++);
ccsds_rsi_ = args->get_name(h, carg_++);
flags_ |= GRIB_ACCESSOR_FLAG_DATA;
}

20
src/accessor/grib_accessor_class_data_complex_packing.cc
View File

@ -18,16 +18,16 @@ void grib_accessor_data_complex_packing_t::init(const long v, grib_arguments* ar
grib_accessor_data_simple_packing_t::init(v, args);
grib_handle* gh = grib_handle_of_accessor(this);
GRIBEX_sh_bug_present_ = grib_arguments_get_name(gh, args, carg_++);
ieee_floats_ = grib_arguments_get_name(gh, args, carg_++);
laplacianOperatorIsSet_ = grib_arguments_get_name(gh, args, carg_++);
laplacianOperator_ = grib_arguments_get_name(gh, args, carg_++);
sub_j_ = grib_arguments_get_name(gh, args, carg_++);
sub_k_ = grib_arguments_get_name(gh, args, carg_++);
sub_m_ = grib_arguments_get_name(gh, args, carg_++);
pen_j_ = grib_arguments_get_name(gh, args, carg_++);
pen_k_ = grib_arguments_get_name(gh, args, carg_++);
pen_m_ = grib_arguments_get_name(gh, args, carg_++);
GRIBEX_sh_bug_present_ = args->get_name(gh, carg_++);
ieee_floats_ = args->get_name(gh, carg_++);
laplacianOperatorIsSet_ = args->get_name(gh, carg_++);
laplacianOperator_ = args->get_name(gh, carg_++);
sub_j_ = args->get_name(gh, carg_++);
sub_k_ = args->get_name(gh, carg_++);
sub_m_ = args->get_name(gh, carg_++);
pen_j_ = args->get_name(gh, carg_++);
pen_k_ = args->get_name(gh, carg_++);
pen_m_ = args->get_name(gh, carg_++);
flags_ |= GRIB_ACCESSOR_FLAG_DATA;
}

6
src/accessor/grib_accessor_class_data_dummy_field.cc
View File

@ -16,9 +16,9 @@ grib_accessor* grib_accessor_data_dummy_field = &_grib_accessor_data_dummy_field
void grib_accessor_data_dummy_field_t::init(const long v, grib_arguments* args)
{
grib_accessor_data_g1simple_packing_t::init(v, args);
missing_value_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, carg_++);
numberOfPoints_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, carg_++);
bitmap_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, carg_++);
missing_value_ = args->get_name(grib_handle_of_accessor(this), carg_++);
numberOfPoints_ = args->get_name(grib_handle_of_accessor(this), carg_++);
bitmap_ = args->get_name(grib_handle_of_accessor(this), carg_++);
}
int grib_accessor_data_dummy_field_t::unpack_double(double* val, size_t* len)

10
src/accessor/grib_accessor_class_data_g1complex_packing.cc
View File

@ -16,11 +16,11 @@ grib_accessor* grib_accessor_data_g1complex_packing = &_grib_accessor_data_g1com
void grib_accessor_data_g1complex_packing_t::init(const long v, grib_arguments* args)
{
grib_accessor_data_complex_packing_t::init(v, args);
half_byte_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, carg_++);
N_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, carg_++);
packingType_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, carg_++);
ieee_packing_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, carg_++);
precision_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, carg_++);
half_byte_ = args->get_name(grib_handle_of_accessor(this), carg_++);
N_ = args->get_name(grib_handle_of_accessor(this), carg_++);
packingType_ = args->get_name(grib_handle_of_accessor(this), carg_++);
ieee_packing_ = args->get_name(grib_handle_of_accessor(this), carg_++);
precision_ = args->get_name(grib_handle_of_accessor(this), carg_++);
edition_ = 1;
flags_ |= GRIB_ACCESSOR_FLAG_DATA;
}

32
src/accessor/grib_accessor_class_data_g1second_order_constant_width_packing.cc
View File

@ -19,22 +19,22 @@ void grib_accessor_data_g1second_order_constant_width_packing_t::init(const long
grib_accessor_data_simple_packing_t::init(v, args);
grib_handle* hand = grib_handle_of_accessor(this);
half_byte_ = grib_arguments_get_name(hand, args, carg_++);
packingType_ = grib_arguments_get_name(hand, args, carg_++);
ieee_packing_ = grib_arguments_get_name(hand, args, carg_++);
precision_ = grib_arguments_get_name(hand, args, carg_++);
widthOfFirstOrderValues_ = grib_arguments_get_name(hand, args, carg_++);
N1_ = grib_arguments_get_name(hand, args, carg_++);
N2_ = grib_arguments_get_name(hand, args, carg_++);
numberOfGroups_ = grib_arguments_get_name(hand, args, carg_++);
numberOfSecondOrderPackedValues_ = grib_arguments_get_name(hand, args, carg_++);
extraValues_ = grib_arguments_get_name(hand, args, carg_++);
Ni_ = grib_arguments_get_name(hand, args, carg_++);
Nj_ = grib_arguments_get_name(hand, args, carg_++);
pl_ = grib_arguments_get_name(hand, args, carg_++);
jPointsAreConsecutive_ = grib_arguments_get_name(hand, args, carg_++);
bitmap_ = grib_arguments_get_name(hand, args, carg_++);
groupWidth_ = grib_arguments_get_name(hand, args, carg_++);
half_byte_ = args->get_name(hand, carg_++);
packingType_ = args->get_name(hand, carg_++);
ieee_packing_ = args->get_name(hand, carg_++);
precision_ = args->get_name(hand, carg_++);
widthOfFirstOrderValues_ = args->get_name(hand, carg_++);
N1_ = args->get_name(hand, carg_++);
N2_ = args->get_name(hand, carg_++);
numberOfGroups_ = args->get_name(hand, carg_++);
numberOfSecondOrderPackedValues_ = args->get_name(hand, carg_++);
extraValues_ = args->get_name(hand, carg_++);
Ni_ = args->get_name(hand, carg_++);
Nj_ = args->get_name(hand, carg_++);
pl_ = args->get_name(hand, carg_++);
jPointsAreConsecutive_ = args->get_name(hand, carg_++);
bitmap_ = args->get_name(hand, carg_++);
groupWidth_ = args->get_name(hand, carg_++);
edition_ = 1;
flags_ |= GRIB_ACCESSOR_FLAG_DATA;
}

44
src/accessor/grib_accessor_class_data_g1second_order_general_extended_packing.cc
View File

@ -58,28 +58,28 @@ void grib_accessor_data_g1second_order_general_extended_packing_t::init(const lo
grib_accessor_data_simple_packing_t::init(v, args);
grib_handle* handle = grib_handle_of_accessor(this);
half_byte_ = grib_arguments_get_name(handle, args, carg_++);
packingType_ = grib_arguments_get_name(handle, args, carg_++);
ieee_packing_ = grib_arguments_get_name(handle, args, carg_++);
precision_ = grib_arguments_get_name(handle, args, carg_++);
widthOfFirstOrderValues_ = grib_arguments_get_name(handle, args, carg_++);
firstOrderValues_ = grib_arguments_get_name(handle, args, carg_++);
N1_ = grib_arguments_get_name(handle, args, carg_++);
N2_ = grib_arguments_get_name(handle, args, carg_++);
numberOfGroups_ = grib_arguments_get_name(handle, args, carg_++);
codedNumberOfGroups_ = grib_arguments_get_name(handle, args, carg_++);
numberOfSecondOrderPackedValues_ = grib_arguments_get_name(handle, args, carg_++);
extraValues_ = grib_arguments_get_name(handle, args, carg_++);
groupWidths_ = grib_arguments_get_name(handle, args, carg_++);
widthOfWidths_ = grib_arguments_get_name(handle, args, carg_++);
groupLengths_ = grib_arguments_get_name(handle, args, carg_++);
widthOfLengths_ = grib_arguments_get_name(handle, args, carg_++);
NL_ = grib_arguments_get_name(handle, args, carg_++);
SPD_ = grib_arguments_get_name(handle, args, carg_++);
widthOfSPD_ = grib_arguments_get_name(handle, args, carg_++);
orderOfSPD_ = grib_arguments_get_name(handle, args, carg_++);
numberOfPoints_ = grib_arguments_get_name(handle, args, carg_++);
dataFlag_ = grib_arguments_get_name(handle, args, carg_++);
half_byte_ = args->get_name(handle, carg_++);
packingType_ = args->get_name(handle, carg_++);
ieee_packing_ = args->get_name(handle, carg_++);
precision_ = args->get_name(handle, carg_++);
widthOfFirstOrderValues_ = args->get_name(handle, carg_++);
firstOrderValues_ = args->get_name(handle, carg_++);
N1_ = args->get_name(handle, carg_++);
N2_ = args->get_name(handle, carg_++);
numberOfGroups_ = args->get_name(handle, carg_++);
codedNumberOfGroups_ = args->get_name(handle, carg_++);
numberOfSecondOrderPackedValues_ = args->get_name(handle, carg_++);
extraValues_ = args->get_name(handle, carg_++);
groupWidths_ = args->get_name(handle, carg_++);
widthOfWidths_ = args->get_name(handle, carg_++);
groupLengths_ = args->get_name(handle, carg_++);
widthOfLengths_ = args->get_name(handle, carg_++);
NL_ = args->get_name(handle, carg_++);
SPD_ = args->get_name(handle, carg_++);
widthOfSPD_ = args->get_name(handle, carg_++);
orderOfSPD_ = args->get_name(handle, carg_++);
numberOfPoints_ = args->get_name(handle, carg_++);
dataFlag_ = args->get_name(handle, carg_++);
edition_ = 1;
dirty_ = 1;
dvalues_ = NULL;

32
src/accessor/grib_accessor_class_data_g1second_order_general_packing.cc
View File

@ -18,22 +18,22 @@ void grib_accessor_data_g1second_order_general_packing_t::init(const long v, gri
grib_accessor_data_simple_packing_t::init(v, args);
grib_handle* hand = grib_handle_of_accessor(this);
half_byte_ = grib_arguments_get_name(hand, args, carg_++);
packingType_ = grib_arguments_get_name(hand, args, carg_++);
ieee_packing_ = grib_arguments_get_name(hand, args, carg_++);
precision_ = grib_arguments_get_name(hand, args, carg_++);
widthOfFirstOrderValues_ = grib_arguments_get_name(hand, args, carg_++);
N1_ = grib_arguments_get_name(hand, args, carg_++);
N2_ = grib_arguments_get_name(hand, args, carg_++);
numberOfGroups_ = grib_arguments_get_name(hand, args, carg_++);
numberOfSecondOrderPackedValues_ = grib_arguments_get_name(hand, args, carg_++);
extraValues_ = grib_arguments_get_name(hand, args, carg_++);
Ni_ = grib_arguments_get_name(hand, args, carg_++);
Nj_ = grib_arguments_get_name(hand, args, carg_++);
pl_ = grib_arguments_get_name(hand, args, carg_++);
jPointsAreConsecutive_ = grib_arguments_get_name(hand, args, carg_++);
bitmap_ = grib_arguments_get_name(hand, args, carg_++);
groupWidths_ = grib_arguments_get_name(hand, args, carg_++);
half_byte_ = args->get_name(hand, carg_++);
packingType_ = args->get_name(hand, carg_++);
ieee_packing_ = args->get_name(hand, carg_++);
precision_ = args->get_name(hand, carg_++);
widthOfFirstOrderValues_ = args->get_name(hand, carg_++);
N1_ = args->get_name(hand, carg_++);
N2_ = args->get_name(hand, carg_++);
numberOfGroups_ = args->get_name(hand, carg_++);
numberOfSecondOrderPackedValues_ = args->get_name(hand, carg_++);
extraValues_ = args->get_name(hand, carg_++);
Ni_ = args->get_name(hand, carg_++);
Nj_ = args->get_name(hand, carg_++);
pl_ = args->get_name(hand, carg_++);
jPointsAreConsecutive_ = args->get_name(hand, carg_++);
bitmap_ = args->get_name(hand, carg_++);
groupWidths_ = args->get_name(hand, carg_++);
edition_ = 1;
flags_ |= GRIB_ACCESSOR_FLAG_DATA;
}

32
src/accessor/grib_accessor_class_data_g1second_order_row_by_row_packing.cc
View File

@ -18,22 +18,22 @@ void grib_accessor_data_g1second_order_row_by_row_packing_t::init(const long v,
grib_accessor_data_simple_packing_t::init(v, args);
grib_handle* gh = grib_handle_of_accessor(this);
half_byte_ = grib_arguments_get_name(gh, args, carg_++);
packingType_ = grib_arguments_get_name(gh, args, carg_++);
ieee_packing_ = grib_arguments_get_name(gh, args, carg_++);
precision_ = grib_arguments_get_name(gh, args, carg_++);
widthOfFirstOrderValues_ = grib_arguments_get_name(gh, args, carg_++);
N1_ = grib_arguments_get_name(gh, args, carg_++);
N2_ = grib_arguments_get_name(gh, args, carg_++);
numberOfGroups_ = grib_arguments_get_name(gh, args, carg_++);
numberOfSecondOrderPackedValues_ = grib_arguments_get_name(gh, args, carg_++);
extraValues_ = grib_arguments_get_name(gh, args, carg_++);
Ni_ = grib_arguments_get_name(gh, args, carg_++);
Nj_ = grib_arguments_get_name(gh, args, carg_++);
pl_ = grib_arguments_get_name(gh, args, carg_++);
jPointsAreConsecutive_ = grib_arguments_get_name(gh, args, carg_++);
groupWidths_ = grib_arguments_get_name(gh, args, carg_++);
bitmap_ = grib_arguments_get_name(gh, args, carg_++);
half_byte_ = args->get_name(gh, carg_++);
packingType_ = args->get_name(gh, carg_++);
ieee_packing_ = args->get_name(gh, carg_++);
precision_ = args->get_name(gh, carg_++);
widthOfFirstOrderValues_ = args->get_name(gh, carg_++);
N1_ = args->get_name(gh, carg_++);
N2_ = args->get_name(gh, carg_++);
numberOfGroups_ = args->get_name(gh, carg_++);
numberOfSecondOrderPackedValues_ = args->get_name(gh, carg_++);
extraValues_ = args->get_name(gh, carg_++);
Ni_ = args->get_name(gh, carg_++);
Nj_ = args->get_name(gh, carg_++);
pl_ = args->get_name(gh, carg_++);
jPointsAreConsecutive_ = args->get_name(gh, carg_++);
groupWidths_ = args->get_name(gh, carg_++);
bitmap_ = args->get_name(gh, carg_++);
edition_ = 1;
flags_ |= GRIB_ACCESSOR_FLAG_DATA;
}

2
src/accessor/grib_accessor_class_data_g1secondary_bitmap.cc
View File

@ -16,7 +16,7 @@ grib_accessor* grib_accessor_data_g1secondary_bitmap = &_grib_accessor_data_g1se
void grib_accessor_data_g1secondary_bitmap_t::init(const long v, grib_arguments* args)
{
grib_accessor_data_secondary_bitmap_t::init(v, args);
number_of_ones_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, 4);
number_of_ones_ = args->get_name(grib_handle_of_accessor(this), 4);
}
int grib_accessor_data_g1secondary_bitmap_t::value_count(long* count)

8
src/accessor/grib_accessor_class_data_g1simple_packing.cc
View File

@ -18,10 +18,10 @@ void grib_accessor_data_g1simple_packing_t::init(const long v, grib_arguments* a
{
grib_accessor_data_simple_packing_t::init(v, args);
half_byte_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, carg_++);
packingType_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, carg_++);
ieee_packing_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, carg_++);
precision_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, carg_++);
half_byte_ = args->get_name(grib_handle_of_accessor(this), carg_++);
packingType_ = args->get_name(grib_handle_of_accessor(this), carg_++);
ieee_packing_ = args->get_name(grib_handle_of_accessor(this), carg_++);
precision_ = args->get_name(grib_handle_of_accessor(this), carg_++);
edition_ = 1;
flags_ |= GRIB_ACCESSOR_FLAG_DATA;
}

40
src/accessor/grib_accessor_class_data_g22order_packing.cc
View File

@ -18,28 +18,28 @@ void grib_accessor_data_g22order_packing_t::init(const long v, grib_arguments* a
grib_accessor_values_t::init(v, args);
grib_handle* gh = grib_handle_of_accessor(this);
numberOfValues_ = grib_arguments_get_name(gh, args, carg_++);
bits_per_value_ = grib_arguments_get_name(gh, args, carg_++);
reference_value_ = grib_arguments_get_name(gh, args, carg_++);
binary_scale_factor_ = grib_arguments_get_name(gh, args, carg_++);
decimal_scale_factor_ = grib_arguments_get_name(gh, args, carg_++);
optimize_scale_factor_ = grib_arguments_get_name(gh, args, carg_++);
numberOfValues_ = args->get_name(gh, carg_++);
bits_per_value_ = args->get_name(gh, carg_++);
reference_value_ = args->get_name(gh, carg_++);
binary_scale_factor_ = args->get_name(gh, carg_++);
decimal_scale_factor_ = args->get_name(gh, carg_++);
optimize_scale_factor_ = args->get_name(gh, carg_++);
typeOfOriginalFieldValues_ = grib_arguments_get_name(gh, args, carg_++);
groupSplittingMethodUsed_ = grib_arguments_get_name(gh, args, carg_++);
missingValueManagementUsed_ = grib_arguments_get_name(gh, args, carg_++);
primaryMissingValueSubstitute_ = grib_arguments_get_name(gh, args, carg_++);
secondaryMissingValueSubstitute_ = grib_arguments_get_name(gh, args, carg_++);
numberOfGroupsOfDataValues_ = grib_arguments_get_name(gh, args, carg_++);
referenceForGroupWidths_ = grib_arguments_get_name(gh, args, carg_++);
numberOfBitsUsedForTheGroupWidths_ = grib_arguments_get_name(gh, args, carg_++);
referenceForGroupLengths_ = grib_arguments_get_name(gh, args, carg_++);
lengthIncrementForTheGroupLengths_ = grib_arguments_get_name(gh, args, carg_++);
trueLengthOfLastGroup_ = grib_arguments_get_name(gh, args, carg_++);
numberOfBitsUsedForTheScaledGroupLengths_ = grib_arguments_get_name(gh, args, carg_++);
typeOfOriginalFieldValues_ = args->get_name(gh, carg_++);
groupSplittingMethodUsed_ = args->get_name(gh, carg_++);
missingValueManagementUsed_ = args->get_name(gh, carg_++);
primaryMissingValueSubstitute_ = args->get_name(gh, carg_++);
secondaryMissingValueSubstitute_ = args->get_name(gh, carg_++);
numberOfGroupsOfDataValues_ = args->get_name(gh, carg_++);
referenceForGroupWidths_ = args->get_name(gh, carg_++);
numberOfBitsUsedForTheGroupWidths_ = args->get_name(gh, carg_++);
referenceForGroupLengths_ = args->get_name(gh, carg_++);
lengthIncrementForTheGroupLengths_ = args->get_name(gh, carg_++);
trueLengthOfLastGroup_ = args->get_name(gh, carg_++);
numberOfBitsUsedForTheScaledGroupLengths_ = args->get_name(gh, carg_++);
orderOfSpatialDifferencing_ = grib_arguments_get_name(gh, args, carg_++);
numberOfOctetsExtraDescriptors_ = grib_arguments_get_name(gh, args, carg_++);
orderOfSpatialDifferencing_ = args->get_name(gh, carg_++);
numberOfOctetsExtraDescriptors_ = args->get_name(gh, carg_++);
flags_ |= GRIB_ACCESSOR_FLAG_DATA;
}

26
src/accessor/grib_accessor_class_data_g2bifourier_packing.cc
View File

@ -20,19 +20,19 @@ void grib_accessor_data_g2bifourier_packing_t::init(const long v, grib_arguments
grib_accessor_data_simple_packing_t::init(v, args);
grib_handle* gh = grib_handle_of_accessor(this);
ieee_floats_ = grib_arguments_get_name(gh, args, carg_++);
laplacianOperatorIsSet_ = grib_arguments_get_name(gh, args, carg_++);
laplacianOperator_ = grib_arguments_get_name(gh, args, carg_++);
biFourierTruncationType_ = grib_arguments_get_name(gh, args, carg_++);
sub_i_ = grib_arguments_get_name(gh, args, carg_++);
sub_j_ = grib_arguments_get_name(gh, args, carg_++);
bif_i_ = grib_arguments_get_name(gh, args, carg_++);
bif_j_ = grib_arguments_get_name(gh, args, carg_++);
biFourierSubTruncationType_ = grib_arguments_get_name(gh, args, carg_++);
biFourierDoNotPackAxes_ = grib_arguments_get_name(gh, args, carg_++);
biFourierMakeTemplate_ = grib_arguments_get_name(gh, args, carg_++);
totalNumberOfValuesInUnpackedSubset_ = grib_arguments_get_name(gh, args, carg_++);
/*numberOfValues = grib_arguments_get_name(gh,args,carg_ ++);*/
ieee_floats_ = args->get_name(gh, carg_++);
laplacianOperatorIsSet_ = args->get_name(gh, carg_++);
laplacianOperator_ = args->get_name(gh, carg_++);
biFourierTruncationType_ = args->get_name(gh, carg_++);
sub_i_ = args->get_name(gh, carg_++);
sub_j_ = args->get_name(gh, carg_++);
bif_i_ = args->get_name(gh, carg_++);
bif_j_ = args->get_name(gh, carg_++);
biFourierSubTruncationType_ = args->get_name(gh, carg_++);
biFourierDoNotPackAxes_ = args->get_name(gh, carg_++);
biFourierMakeTemplate_ = args->get_name(gh, carg_++);
totalNumberOfValuesInUnpackedSubset_ = args->get_name(gh, carg_++);
/*numberOfValues = args->get_name(gh, carg_++);*/
flags_ |= GRIB_ACCESSOR_FLAG_DATA;
dirty_ = 1;

2
src/accessor/grib_accessor_class_data_g2complex_packing.cc
View File

@ -16,7 +16,7 @@ grib_accessor* grib_accessor_data_g2complex_packing = &_grib_accessor_data_g2com
void grib_accessor_data_g2complex_packing_t::init(const long v, grib_arguments* args)
{
grib_accessor_data_complex_packing_t::init(v, args);
numberOfValues_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, carg_++);
numberOfValues_ = args->get_name(grib_handle_of_accessor(this), carg_++);
edition_ = 2;
flags_ |= GRIB_ACCESSOR_FLAG_DATA;

2
src/accessor/grib_accessor_class_data_g2secondary_bitmap.cc
View File

@ -16,7 +16,7 @@ grib_accessor* grib_accessor_data_g2secondary_bitmap = &_grib_accessor_data_g2se
void grib_accessor_data_g2secondary_bitmap_t::init(const long v, grib_arguments* args)
{
grib_accessor_data_secondary_bitmap_t::init(v, args);
number_of_values_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, 4);
number_of_values_ = args->get_name(grib_handle_of_accessor(this), 4);
}
int grib_accessor_data_g2secondary_bitmap_t::value_count(long* len)

4
src/accessor/grib_accessor_class_data_g2shsimple_packing.cc
View File

@ -17,8 +17,8 @@ void grib_accessor_data_g2shsimple_packing_t::init(const long v, grib_arguments*
{
grib_accessor_data_shsimple_packing_t::init(v, args);
numberOfValues_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, 2);
numberOfDataPoints_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, 3);
numberOfValues_ = args->get_name(grib_handle_of_accessor(this), 2);
numberOfDataPoints_ = args->get_name(grib_handle_of_accessor(this), 3);
flags_ |= GRIB_ACCESSOR_FLAG_DATA;
}

4
src/accessor/grib_accessor_class_data_g2simple_packing_with_preprocessing.cc
View File

@ -18,8 +18,8 @@ grib_accessor* grib_accessor_data_g2simple_packing_with_preprocessing = &_grib_a
void grib_accessor_data_g2simple_packing_with_preprocessing_t::init(const long v, grib_arguments* args)
{
grib_accessor_data_g2simple_packing_t::init(v, args);
pre_processing_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, carg_++);
pre_processing_parameter_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, carg_++);
pre_processing_ = args->get_name(grib_handle_of_accessor(this), carg_++);
pre_processing_parameter_ = args->get_name(grib_handle_of_accessor(this), carg_++);
flags_ |= GRIB_ACCESSOR_FLAG_DATA;
}

14
src/accessor/grib_accessor_class_data_jpeg2000_packing.cc
View File

@ -25,13 +25,13 @@ void grib_accessor_data_jpeg2000_packing_t::init(const long v, grib_arguments* a
grib_handle* hand = grib_handle_of_accessor(this);
jpeg_lib_ = 0;
type_of_compression_used_ = grib_arguments_get_name(hand, args, carg_++);
target_compression_ratio_ = grib_arguments_get_name(hand, args, carg_++);
ni_ = grib_arguments_get_name(hand, args, carg_++);
nj_ = grib_arguments_get_name(hand, args, carg_++);
list_defining_points_ = grib_arguments_get_name(hand, args, carg_++);
number_of_data_points_ = grib_arguments_get_name(hand, args, carg_++);
scanning_mode_ = grib_arguments_get_name(hand, args, carg_++);
type_of_compression_used_ = args->get_name(hand, carg_++);
target_compression_ratio_ = args->get_name(hand, carg_++);
ni_ = args->get_name(hand, carg_++);
nj_ = args->get_name(hand, carg_++);
list_defining_points_ = args->get_name(hand, carg_++);
number_of_data_points_ = args->get_name(hand, carg_++);
scanning_mode_ = args->get_name(hand, carg_++);
edition_ = 2;
flags_ |= GRIB_ACCESSOR_FLAG_DATA;

20
src/accessor/grib_accessor_class_data_png_packing.cc
View File

@ -21,16 +21,16 @@ void grib_accessor_data_png_packing_t::init(const long v, grib_arguments* args)
grib_accessor_values_t::init(v, args);
grib_handle* h = grib_handle_of_accessor(this);
number_of_values_ = grib_arguments_get_name(h, args, carg_++);
reference_value_ = grib_arguments_get_name(h, args, carg_++);
binary_scale_factor_ = grib_arguments_get_name(h, args, carg_++);
decimal_scale_factor_ = grib_arguments_get_name(h, args, carg_++);
bits_per_value_ = grib_arguments_get_name(h, args, carg_++);
ni_ = grib_arguments_get_name(h, args, carg_++);
nj_ = grib_arguments_get_name(h, args, carg_++);
list_defining_points_ = grib_arguments_get_name(h, args, carg_++);
number_of_data_points_ = grib_arguments_get_name(h, args, carg_++);
scanning_mode_ = grib_arguments_get_name(h, args, carg_++);
number_of_values_ = args->get_name(h, carg_++);
reference_value_ = args->get_name(h, carg_++);
binary_scale_factor_ = args->get_name(h, carg_++);
decimal_scale_factor_ = args->get_name(h, carg_++);
bits_per_value_ = args->get_name(h, carg_++);
ni_ = args->get_name(h, carg_++);
nj_ = args->get_name(h, carg_++);
list_defining_points_ = args->get_name(h, carg_++);
number_of_data_points_ = args->get_name(h, carg_++);
scanning_mode_ = args->get_name(h, carg_++);
flags_ |= GRIB_ACCESSOR_FLAG_DATA;
}

4
src/accessor/grib_accessor_class_data_raw_packing.cc
View File

@ -18,8 +18,8 @@ void grib_accessor_data_raw_packing_t::init(const long v, grib_arguments* args)
{
grib_accessor_values_t::init(v, args);
number_of_values_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, carg_++);
precision_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, carg_++);
number_of_values_ = args->get_name(grib_handle_of_accessor(this), carg_++);
precision_ = args->get_name(grib_handle_of_accessor(this), carg_++);
flags_ |= GRIB_ACCESSOR_FLAG_DATA;
}

12
src/accessor/grib_accessor_class_data_run_length_packing.cc
View File

@ -18,12 +18,12 @@ void grib_accessor_data_run_length_packing_t::init(const long v, grib_arguments*
{
grib_accessor_values_t::init(v, args);
grib_handle* gh = grib_handle_of_accessor(this);
number_of_values_ = grib_arguments_get_name(gh, args, carg_++);
bits_per_value_ = grib_arguments_get_name(gh, args, carg_++);
max_level_value_ = grib_arguments_get_name(gh, args, carg_++);
number_of_level_values_ = grib_arguments_get_name(gh, args, carg_++);
decimal_scale_factor_ = grib_arguments_get_name(gh, args, carg_++);
level_values_ = grib_arguments_get_name(gh, args, carg_++);
number_of_values_ = args->get_name(gh, carg_++);
bits_per_value_ = args->get_name(gh, carg_++);
max_level_value_ = args->get_name(gh, carg_++);
number_of_level_values_ = args->get_name(gh, carg_++);
decimal_scale_factor_ = args->get_name(gh, carg_++);
level_values_ = args->get_name(gh, carg_++);
flags_ |= GRIB_ACCESSOR_FLAG_DATA;
}

8
src/accessor/grib_accessor_class_data_secondary_bitmap.cc
View File

@ -16,10 +16,10 @@ grib_accessor* grib_accessor_data_secondary_bitmap = &_grib_accessor_data_second
void grib_accessor_data_secondary_bitmap_t::init(const long v, grib_arguments* args)
{
grib_accessor_gen_t::init(v, args);
primary_bitmap_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, 0);
secondary_bitmap_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, 1);
missing_value_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, 2);
expand_by_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, 3);
primary_bitmap_ = args->get_name(grib_handle_of_accessor(this), 0);
secondary_bitmap_ = args->get_name(grib_handle_of_accessor(this), 1);
missing_value_ = args->get_name(grib_handle_of_accessor(this), 2);
expand_by_ = args->get_name(grib_handle_of_accessor(this), 3);
length_ = 0;
}

20
src/accessor/grib_accessor_class_data_sh_packed.cc
View File

@ -22,16 +22,16 @@ void grib_accessor_data_sh_packed_t::init(const long v, grib_arguments* args)
grib_accessor_data_simple_packing_t::init(v, args);
grib_handle* hand = grib_handle_of_accessor(this);
GRIBEX_sh_bug_present_ = grib_arguments_get_name(hand, args, carg_++);
ieee_floats_ = grib_arguments_get_name(hand, args, carg_++);
laplacianOperatorIsSet_ = grib_arguments_get_name(hand, args, carg_++);
laplacianOperator_ = grib_arguments_get_name(hand, args, carg_++);
sub_j_ = grib_arguments_get_name(hand, args, carg_++);
sub_k_ = grib_arguments_get_name(hand, args, carg_++);
sub_m_ = grib_arguments_get_name(hand, args, carg_++);
pen_j_ = grib_arguments_get_name(hand, args, carg_++);
pen_k_ = grib_arguments_get_name(hand, args, carg_++);
pen_m_ = grib_arguments_get_name(hand, args, carg_++);
GRIBEX_sh_bug_present_ = args->get_name(hand, carg_++);
ieee_floats_ = args->get_name(hand, carg_++);
laplacianOperatorIsSet_ = args->get_name(hand, carg_++);
laplacianOperator_ = args->get_name(hand, carg_++);
sub_j_ = args->get_name(hand, carg_++);
sub_k_ = args->get_name(hand, carg_++);
sub_m_ = args->get_name(hand, carg_++);
pen_j_ = args->get_name(hand, carg_++);
pen_k_ = args->get_name(hand, carg_++);
pen_m_ = args->get_name(hand, carg_++);
flags_ |= GRIB_ACCESSOR_FLAG_DATA;
length_ = 0;

20
src/accessor/grib_accessor_class_data_sh_unpacked.cc
View File

@ -22,16 +22,16 @@ void grib_accessor_data_sh_unpacked_t::init(const long v, grib_arguments* args)
grib_accessor_data_simple_packing_t::init(v, args);
grib_handle* hand = grib_handle_of_accessor(this);
GRIBEX_sh_bug_present_ = grib_arguments_get_name(hand, args, carg_++);
ieee_floats_ = grib_arguments_get_name(hand, args, carg_++);
laplacianOperatorIsSet_ = grib_arguments_get_name(hand, args, carg_++);
laplacianOperator_ = grib_arguments_get_name(hand, args, carg_++);
sub_j_ = grib_arguments_get_name(hand, args, carg_++);
sub_k_ = grib_arguments_get_name(hand, args, carg_++);
sub_m_ = grib_arguments_get_name(hand, args, carg_++);
pen_j_ = grib_arguments_get_name(hand, args, carg_++);
pen_k_ = grib_arguments_get_name(hand, args, carg_++);
pen_m_ = grib_arguments_get_name(hand, args, carg_++);
GRIBEX_sh_bug_present_ = args->get_name(hand, carg_++);
ieee_floats_ = args->get_name(hand, carg_++);
laplacianOperatorIsSet_ = args->get_name(hand, carg_++);
laplacianOperator_ = args->get_name(hand, carg_++);
sub_j_ = args->get_name(hand, carg_++);
sub_k_ = args->get_name(hand, carg_++);
sub_m_ = args->get_name(hand, carg_++);
pen_j_ = args->get_name(hand, carg_++);
pen_k_ = args->get_name(hand, carg_++);
pen_m_ = args->get_name(hand, carg_++);
flags_ |= GRIB_ACCESSOR_FLAG_DATA;
length_ = 0;

4
src/accessor/grib_accessor_class_data_shsimple_packing.cc
View File

@ -17,8 +17,8 @@ void grib_accessor_data_shsimple_packing_t::init(const long v, grib_arguments* a
{
grib_accessor_gen_t::init(v, args);
coded_values_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, 0);
real_part_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, 1);
coded_values_ = args->get_name(grib_handle_of_accessor(this), 0);
real_part_ = args->get_name(grib_handle_of_accessor(this), 1);
flags_ |= GRIB_ACCESSOR_FLAG_DATA;
length_ = 0;

18
src/accessor/grib_accessor_class_data_simple_packing.cc
View File

@ -21,15 +21,15 @@ void grib_accessor_data_simple_packing_t::init(const long v, grib_arguments* arg
{
grib_accessor_values_t::init(v, args);
grib_handle* gh = grib_handle_of_accessor(this);
units_factor_ = grib_arguments_get_name(gh, args, carg_++);
units_bias_ = grib_arguments_get_name(gh, args, carg_++);
changing_precision_ = grib_arguments_get_name(gh, args, carg_++);
number_of_values_ = grib_arguments_get_name(gh, args, carg_++);
bits_per_value_ = grib_arguments_get_name(gh, args, carg_++);
reference_value_ = grib_arguments_get_name(gh, args, carg_++);
binary_scale_factor_ = grib_arguments_get_name(gh, args, carg_++);
decimal_scale_factor_ = grib_arguments_get_name(gh, args, carg_++);
optimize_scaling_factor_ = grib_arguments_get_name(gh, args, carg_++);
units_factor_ = args->get_name(gh, carg_++);
units_bias_ = args->get_name(gh, carg_++);
changing_precision_ = args->get_name(gh, carg_++);
number_of_values_ = args->get_name(gh, carg_++);
bits_per_value_ = args->get_name(gh, carg_++);
reference_value_ = args->get_name(gh, carg_++);
binary_scale_factor_ = args->get_name(gh, carg_++);
decimal_scale_factor_ = args->get_name(gh, carg_++);
optimize_scaling_factor_ = args->get_name(gh, carg_++);
flags_ |= GRIB_ACCESSOR_FLAG_DATA;
dirty_ = 1;
}

8
src/accessor/grib_accessor_class_decimal_precision.cc
View File

@ -18,10 +18,10 @@ void grib_accessor_decimal_precision_t::init(const long l, grib_arguments* args)
grib_accessor_long_t::init(l, args);
int n = 0;
bits_per_value_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, n++);
decimal_scale_factor_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, n++);
changing_precision_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, n++);
values_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, n++);
bits_per_value_ = args->get_name(grib_handle_of_accessor(this), n++);
decimal_scale_factor_ = args->get_name(grib_handle_of_accessor(this), n++);
changing_precision_ = args->get_name(grib_handle_of_accessor(this), n++);
values_ = args->get_name(grib_handle_of_accessor(this), n++);
flags_ |= GRIB_ACCESSOR_FLAG_FUNCTION;
length_ = 0;

10
src/accessor/grib_accessor_class_dictionary.cc
View File

@ -18,11 +18,11 @@ void grib_accessor_dictionary_t::init(const long len, grib_arguments* params)
grib_accessor_gen_t::init(len, params);
int n = 0;
dictionary_ = grib_arguments_get_string(grib_handle_of_accessor(this), params, n++);
key_ = grib_arguments_get_name(grib_handle_of_accessor(this), params, n++);
column_ = grib_arguments_get_long(grib_handle_of_accessor(this), params, n++);
masterDir_ = grib_arguments_get_name(grib_handle_of_accessor(this), params, n++);
localDir_ = grib_arguments_get_name(grib_handle_of_accessor(this), params, n++);
dictionary_ = params->get_string(grib_handle_of_accessor(this), n++);
key_ = params->get_name(grib_handle_of_accessor(this), n++);
column_ = params->get_long(grib_handle_of_accessor(this), n++);
masterDir_ = params->get_name(grib_handle_of_accessor(this), n++);
localDir_ = params->get_name(grib_handle_of_accessor(this), n++);
length_ = 0;
flags_ |= GRIB_ACCESSOR_FLAG_READ_ONLY;

2
src/accessor/grib_accessor_class_dirty.cc
View File

@ -16,7 +16,7 @@ grib_accessor* grib_accessor_dirty = &_grib_accessor_dirty;
void grib_accessor_dirty_t::init(const long l, grib_arguments* c)
{
grib_accessor_long_t::init(l, c);
accessor_ = grib_arguments_get_name(grib_handle_of_accessor(this), c, 0);
accessor_ = c->get_name(grib_handle_of_accessor(this), 0);
flags_ |= GRIB_ACCESSOR_FLAG_FUNCTION;
flags_ |= GRIB_ACCESSOR_FLAG_HIDDEN;
length_ = 0;

4
src/accessor/grib_accessor_class_divdouble.cc
View File

@ -18,8 +18,8 @@ void grib_accessor_divdouble_t::init(const long l, grib_arguments* c)
grib_accessor_double_t::init(l, c);
int n = 0;
val_ = grib_arguments_get_name(grib_handle_of_accessor(this), c, n++);
divisor_ = grib_arguments_get_double(grib_handle_of_accessor(this), c, n++);
val_ = c->get_name(grib_handle_of_accessor(this), n++);
divisor_ = c->get_double(grib_handle_of_accessor(this), n++);
}
int grib_accessor_divdouble_t::unpack_double(double* val, size_t* len)

4
src/accessor/grib_accessor_class_element.cc
View File

@ -19,8 +19,8 @@ void grib_accessor_element_t::init(const long l, grib_arguments* c)
grib_handle* hand = grib_handle_of_accessor(this);
int n = 0;
array_ = grib_arguments_get_name(hand, c, n++);
element_ = grib_arguments_get_long(hand, c, n++);
array_ = c->get_name(hand, n++);
element_ = c->get_long(hand, n++);
}
static int check_element_index(const char* func, const char* array_name, long index, size_t size)

4
src/accessor/grib_accessor_class_evaluate.cc
View File

@ -23,9 +23,9 @@ void grib_accessor_evaluate_t::init(const long l, grib_arguments* c)
int grib_accessor_evaluate_t::unpack_long(long* val, size_t* len)
{
grib_handle* h = grib_handle_of_accessor(this);
grib_expression* e = grib_arguments_get_expression(h, arg_, 0);
grib_expression* e = arg_->get_expression(h, 0);
int ret = grib_expression_evaluate_long(h, e, val);
int ret = e->evaluate_long(h, val);
*len = 1;
return ret;

10
src/accessor/grib_accessor_class_expanded_descriptors.cc
View File

@ -34,17 +34,17 @@ void grib_accessor_expanded_descriptors_t::init(const long len, grib_arguments*
grib_accessor_long_t::init(len, args);
int n = 0;
grib_handle* hand = grib_handle_of_accessor(this);
tablesAccessorName_ = grib_arguments_get_name(hand, args, n++);
expandedName_ = grib_arguments_get_name(hand, args, n++);
rank_ = grib_arguments_get_long(hand, args, n++);
tablesAccessorName_ = args->get_name(hand, n++);
expandedName_ = args->get_name(hand, n++);
rank_ = args->get_long(hand, n++);
if (rank_ != 0) {
expandedAccessor_ = dynamic_cast<grib_accessor_expanded_descriptors_t*>(grib_find_accessor(hand, expandedName_));
}
else {
expandedAccessor_ = 0;
}
unexpandedDescriptors_ = grib_arguments_get_name(hand, args, n++);
sequence_ = grib_arguments_get_name(hand, args, n++);
unexpandedDescriptors_ = args->get_name(hand, n++);
sequence_ = args->get_name(hand, n++);
do_expand_ = 1;
expanded_ = 0;
length_ = 0;

4
src/accessor/grib_accessor_class_from_scale_factor_scaled_value.cc
View File

@ -20,8 +20,8 @@ void grib_accessor_from_scale_factor_scaled_value_t::init(const long l, grib_arg
int n = 0;
grib_handle* hand = grib_handle_of_accessor(this);
scaleFactor_ = grib_arguments_get_name(hand, c, n++);
scaledValue_ = grib_arguments_get_name(hand, c, n++); // Can be scalar or array
scaleFactor_ = c->get_name(hand, n++);
scaledValue_ = c->get_name(hand, n++); // Can be scalar or array
// ECC-979: Allow user to encode
// flags_ |= GRIB_ACCESSOR_FLAG_READ_ONLY;

2
src/accessor/grib_accessor_class_g1_message_length.cc
View File

@ -16,7 +16,7 @@ grib_accessor* grib_accessor_g1_message_length = &_grib_accessor_g1_message_leng
void grib_accessor_g1_message_length_t::init(const long len, grib_arguments* args)
{
grib_accessor_section_length_t::init(len, args);
sec4_length_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, 0);
sec4_length_ = args->get_name(grib_handle_of_accessor(this), 0);
}
int grib_get_g1_message_size(grib_handle* h, grib_accessor* tl, grib_accessor* s4,

2
src/accessor/grib_accessor_class_g1_section4_length.cc
View File

@ -16,7 +16,7 @@ grib_accessor* grib_accessor_g1_section4_length = &_grib_accessor_g1_section4_le
void grib_accessor_g1_section4_length_t::init(const long len, grib_arguments* args)
{
grib_accessor_section_length_t::init(len, args);
total_length_ = grib_arguments_get_name(grib_handle_of_accessor(this), args, 0);
total_length_ = args->get_name(grib_handle_of_accessor(this), 0);
}
int grib_accessor_g1_section4_length_t::pack_long(const long* val, size_t* len)

2
src/accessor/grib_accessor_class_g1bitmap.cc
View File

@ -16,7 +16,7 @@ grib_accessor* grib_accessor_g1bitmap = &_grib_accessor_g1bitmap;
void grib_accessor_g1bitmap_t::init(const long len, grib_arguments* arg)
{
grib_accessor_bitmap_t::init(len, arg);
unusedBits_ = grib_arguments_get_name(grib_handle_of_accessor(this), arg, 4);
unusedBits_ = arg->get_name(grib_handle_of_accessor(this), 4);
}
int grib_accessor_g1bitmap_t::pack_double(const double* val, size_t* len)

8
src/accessor/grib_accessor_class_g1date.cc
View File

@ -19,10 +19,10 @@ void grib_accessor_g1date_t::init(const long l, grib_arguments* c)
grib_handle* hand = grib_handle_of_accessor(this);
int n = 0;
century_ = grib_arguments_get_name(hand, c, n++);
year_ = grib_arguments_get_name(hand, c, n++);
month_ = grib_arguments_get_name(hand, c, n++);
day_ = grib_arguments_get_name(hand, c, n++);
century_ = c->get_name(hand, n++);
year_ = c->get_name(hand, n++);
month_ = c->get_name(hand, n++);
day_ = c->get_name(hand, n++);
}
int grib_accessor_g1date_t::unpack_long(long* val, size_t* len)

2
src/accessor/grib_accessor_class_g1end_of_interval_monthly.cc
View File

@ -18,7 +18,7 @@ void grib_accessor_g1end_of_interval_monthly_t::init(const long l, grib_argument
grib_accessor_abstract_vector_t::init(l, c);
int n = 0;
verifyingMonth_ = grib_arguments_get_name(grib_handle_of_accessor(this), c, n++);
verifyingMonth_ = c->get_name(grib_handle_of_accessor(this), n++);
flags_ |= GRIB_ACCESSOR_FLAG_READ_ONLY;
flags_ |= GRIB_ACCESSOR_FLAG_FUNCTION;
flags_ |= GRIB_ACCESSOR_FLAG_HIDDEN;

14
src/accessor/grib_accessor_class_g1forecastmonth.cc
View File

@ -18,14 +18,14 @@ void grib_accessor_g1forecastmonth_t::init(const long l, grib_arguments* c)
grib_accessor_long_t::init(l, c);
grib_handle* h = grib_handle_of_accessor(this);
int n = 0;
const int count = grib_arguments_get_count(c);
const int count = c->get_count();
if (count == 6) { /* GRIB1 case -- this needs to be refactored */
verification_yearmonth_ = grib_arguments_get_name(h, c, n++);
base_date_ = grib_arguments_get_name(h, c, n++);
day_ = grib_arguments_get_name(h, c, n++);
hour_ = grib_arguments_get_name(h, c, n++);
fcmonth_ = grib_arguments_get_name(h, c, n++);
check_ = grib_arguments_get_name(h, c, n++);
verification_yearmonth_ = c->get_name(h, n++);
base_date_ = c->get_name(h, n++);
day_ = c->get_name(h, n++);
hour_ = c->get_name(h, n++);
fcmonth_ = c->get_name(h, n++);
check_ = c->get_name(h, n++);
}
}

2
src/accessor/grib_accessor_class_g1monthlydate.cc
View File

@ -18,7 +18,7 @@ void grib_accessor_g1monthlydate_t::init(const long l, grib_arguments* c)
grib_accessor_long_t::init(l, c);
int n = 0;
date_ = grib_arguments_get_name(grib_handle_of_accessor(this), c, n++);
date_ = c->get_name(grib_handle_of_accessor(this), n++);
flags_ |= GRIB_ACCESSOR_FLAG_READ_ONLY;
}

16
src/accessor/grib_accessor_class_g1number_of_coded_values_sh_complex.cc
View File

@ -17,14 +17,14 @@ void grib_accessor_g1number_of_coded_values_sh_complex_t::init(const long l, gri
{
grib_accessor_long_t::init(l, c);
int n = 0;
bitsPerValue_ = grib_arguments_get_name(grib_handle_of_accessor(this), c, n++);
offsetBeforeData_ = grib_arguments_get_name(grib_handle_of_accessor(this), c, n++);
offsetAfterData_ = grib_arguments_get_name(grib_handle_of_accessor(this), c, n++);
unusedBits_ = grib_arguments_get_name(grib_handle_of_accessor(this), c, n++);
numberOfValues_ = grib_arguments_get_name(grib_handle_of_accessor(this), c, n++);
JS_ = grib_arguments_get_name(grib_handle_of_accessor(this), c, n++);
KS_ = grib_arguments_get_name(grib_handle_of_accessor(this), c, n++);
MS_ = grib_arguments_get_name(grib_handle_of_accessor(this), c, n++);
bitsPerValue_ = c->get_name(grib_handle_of_accessor(this), n++);
offsetBeforeData_ = c->get_name(grib_handle_of_accessor(this), n++);
offsetAfterData_ = c->get_name(grib_handle_of_accessor(this), n++);
unusedBits_ = c->get_name(grib_handle_of_accessor(this), n++);
numberOfValues_ = c->get_name(grib_handle_of_accessor(this), n++);
JS_ = c->get_name(grib_handle_of_accessor(this), n++);
KS_ = c->get_name(grib_handle_of_accessor(this), n++);
MS_ = c->get_name(grib_handle_of_accessor(this), n++);
flags_ |= GRIB_ACCESSOR_FLAG_READ_ONLY;
flags_ |= GRIB_ACCESSOR_FLAG_FUNCTION;
length_ = 0;

10
src/accessor/grib_accessor_class_g1number_of_coded_values_sh_simple.cc
View File

@ -17,11 +17,11 @@ void grib_accessor_g1number_of_coded_values_sh_simple_t::init(const long l, grib
{
grib_accessor_long_t::init(l, c);
int n = 0;
bitsPerValue_ = grib_arguments_get_name(grib_handle_of_accessor(this), c, n++);
offsetBeforeData_ = grib_arguments_get_name(grib_handle_of_accessor(this), c, n++);
offsetAfterData_ = grib_arguments_get_name(grib_handle_of_accessor(this), c, n++);
unusedBits_ = grib_arguments_get_name(grib_handle_of_accessor(this), c, n++);
numberOfValues_ = grib_arguments_get_name(grib_handle_of_accessor(this), c, n++);
bitsPerValue_ = c->get_name(grib_handle_of_accessor(this), n++);
offsetBeforeData_ = c->get_name(grib_handle_of_accessor(this), n++);
offsetAfterData_ = c->get_name(grib_handle_of_accessor(this), n++);
unusedBits_ = c->get_name(grib_handle_of_accessor(this), n++);
numberOfValues_ = c->get_name(grib_handle_of_accessor(this), n++);
flags_ |= GRIB_ACCESSOR_FLAG_READ_ONLY;
flags_ |= GRIB_ACCESSOR_FLAG_FUNCTION;
length_ = 0;

14
src/accessor/grib_accessor_class_g1step_range.cc
View File

@ -18,13 +18,13 @@ void grib_accessor_g1step_range_t::init(const long l, grib_arguments* c)
grib_accessor_abstract_long_vector_t::init(l, c);
grib_handle* h = grib_handle_of_accessor(this);
int n = 0;
p1_ = grib_arguments_get_name(h, c, n++);
p2_ = grib_arguments_get_name(h, c, n++);
timeRangeIndicator_ = grib_arguments_get_name(h, c, n++);
unit_ = grib_arguments_get_name(h, c, n++);
step_unit_ = grib_arguments_get_name(h, c, n++);
stepType_ = grib_arguments_get_name(h, c, n++);
patch_fp_precip_ = grib_arguments_get_name(h, c, n++);
p1_ = c->get_name(h, n++);
p2_ = c->get_name(h, n++);
timeRangeIndicator_ = c->get_name(h, n++);
unit_ = c->get_name(h, n++);
step_unit_ = c->get_name(h, n++);
stepType_ = c->get_name(h, n++);
patch_fp_precip_ = c->get_name(h, n++);
error_on_units_ = 1;
number_of_elements_ = 2;

6
src/accessor/grib_accessor_class_g1verificationdate.cc
View File

@ -18,9 +18,9 @@ void grib_accessor_g1verificationdate_t::init(const long l, grib_arguments* c)
grib_accessor_long_t::init(l, c);
int n = 0;
date_ = grib_arguments_get_name(grib_handle_of_accessor(this), c, n++);
time_ = grib_arguments_get_name(grib_handle_of_accessor(this), c, n++);
step_ = grib_arguments_get_name(grib_handle_of_accessor(this), c, n++);
date_ = c->get_name(grib_handle_of_accessor(this), n++);
time_ = c->get_name(grib_handle_of_accessor(this), n++);
step_ = c->get_name(grib_handle_of_accessor(this), n++);
flags_ |= GRIB_ACCESSOR_FLAG_READ_ONLY;
}

6
src/accessor/grib_accessor_class_g2_aerosol.cc
View File

@ -19,9 +19,9 @@ void grib_accessor_g2_aerosol_t::init(const long l, grib_arguments* c)
grib_handle* hand = grib_handle_of_accessor(this);
int n = 0;
productDefinitionTemplateNumber_ = grib_arguments_get_name(hand, c, n++);
stepType_ = grib_arguments_get_name(hand, c, n++);
optical_ = grib_arguments_get_long(hand, c, n++);
productDefinitionTemplateNumber_ = c->get_name(hand, n++);
stepType_ = c->get_name(hand, n++);
optical_ = c->get_long(hand, n++);
}
int grib_accessor_g2_aerosol_t::unpack_long(long* val, size_t* len)

6
src/accessor/grib_accessor_class_g2_chemical.cc
View File

@ -28,9 +28,9 @@ void grib_accessor_g2_chemical_t::init(const long l, grib_arguments* c)
grib_handle* hand = grib_handle_of_accessor(this);
int n = 0;
productDefinitionTemplateNumber_ = grib_arguments_get_name(hand, c, n++);
stepType_ = grib_arguments_get_name(hand, c, n++);
chemical_type_ = grib_arguments_get_long(hand, c, n++);
productDefinitionTemplateNumber_ = c->get_name(hand, n++);
stepType_ = c->get_name(hand, n++);
chemical_type_ = c->get_long(hand, n++);
}
int grib_accessor_g2_chemical_t::unpack_long(long* val, size_t* len)

10
src/accessor/grib_accessor_class_g2_eps.cc
View File

@ -18,11 +18,11 @@ void grib_accessor_g2_eps_t::init(const long l, grib_arguments* c)
grib_accessor_unsigned_t::init(l, c);
int n = 0;
productDefinitionTemplateNumber_ = grib_arguments_get_name(grib_handle_of_accessor(this), c, n++);
type_ = grib_arguments_get_name(grib_handle_of_accessor(this), c, n++);
stream_ = grib_arguments_get_name(grib_handle_of_accessor(this), c, n++);
stepType_ = grib_arguments_get_name(grib_handle_of_accessor(this), c, n++);
derivedForecast_ = grib_arguments_get_name(grib_handle_of_accessor(this), c, n++);
productDefinitionTemplateNumber_ = c->get_name(grib_handle_of_accessor(this), n++);
type_ = c->get_name(grib_handle_of_accessor(this), n++);
stream_ = c->get_name(grib_handle_of_accessor(this), n++);
stepType_ = c->get_name(grib_handle_of_accessor(this), n++);
derivedForecast_ = c->get_name(grib_handle_of_accessor(this), n++);
}
int grib_accessor_g2_eps_t::unpack_long(long* val, size_t* len)

20
src/accessor/grib_accessor_class_g2_mars_labeling.cc
View File

@ -19,16 +19,16 @@ void grib_accessor_g2_mars_labeling_t::init(const long l, grib_arguments* c)
int n = 0;
grib_handle* hand = grib_handle_of_accessor(this);
index_ = grib_arguments_get_long(hand, c, n++);
the_class_ = grib_arguments_get_name(hand, c, n++);
type_ = grib_arguments_get_name(hand, c, n++);
stream_ = grib_arguments_get_name(hand, c, n++);
expver_ = grib_arguments_get_name(hand, c, n++);
typeOfProcessedData_ = grib_arguments_get_name(hand, c, n++);
productDefinitionTemplateNumber_ = grib_arguments_get_name(hand, c, n++);
stepType_ = grib_arguments_get_name(hand, c, n++);
derivedForecast_ = grib_arguments_get_name(hand, c, n++);
typeOfGeneratingProcess_ = grib_arguments_get_name(hand, c, n++);
index_ = c->get_long(hand, n++);
the_class_ = c->get_name(hand, n++);
type_ = c->get_name(hand, n++);
stream_ = c->get_name(hand, n++);
expver_ = c->get_name(hand, n++);
typeOfProcessedData_ = c->get_name(hand, n++);
productDefinitionTemplateNumber_ = c->get_name(hand, n++);
stepType_ = c->get_name(hand, n++);
derivedForecast_ = c->get_name(hand, n++);
typeOfGeneratingProcess_ = c->get_name(hand, n++);
}
int grib_accessor_g2_mars_labeling_t::unpack_long(long* val, size_t* len)

2
src/accessor/grib_accessor_class_g2bitmap.cc
View File

@ -17,7 +17,7 @@ void grib_accessor_g2bitmap_t::init(const long len, grib_arguments* arg)
{
grib_accessor_bitmap_t::init(len, arg);
numberOfValues_ = grib_arguments_get_name(grib_handle_of_accessor(this), arg, 4);
numberOfValues_ = arg->get_name(grib_handle_of_accessor(this), 4);
}
// For speed use a local static function

2
src/accessor/grib_accessor_class_g2bitmap_present.cc
View File

@ -17,7 +17,7 @@ void grib_accessor_g2bitmap_present_t::init(const long l, grib_arguments* c)
{
grib_accessor_long_t::init(l, c);
int n = 0;
bitmapIndicator_ = grib_arguments_get_name(grib_handle_of_accessor(this), c, n++);
bitmapIndicator_ = c->get_name(grib_handle_of_accessor(this), n++);
length_ = 0;
}

6
src/accessor/grib_accessor_class_g2date.cc
View File

@ -18,9 +18,9 @@ void grib_accessor_g2date_t::init(const long l, grib_arguments* c)
grib_accessor_long_t::init(l, c);
int n = 0;
year_ = grib_arguments_get_name(grib_handle_of_accessor(this), c, n++);
month_ = grib_arguments_get_name(grib_handle_of_accessor(this), c, n++);
day_ = grib_arguments_get_name(grib_handle_of_accessor(this), c, n++);
year_ = c->get_name(grib_handle_of_accessor(this), n++);
month_ = c->get_name(grib_handle_of_accessor(this), n++);
day_ = c->get_name(grib_handle_of_accessor(this), n++);
}
int grib_accessor_g2date_t::unpack_long(long* val, size_t* len)

36
src/accessor/grib_accessor_class_g2end_step.cc
View File

@ -22,27 +22,27 @@ void grib_accessor_g2end_step_t::init(const long l, grib_arguments* c)
int n = 0;
grib_handle* h = grib_handle_of_accessor(this);
start_step_value_ = grib_arguments_get_name(h, c, n++);
step_units_ = grib_arguments_get_name(h, c, n++);
start_step_value_ = c->get_name(h, n++);
step_units_ = c->get_name(h, n++);
year_ = grib_arguments_get_name(h, c, n++);
month_ = grib_arguments_get_name(h, c, n++);
day_ = grib_arguments_get_name(h, c, n++);
hour_ = grib_arguments_get_name(h, c, n++);
minute_ = grib_arguments_get_name(h, c, n++);
second_ = grib_arguments_get_name(h, c, n++);
year_ = c->get_name(h, n++);
month_ = c->get_name(h, n++);
day_ = c->get_name(h, n++);
hour_ = c->get_name(h, n++);
minute_ = c->get_name(h, n++);
second_ = c->get_name(h, n++);
year_of_end_of_interval_ = grib_arguments_get_name(h, c, n++);
month_of_end_of_interval_ = grib_arguments_get_name(h, c, n++);
day_of_end_of_interval_ = grib_arguments_get_name(h, c, n++);
hour_of_end_of_interval_ = grib_arguments_get_name(h, c, n++);
minute_of_end_of_interval_ = grib_arguments_get_name(h, c, n++);
second_of_end_of_interval_ = grib_arguments_get_name(h, c, n++);
year_of_end_of_interval_ = c->get_name(h, n++);
month_of_end_of_interval_ = c->get_name(h, n++);
day_of_end_of_interval_ = c->get_name(h, n++);
hour_of_end_of_interval_ = c->get_name(h, n++);
minute_of_end_of_interval_ = c->get_name(h, n++);
second_of_end_of_interval_ = c->get_name(h, n++);
time_range_unit_ = grib_arguments_get_name(h, c, n++);
time_range_value_ = grib_arguments_get_name(h, c, n++);
typeOfTimeIncrement_ = grib_arguments_get_name(h, c, n++);
numberOfTimeRanges_ = grib_arguments_get_name(h, c, n++);
time_range_unit_ = c->get_name(h, n++);
time_range_value_ = c->get_name(h, n++);
typeOfTimeIncrement_ = c->get_name(h, n++);
numberOfTimeRanges_ = c->get_name(h, n++);
}
void grib_accessor_g2end_step_t::dump(grib_dumper* dumper)

16
src/accessor/grib_accessor_class_g2grid.cc
View File

@ -19,14 +19,14 @@ void grib_accessor_g2grid_t::init(const long l, grib_arguments* c)
grib_handle* hand = grib_handle_of_accessor(this);
int n = 0;
latitude_first_ = grib_arguments_get_name(hand, c, n++);
longitude_first_ = grib_arguments_get_name(hand, c, n++);
latitude_last_ = grib_arguments_get_name(hand, c, n++);
longitude_last_ = grib_arguments_get_name(hand, c, n++);
i_increment_ = grib_arguments_get_name(hand, c, n++);
j_increment_ = grib_arguments_get_name(hand, c, n++);
basic_angle_ = grib_arguments_get_name(hand, c, n++);
sub_division_ = grib_arguments_get_name(hand, c, n++);
latitude_first_ = c->get_name(hand, n++);
longitude_first_ = c->get_name(hand, n++);
latitude_last_ = c->get_name(hand, n++);
longitude_last_ = c->get_name(hand, n++);
i_increment_ = c->get_name(hand, n++);
j_increment_ = c->get_name(hand, n++);
basic_angle_ = c->get_name(hand, n++);
sub_division_ = c->get_name(hand, n++);
flags_ |= GRIB_ACCESSOR_FLAG_EDITION_SPECIFIC | GRIB_ACCESSOR_FLAG_READ_ONLY;
}

6
src/accessor/grib_accessor_class_g2latlon.cc
View File

@ -19,9 +19,9 @@ void grib_accessor_g2latlon_t::init(const long l, grib_arguments* c)
grib_accessor_double_t::init(l, c);
int n = 0;
grid_ = grib_arguments_get_name(grib_handle_of_accessor(this), c, n++);
index_ = grib_arguments_get_long(grib_handle_of_accessor(this), c, n++);
given_ = grib_arguments_get_name(grib_handle_of_accessor(this), c, n++);
grid_ = c->get_name(grib_handle_of_accessor(this), n++);
index_ = c->get_long(grib_handle_of_accessor(this), n++);
given_ = c->get_name(grib_handle_of_accessor(this), n++);
}
int grib_accessor_g2latlon_t::unpack_double(double* val, size_t* len)

8
src/accessor/grib_accessor_class_g2level.cc
View File

@ -19,10 +19,10 @@ void grib_accessor_g2level_t::init(const long l, grib_arguments* c)
grib_handle* hand = grib_handle_of_accessor(this);
int n = 0;
type_first_ = grib_arguments_get_name(hand, c, n++);
scale_first_ = grib_arguments_get_name(hand, c, n++);
value_first_ = grib_arguments_get_name(hand, c, n++);
pressure_units_ = grib_arguments_get_name(hand, c, n++);
type_first_ = c->get_name(hand, n++);
scale_first_ = c->get_name(hand, n++);
value_first_ = c->get_name(hand, n++);
pressure_units_ = c->get_name(hand, n++);
// See ECC-1644
flags_ |= GRIB_ACCESSOR_FLAG_COPY_IF_CHANGING_EDITION;

Some files were not shown because too many files have changed in this diff Show More