Line data    Source code

       1              : /* File: ctrl_undo_redo_iterator.inl; Copyright and License: see below */
       2              : 
       3           20 : static inline void ctrl_undo_redo_iterator_init ( ctrl_undo_redo_iterator_t *this_,
       4              :                                                   const ctrl_undo_redo_entry_t (*ring_buf)[],
       5              :                                                   uint32_t ring_buf_size,
       6              :                                                   bool iterate_upwards,
       7              :                                                   uint32_t current,
       8              :                                                   uint32_t length )
       9              : {
      10           20 :     assert( ring_buf != NULL );
      11           20 :     assert( ring_buf_size > 0 );
      12           20 :     assert( current < ring_buf_size );
      13           20 :     assert( length <= ring_buf_size );
      14           20 :     (*this_).ring_buf = ring_buf;
      15           20 :     (*this_).ring_buf_size = ring_buf_size;
      16           20 :     (*this_).iterate_upwards = iterate_upwards;
      17           20 :     (*this_).current = current;
      18           20 :     (*this_).length = length;
      19           20 : }
      20              : 
      21            9 : static inline void ctrl_undo_redo_iterator_reinit ( ctrl_undo_redo_iterator_t *this_,
      22              :                                                     const ctrl_undo_redo_entry_t (*ring_buf)[],
      23              :                                                     uint32_t ring_buf_size,
      24              :                                                     bool iterate_upwards,
      25              :                                                     uint32_t current,
      26              :                                                     uint32_t length )
      27              : {
      28            9 :     ctrl_undo_redo_iterator_init( this_, ring_buf, ring_buf_size, iterate_upwards, current, length );
      29            9 : }
      30              : 
      31            9 : static inline void ctrl_undo_redo_iterator_init_empty ( ctrl_undo_redo_iterator_t *this_ )
      32              : {
      33            9 :     (*this_).ring_buf = NULL;
      34            9 :     (*this_).ring_buf_size = 1;
      35            9 :     (*this_).iterate_upwards = true;
      36            9 :     (*this_).current = 0;
      37            9 :     (*this_).length = 0;
      38            9 : }
      39              : 
      40           20 : static inline void ctrl_undo_redo_iterator_destroy ( ctrl_undo_redo_iterator_t *this_ )
      41              : {
      42           20 :     (*this_).ring_buf = NULL;
      43           20 : }
      44              : 
      45           80 : static inline bool ctrl_undo_redo_iterator_has_next ( const ctrl_undo_redo_iterator_t *this_ )
      46              : {
      47           80 :     return ( (*this_).length != 0 );
      48              : }
      49              : 
      50           59 : static inline const ctrl_undo_redo_entry_t * ctrl_undo_redo_iterator_next ( ctrl_undo_redo_iterator_t *this_ )
      51              : {
      52           59 :     assert( (*this_).length > 0 );
      53              : 
      54           59 :     const ctrl_undo_redo_entry_t * result = NULL;
      55           59 :     if ( (*this_).length > 0 )
      56              :     {
      57           59 :         result = &((*(*this_).ring_buf)[(*this_).current]);
      58           59 :         if ( (*this_).iterate_upwards )
      59              :         {
      60            3 :             (*this_).current = ( (*this_).current + 1 ) % (*this_).ring_buf_size;
      61              :         }
      62              :         else
      63              :         {
      64           56 :             (*this_).current = ( (*this_).current + (*this_).ring_buf_size - 1 ) % (*this_).ring_buf_size;
      65              :         }
      66           59 :         (*this_).length --;
      67              :     }
      68              : 
      69           59 :     return result;
      70              : }
      71              : 
      72            9 : static inline void ctrl_undo_redo_iterator_collect_statistics ( ctrl_undo_redo_iterator_t *this_,
      73              :                                                                 bool undo,
      74              :                                                                 data_stat_t *io_stat )
      75              : {
      76            9 :     assert( io_stat != NULL );
      77           33 :     while ( ctrl_undo_redo_iterator_has_next( this_ ) )
      78              :     {
      79           24 :         const ctrl_undo_redo_entry_t *const current_entry = ctrl_undo_redo_iterator_next( this_ );
      80           24 :         ctrl_undo_redo_entry_to_statistics ( current_entry, undo /*=undo*/, false /*=err*/, io_stat );
      81              :     }
      82            9 : }
      83              : 
      84              : 
      85              : /*
      86              : Copyright 2024-2025 Andreas Warnke
      87              : 
      88              : Licensed under the Apache License, Version 2.0 (the "License");
      89              : you may not use this file except in compliance with the License.
      90              : You may obtain a copy of the License at
      91              : 
      92              :     http://www.apache.org/licenses/LICENSE-2.0
      93              : 
      94              : Unless required by applicable law or agreed to in writing, software
      95              : distributed under the License is distributed on an "AS IS" BASIS,
      96              : WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      97              : See the License for the specific language governing permissions and
      98              : limitations under the License.
      99              : */