apt-pkg/contrib/progress.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: progress.cc,v 1.12 2003/01/11 07:17:04 jgg Exp $
   4 /* ######################################################################
   5
   6    OpProgress - Operation Progress
   7
   8    ##################################################################### */
   9                                                                         /*}}}*/
  10 // Include Files                                                        /*{{{*/
  11 #include <config.h>
  12
  13 #include <apt-pkg/progress.h>
  14 #include <apt-pkg/error.h>
  15 #include <apt-pkg/configuration.h>
  16
  17 #include <iostream>
  18 #include <stdio.h>
  19 #include <cstring>
  20
  21 #include <apti18n.h>
  22                                                                         /*}}}*/
  23
  24 using namespace std;
  25
  26 // OpProgress::OpProgress - Constructor                                 /*{{{*/
  27 // ---------------------------------------------------------------------
  28 /* */
  29 OpProgress::OpProgress() : Current(0), Total(0), Size(0), SubTotal(1),
  30                            LastPercent(0), Percent(0)
  31 {
  32    memset(&LastTime,0,sizeof(LastTime));
  33 }
  34                                                                         /*}}}*/
  35 // OpProgress::Progress - Sub progress with no state change             /*{{{*/
  36 // ---------------------------------------------------------------------
  37 /* Current is the Base Overall progress in units of Total. Cur is the sub
  38    progress in units of SubTotal. Size is a scaling factor that says what
  39    percent of Total SubTotal is. */
  40 void OpProgress::Progress(unsigned long long Cur)
  41 {
  42    if (Total == 0 || Size == 0 || SubTotal == 0)
  43       Percent = 0;
  44    else
  45       Percent = (Current + Cur/((float)SubTotal)*Size)*100.0/Total;
  46    Update();
  47 }
  48                                                                         /*}}}*/
  49 // OpProgress::OverallProgress - Set the overall progress               /*{{{*/
  50 // ---------------------------------------------------------------------
  51 /* */
  52 void OpProgress::OverallProgress(unsigned long long Current, unsigned long long Total,
  53                                  unsigned long long Size,const string &Op)
  54 {
  55    this->Current = Current;
  56    this->Total = Total;
  57    this->Size = Size;
  58    this->Op = Op;
  59    SubOp = string();
  60    if (Total == 0)
  61       Percent = 0;
  62    else
  63       Percent = Current*100.0/Total;
  64    Update();
  65 }
  66                                                                         /*}}}*/
  67 // OpProgress::SubProgress - Set the sub progress state                 /*{{{*/
  68 // ---------------------------------------------------------------------
  69 /* */
  70 void OpProgress::SubProgress(unsigned long long SubTotal,const string &Op,
  71                              float const Percent)
  72 {
  73    this->SubTotal = SubTotal;
  74    if (Op.empty() == false)
  75       SubOp = Op;
  76    if (Total == 0 || Percent == 0)
  77       this->Percent = 0;
  78    else if (Percent != -1)
  79       this->Percent = this->Current += (Size*Percent)/SubTotal;
  80    else
  81       this->Percent = Current*100.0/Total;
  82    Update();
  83 }
  84                                                                         /*}}}*/
  85 // OpProgress::CheckChange - See if the display should be updated       /*{{{*/
  86 // ---------------------------------------------------------------------
  87 /* Progress calls are made so frequently that if every one resulted in
  88    an update the display would be swamped and the system much slower.
  89    This provides an upper bound on the update rate. */
  90 bool OpProgress::CheckChange(float Interval)
  91 {
  92    // New major progress indication
  93    if (Op != LastOp)
  94    {
  95       MajorChange = true;
  96       LastOp = Op;
  97       return true;
  98    }
  99    MajorChange = false;
 100
 101    if (SubOp != LastSubOp)
 102    {
 103       LastSubOp = SubOp;
 104       return true;
 105    }
 106
 107    if ((int)LastPercent == (int)Percent)
 108       return false;
 109
 110    LastPercent = Percent;
 111
 112    if (Interval == 0)
 113       return false;
 114
 115    // Check time delta
 116    struct timeval Now;
 117    gettimeofday(&Now,0);
 118    double Diff = Now.tv_sec - LastTime.tv_sec + (Now.tv_usec - LastTime.tv_usec)/1000000.0;
 119    if (Diff < Interval)
 120       return false;
 121    LastTime = Now;
 122    return true;
 123 }
 124                                                                         /*}}}*/
 125 // OpTextProgress::OpTextProgress - Constructor                         /*{{{*/
 126 // ---------------------------------------------------------------------
 127 /* */
 128 OpTextProgress::OpTextProgress(Configuration &Config) :
 129                                NoUpdate(false), NoDisplay(false), LastLen(0)
 130 {
 131    if (Config.FindI("quiet",0) >= 1 || Config.FindB("quiet::NoUpdate", false) == true)
 132       NoUpdate = true;
 133    if (Config.FindI("quiet",0) >= 2)
 134       NoDisplay = true;
 135 };
 136                                                                         /*}}}*/
 137 // OpTextProgress::Done - Clean up the display                          /*{{{*/
 138 // ---------------------------------------------------------------------
 139 /* */
 140 void OpTextProgress::Done()
 141 {
 142    if (NoUpdate == false && OldOp.empty() == false)
 143    {
 144       char S[300];
 145       if (_error->PendingError() == true)
 146          snprintf(S,sizeof(S),_("%c%s... Error!"),'\r',OldOp.c_str());
 147       else
 148          snprintf(S,sizeof(S),_("%c%s... Done"),'\r',OldOp.c_str());
 149       Write(S);
 150       cout << endl;
 151       OldOp = string();
 152    }
 153
 154    if (NoUpdate == true && NoDisplay == false && OldOp.empty() == false)
 155    {
 156       OldOp = string();
 157       cout << endl;
 158    }
 159 }
 160                                                                         /*}}}*/
 161 // OpTextProgress::Update - Simple text spinner                         /*{{{*/
 162 // ---------------------------------------------------------------------
 163 /* */
 164 void OpTextProgress::Update()
 165 {
 166    if (CheckChange((NoUpdate == true?0:0.7)) == false)
 167       return;
 168
 169    // No percent spinner
 170    if (NoUpdate == true)
 171    {
 172       if (MajorChange == false)
 173          return;
 174       if (NoDisplay == false)
 175       {
 176          if (OldOp.empty() == false)
 177             cout << endl;
 178          OldOp = "a";
 179          cout << Op << "..." << flush;
 180       }
 181
 182       return;
 183    }
 184
 185    // Erase the old text and 'log' the event
 186    char S[300];
 187    if (MajorChange == true && OldOp.empty() == false)
 188    {
 189       snprintf(S,sizeof(S),"\r%s",OldOp.c_str());
 190       Write(S);
 191       cout << endl;
 192    }
 193
 194    // Print the spinner
 195    snprintf(S,sizeof(S),"\r%s... %u%%",Op.c_str(),(unsigned int)Percent);
 196    Write(S);
 197
 198    OldOp = Op;
 199 }
 200                                                                         /*}}}*/
 201 // OpTextProgress::Write - Write the progress string                    /*{{{*/
 202 // ---------------------------------------------------------------------
 203 /* This space fills the end to overwrite the previous text */
 204 void OpTextProgress::Write(const char *S)
 205 {
 206    cout << S;
 207    for (unsigned int I = strlen(S); I < LastLen; I++)
 208       cout << ' ';
 209    cout << '\r' << flush;
 210    LastLen = strlen(S);
 211 }
 212                                                                         /*}}}*/