source: trunk/lib/Stats.cc @ 73

//$Id: Stats.cc 73 2006-03-04 18:10:07Z jari $

#include "Stats.h"
#include "GnuplotFE.h"
#include "utility.h"

#include <algorithm>
#include <cassert>
#include <cstdlib>
#include <fstream>
#include <iostream>
#include <map>
#include <numeric>
#include <sstream>
#include <string>
#include <unistd.h>
#include <utility>
#include <vector>


namespace theplu{
namespace svnstat{

  u_int Stats::latest_revision_=0;

  std::vector<double> Stats::accumulated(void) const
  {
    // sum of all users
    std::vector<u_int> sum(latest_revision_+1, 0);
    sum=std::accumulate(map_.begin(), map_.end(), sum,
                        PairValuePlus<std::string,u_int>());

    // calculate accumulated sum
    std::vector<double> accum(sum.size());
    std::partial_sum(sum.begin(),sum.end(),accum.begin());
    assert(sum.size()==accum.size());
    return accum;
  }

  std::vector<double> Stats::accumulated(const std::string& user) const
  {
    if (!map_.count(user))
      return std::vector<double>();
    std::vector<u_int> vec=(map_.find(user))->second;
  
    if (vec.size() < latest_revision_+1)
      vec.insert(vec.end(), latest_revision_+1-vec.size(), 0);

    std::vector<double> accum(vec.size());
    std::partial_sum(vec.begin(),vec.end(),accum.begin());
    return accum;
  }

  void Stats::add(const std::string& user, const u_int& rev)
  {
    std::vector<u_int>* vec = &(map_[user]);
    if (vec->size() < rev+1){
      vec->reserve(rev+1);
      vec->insert(vec->end(), rev - vec->size(),0);
      vec->push_back(1);
      latest_revision_ = std::max(latest_revision_,rev);
    }
    else
      (*vec)[rev]++;
  }


  bool Stats::parse(const std::string& path)
  {
    // Calling svn blame
    if (blame(path))
      return true;

    // Check if file is binary
    std::ifstream is("svnstat.tmp");
    std::string line;
    getline(is,line,' ');
    if (line==std::string("Skipping")){
      getline(is,line,' ');
      if (line==std::string("binary")){
        is.close();
        return true;
      }
    }
    is.close();

    is.open("svnstat.tmp");
    while (getline(is,line, '\n')){
      if (!line.size()) // skip empty line
        continue;
      std::stringstream ss(line);
      u_int revision;
      std::string user;
      ss >> revision;
      ss >> user;
      add(user, revision);
    }
    is.close();
    return false;
  }


  std::string Stats::plot(const std::string& name) const
  {
    std::string cmd=std::string("set term png; set output '")+name+"'";
    GnuplotFE* gp=GnuplotFE::instance();
    gp->command(cmd);
    gp->command("set key default");
    gp->command("set key left Left reverse");
    gp->command("set multiplot");
    std::vector<double> x=accumulated();    
    std::stringstream sa;
    sa << x.back() << " total";
    gp->linetitle(sa.str());
    gp->linestyle("steps 1");
    gp->plot(x);
    size_t plotno=2;
    for (MapConstIter_ i= map_.begin(); i != map_.end(); i++) {
      std::stringstream s0;
      s0 << "set key height " << plotno;
      gp->command(s0.str());
      x=accumulated(i->first);
      std::stringstream s;
      s << x.back() << " " << i->first;
      gp->linetitle(s.str());
      // Jari, reuse the stream above
      std::stringstream s2;
      s2 << "steps " << plotno++;
      gp->linestyle(s2.str());
      gp->plot(x);
    }
    gp->command("unset multiplot");

    return name;
  }

  Stats& Stats::operator+=(const Stats& other)
  {
    for (MapConstIter_ o_i= other.map_.begin(); o_i != other.map_.end(); ++o_i)
    {
      std::pair<MapIter_,bool> result = map_.insert(*o_i);
      if (!result.second)
        map_[(*(result.first)).first] = 
          VectorPlus<u_int>()( (*(result.first)).second, (*o_i).second );
  
    }
    return *this;
  }

}} // end of namespace svnstat and namespace theplu