---

gnuplot.h

Go to the documentation of this file.

// -*- c++ -*-
// $Header: /home/asanuma/lib/cvsroot/c/gnuplot/gnuplot.h,v 1.7 2004/08/04 16:14:41 asanuma Exp $
//

#ifndef __gnuplot_H__
#define __gnuplot_H__

#ifndef lint
static char *RCSid_gnuplot_h="$Header: /home/asanuma/lib/cvsroot/c/gnuplot/gnuplot.h,v 1.7 2004/08/04 16:14:41 asanuma Exp $";
#endif

#include <vector>
#include <cstdio>

#include "gp_base.h"
#include "gp_components.h"
#include "gp_traits.h"

namespace gnuplotpp{
  using components::gprange;
  using components::gpset;
  using components::gpusing;
  using components::gpcoord;
  using std::string;
  using std::ostream;
        
  class subplot: public gp_base::gpstream{ // one plot
  protected:
    virtual string _quote( const string &s ){   return string(s); }
        
  public:
    subplot( void ): gp_base::gpstream() {};
    subplot( const subplot &s ): gpstream(s.str()){};
        
    template<class C1>
    subplot( const C1 fn, 
             const int u1=gpusing::omit, 
             const int u2=gpusing::omit ):
      gpstream( fn ){
      *this << gpusing(u1,u2);
    }
        
  };
      
  class subfile: public subplot{
  private:
    template<class C>
    string _quote( const C &s ){ 
      std::ostringstream o; o<<"\""<<s<< "\"";
      return o.str();
    }
        
  public:
    template<class C1>
    subfile( const C1 fn, 
             const int u1=gpusing::omit, 
             const int u2=gpusing::omit  ):
      subplot(_quote(fn),u1,u2){};
    // note this cannot be done in the initialization list.
        
  };
      
  class subfunc: public subplot{
  private:
    //    string _quote( const string &s ){ return s; }
  public:
    template<class C1>
    subfunc( const C1 fn ):
      subplot(fn,gpusing::omit,gpusing::omit){};
        
  };
    

  class plot: 
    public gp_base::setbufbase, 
    public gp_base::contbase<subplot>,  
    public gp_base::plotbase{
      
    private:
    typedef gp_base::contbase<subplot> _contbase;
    typedef gp_base::setbufbase        _bufbase;
    typedef gp_base::plotbase          _plotbase;
    typedef _contbase::_container      _container;
    typedef subplot                    _subclass;
      
    protected:
    static const int _omit=gpusing::omit;
      
    public:
    plot(void): _plotbase(_pre,_post) {};

    private:
    stream_type &prebuf( void ){ return _pre; }
    stream_type &postbuf( void ){ return _post; }

    public:
    void print(std::ostream &o )const;
    
    subplot& _plot( void );
    subplot& plotfile( void );
    subplot& plotfunc( void );

    template<class C1>
      subplot& plotfile( const C1 fn, 
                         const int u1=gpusing::omit, 
                         const int u2=gpusing::omit ){
      _p.push_back(subfile(fn,u1,u2)); 
      return _p.back();
    }
      
    template<class C1>
      subplot& plotfunc( const C1 fn ){
      _p.push_back(subfunc(fn));
      return _p.back();
    }


      
  }; // class plot
    
  // std::ostream & operator << (std::ostream &o, const plot &p );      
    
  class singleplot: public plot, 
                    public gp_base::filebase, 
                    public gp_base::sizebase{
        
  private:
    typedef plot                       _base;
    typedef gp_base::filebase          _filebase;
    typedef gp_base::sizebase          _sizebase;

  public:
    singleplot( void );
    singleplot( const std::string &_s );
    singleplot( const char *_s );

  private:
    singleplot( const singleplot & ){};

  private:
    stream_type &prebuf( void ){ return _pre; }
    stream_type &postbuf( void ){ return _post; }

  public: // output 
    void print( std::ostream & )const;
        
  }; // singleplot

  // new stream interface 
  // g.set() << set( .... )
  // g.x.range()
        /*! Each graph can be accessed as
         *   g[0] ... g[n]
         */
  class multiplot: 
    public gp_base::setbufbase, 
    public gp_base::contbase<plot>, // _p is vector<plot>
    public gp_base::plotbase, 
    public gp_base::filebase, 
    public gp_base::sizebase
  {

  protected:
    typedef gp_base::contbase<plot>    _contbase;
    typedef gp_base::setbufbase        _bufbase;
    typedef gp_base::plotbase          _plotbase;
    typedef gp_base::filebase          _filebase;
    typedef gp_base::sizebase          _sizebase;
    typedef _contbase::_container      _container;
    typedef plot                       _subclass;

  public: // constructor
    multiplot( int n=1 );
    multiplot( const std::string &_s, int n=1 );
    multiplot( const char *_s, int n=1 );

  private:
    multiplot( const multiplot & );

  private:
    stream_type &prebuf( void ){ return _pre; }
    stream_type &postbuf( void ){ return _post; }

  public: // iterator
    typedef _container::iterator        iterator;
    typedef _container::const_iterator  const_iterator;
    iterator       begin(void)     { return _p.begin();};
    const_iterator begin(void)const{ return _p.begin();};
    iterator       end  (void)     { return _p.end();};
    const_iterator end  (void)const{ return _p.end();};

    typedef _container::reverse_iterator       reverse_iterator;
    typedef _container::const_reverse_iterator const_reverse_iterator;
    reverse_iterator       rbegin(void)     { return _p.rbegin();};
    const_reverse_iterator rbegin(void)const{ return _p.rbegin();};
    reverse_iterator       rend  (void)     { return _p.rend();};
    const_reverse_iterator rend  (void)const{ return _p.rend();};

  public: // output 
    void print( std::ostream & )const;

  }; // class multiplot 


  class gptable:
    public gp_base::setbufbase, 
    public gp_base::contbase<std::vector<plot> >,
    public gp_base::plotbase, 
    public gp_base::filebase, 
    public gp_base::sizebase{

  private:
    typedef gp_base::contbase<std::vector<plot> >    _contbase;
    typedef gp_base::setbufbase        _bufbase;
    typedef gp_base::plotbase          _plotbase;
    typedef gp_base::filebase          _filebase;
    typedef gp_base::sizebase          _sizebase;
    typedef _contbase::_container      _container;
    typedef std::vector<plot>          _subcontainer;
    typedef plot                       _subclass;

  private:
    int _nx, _ny;

  public:
    gptable( int nx, int ny );
    gptable( const char *_s, int nx, int ny );

  private:
    gptable( const gptable & );

  private:
    stream_type &prebuf( void ){ return _pre; }
    stream_type &postbuf( void ){ return _post; }

  public:
    void print( std::ostream & )const;
    size_t xsize( void )const{ return _nx; };
    size_t ysize( void )const{ return _ny; };

  private:
    void outsize( void ) ;

  }; // class gptable
 
  class gpsquare: public singleplot{
  public:
    gpsquare( void );
    gpsquare( const char *_s ); // not implemented yet

  private:
    gpsquare( const gpsquare &){};

  public:
    void setsize( double x );
    template<typename C1, typename C2>
    void setrange( const C1 & c1, const C2 &c2 ){
      x.range( c1, c2 ); y.range( c1, c2 );
    }

  private:
    void outsize( void );
                
  }; // class gptable
 

} // namespace gnuplotpp

#endif // __ggnuplot_H__

---