Line data    Source code

       1              : #include "precizer.h"
       2              : 
       3              : /**
       4              :  * @brief Retrieve a const pointer to a flag descriptor by index.
       5              :  *
       6              :  * Uses the mem helper to obtain a typed readonly view of the @ref Flags array and
       7              :  * performs bounds checking. Returns NULL if the descriptor is missing, type
       8              :  * verification fails, or the index is out of range.
       9              :  */
      10            0 : static const Flags *lookup(
      11              :         const memory *flags,
      12              :         size_t       index)
      13              : {
      14            0 :         const Flags *flags_data = cdata(Flags,flags);
      15              : 
      16            0 :         if(flags_data == NULL || index >= flags->length)
      17              :         {
      18            0 :                 return(NULL);
      19              :         }
      20              : 
      21            0 :         return(&flags_data[index]);
      22              : }
      23              : 
      24            0 : Return show_difference(
      25              :         Changed         change_flags_mask,
      26              :         const CmpctStat *before,
      27              :         const CmpctStat *after)
      28              : {
      29              :         /* Validate input parameters */
      30            0 :         if(NULL == before || NULL == after)
      31              :         {
      32            0 :                 return(FAILURE);
      33              :         }
      34              : 
      35            0 :         if(change_flags_mask == IDENTICAL)
      36              :         {
      37            0 :                 return(SUCCESS);
      38              :         }
      39              : 
      40            0 :         Return status = SUCCESS;
      41              : 
      42            0 :         create(Flags,flags);
      43            0 :         call(resize(flags,3));
      44              : 
      45            0 :         Flags *flags_data = data(Flags,flags);
      46              : 
      47            0 :         if(flags_data == NULL)
      48              :         {
      49            0 :                 del(flags);
      50            0 :                 provide(FAILURE);
      51              :         }
      52              : 
      53            0 :         flags_data[0] = (Flags){SIZE_CHANGED,"size"};
      54            0 :         flags_data[1] = (Flags){STATUS_CHANGED_TIME,"ctime"};
      55            0 :         flags_data[2] = (Flags){MODIFICATION_TIME_CHANGED,"mtime"};
      56              : 
      57            0 :         unsigned int flags_found = 0;
      58            0 :         bool first_word = true;
      59              : 
      60              :         /* Check each flag */
      61            0 :         for(size_t i = 0; i < flags->length; i++)
      62              :         {
      63            0 :                 const Flags *flag = lookup(flags,i);
      64              : 
      65            0 :                 if(flag == NULL)
      66              :                 {
      67            0 :                         break;
      68              :                 }
      69              : 
      70            0 :                 if(((unsigned int)change_flags_mask & (unsigned int)flag->flag_value) != 0u)
      71              :                 {
      72            0 :                         if(first_word == true)
      73              :                         {
      74            0 :                                 slog(ERROR,"Database file details: ");
      75            0 :                                 first_word = false;
      76              :                         }
      77              : 
      78              :                         /* Add separator if not the first flag */
      79            0 :                         if(flags_found > 0)
      80              :                         {
      81            0 :                                 slog(ERROR|UNDECOR," & ");
      82              :                         }
      83            0 :                         slog(ERROR|UNDECOR,"%s",flag->flag_name);
      84            0 :                         show_metadata(ERROR,flag->flag_value,before,after);
      85            0 :                         flags_found++;
      86              :                 }
      87              :         }
      88              : 
      89            0 :         if(flags_found > 0)
      90              :         {
      91            0 :                 slog(ERROR|UNDECOR,"\n");
      92              :         }
      93              : 
      94            0 :         del(flags);
      95              : 
      96            0 :         return(SUCCESS);
      97              : }