Ignore:
Timestamp:
Oct 14, 2007, 12:20:17 AM (14 years ago)
Author:
Peter Johansson
Message:

fixes #272 in trunk and also #211 - split stats class into inherited and base class

File:
1 copied

Legend:

Unmodified
Added
Removed
  • trunk/lib/ClassicStats.cc

    r482 r487  
    2323*/
    2424
    25 #include "Stats.h"
     25#include "ClassicStats.h"
    2626
    2727#include "Functor.h"
     
    5050
    5151
    52   Stats::Stats(const std::string& path)
    53   {
    54     // Make sure latest revision is set properly
    55     SVNinfo svn_info(path);
    56     revision_=svn_info.rev();
    57     last_changed_rev_=svn_info.last_changed_rev();
    58   }
    59 
    60 
    61   std::vector<u_int> Stats::accumulated(const Map_& map) const
     52  ClassicStats::ClassicStats(const std::string& path)
     53    : Stats(path)
     54  {
     55  }
     56
     57
     58  std::vector<u_int> ClassicStats::accumulated(const Map_& map) const
    6259  {
    6360    // sum of all users
    64     std::vector<u_int> sum(revision_+1);
     61    std::vector<u_int> sum(revision()+1);
    6562    sum=std::accumulate(map.begin(), map.end(), sum,
    6663                        PairValuePlus<std::string,u_int>());
     
    7370  }
    7471
    75   std::vector<u_int> Stats::accumulated(const Map_& map,
     72  std::vector<u_int> ClassicStats::accumulated(const Map_& map,
    7673                                        const std::string& user) const
    7774  {
    7875    if (!map.count(user))
    79       return std::vector<u_int>(last_changed_rev_,0);
     76      return std::vector<u_int>(last_changed_rev(),0);
    8077    std::vector<u_int> vec=(map.find(user))->second;
    8178
    8279    // static_cast to remove annoying compiler warning
    83     if (vec.size() < static_cast<size_t>(revision_+1))
    84       vec.insert(vec.end(), revision_+1-vec.size(), 0);
     80    if (vec.size() < static_cast<size_t>(revision()+1))
     81      vec.insert(vec.end(), revision()+1-vec.size(), 0);
    8582
    8683    std::vector<u_int> accum(vec.size());
     
    8986  }
    9087
    91   void Stats::add(const std::string& user, const u_int& rev,
    92                   const Parser::line_type& lt)
     88  void ClassicStats::add(const std::string& user, const u_int& rev,
     89                         const Parser::line_type& lt)
    9390  {
    9491    assert(user.size());
    95     authors_.insert(user);
     92    add_author(user);
    9693
    9794    std::vector<u_int>* total = &(total_[user]);
    9895    assert(total);
    9996    if (total->size() < rev+1){
    100       total->reserve(revision_ + 1);
     97      total->reserve(revision() + 1);
    10198      total->insert(total->end(), rev - total->size(), 0);
    10299      total->push_back(1);
     
    108105    assert(code);
    109106    if (code->size() < rev+1){
    110       code->reserve(revision_ + 1);
     107      code->reserve(revision() + 1);
    111108      code->insert(code->end(), rev - code->size(), 0);
    112109      if (lt == Parser::code)
     
    121118    assert(comments);
    122119    if (comments->size() < rev+1){
    123       comments->reserve(revision_ + 1);
     120      comments->reserve(revision() + 1);
    124121      comments->insert(comments->end(), rev - comments->size(), 0);
    125122      if (lt == Parser::comment)
     
    134131    assert(empty);
    135132    if (empty->size() < rev+1){
    136       empty->reserve(revision_ + 1);
     133      empty->reserve(revision() + 1);
    137134      empty->insert(empty->end(), rev - empty->size(), 0);
    138135      if (lt == Parser::empty)
     
    146143
    147144
    148   bool Stats::load_cache(std::istream& is)
     145  bool ClassicStats::do_load_cache(std::istream& is)
    149146  {
    150147    svn_revnum_t rev;
    151148    is >> rev;
    152     if (rev<last_changed_rev_){
     149    if (rev<last_changed_rev()){
    153150      return false; // cache is not up to date
    154151    }
     152    reset();
    155153    size_t a_size=0;
    156     authors_.clear();
    157154    is >> a_size;
    158155    std::string str;
    159     while (authors_.size()<a_size){
     156    while (authors().size()<a_size){
    160157      getline(is, str);
    161158      assert(str.size());
    162       authors_.insert(str);
     159      add_author(str);
    163160    }
    164161    getline(is, str);
     
    191188
    192189
    193   void Stats::load(std::istream& is, Map_& m)
    194   {
    195     m.clear();
    196     while (m.size() < authors_.size() && is.good()) {
     190  void ClassicStats::load(std::istream& is, Map_& m)
     191  {
     192    while (m.size() < authors().size() && is.good()) {
    197193      std::string name;
    198194      std::getline(is, name);
     
    211207
    212208
    213   void Stats::parse(const std::string& path)
     209  void ClassicStats::do_parse(const std::string& path)
    214210  {
    215211    Parser parser(path);
     
    222218      ++count;
    223219    }
    224    
    225   }
    226 
    227 
    228   std::string Stats::plot(const std::string& filename,
    229                           const std::string& linetype) const
     220  }
     221
     222
     223  std::string ClassicStats::do_plot(const std::string& filename,
     224                                    const std::string& linetype) const
    230225  {
    231226    plot_init(filename);
     
    288283
    289284
    290   void Stats::plot_init(const std::string& filename) const
    291   {
    292     GnuplotFE* gp=GnuplotFE::instance();
    293     gp->command("set term png");
    294     gp->command("set output '"+filename+"'");
    295     gp->command("set xtics nomirror");
    296     gp->command("set ytics nomirror");
    297     gp->command("set key default");
    298     gp->command("set key left Left reverse");
    299     gp->command("set multiplot");
    300   }
    301 
    302 
    303   void Stats::plot_summary(const std::string& filename) const
    304   {
    305     plot_init(filename);
    306     GnuplotFE* gp=GnuplotFE::instance();
    307     std::vector<u_int> total=accumulated(total_);   
    308     double yrange_max=1.03*total.back()+1;
    309     gp->yrange(yrange_max);
    310     std::stringstream ss;
    311    
    312     ss.str("");
    313     std::vector<u_int> x=accumulated(code_);   
    314     ss << x.back() << " code";
    315     gp->command("set key height 2");
    316     gp->linetitle(ss.str());
    317     gp->linestyle("steps 2");
    318     gp->plot(x);
    319 
    320     ss.str("");
    321     x=accumulated(comments_);   
    322     ss << x.back() << " comment";
    323     gp->command("set key height 4");
    324     gp->linetitle(ss.str());
    325     gp->linestyle("steps 3");
    326     gp->plot(x);
    327 
    328     ss.str("");
    329     x=accumulated(empty_);   
    330     ss << x.back() << " other";
    331     gp->command("set key height 6");
    332     gp->linetitle(ss.str());
    333     gp->linestyle("steps 4");
    334     gp->plot(x);
    335 
    336     ss.str("");
    337     ss << total.back() << " total";
    338     gp->command("set key height 0");
    339     gp->linetitle(ss.str());
    340     gp->linestyle("steps 1");
    341     gp->plot(total);
    342 
    343     gp->command("unset multiplot");
    344     gp->yrange();
    345   }
    346 
    347 
    348   void Stats::print(std::ostream& os) const
    349   {
    350     os << last_changed_rev_ << " ";
    351     os << authors_.size() << " ";
    352 
    353     std::copy(authors_.begin(), authors_.end(),
     285  void ClassicStats::do_print(std::ostream& os) const
     286  {
     287    os << last_changed_rev() << " ";
     288    os << authors().size() << " ";
     289
     290    std::copy(authors().begin(), authors().end(),
    354291              std::ostream_iterator<std::string>(os, "\n"));
    355292    os << code_cache() << "\n";
    356     print(os, code_);
     293    do_print(os, code_);
    357294    os << "\n" << comments_cache() << "\n";
    358     print(os, comments_);
     295    do_print(os, comments_);
    359296    os << "\n" << empty_cache() << "\n";
    360     print(os, empty_);
     297    do_print(os, empty_);
    361298    os << "\n" << total_cache() << "\n";
    362     print(os, total_);
     299    do_print(os, total_);
    363300    os << "\n" << end_of_cache() << "\n";
    364301  }
    365302
    366303
    367   void Stats::print(std::ostream& os, const Map_& m) const
     304  void ClassicStats::do_print(std::ostream& os, const Map_& m) const
    368305  {
    369306    for (MapConstIter_ i(m.begin()); i!=m.end(); ++i){
     
    375312  }
    376313
    377 
    378   Stats& Stats::operator+=(const Stats& other)
     314 
     315  std::vector<u_int> ClassicStats::vector(std::string type,
     316                                          std::string user) const
     317  {
     318    const Map_* map = NULL;
     319    if (type=="code")
     320      map = &code_;
     321    else if (type=="comments")
     322      map = &comments_;
     323    else if (type=="other")
     324      map = &empty_;
     325    assert(map && "type is of invalid type");
     326    if (!map->count(user))
     327      return std::vector<u_int>(last_changed_rev(),0);
     328    const std::vector<u_int>& vec=(map->find(user))->second;
     329   
     330    std::vector<u_int> accum(vec.size());
     331    std::partial_sum(vec.begin(),vec.end(),accum.begin());
     332    // static_cast to remove annoying compiler warning
     333    if (accum.size() < static_cast<size_t>(revision()+1))
     334      accum.insert(accum.end(), revision()+1-vec.size(), accum.back());
     335    return accum;
     336
     337  }
     338
     339
     340  ClassicStats& ClassicStats::operator+=(const ClassicStats& rhs)
    379341  {
    380     for (MapConstIter_ o_i= other.code_.begin();
    381          o_i != other.code_.end(); ++o_i)
    382     {
    383       std::pair<MapIter_,bool> result = code_.insert(*o_i);
    384       if (!result.second)
    385         code_[(*(result.first)).first] =
    386           VectorPlus<u_int>()( (*(result.first)).second, (*o_i).second );
    387  
    388     }
    389  
    390     for (MapConstIter_ o_i= other.comments_.begin();
    391          o_i != other.comments_.end(); ++o_i)
    392     {
    393       std::pair<MapIter_,bool> result = comments_.insert(*o_i);
    394       if (!result.second)
    395         comments_[(*(result.first)).first] =
    396           VectorPlus<u_int>()( (*(result.first)).second, (*o_i).second );
    397  
    398     }
     342    base_add(rhs.code_.begin(), rhs.code_.end(), code_);
     343    base_add(rhs.comments_.begin(), rhs.comments_.end(), comments_);
     344    base_add(rhs.empty_.begin(), rhs.empty_.end(), empty_);
     345    base_add(rhs.total_.begin(), rhs.total_.end(), total_);
    399346   
    400     for (MapConstIter_ o_i= other.empty_.begin();
    401          o_i != other.empty_.end(); ++o_i)
    402     {
    403       std::pair<MapIter_,bool> result = empty_.insert(*o_i);
    404       if (!result.second)
    405         empty_[(*(result.first)).first] =
    406           VectorPlus<u_int>()( (*(result.first)).second, (*o_i).second );
    407  
    408     }
    409    
    410     for (MapConstIter_ o_i= other.total_.begin();
    411          o_i != other.total_.end(); ++o_i)
    412     {
    413       std::pair<MapIter_,bool> result = total_.insert(*o_i);
    414       if (!result.second)
    415         total_[(*(result.first)).first] =
    416           VectorPlus<u_int>()( (*(result.first)).second, (*o_i).second );
    417  
    418     }
    419    
    420     if (!other.authors().empty())
    421       authors_.insert(other.authors().begin(), other.authors().end());
     347    base_add(rhs);
    422348    return *this;
    423349  }
Note: See TracChangeset for help on using the changeset viewer.