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.