gracetmpl.h

/*-*- c++ -*-******************************************************************
 * GraceTMPL Library 
 * Copyright (C) 2001,2002  Andy Thaller
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as 
 * published by the Free Software Foundation; either version 2 of
 * the License, or (at your option) any later version.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *****************************************************************************/

#ifndef __GRACETMPL_H__
#define __GRACETMPL_H__

#include <vector>
#include <string>
#include <map>

extern "C" {
#include <stdio.h>
}


namespace GraceTMPL {

  typedef std::vector<std::string> StringVec;

  typedef std::vector<StringVec> String2Vec;

  typedef std::map<int,StringVec> StringVecMap;

  typedef std::map<int,StringVecMap> StringVec2Map;

  typedef std::map<std::string,std::string> StringMap;

  typedef std::map<std::string,StringMap*> StringStringMap;

  std::string smashVars(const std::string &from);

  std::string stringNum(double d, const char *fmt= "%lg");
  std::string stringNum(float d, const char *fmt= "%g");
  std::string stringNum(long i, const char *fmt= "%ld");
  std::string stringNum(int i, const char *fmt= "%d");
 
  class Environment {
    std::string name_; //< Context name
    Environment *parent_; //< The enclosing Environment
    std::map<std::string,std::string> variable_; //< Variablename/value pairs
    std::map<std::string,Environment *> context_; //< Contextname/Environment pairs
    int usage_; //< Usage count (possibly useless?)

  public:
    Environment(Environment *parent= 0) 
      : name_(""), parent_(parent), usage_(1) {};

    void clear() {
      variable_.clear();
      //context_.clear();
    }

    void setParent(Environment *parent) { 
      parent_= parent; 
      if (parent_ && name_!="") parent_->add(name_,this);
    }

    void setName(const std::string &name) { 
      name_= name; 
      if (parent_ && name_!="") parent_->add(name_,this);
    }

    void set(const std::string &name,const std::string &value) {
      variable_[name]= value;
    }

    void add(const std::string &name,Environment *value) {
      if (context_[name]== value) return;
      context_[name]= value;
      value->setParent(this);
      value->setName(name);
      // cerr << "registered "<<name<<" within "<<name_<<"\n";
    }

    Environment *use() { usage_++; return this; }

    int unuse() { return !(--usage_); }

    std::string expand(const std::string &, int nests=20);

    std::string substitute(const std::string &context,
                           const std::string &variable,
                           const std::string &fallback);
  };

  class EnvironmentUser {

  protected:
    Environment *env_;

  public:
    EnvironmentUser() { env_= new Environment(); } 

    ~EnvironmentUser() { if (env_ && env_->unuse()) delete env_; }

    Environment *env() { return env_; }

    void setenv(Environment *env) 
    {
      if (!env) return;
      if (env_ && env_->unuse()) delete env_;
      env_= env->use();
    }

    void setenv(const std::string &name,const std::string &value) 
    {
      if (!env_) return;
      env_->set(name,value);
    }

    void setenv(const std::string &name,double value) 
    { 
      setenv(name,stringNum(value)); 
    }

    std::string expand(const std::string &str, int nests=20) 
    {
      if (!env_) return "";
      return env_->expand(str, nests); 
    } 
  };

  class Data : public EnvironmentUser {

    std::string name_;
  
    int n_;
    
    int setnum_;
    
    double *x_,*y_,*dx_,*dy_;

    double xoffs_, yoffs_;

    double scale_;

  public:

    Data();
    
    Data(const std::string &name, int n,
         const double *x, const double *y,
         const double *dx=0, const double *dy=0);

    std::string name() { return name_; }

    int hasErrors() { return (dy_ || dx_); }

    void setNum(int i) { setnum_= i; }

    int num() { return setnum_; }

    void setXOffset(double x) { xoffs_= x; }
    void setYOffset(double y) { yoffs_= y; }
    void setScaling(double s) { scale_= s; }

    void autoscale(double &xmin, double &xmax, double &ymin, double &ymax,
                   double XMIN,  double XMAX,  double YMIN,  double YMAX, 
                   double errorfac= 1.0);

    void saveinfo(FILE *f, const StringVec *daSet=0);

    void savedata(FILE *f, int correctLog= 0);
  };

  class Save;

  class Graph : public EnvironmentUser {
    int graphnum_;

    Save* saver_;
  
    std::vector <Data *> dataVec_;
    std::vector <std::string> params_;

    std::map<int, int> literalData_;

    double xoffs_, yoffs_;

    double scale_;

    int correctLog_;

  public:
    Graph(Save *saver, int logplot=0);

    void setGraph(int i) { graphnum_= i; }

    void addData(Data *d) {
      dataVec_.push_back(d);
      d->env()->setParent(env());
    }

    std::vector <Data *> *data() { return &dataVec_; }
    
    void setXOffset(double x) { xoffs_= x; }

    void setYOffset(double y) { yoffs_= y; }

    void setScaling(double s) { scale_= s; }

    double xoffset() { return xoffs_; }

    double yoffset() { return yoffs_; }

    double scale() { return scale_; }

    int correctLog() { return correctLog_; }

    void addParam(const std::string &name,double value);

    void saveprep(const StringVecMap *daSets);

    void saveinfo(FILE *f, 
                  const StringVec *daGraph=0, 
                  const StringVecMap *daSets=0,
                  const StringVecMap *daStrings= 0);

    void savedata(FILE *f, StringMap *literalData, int dataonly= 0);
  };

  class Save : public EnvironmentUser
  {
  protected:

    struct CopySrc
    {
      int g;     
      int s;     
      Data *src; 

      CopySrc() : g(-1),s(-1),src(0) {};
    };

    typedef std::map<int,CopySrc> CopyMap;
    
    typedef std::map<int,CopyMap> Copy2Map;

    struct Template 
    {
      std::string filename_;      
      std::string header_;        
      StringVec common_;     
      String2Vec strings_;   
      StringVecMap graphs_;  
      StringVec2Map sets_;   
      StringVec2Map params_; 
      String2Vec request_;   
      StringMap data_;       
      Copy2Map copy_;        
      std::map<int, int> ignore_; 
      int gpp_;              
      int ignores_;          
      int useG0_;            
      int valid_;            
    };

    Template tmpl_;

    std::vector<Graph*> graphsVec_;

    StringStringMap docEnvs_;
    StringMap myEnv_;
    
    std::string nameTmpl_;

    int allowPipe_;

  public:

    Save();

    virtual ~Save() { ; }

    virtual Graph *newGraph(int logplot= 0) {
      Graph *g= new Graph(this,logplot);
      if (!g) return 0;
      graphsVec_.push_back(g);
      return g;
    }

    int isCopydata(int g, int s);

    Data *copydata(int g, int s) 
    {
      if (isCopydata(g,s)) return tmpl_.copy_[g][s].src;
      return 0;
    }

    void regCopydata(int g, int s, Data* src);

    void clearCopydata();

    virtual Graph *graph(int i) 
    {
      if (i<0 || i>=int(graphsVec_.size())) return 0;
      return graphsVec_[i];
    }

    virtual int graphs() { return graphsVec_.size(); }

    void setOutputName(const std::string &name) { nameTmpl_= name; } 

    void enablePipe(int i) { allowPipe_= i; }

    int pipeEnabled() { return allowPipe_; }

    virtual int loadTemplate(const char *filename, int useS0= 0);

    virtual String2Vec templateDataRequestInfo();

    virtual void save();
  };

}


#endif

---