Changeset 552 for trunk


Ignore:
Timestamp:
Jan 8, 2008, 3:40:37 PM (14 years ago)
Author:
Peter Johansson
Message:

fixes linetype Copyright

Location:
trunk
Files:
10 edited
2 moved

Legend:

Unmodified
Added
Removed
  • trunk/lib/AddStats.cc

    r545 r552  
    5656  void AddStats::do_parse(const std::string& path)
    5757  {
    58     Parser parser(path);
     58    LineTypeParser parser(path);
    5959    SVNlog log(path);
    6060    typedef std::set<svn_revnum_t> RevSet;
  • trunk/lib/BlameStats.cc

    r537 r552  
    7878  void BlameStats::do_parse(const std::string& path)
    7979  {
    80     Parser parser(path);
     80    LineTypeParser parser(path);
    8181    SVNlog log(path);
    8282    typedef std::set<svn_revnum_t> RevSet;
     
    100100        ++rev_iter;
    101101      else {
    102         fill_in(code_,rev);
    103         fill_in(comments_,rev);
    104         fill_in(other_,rev);
     102        fill_in(code_stats(),rev);
     103        fill_in(comment_stats(),rev);
     104        fill_in(other_stats(),rev);
     105        fill_in(copyright_stats(),rev);
    105106      }
    106107    }
  • trunk/lib/ClassicStats.cc

    r537 r552  
    6464  void ClassicStats::do_parse(const std::string& path)
    6565  {
    66     Parser parser(path);
     66    LineTypeParser parser(path);
    6767    SVNblame svn_blame(path);
    6868    while (svn_blame.valid()) {
  • trunk/lib/File.cc

    r546 r552  
    6363    map<int, set<Alias> > year_authors;
    6464    SVNlog log(path());
    65 
    66     assert(log.author().size()==log.date().size());
    67     vector<string>::const_iterator author=log.author().begin();
    68     for (vector<string>::const_iterator date=log.date().begin();
    69          date!=log.date().end(); ++date, ++author) {
    70       time_t sec = str2time(*date);
    71       tm* timeinfo = gmtime(&sec);
    72 
    73       // find username in map of aliases
    74       std::map<string,Alias>::iterator name(alias.lower_bound(*author));
    75 
    76       // if alias exist insert alias
    77       if (name != alias.end() && name->first==*author)
    78         year_authors[timeinfo->tm_year].insert(name->second);
    79       else {
    80         // else insert user name
    81         Alias a(*author,alias.size());
    82         year_authors[timeinfo->tm_year].insert(a);
    83         std::cerr << "svndigest: warning: no copyright alias found for `"
    84                   << *author << "'\n";
    85         // insert alias to avoid multiple warnings.
    86         alias.insert(name, std::make_pair(*author, a));
     65    const Stats& stats = stats_["add"];
     66   
     67
     68    for (LogIterator i=log.begin(); i<log.end(); ++i){
     69      if (i->revision() &&
     70          (stats(LineTypeParser::code, i->author(), i->revision()) >
     71           stats(LineTypeParser::code, i->author(), i->revision()-1) ||
     72           stats(LineTypeParser::comment, i->author(), i->revision()) >
     73           stats(LineTypeParser::comment, i->author(), i->revision()-1))
     74          ) {
     75       
     76        time_t sec = str2time(i->date());
     77        tm* timeinfo = gmtime(&sec);
     78       
     79        // find username in map of aliases
     80        std::map<string,Alias>::iterator name(alias.lower_bound(i->author()));
     81       
     82        // if alias exist insert alias
     83        if (name != alias.end() && name->first==i->author())
     84          year_authors[timeinfo->tm_year].insert(name->second);
     85        else {
     86          // else insert user name
     87          Alias a(i->author(),alias.size());
     88          year_authors[timeinfo->tm_year].insert(a);
     89          std::cerr << "svndigest: warning: no copyright alias found for `"
     90                    << i->author() << "'\n";
     91          // insert alias to avoid multiple warnings.
     92          alias.insert(name, std::make_pair(i->author(), a));
     93        }
    8794      }
    8895    }
     
    129136  {
    130137    using namespace std;
    131     ifstream is(path().c_str());
    132     assert(is.good());
    133     string line;
    134     bool found_copyright = false;
    135     bool after_copyright = false;
    136     size_t line_no=0;
    137     while(getline(is, line) && !after_copyright){
    138       ++line_no;
    139       if (found_copyright){
    140         // check if line is end of copyright statement, i.e. contains
    141         // no alphanumerical character (except in prefix).
    142         after_copyright = true;
    143         for (size_t i=0; i<line.size()&&after_copyright; ++i)
    144           if (isalnum(line[i]) && !(i<prefix.size() && prefix[i]==line[i])) {
    145             after_copyright = false;
    146             block += line + "\n";
    147           }
    148         if (after_copyright)
    149           end_at_line=line_no;
    150       }
    151       else {
    152         // check whether copyright starts on this line
    153         string::iterator i = search(line.begin(), line.end(), "Copyright (C)");
    154         if (i!=line.end()) {
    155           start_at_line=line_no;
    156           prefix = line.substr(0, distance(line.begin(), i));
    157           found_copyright = true;
    158           block = line + "\n";
    159         }
    160       }
    161     }
    162     is.close();
    163     return found_copyright;
     138    LineTypeParser parser(path());
     139    if (!parser.copyright_found())
     140      return false;
     141    block = parser.block();
     142    start_at_line = parser.start_line();
     143    end_at_line = parser.end_line();
     144    prefix = parser.prefix();
     145    return true;
    164146  }
    165147
     
    229211    HtmlStream hs(os);
    230212    SVNblame blame(path_);
    231     Parser parser(path_);
     213    LineTypeParser parser(path_);
    232214    while (blame.valid()) {
    233215      parser.parse(blame.line());
     
    236218    blame.reset();
    237219
    238     std::vector<Parser::line_type>::const_iterator
     220    std::vector<LineTypeParser::line_type>::const_iterator
    239221      line_type(parser.type().begin());
    240222    int last=0;
     
    271253      os << "</td>\n<td class=\"";
    272254      assert(line_type!=parser.type().end());
    273       if (*line_type==Parser::other)
     255      if (*line_type==LineTypeParser::other)
    274256        os << "line-other";
    275       else if (*line_type==Parser::comment)
     257      else if (*line_type==LineTypeParser::comment)
    276258        os << "line-comment";
    277259      else
  • trunk/lib/LineTypeParser.cc

    r550 r552  
    2222*/
    2323
    24 #include "Parser.h"
     24#include "LineTypeParser.h"
    2525#include "Configuration.h"
    2626#include "utility.h"
     
    3939
    4040
    41   Parser::Parser(std::string path)
    42     : mode_(0)
     41  LineTypeParser::LineTypeParser(std::string path)
     42    : mode_(0), post_copyright_(false), copyright_found_(false)
    4343  {
    4444    codon_ = Configuration::instance().codon(path);
     
    4646
    4747
    48   Parser::line_type Parser::parse(const std::string& line)
     48  LineTypeParser::line_type LineTypeParser::parse(std::string line)
    4949  {
    50     if (codon_)
     50    if (!post_copyright_) {
     51      if (copyright_found_) {
     52        // check if line is end of copyright statement, i.e. contains
     53        // no alphanumerical character (except in copyright_prefix).
     54        for (size_t i=0; i<line.size()&&post_copyright_; ++i)
     55          if (isalnum(line[i]) &&
     56              !(i<copyright_prefix_.size() && copyright_prefix_[i]==line[i])){
     57            post_copyright_ = false;
     58            block_ += line + "\n";
     59          }
     60        if (post_copyright_)
     61          end_line_ = type_.size()+1;
     62      }
     63      else {
     64        // check whether copyright starts on this line
     65        std::string::iterator i=search(line.begin(),line.end(),"Copyright (C)");
     66        if (i!=line.end()) {
     67          start_line_ = type_.size()+1;
     68          copyright_prefix_ = line.substr(0, distance(line.begin(), i));
     69          copyright_found_ = true;
     70          block_ = line+"\n";
     71        }
     72      }
     73    }
     74    // we are in copyright block
     75    if (copyright_found_ && !post_copyright_)
     76      type_.push_back(LineTypeParser::copyright);
     77
     78    else if (codon_)
    5179      type_.push_back(code_mode(line));
    5280    else
     
    5785
    5886
    59   Parser::line_type Parser::code_mode(const std::string& str)
     87  LineTypeParser::line_type LineTypeParser::code_mode(const std::string& str)
    6088  {
    6189    // mode zero means we are currently not in a comment
     
    99127
    100128
    101   Parser::line_type Parser::text_mode(const std::string& str)
     129  LineTypeParser::line_type LineTypeParser::text_mode(const std::string& str)
    102130  {
    103131    for (std::string::const_iterator iter=str.begin(); iter!=str.end(); ++iter)
  • trunk/lib/LineTypeParser.h

    r550 r552  
    1 #ifndef _theplu_svndigest_parser_
    2 #define _theplu_svndigest_parser_
     1#ifndef _theplu_svndigest_line_type_parser_
     2#define _theplu_svndigest_line_type_parser_
    33
    44// $Id$
     
    3434
    3535  /**
    36      \brief Class parsing files
     36     \brief differentiate code, comments, and blank lines
    3737     
    3838     Class gets parsing rules from Configuration. Which rules depends
     
    4141     which can be accessed through function type(void).
    4242  */
    43   class Parser
     43  class LineTypeParser
    4444  {
    4545  public:
     
    4747    /// see 'doc/readmea.txt' for info on what is code, comment, and other.
    4848    ///
     49    // do not change these without checking in Stats class
    4950    enum line_type {
    50       copyright,
    51       other,
    52       comment,
    53       code
     51      copyright = 0,
     52      other = 1,
     53      comment = 2,
     54      code = 3,
     55      comment_or_copy = 4,
     56      total = 5 // total should always be the largest
    5457    };
    5558
     
    5861    /// \param filename is used to decide which parsing rules to use
    5962    ///
    60     explicit Parser(std::string filename);
     63    explicit LineTypeParser(std::string filename);
     64
     65    const std::string& block(void) const { return block_; }
     66    inline bool copyright_found(void) const { return copyright_found_; }
     67
     68    inline size_t end_line(void) const { return end_line_; }
    6169
    6270    /**
     
    6775       The line is parsed and added to internal vector. 
    6876     */
    69     line_type parse(const std::string& line);
     77    line_type parse(std::string line);
     78
     79    const std::string& prefix(void) const { return copyright_prefix_; }
     80
     81    inline size_t start_line(void) const { return start_line_; }
    7082
    7183    ///
     
    7688  private:
    7789    // no copy allowed
    78     Parser(const Parser& other);
    79     Parser& operator=(const Parser&);
     90    LineTypeParser(const LineTypeParser& other);
     91    LineTypeParser& operator=(const LineTypeParser&);
    8092
    8193    line_type code_mode(const std::string& line);
     
    8395
    8496    size_t mode_;
     97    bool post_copyright_;
     98    bool copyright_found_;
     99    std::string copyright_prefix_;
     100    std::string block_;
     101    size_t start_line_;
     102    size_t end_line_;
    85103   
    86104    std::vector<line_type> type_;
  • trunk/lib/LogIterator.cc

    r519 r552  
    7474
    7575
     76  bool LogIterator::operator==(const LogIterator& other) const
     77  {
     78    assert(&log_==&other.log_);
     79    return index_==other.index_;
     80  }
     81
     82
     83  bool LogIterator::operator!=(const LogIterator& other) const
     84  {
     85    assert(&log_==&other.log_);
     86    return index_!=other.index_;
     87  }
     88
     89
    7690  const Commitment& LogIterator::operator*() const
    7791  {
  • trunk/lib/LogIterator.h

    r519 r552  
    4949
    5050    bool operator<(const LogIterator&) const;
     51    bool operator==(const LogIterator&) const;
     52    bool operator!=(const LogIterator&) const;
    5153    const Commitment* operator->() const;
    5254    const Commitment& operator*() const;
  • trunk/lib/Makefile.am

    r549 r552  
    2929  Commitment.h Configuration.h css.h\
    3030  Date.h Directory.h File.h first_page.h Functor.h Gnuplot.h GnuplotFE.h \
    31   HtmlStream.h html_utility.h LogIterator.h Node.h Parser.h rmdirhier.h \
     31  HtmlStream.h html_utility.h LineTypeParser.h \
     32  LogIterator.h Node.h rmdirhier.h \
    3233  Stats.h StatsCollection.h SVN.h SVNblame.h  \
    3334  SVNinfo.h SVNlog.h SVNproperty.h Trac.h utility.h
     
    3839  css.cc Date.cc Directory.cc File.cc first_page.cc\
    3940  Functor.cc Gnuplot.cc GnuplotFE.cc  HtmlStream.cc \
    40   html_utility.cc LogIterator.cc Node.cc Parser.cc \
     41  html_utility.cc LineTypeParser.cc LogIterator.cc Node.cc \
    4142  rmdirhier.cc Stats.cc StatsCollection.cc SVN.cc       \
    4243  SVNblame.cc SVNinfo.cc SVNlog.cc SVNproperty.cc Trac.cc utility.cc
  • trunk/lib/Stats.cc

    r537 r552  
    5151
    5252  Stats::Stats(const std::string& path)
     53    : stats_(std::vector<Author2Vector>(LineTypeParser::total+1))
    5354  {
    5455    // Make sure latest revision is set properly
     
    8182    for (std::set<std::string>::const_iterator iter(authors().begin());
    8283         iter!=authors().end(); ++iter) {
    83       std::vector<u_int>& code = code_[*iter];
     84      std::vector<u_int>& code = code_stats()[*iter];
    8485      accumulate(code);
    85       std::vector<u_int>& comments = comments_[*iter];
     86      std::vector<u_int>& comments = comment_stats()[*iter];
    8687      accumulate(comments);
    87       std::vector<u_int>& other = other_[*iter];
     88      std::vector<u_int>& other = other_stats()[*iter];
    8889      accumulate(other);
    8990    }
     
    9293
    9394  void Stats::add(const std::string& user, const u_int& rev,
    94                   const Parser::line_type& lt, u_int n)
     95                  const LineTypeParser::line_type& lt, u_int n)
    9596  {
    9697    assert(user.size());
    9798    add_author(user);
    9899
    99     std::vector<u_int>& code = code_[user];
     100    // Peter remove repeat
     101    std::vector<u_int>& code = code_stats()[user];
    100102    if (code.size() < rev+1){
    101103      code.reserve(rev+1);
    102104      code.resize(rev);
    103       if (lt == Parser::code)
     105      if (lt == LineTypeParser::code)
    104106        code.push_back(n);
    105107      else
    106108        code.push_back(0);
    107109    }
    108     else if (lt == Parser::code)
     110    else if (lt == LineTypeParser::code)
    109111      code[rev]+=n;
    110112
    111     std::vector<u_int>& comments = comments_[user];
     113    std::vector<u_int>& comments = comment_stats()[user];
    112114    if (comments.size() < rev+1){
    113115      comments.reserve(revision() + 1);
    114116      comments.insert(comments.end(), rev - comments.size(), 0);
    115       if (lt == Parser::comment)
     117      if (lt == LineTypeParser::comment)
    116118        comments.push_back(n);
    117119      else
    118120        comments.push_back(0);
    119121    }
    120     else if (lt == Parser::comment)
     122    else if (lt == LineTypeParser::comment)
    121123      comments[rev]+=n;
    122124
    123     std::vector<u_int>& other = other_[user];
     125    std::vector<u_int>& other = other_stats()[user];
    124126    if (other.size() < rev+1){
    125127      other.reserve(revision() + 1);
    126128      other.insert(other.end(), rev - other.size(), 0);
    127       if (lt == Parser::other)
     129      if (lt == LineTypeParser::other)
    128130        other.push_back(n);
    129131      else
    130132        other.push_back(0);
    131133    }
    132     else if (lt == Parser::other)
     134    else if (lt == LineTypeParser::other)
    133135      other[rev]+=n;
    134136  }
     
    157159  {
    158160    std::vector<u_int> init(revision()+1);
    159     code_["all"]=std::accumulate(code_.begin(), code_.end(), init,
    160                                  PairValuePlus<std::string,u_int>());
    161     comments_["all"]=std::accumulate(comments_.begin(), comments_.end(), init,
    162                                      PairValuePlus<std::string,u_int>());
    163     other_["all"]=std::accumulate(other_.begin(), other_.end(), init,
    164                                   PairValuePlus<std::string,u_int>());
     161    code_stats()["all"]=std::accumulate(code_stats().begin(),
     162                                        code_stats().end(), init,
     163                                        PairValuePlus<std::string,u_int>());
     164    comment_stats()["all"]=std::accumulate(comment_stats().begin(),
     165                                           comment_stats().end(), init,
     166                                           PairValuePlus<std::string,u_int>());
     167    other_stats()["all"]=std::accumulate(other_stats().begin(),
     168                                         other_stats().end(), init,
     169                                         PairValuePlus<std::string,u_int>());
     170    copyright_stats()["all"]=std::accumulate(copyright_stats().begin(),
     171                                             copyright_stats().end(), init,
     172                                             PairValuePlus<std::string,u_int>());
    165173    VectorPlus<u_int> vp;
    166     total_["all"] = vp(vp(code_["all"], comments_["all"]), other_["all"]);
     174    comment_or_copy_stats()["all"] =
     175      vp(comment_stats()["all"], copyright_stats()["all"]);
     176
     177    total_stats()["all"] =
     178      vp(vp(code_stats()["all"], comment_or_copy_stats()["all"]),
     179            other_stats()["all"]);
    167180  }
    168181
     
    172185    for (std::set<std::string>::const_iterator iter(authors().begin());
    173186         iter!=authors().end(); ++iter) {
    174       std::vector<u_int>& code = code_[*iter];
    175       std::vector<u_int>& comments = comments_[*iter];
    176       std::vector<u_int>& other = other_[*iter];
     187      std::vector<u_int>& code = code_stats()[*iter];
     188      std::vector<u_int>& comments = comment_stats()[*iter];
     189      std::vector<u_int>& other = other_stats()[*iter];
     190      std::vector<u_int>& copy = copyright_stats()[*iter];
    177191
    178192      VectorPlus<u_int> vp;
    179       total_[*iter] = vp(vp(code, comments),other);
     193      total_stats()[*iter] = vp(vp(vp(code, comments),other),copy);
     194    }
     195
     196  }
     197
     198
     199  void Stats::calc_comment_or_copy(void)
     200  {
     201    for (std::set<std::string>::const_iterator iter(authors().begin());
     202         iter!=authors().end(); ++iter) {
     203      std::vector<u_int>& comments = comment_stats()[*iter];
     204      std::vector<u_int>& copy = copyright_stats()[*iter];
     205
     206      VectorPlus<u_int> vp;
     207      comment_or_copy_stats()[*iter] = vp(comments, copy);
    180208    }
    181209
     
    185213  u_int Stats::code(const std::string& user) const
    186214  {
    187     return get_back(code_, user);
     215    return get_back(code_stats(), user);
    188216  }
    189217
     
    191219  u_int Stats::comments(const std::string& user) const
    192220  {
    193     return get_back(comments_, user);
     221    return get_back(comment_or_copy_stats(), user);
    194222  }
    195223
     
    197225  u_int Stats::empty(const std::string& user) const
    198226  {
    199     return get_back(other_, user);
     227    return get_back(other_stats(), user);
    200228  }
    201229
     
    228256  u_int Stats::lines(const std::string& user) const
    229257  {
    230     return get_back(total_, user);
     258    return get_back(total_stats(), user);
    231259  }
    232260
     
    255283  bool Stats::load_cache(std::istream& is)
    256284  {
     285    std::string str;
     286    getline(is, str);
     287    if (str!=cache_check_str())
     288      return false;
    257289    svn_revnum_t rev;
    258290    is >> rev;
     
    263295    size_t a_size=0;
    264296    is >> a_size;
    265     std::string str;
    266297    while (authors().size()<a_size && is.good()){
    267298      getline(is, str);
     
    270301    }
    271302    getline(is, str);
    272     if (str!=code_cache()){
     303    if (str!=cache_check_str())
    273304      return false;
    274     }
    275     load(is, code_);
    276     getline(is, str);
    277     getline(is, str);
    278     if (str!=comments_cache()){
    279       return false;
    280     }
    281     load(is, comments_);
    282     getline(is, str);
    283     getline(is, str);
    284     if (str!=other_cache()){
    285       return false;
    286     }
    287     load(is, other_);
    288     getline(is, str);
    289     getline(is, str);
    290     if (str!=total_cache()){
    291       return false;
    292     }
    293     load(is, total_);
    294     getline(is,str);
    295     getline(is,str);
    296     if (total_.size()>static_cast<size_t>(rev+1))
    297       return false;
    298     accumulate_stats();
    299     return false;
    300     return str==end_of_cache();
     305    for (size_t i=0; i<stats_.size(); ++i){
     306      load(is, stats_[i]);
     307      getline(is, str);
     308      if (str!=cache_check_str())
     309        return false;
     310    }
     311    return true;
    301312  }
    302313
     
    331342  {
    332343    do_parse(path);
     344    calc_comment_or_copy();
    333345    calc_total();
    334346    calc_all();
     
    342354    const Author2Vector* stat=NULL;
    343355    if (linetype=="total")
    344       stat = &total_;
     356      stat = &total_stats();
    345357    else if (linetype=="code")
    346       stat = &code_;
     358      stat = &code_stats();
    347359    else if (linetype=="comments")
    348       stat = &comments_;
     360      stat = &comment_or_copy_stats();
    349361    else if (linetype=="empty")
    350       stat = &other_;
     362      stat = &other_stats();
    351363    assert(stat);
    352364    assert(stat->size());
     365    assert(stat->find("all")!=stat->end());
    353366    std::vector<u_int> total=get_vector(*stat, "all");   
    354367    double yrange_max=1.03*total.back()+1;
     
    360373    for (std::set<std::string>::const_iterator i=authors_.begin();
    361374         i != authors_.end(); ++i) {
    362       if (lines(*i))
     375      if (lines(*i)) {
     376        assert(stat->find(*i)!=stat->end());
    363377        author_cont.push_back(std::make_pair(*i,get_vector(*stat,*i)));
     378      }
    364379    }
    365380
     
    416431    plot_init(filename);
    417432    GnuplotFE* gp=GnuplotFE::instance();
    418     std::vector<u_int> total = get_vector(total_, "all");
     433    std::vector<u_int> total = get_vector(total_stats(), "all");
    419434    double yrange_max=1.03*total.back()+1;
    420435    gp->yrange(yrange_max);
     
    422437   
    423438    ss.str("");
    424     std::vector<u_int> x(get_vector(code_, "all"));
     439    std::vector<u_int> x(get_vector(code_stats(), "all"));
    425440    ss << x.back() << " code";
    426441    gp->command("set key height 2");
     
    430445
    431446    ss.str("");
    432     x = get_vector(comments_, "all");
     447    x = get_vector(comment_or_copy_stats(), "all");
    433448    ss << x.back() << " comment";
    434449    gp->command("set key height 4");
     
    438453
    439454    ss.str("");
    440     x = get_vector(other_, "all");
     455    x = get_vector(other_stats(), "all");
    441456    ss << x.back() << " other";
    442457    gp->command("set key height 6");
     
    459474  void Stats::print(std::ostream& os) const
    460475  {
     476    os << cache_check_str() << "\n";
    461477    os << last_changed_rev() << " ";
    462478    os << authors().size() << " ";
     
    464480    std::copy(authors().begin(), authors().end(),
    465481              std::ostream_iterator<std::string>(os, "\n"));
    466     os << code_cache() << "\n";
    467     print(os, code_);
    468     os << "\n" << comments_cache() << "\n";
    469     print(os, comments_);
    470     os << "\n" << other_cache() << "\n";
    471     print(os, other_);
    472     os << "\n" << total_cache() << "\n";
    473     print(os, total_);
    474     os << "\n" << end_of_cache() << "\n";
     482    os << cache_check_str() << "\n";
     483    for (size_t i=0; i<stats_.size(); ++i){
     484      print(os, stats_[i]);
     485      os << cache_check_str() << "\n";
     486    }
    475487  }
    476488
     
    490502  void Stats::reset(void)
    491503  {
    492     total_.clear();
    493     code_.clear();
    494     comments_.clear();
    495     other_.clear();
     504    for (size_t i=0; i<stats_.size(); ++i){
     505      stats_[i].clear();
     506      std::vector<u_int> vec;
     507      stats_[i]["all"] = vec;
     508    }
    496509    authors_.clear();
    497     std::vector<u_int> vec;
    498     code_["all"] = vec;
    499     comments_["all"] = vec;
    500     other_["all"] = vec;
    501     total_["all"] = vec;
    502510  }
    503511
     
    508516    last_changed_rev_ = std::max(last_changed_rev_, rhs.last_changed_rev_);
    509517    add_authors(rhs.authors().begin(), rhs.authors().end());
    510     map_add(rhs.code_.begin(), rhs.code_.end(), code_);
    511     map_add(rhs.comments_.begin(), rhs.comments_.end(), comments_);
    512     map_add(rhs.other_.begin(), rhs.other_.end(), other_);
    513     map_add(rhs.total_.begin(), rhs.total_.end(), total_);
    514     assert(rhs.other_.size());
    515     assert(other_.size());
     518    assert(stats_.size()==rhs.stats_.size());
     519    for (size_t i=0; i<stats_.size(); ++i)
     520      map_add(rhs.stats_[i].begin(), rhs.stats_[i].end(), stats_[i]);
    516521   
    517522    return *this;
    518523  }
    519524
     525 
     526  size_t Stats::operator()(int linetype, std::string author, size_t rev) const
     527  {
     528    assert(linetype<=LineTypeParser::total);
     529    A2VConstIter i = stats_[linetype].find(author);
     530    if (i==stats_[linetype].end())
     531      throw std::runtime_error(author + " does not exist");
     532    return i->second[rev];
     533  }
    520534
    521535}} // end of namespace svndigest and namespace theplu
  • trunk/lib/Stats.h

    r537 r552  
    2727*/
    2828
    29 #include "Parser.h"
     29#include "LineTypeParser.h"
    3030
    3131#include <subversion-1/svn_types.h>
     
    6060    ///
    6161    void add(const std::string& user, const u_int& revision,
    62              const Parser::line_type&, u_int n=1);
     62             const LineTypeParser::line_type&, u_int n=1);
    6363
    6464    ///
     
    136136    Stats& operator+=(const Stats&);
    137137
    138 
     138    /**
     139       \return number of lines for \a author and \a linetype from
     140       revision \a rev.
     141
     142       \throw if \a author does not exist
     143     */
     144    size_t operator()(int linetype, std::string author, size_t rev) const;
    139145
    140146  protected:
     
    148154                     std::set<std::string>::const_iterator);
    149155
     156    // references to data
     157    inline Author2Vector& code_stats(void)
     158    { return stats_[LineTypeParser::code]; }
     159    inline Author2Vector& comment_stats(void)
     160    { return stats_[LineTypeParser::comment]; }
     161    inline Author2Vector& copyright_stats(void)
     162    { return stats_[LineTypeParser::copyright]; }
     163    inline Author2Vector& other_stats(void)
     164    { return stats_[LineTypeParser::other]; }
     165    inline Author2Vector& comment_or_copy_stats(void)
     166    { return stats_[LineTypeParser::comment_or_copy]; }
     167    inline Author2Vector& total_stats(void)
     168    { return stats_[LineTypeParser::total]; }
     169
     170    // const references to data
     171    inline const Author2Vector& code_stats(void) const
     172    { return stats_[LineTypeParser::code]; }
     173    inline const Author2Vector& comment_stats(void) const
     174    { return stats_[LineTypeParser::comment]; }
     175    inline const Author2Vector& copyright_stats(void) const
     176    { return stats_[LineTypeParser::copyright]; }
     177    inline const Author2Vector& other_stats(void) const
     178    { return stats_[LineTypeParser::other]; }
     179    inline const Author2Vector& comment_or_copy_stats(void) const
     180    { return stats_[LineTypeParser::comment_or_copy]; }
     181    inline const Author2Vector& total_stats(void) const
     182    { return stats_[LineTypeParser::total]; }
     183
    150184    /**
    151185       add range [\a first, \a last) to \a map
     
    160194    void plot_init(const std::string& output) const;
    161195
    162     Author2Vector total_;
    163     Author2Vector code_;
    164     Author2Vector comments_;
    165     Author2Vector other_;
    166196    std::set<std::string> authors_;
    167197
     
    174204    // Change this string if cache format is changed in such a way
    175205    // that all old cache files are obsolete.
    176     inline std::string end_of_cache(void) const
    177     {return "END OF OK CACHE FILE VERSION 4";}
    178     inline std::string code_cache(void) const {return "CACHE CODE";}
    179     inline std::string comments_cache(void) const {return "CACHE COMMENTS";}
    180     inline std::string other_cache(void) const {return "CACHE EMPTY";}
    181     inline std::string total_cache(void) const {return "CACHE TOTAL";}
    182 
    183    
     206    inline std::string cache_check_str(void) const
     207    {return "CACHE FILE VERSION 5";}
    184208
    185209    void calc_all(void);
     210    void calc_comment_or_copy(void);
    186211    void calc_total(void);
    187212    u_int get_back(const Author2Vector&, std::string user) const;
     
    192217    svn_revnum_t last_changed_rev_; // Should be the latest revision for file
    193218
     219    std::vector<Author2Vector> stats_; // from linetype to a2v
    194220
    195221    // using compiler generated copy constructor
  • trunk/test/parser.cc

    r528 r552  
    2323*/
    2424
    25 #include "Parser.h"
     25#include "LineTypeParser.h"
    2626
    2727#include <iostream>
     
    4444  using namespace theplu::svndigest;
    4545  os << "Testing: " << file << std::endl;
    46   Parser parser(file);
     46  LineTypeParser parser(file);
    4747  std::ifstream is(file.c_str());
    4848  for (size_t i=0; i<parser.type().size(); ++i){
    49     if (parser.type()[i]==Parser::other)
     49    if (parser.type()[i]==LineTypeParser::other)
    5050      os << "other:   ";
    51     else if (parser.type()[i]==Parser::comment)
     51    else if (parser.type()[i]==LineTypeParser::comment)
    5252      os << "comment: ";
    5353    else
Note: See TracChangeset for help on using the changeset viewer.