Freight rate data updating method and system

Abstract

The invention provides a freight rate data updating method and system, and the method comprises the steps: constructing a Hash bucket data structure of each kind of Index type data according to the Index type data; creating a series of iterators for the Hash bucket data structure, so that the DFF and the LE can use the Hash bucket data structure to modify and query Index type data; configuring a fragment file based on the constructed Hash bucket data structure, constructing Index type data into the fragment file, and mapping the Index type data into a memory space; detecting whether the Index type data is updated or not; if updating exists, the LE loads the incremental data of the Index type data, and updating operation of the incremental data of the Index type data is completed. According to the method, the Index type data file is fragmented, the Hash bucket data structure is used for replacing an STL Map data structure and an STL Vector data structure, and the Hash bucket data structure is controlled, so that the data updating speed and efficiency can be effectively improved, and the data updating time is shortened.

Description

Technical Field

[0001] The present invention relates to the field of domestic freight rate data construction, and in particular to a method and system for updating freight rate data. Background Art

[0002] The current domestic freight rate calculation software uses MMAP memory mapping to construct data, converting RAWDATA source data (freight rate source data) into DFF data (freight rate data), and uses it as the data source of the calculation engine for the calculation engine to use for business logic. Usually, data construction is completed automatically using Intake server, Updater server and Pricing Node server, among which, Intake server is used to receive RAWDATA source data (freight source data) and push RAWDATA source data (freight source data) to Updater server by multicast; Updater server uses full RAWDATA source data (freight source data) to build full data, and each time RAWDATA source data (freight source data) is updated, Updater server uses incremental RAWDATA source data (freight source data) to build incremental data based on full data; the constructed DFF data (freight data) includes three types: recode type data, segment type data, and index type data; after data construction is successful, Updater server pushes DFF data (freight data) to Pricing Node server by multicast; when Pricing Node server receives incremental DFF data (freight data) pushed by Updater server, LE (domestic freight calculation engine) needs to reload all DFF data (freight data), and the time of each data update is increased due to the large data file.

[0003] In order to shorten the time of each data update and improve the update efficiency, it is usually necessary to fragment the recode type data, segment type data and Index type data in the constructed DFF data (freight rate data) package. However, in the current domestic freight rate system, only the recode type data and segment type data can be fragmented, and the Index type data is a data in the form of Key-Value stored using STL Map, where STL Map is a library provided in the C++ standard, making it impossible to control the data structure of the STL Map data, and thus unable to fragment the Index type data, so that when LE (domestic freight rate calculation engine) loads and updates the entire Index type data file, its data update performance and efficiency are not effectively improved. Summary of the invention

[0004] In view of the shortcomings of the prior art, the present invention provides a method and system for updating freight rate data, which uses a Hash bucket data structure to replace the STL Map data structure, implements comprehensive control over the Hash bucket data structure, and then performs fragmentation processing on the Index data type to improve the efficiency of data updating. The specific implementation scheme of the present invention is as follows:

[0005] In one aspect, the present invention provides a method for updating freight rate data, the method comprising the following steps:

[0006] Step S1: construct a Hash bucket data structure for each type of Index data according to the Index type data;

[0007] Furthermore, in step S1, it also includes:

[0008] Step S101: Determine the size of the Hash bucket according to the number of data of each type of key in each data table, and create a data node with the same data to store the data, wherein the data node includes: a key, a next pointer, and a data set;

[0009] Step S102: convert the key into a hash value through a hash function, then obtain the index value of the key by taking the modulus of the number of hash buckets, and store the data node in the index of the hash bucket;

[0010] Step S103: the address of the record type data is stored in the data object. When the data set is pushed, if the data set is full, the memory constructor dynamically expands the size of the data set.

[0011] Furthermore, in step 101, the key is used for comparison with the query key during query, the next pointer points to the next data node, and the data set is a variable-length array for storing data corresponding to the key.

[0012] Furthermore, in step 102, it also includes: when a hash value conflict occurs, storing the conflicting data node in an index of the hash bucket in the form of a single linked list.

[0013] Step S2: Create a series of iterators for the Hash bucket data structure, so that DFF and LE can modify and query data using the Hash bucket data structure;

[0014] Furthermore, the creation of a series of iterators includes ordinary iterators, constant iterators, reverse iterators and constant reverse iterators, wherein ordinary iterators and reverse iterators are used to modify data, and constant iterators and constant reverse iterators are used to query data.

[0015] Step S3: configure the fragment file based on the constructed Hash bucket data structure, construct the Index type data into the fragment file and map it to the memory space;

[0016] Furthermore, in step S3, the following steps are also included:

[0017] Step S301: Create a fragment file of Index type data according to the fragment size configured in the configuration file of the software, and use the memory constructor to construct a continuous memory space for the Hash bucket data structure of each Index type data;

[0018] Step S302: Map all fragmented files of each Index type data to the constructed memory space through the MMAP component;

[0019] Step S303: read the RAWDATA data, add the data to the corresponding Hash bucket data structure of the Index type, and determine whether each data in the RAWDATA data exists in the Index fragment file through the iterator component;

[0020] Step S304: If it exists, store the new data into the existing data set; if it does not exist, append the new data to the end of the data of the last data fragment file; when the last data fragment file is full, dynamically create a new data fragment file and store the new data into the new data fragment file.

[0021] Step S4: Check whether the Index type data is updated;

[0022] Furthermore, the step of detecting whether the Index type data is updated specifically includes the following steps:

[0023] Step S401: when data is updated, the index information of each data in each data table in the Hash bucket is recorded, and the update information and data batch number are persisted in the data information file;

[0024] Step S402: After the incremental update is completed, the data fragment files whose data content is updated are determined according to the batch number and update information in the data information file, and recorded in the changeFile file according to the data batch number.

[0025] Step S5: If there is an update, LE loads the incremental data of the Index type data to complete the update operation of the incremental data of the Index type data.

[0026] Furthermore, the incremental data is the Index type data updated in the Index type data; the LE loads the incremental data of the Index type data and completes the update operation of the incremental data of the Index type data, specifically: after receiving the request, the LE will reload the latest DFF data, and determine the incremental data fragment file of the Index type data updated by this batch data according to the batch number recorded in the changeFile file in the latest DFF data, and map the fragment file to the memory space.

[0027] On the one hand, the present invention also provides a system for updating freight rate data, the system comprising a data construction component, an iterator component, a hash bucket component, an MMAP component, a memory constructor component, an incremental data detection component and an incremental data loading component, wherein:

[0028] The data construction component belongs to the general control component, which is used to construct RAWDATA data into DFF data and fragment the Index type data;

[0029] The Hash bucket component is responsible for data storage and access; in the Hash bucket component, data is stored and accessed by mapping to the index in the Hash bucket data structure, a fixed-length array is used to represent the bucket, each bucket can store one or more data nodes, a hash function is used to calculate the hash value of the key, and then the modulo of the number of buckets is used to obtain the index value of the key;

[0030] Furthermore, the Hash bucket component also includes a data node, a Hash function and a linked list, wherein:

[0031] The data node is used to store data information, including: a key, a data set and a next pointer pointing to the next data node, wherein the data set is a variable length array and is used to replace the data corresponding to the key stored in the STL Vector data structure;

[0032] The Hash function is used to calculate the hash value of the key;

[0033] The linked list is used to resolve hash conflicts.

[0034] Furthermore, the hash conflict refers to: different keys are mapped to the same hash value by the hash function, resulting in a hash conflict; the linked list is used to resolve the hash conflict, specifically: keys with the same hash value are stored in one bucket, and a linked list is used to store multiple data nodes; because the data structure of the STL Vector cannot be determined when the Index type data file is fragmented, a data set band is used instead of the STL Vector to store the data corresponding to the key.

[0035] The iterator component is responsible for traversing, modifying, adding and other operations on the data in the Hash bucket component and the data set;

[0036] Furthermore, the iterator includes a common iterator, a constant iterator, a reverse iterator and a constant reverse iterator, wherein: the common iterator and the reverse iterator are used to modify data, and the constant iterator and the constant reverse iterator are used to query data.

[0037] The memory builder component is responsible for constructing the memory required for data;

[0038] The MMAP component is responsible for mapping the data file to the memory space;

[0039] The incremental data loading component is responsible for mapping the constructed DFF data to the memory space;

[0040] The incremental data detection component is used to detect whether the Index type data is updated, and is responsible for calculating in which data fragment file the incremental data is located.

[0041] Compared with the prior art, the present invention has the following advantages:

[0042] 1. The present invention uses a Hash bucket data structure to replace the STL Map data structure and the STL Vector data structure. By controlling the Hash bucket data structure, the Index data file can be fragmented. When LE loads incremental data, only the Index fragment data needs to be loaded to complete the data update, without modifying and loading the entire Index type data file. In this way, the speed and efficiency of incremental data update are improved.

[0043] 2. The Hash bucket data structure uses key-value format to store data, which is more conducive to memory management. When querying data, the hash function can be used to quickly find the corresponding key, which improves the speed of data query. At the same time, when providing external queries and modifications, the Hash bucket data structure will not change, and will not affect LE's use of DFF data.

[0044] Other features and advantages of the present invention will be described in the following description, and partly become apparent from the description, or understood by practicing the present invention. The purpose and other advantages of the present invention can be realized and obtained by the structures pointed out in the description, claims and drawings. BRIEF DESCRIPTION OF THE DRAWINGS

[0045] In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings required for use in the embodiments or the description of the prior art will be briefly introduced below. Obviously, the drawings described below are some embodiments of the present invention. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying creative work.

[0046] Figure 1 : A flow chart of a method for updating freight rate data;

[0047] Figure 2 :A schematic diagram of the system structure for updating freight rate data

[0048] Figure 3 : Schematic diagram of constructing the Hash bucket structure;

[0049] Figure 4 : Schematic diagram of data structure reorganization;

[0050] Figure 5 : Another schematic diagram of data structure reorganization;

[0051] Figure 6 : Another schematic diagram of data structure reorganization;

[0052] Figure 7 : Schematic diagram of file data after incremental data update; DETAILED DESCRIPTION

[0053] In order to make the purpose, technical solution and advantages of the embodiments of the present invention clearer, the technical solution in the embodiments of the present invention will be clearly and completely described below in conjunction with the drawings in the embodiments of the present invention. Obviously, the described embodiments are part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without creative work are within the scope of protection of the present invention.

[0054] In one embodiment, see Figure 1 , provides a method for updating freight rate data, the method comprising the following steps:

[0055] Step S1: construct a Hash bucket data structure for each type of Index data according to the Index type data;

[0056] Step S2: Create a series of iterators for the Hash bucket data structure, so that DFF and LE can modify and query data using the Hash bucket data structure;

[0057] Step S3: configure the fragment file based on the constructed Hash bucket data structure, construct the Index type data into the fragment file and map it to the memory space;

[0058] Step S4: Check whether the Index type data is updated;

[0059] Step S5: If there is an update, LE loads the incremental data of the Index type data to complete the update operation of the incremental data of the Index type data.

[0060] Furthermore, in step S1, the construction of the Hash bucket data structure for each Index type data further includes:

[0061] Step S101: Determine the size of the Hash bucket according to the number of data of each type of key in each data table, and create a data node with the same data to store the data, wherein the data node includes: a key, a next pointer, and a data set;

[0062] Step S102: convert the key into a hash value through a hash function, then obtain the index value of the key by taking the modulus of the number of hash buckets, and store the data node in the index of the hash bucket;

[0063] Step S103: the address of the record type data is stored in the data object. When the data set is pushed, if the data set is full, the memory constructor dynamically expands the size of the data set.

[0064] Furthermore, in step 101, the key is used for comparison with the query key during query, the next pointer points to the next data node, and the data set is a variable-length array for storing data corresponding to the key.

[0065] Furthermore, in step 102, it also includes: when a hash value conflict occurs, storing the conflicting data node in an index of the hash bucket in the form of a single linked list.

[0066] Furthermore, in step S2, a series of iterators are created for the Hash bucket data structure, including ordinary iterators, constant iterators, reverse iterators and constant reverse iterators, wherein ordinary iterators and reverse iterators are used to modify data, and constant iterators and constant reverse iterators are used to query data.

[0067] Furthermore, in step S3, the following steps are also included:

[0068] Step S301: Create a fragment file of Index type data according to the fragment size configured in the configuration file of the software, and use the memory constructor to construct a continuous memory space for the Hash bucket data structure of each Index type data;

[0069] Step S302: Map all fragmented files of each Index type data to the constructed memory space through the MMAP component;

[0070] Step S303: read the RAWDATA data, add the data to the corresponding Hash bucket data structure of the Index type, and determine whether each data in the RAWDATA data exists in the Index fragment file through the iterator component;

[0071] Step S304: If it exists, store the new data into the existing data set; if it does not exist, append the new data to the end of the data of the last data fragment file; when the last data fragment file is full, dynamically create a new data fragment file and store the new data into the new data fragment file.

[0072] Furthermore, in step S4, the step of detecting whether the Index type data is updated includes the following steps:

[0073] Step S401: when data is updated, the index information of each data in each data table in the Hash bucket is recorded, and the update information and data batch number are persisted in the data information file;

[0074] Step S402: After the incremental update is completed, the data fragment files whose data content is updated are determined according to the batch number and update information in the data information file, and recorded in the changeFile file according to the data batch number.

[0075] Further, in step S5, the incremental data is the Index type data updated in the Index type data; the LE loads the incremental data of the Index type data to complete the update operation of the incremental data of the Index type data, specifically: after receiving the request, the LE will reload the latest DFF data, and determine the incremental data fragment file of the Index type data updated by this batch data according to the batch number recorded in the changeFile file in the latest DFF data, and map the fragment file to the memory space.

[0076] In one embodiment, see Figure 2 , provides a system for updating freight rate data, including: building data component, iterator component, Hash bucket component, MMAP component, memory constructor component, incremental data detection component and incremental data loading component, wherein:

[0077] The data construction component belongs to the general control component, which is used to construct RAWDATA data into DFF data and fragment the Index type data;

[0078] The Hash bucket component is responsible for data storage and access. It stores and accesses data by mapping to indexes in the Hash bucket data structure. A fixed-length array is used to represent the bucket. Each bucket can store one or more data nodes. A hash function is used to calculate the hash value of the key, and then the index value of the key is obtained by taking the modulus of the number of buckets.

[0079] Furthermore, the Hash bucket component also includes a data node, a Hash function and a linked list, wherein:

[0080] The data node is used to store data information, including: a key, a data set and a next pointer pointing to the next data node, wherein the data set is a variable length array and is used to replace the data corresponding to the key stored in the STL Vector data structure;

[0081] The Hash function is used to calculate the hash value of the key;

[0082] The linked list is used to resolve hash conflicts.

[0083] Furthermore, the hash conflict refers to: different keys are mapped to the same hash value by the hash function, resulting in a hash conflict; the linked list is used to resolve the hash conflict, specifically: keys with the same hash value are stored in one bucket, and a linked list is used to store multiple data nodes; because the data structure of the STL Vector cannot be determined when the Index type data file is fragmented, a data set band is used instead of the STL Vector to store the data corresponding to the key.

[0084] The iterator component is responsible for traversing, modifying, adding and other operations on the data in the Hash bucket component and the data set;

[0085] Furthermore, the iterator includes a common iterator, a constant iterator, a reverse iterator and a constant reverse iterator, wherein: the common iterator and the reverse iterator are used to modify data, and the constant iterator and the constant reverse iterator are used to query data.

[0086] The memory builder component is responsible for constructing the memory required for data;

[0087] The MMAP component is responsible for mapping the data file to the memory space;

[0088] The incremental data loading component is responsible for mapping the constructed DFF data to the memory space;

[0089] The incremental data detection component is responsible for calculating in which data fragment file the incremental data is located.

[0090] In one embodiment, see Figure 3 , provides a method for updating freight rate data. When the system detects that there is incremental data to update, the entire method operates as follows:

[0091] Step 1: Initialize the Hash bucket, obtain the amount of data in the Hash bucket required for each type of key from the configuration file, and initialize the number of Hash buckets;

[0092] Step 2: Map the incremental data file to the memory and create a Hash bucket data structure;

[0093] Further, in one embodiment, see Figure 4 Incremental updates are performed based on the full data. When constructing the full data, the Index data file has been fragmented. During the incremental update, the full DFF data is first mapped to the memory space. The size of the Index data file saved by the first fragment file is used to map all Index data fragment files to the memory space, and the Hash bucket pointer points to the first address of the memory space. At this time, the Hash bucket data structure is completed.

[0094] Step 3: After the Hash bucket data structure is built, reorganize the updated data. Figure 5 and Figure 6 , specifically:

[0095] Step 301: Generate a key for a new record and determine whether the key generated for the new record exists;

[0096] Furthermore, the determination of whether the key generated by the new record exists is specifically performed by using an iterator to facilitate the data node in the Hash bucket data structure, comparing whether the key and the key in the data node are the same, and then determining whether the key in the Hash bucket exists;

[0097] Step 302: If the key exists, find the data node with the same key and put the address of the new record into the data set of the data node;

[0098] Step 302: If the key does not exist, use the Hash function to generate a hash value for the key, and take the modulus of the number of buckets to get the index of the key, and use the memory constructor to construct a data node object. The key of the data node object is the key generated for the new record, the next pointer of the data node object is empty, and the data set of the data node object stores the address of the new record.

[0099] Further, in one embodiment, see Figure 6If there is no data node loaded at the index position in the Hash bucket, the data node is loaded into the index corresponding to the Hash bucket; if the index has been loaded with other data nodes in the Hash bucket, when constructing the data node, the next pointer of the data node is pointed to the data node that has been loaded at the index position in the Hash bucket, and the data node is loaded at the index position in the Hash bucket.

[0100] Step 4: Detect data updates. When data is updated, save the key index, key, table name and data batch number of the new record into the data information file;

[0101] Step 5: After the incremental data update is completed, synchronize the updated data in the memory space to the corresponding Index data fragment file; parse the data information file, calculate the updated Index data fragment file according to the key index, key, and table name, and record the Index data fragment file in the changeFile file;

[0102] Furthermore, in one embodiment, the Index data fragment file is recorded in the changeFile file, and its specific file structure is as follows: Figure 7 As shown, Figure 7 It is a schematic diagram of file data after incremental data update.

[0103] Step 6: Loading of incremental data. When LE has updated freight rate data, it needs to reload the updated freight rate data, read the changeFile file to obtain the data fragment file that needs to be loaded and map it to the memory space.

[0104] In one embodiment, a method for improving the data update performance of a freight rate calculation system is provided. The technical solution is described from the perspective of data query. The data query table name is: NFSXXFARE; key index: 1; key: "CAPEK SHA OW 0"; the specific method is as follows:

[0105] First, start the domestic freight rate calculation system, obtain the data volume of the hash bucket required for each type of key from the configuration file, and initialize the number of hash buckets;

[0106] Secondly, map the data file to the memory and build a Hash bucket data structure, map the DFF data to the memory space, and use the DFF data to build a Hash bucket;

[0107] Next, use the constant iterator to query the data, find the corresponding Hash bucket according to the table name and key index, use the hash function to generate the hash value of the key and get the key index value modulo the number of the Hash bucket; traverse all the data nodes loaded by the index in the Hash bucket, and compare whether the key of the data node is the same as the key in the query condition. If the keys are the same, return the data set in the data node;

[0108] Then, use the constant iterator to iterate over the data in the dataset;

[0109] Finally, get the data query results.

[0110] In the present invention, the explanations of the professional terms and abbreviations involved are shown in Table 1: A method for updating freight rate data.

[0111] Table 1: A method for updating freight rate data Industry terminology table

[0112]

[0113]

[0114] Although the present invention has been described in detail with reference to the aforementioned embodiments, those skilled in the art should understand that they can still modify the technical solutions described in the aforementioned embodiments, or make equivalent substitutions for some of the technical features therein; and these modifications or substitutions do not make the essence of the corresponding technical solutions deviate from the spirit and scope of the technical solutions of the embodiments of the present invention.

Claims

1. A method for updating freight rate data, characterized in that: According to the Index type data, construct the Hash bucket data structure of each Index type data; Create a series of iterators for the Hash bucket data structure to facilitate DFF and LE to modify and query Index type data using the Hash bucket data structure; Configure fragment files based on the constructed Hash bucket data structure, build Index type data into fragment files and map them to memory space; Check whether the Index type data is updated; If there is an update, LE loads the incremental data of the Index type data to complete the update operation of the incremental data of the Index type data.

2. A method for updating freight rate data according to claim 1, characterized in that: The Hash bucket data structure for constructing each type of Index data also includes: Determine the size of the Hash bucket according to the number of data of each type of key in each data table, and create a data node of the same data to store the data, wherein the data node includes: a key, a next pointer, and a data set, wherein the key and the data set constitute a key-value pair; The key is converted into a hash value through the hash function, and then the index value of the key is obtained by taking the modulus of the number of hash buckets, and the data node is stored in the index of the hash bucket; The address of the record type data in the data object. When the data set is pushed, if the data set is full, the memory constructor dynamically expands the size of the data set.

3. A method for updating freight rate data according to claim 2, characterized in that: The key is used to compare with the query key when querying; The next pointer points to the next data node; The data set is a variable-length array used to store data corresponding to a key.

4. A method for updating freight rate data according to claim 1, characterized in that: The above-mentioned method of creating a series of iterators for the Hash bucket data structure includes: a common iterator, a constant iterator, a reverse iterator and a constant reverse iterator, wherein the common iterator and the reverse iterator are used to modify data, and the constant iterator and the constant reverse iterator are used to query data.

5. A method for updating freight rate data according to claim 1, characterized in that: The configuration of the fragment file based on the constructed Hash bucket data structure, constructing the Index type data into the fragment file and mapping it to the memory space also includes: Create fragment files of Index type data according to the fragment size configured in the software configuration file, and use the memory constructor to construct continuous memory space for the Hash bucket data structure of each Index type data; Use the MMAP component to map all fragment files of each Index type data to the constructed memory space; Read the RAWDATA data, add the data to the corresponding Index type Hash bucket data structure, and use the iterator component to determine whether each data in the RAWDATA data exists in the Index fragment file; If it exists, the new data is stored in the existing data set. If it does not exist, the new data is appended to the end of the data of the last data fragment file. When the last data fragment file is full, a new data fragment file is dynamically created and the new data is stored in the new data fragment file.

6. A method for updating freight rate data according to claim 1, characterized in that: The detecting whether the Index type data is updated also includes: When data is updated, the index information of each data in each data table in the hash bucket is recorded, and the update information and data batch number are persisted in the data information file; After the incremental update is completed, the data fragment file whose data content is updated is determined according to the batch number and update information in the data information file, and is recorded in the changeFile file according to the data batch number.

7. A method for updating freight rate data according to claim 6, characterized in that: The LE loads the incremental data of the Index type data and completes the update operation of the incremental data of the Index type data. Specifically, after receiving the request, the LE will reload the latest DFF data, determine the incremental data fragment file of the Index type data updated by this batch data according to the batch number recorded in the changeFile file in the latest DFF data, and map the fragment file to the memory space.

8. A system for updating freight rate data, characterized in that: The system includes a data construction component, an iterator component, a Hash bucket component, an MMAP component, a memory constructor component, an incremental data detection component and an incremental data loading component, wherein: The data construction component belongs to the general control component, which is used to construct RAWDATA data into DFF data and fragment the Index type data; The Hash bucket component is used to construct DFF data and is responsible for data storage and access; The iterator component is responsible for traversing, modifying and adding data in the Hash bucket component and the data set; The memory builder component is responsible for constructing the memory required for data; The MMAP component is responsible for mapping the data file to the memory space; The incremental data loading component is responsible for mapping the constructed DFF data to the memory space; The incremental data detection component is used to detect whether the Index type data in the DFF data is updated, and is responsible for calculating in which data fragment file the incremental data is located.

9. A system for updating freight rate data according to claim 8, characterized in that: The Hash bucket component also includes data nodes, Hash functions and linked lists, where: Data nodes are used to store data information; Hash function is used to calculate the hash value of the key; Linked lists are used to resolve hash conflicts.

10. A system for updating freight rate data according to claim 9, characterized in that: The data node also includes: a key, a data set and a next pointer pointing to the next data node; the data set is a variable length array used to replace the data corresponding to the key stored in the STL Vector data structure; The hash conflict refers to different keys being mapped to the same hash value by the hash function; The linked list is used to resolve hash conflicts, specifically: storing keys with the same hash value in one bucket, using a linked list to store multiple data nodes; using a data set band instead of an STL Vector to store data corresponding to the key.

11. A system for updating freight rate data according to claim 8, characterized in that: The iterators include common iterators, constant iterators, reverse iterators and constant reverse iterators, wherein: the common iterators and reverse iterators are used to modify data, and the constant iterators and constant reverse iterators are used to query data.

Images