source: trunk/lib/Gnuplot.h @ 63

// $Id: Gnuplot.h 63 2006-01-19 23:07:36Z peter $

#ifndef _theplu_svnstat_gnuplot_
#define _theplu_svnstat_gnuplot_

#include <cstdio>
#include <fstream>
#include <list>
#include <stdexcept>
#include <string>
#include <vector>


namespace theplu {
namespace svnstat {

  ///
  /// If something goes wrong in the use of the Gnuplot class, a
  /// GnuplotException is thrown.
  ///
  struct GnuplotException : public std::runtime_error
  { inline GnuplotException(const std::string& msg) : runtime_error(msg) {} };

  ///
  /// The Gnuplot class creates a pipe to 'gnuplot' and facilitates
  /// communication with the binary.
  ///
  /// Temporary files are created in directory /tmp. These temporaru
  /// files are removed on a normal program exit.
  ///
  class Gnuplot
  {
  public:
    ///
    /// This constructor sets up the pipe to the first gnuplot
    /// executable found in the PATH environment variable. The PATH
    /// variable must exist.
    ///
    /// @throw Throws a GnuplotException if a no PATH variable is
    /// found, if the gnuplot binary cannot be found, or if a pipe
    /// cannot to the gnuplot binary cannot be established.
    ///
    Gnuplot(void);

    ///
    /// The destructor deletes all temporary files created in the
    /// calls to plot_xy and plot_x. If the program execution fails to
    /// reach this destructor the temporary files will not be removed
    /// from the storage area.
    ///
    ~Gnuplot(void);

    ///
    /// Send arbitrary commands to Gnuplot.
    ///
    void command(std::string);

    ///
    /// @return input format for date 
    ///
    // Peter, obsolete ?
    const std::string& date_input_format(void) { return date_input_format_; }

    ///
    ///
    ///
    void date_plot(const std::vector<double>& y, 
                   const std::string& format="%y-%b-%d");
    ///
    ///
    ///
    void date_replot(const std::vector<double>& y,
                     const std::string& format="%y-%b-%d");

    ///
    /// Set the \a style of the line in the subsequent plot or
    /// replot calls. The setting applies until this function is
    /// called again.
    ///
    /// @note The \a style is not checked to be valid.
    ///
    inline void linestyle(const std::string& style) { linestyle_=style; }

    ///
    /// Set the \a title of the line in the subsequent plot or
    /// replot calls. The setting applies until this function is
    /// called again.
    ///
    inline void linetitle(const std::string& title) { linetitle_=title; }

    ///
    /// Plot the data \a y as a function of \a x using the Gnuplot
    /// 'plot' command. The \a x vector can be omitted as in normal
    /// Gnuplot usage.
    ///
    // Peter, do we have to set xdata for replot
    inline void
    plot(const std::vector<double>& y,
         const std::vector<double>& x=std::vector<double>())
    { command("set xdata"); plot(y,x,"plot"); }

    ///
    /// Plot the data \a y as a function of \a x using the Gnuplot
    /// 'replot' command. The \a x vector can be omitted as in normal
    /// Gnuplot usage.
    ///
    inline void
    replot(const std::vector<double>& y,
           const std::vector<double>& x=std::vector<double>())
    { command("set xdata"); plot(y,x,"replot"); }

    ///
    /// sets format of date output
    ///
    inline void set_date_format(const std::string& format) 
    { date_output_format_ = format;}

    ///
    /// Function setting the dates. \a format must comply with strings
    /// in date
    ///
    inline void set_dates(const std::vector<std::string>& date, 
                          const std::string& format="%Y-%m-%d")
    { date_=date; date_input_format_=format; }

  private:
    ///
    /// Copy constructor, not implemented.
    ///
    Gnuplot(const Gnuplot&);

    void acquire_program_path(const std::string&);

    ///
    /// @param \a plotcmd must be "plot" or "replot".
    ///
    template <class T1, class T2>
    void plot(const std::vector<T1>& y, const std::vector<T2>& x,
              const std::string& plotcmd)
    {
      assert(x.size()==y.size() || x.empty());
      assert(plotcmd=="plot" || plotcmd=="replot");
      char name[]="/tmp/svnstatXXXXXX";
      if (mkstemp(name) == -1){
        throw GnuplotException(std::string("Failed to get unique filename: ") +
                               name);
      }
      std::ofstream tmp(name);
      if (tmp.bad())
        throw GnuplotException(std::string("Failed to create file: ") + name);
      
      for (size_t i = 0; i<y.size() && (i<x.size() || x.empty()); ++i ){
        if (x.empty())
          tmp << y[i] << '\n';
        else
          tmp << x[i] << '\t' << y[i] << '\n';
      }
      tmp.close();
      std::string cmdstring(plotcmd + " '" + name + "' u 1:2 title '" + 
                              linetitle_ + "' with " + linestyle_ + "\n");
      if (x.empty())
        cmdstring = plotcmd + " '" + name + "' u 1 title '" + 
          linetitle_ + "' with " + linestyle_ + "\n";
       
      command(cmdstring);
      // need to keep track of created files since the gnuplot command
      // is not executed until pclose on MacOSX, shouldn't the fflush
      // fix this in the command() member function?
      tempfiles_.push_back(name);
    }

    void tokenizer(const std::string& in, std::list<std::string>& tokens,
                   const std::string& delimiters = ":");

    // need to keep track of created files since the gnuplot command
    // is not executed until pclose on MacOSX, shouldn't the fflush
    // fix this in the command() member function?
    std::list<std::string> tempfiles_;
    std::vector<std::string> date_;
    std::string date_input_format_; 
    std::string date_output_format_; 
    std::string gnuplot_binary_;
    std::string linestyle_;
    std::string linetitle_;
    FILE* pipe_;
};

}} // end of namespace svnstat and namespace theplu

#endif