Main Page   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Namespace Members   Compound Members   Related Pages  

gracetmpl.h

00001 /*-*- c++ -*-******************************************************************
00002  * GraceTMPL Library 
00003  * Copyright (C) 2001,2002  Andy Thaller
00004  * 
00005  * This library is free software; you can redistribute it and/or
00006  * modify it under the terms of the GNU General Public License as 
00007  * published by the Free Software Foundation; either version 2 of
00008  * the License, or (at your option) any later version.
00009  * 
00010  * This library is distributed in the hope that it will be useful,
00011  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00012  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00013  * General Public License for more details.
00014  * 
00015  * You should have received a copy of the GNU General Public License
00016  * along with this library; if not, write to the Free Software
00017  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00018  *****************************************************************************/
00019 
00020 #ifndef __GRACETMPL_H__
00021 #define __GRACETMPL_H__
00022 
00023 #include <vector>
00024 #include <string>
00025 #include <map>
00026 
00027 extern "C" {
00028 #include <stdio.h>
00029 }
00030 
00031 
00038 namespace GraceTMPL {
00039 
00041   typedef std::vector<std::string> StringVec;
00042 
00044   typedef std::vector<StringVec> String2Vec;
00045 
00047   typedef std::map<int,StringVec> StringVecMap;
00048 
00050   typedef std::map<int,StringVecMap> StringVec2Map;
00051 
00053   typedef std::map<std::string,std::string> StringMap;
00054 
00056   typedef std::map<std::string,StringMap*> StringStringMap;
00057 
00060   std::string smashVars(const std::string &from);
00061 
00063   std::string stringNum(double d, const char *fmt= "%lg");
00065   std::string stringNum(float d, const char *fmt= "%g");
00067   std::string stringNum(long i, const char *fmt= "%ld");
00069   std::string stringNum(int i, const char *fmt= "%d");
00070  
00078   class Environment {
00079     std::string name_; //< Context name
00080     Environment *parent_; //< The enclosing Environment
00081     std::map<std::string,std::string> variable_; //< Variablename/value pairs
00082     std::map<std::string,Environment *> context_; //< Contextname/Environment pairs
00083     int usage_; //< Usage count (possibly useless?)
00084 
00085   public:
00087     Environment(Environment *parent= 0) 
00088       : name_(""), parent_(parent), usage_(1) {};
00089 
00091     void clear() {
00092       variable_.clear();
00093       //context_.clear();
00094     }
00095 
00097     void setParent(Environment *parent) { 
00098       parent_= parent; 
00099       if (parent_ && name_!="") parent_->add(name_,this);
00100     }
00101 
00103     void setName(const std::string &name) { 
00104       name_= name; 
00105       if (parent_ && name_!="") parent_->add(name_,this);
00106     }
00107 
00109     void set(const std::string &name,const std::string &value) {
00110       variable_[name]= value;
00111     }
00112 
00114     void add(const std::string &name,Environment *value) {
00115       if (context_[name]== value) return;
00116       context_[name]= value;
00117       value->setParent(this);
00118       value->setName(name);
00119       // cerr << "registered "<<name<<" within "<<name_<<"\n";
00120     }
00121 
00123     Environment *use() { usage_++; return this; }
00124 
00126     int unuse() { return !(--usage_); }
00127 
00157     std::string expand(const std::string &, int nests=0);
00158 
00165     std::string substitute(const std::string &context,
00166                            const std::string &variable,
00167                            const std::string &fallback);
00168   };
00169 
00174   class EnvironmentUser {
00175 
00176   protected:
00178     Environment *env_;
00179 
00180   public:
00182     EnvironmentUser() { env_= new Environment(); } 
00183 
00185     ~EnvironmentUser() { if (env_ && env_->unuse()) delete env_; }
00186 
00188     Environment *env() { return env_; }
00189 
00195     void setenv(Environment *env) 
00196     {
00197       if (!env) return;
00198       if (env_ && env_->unuse()) delete env_;
00199       env_= env->use();
00200     }
00201 
00203     void setenv(const std::string &name,const std::string &value) 
00204     {
00205       if (!env_) return;
00206       env_->set(name,value);
00207     }
00208 
00210     void setenv(const std::string &name,double value) 
00211     { 
00212       setenv(name,stringNum(value)); 
00213     }
00214 
00217     std::string expand(const std::string &str, int nests=0) 
00218     {
00219       if (!env_) return "";
00220       return env_->expand(str, nests); 
00221     } 
00222   };
00223 
00232   class Data : public EnvironmentUser {
00233 
00235     std::string name_;
00236   
00238     int n_;
00239     
00241     int setnum_;
00242     
00244     double *x_,*y_,*dx_,*dy_;
00245 
00247     double xoffs_, yoffs_;
00248 
00250     double scale_;
00251 
00252   public:
00253 
00258     Data();
00259     
00266     Data(const std::string &name, int n,
00267          const double *x, const double *y,
00268          const double *dx=0, const double *dy=0);
00269 
00271     std::string name() { return name_; }
00272 
00274     int hasErrors() { return (dy_ || dx_); }
00275 
00281     void setNum(int i) { setnum_= i; }
00282 
00284     int num() { return setnum_; }
00285 
00287     void setXOffset(double x) { xoffs_= x; }
00289     void setYOffset(double y) { yoffs_= y; }
00291     void setScaling(double s) { scale_= s; }
00292 
00307     void autoscale(double &xmin, double &xmax, double &ymin, double &ymax,
00308                    double XMIN,  double XMAX,  double YMIN,  double YMAX, 
00309                    double errorfac= 1.0);
00310 
00322     void saveinfo(FILE *f, const StringVec *daSet=0);
00323 
00331     void savedata(FILE *f, int correctLog= 0);
00332   };
00333 
00334   class Save;
00335 
00345   class Graph : public EnvironmentUser {
00347     int graphnum_;
00348 
00350     Save* saver_;
00351   
00353     std::vector <Data *> dataVec_;
00355     std::vector <std::string> params_;
00356 
00358     std::map<int, int> literalData_;
00359 
00361     double xoffs_, yoffs_;
00362 
00364     double scale_;
00365 
00369     int correctLog_;
00370 
00371   public:
00380     Graph(Save *saver, int logplot=0);
00381 
00387     void setGraph(int i) { graphnum_= i; }
00388 
00393     void addData(Data *d) {
00394       dataVec_.push_back(d);
00395       d->env()->setParent(env());
00396     }
00397 
00399     std::vector <Data *> *data() { return &dataVec_; }
00400     
00402     void setXOffset(double x) { xoffs_= x; }
00403 
00405     void setYOffset(double y) { yoffs_= y; }
00406 
00408     void setScaling(double s) { scale_= s; }
00409 
00411     double xoffset() { return xoffs_; }
00412 
00414     double yoffset() { return yoffs_; }
00415 
00417     double scale() { return scale_; }
00418 
00420     int correctLog() { return correctLog_; }
00421 
00423     void addParam(const std::string &name,double value);
00424 
00426     void saveprep(const StringVecMap *daSets);
00427 
00442     void saveinfo(FILE *f, 
00443                   const StringVec *daGraph=0, 
00444                   const StringVecMap *daSets=0,
00445                   const StringVecMap *daStrings= 0);
00446 
00455     void savedata(FILE *f, StringMap *literalData, int dataonly= 0);
00456   };
00457 
00523   class Save : public EnvironmentUser
00524   {
00525   protected:
00526 
00528     struct CopySrc
00529     {
00530       int g;     
00531       int s;     
00532       Data *src; 
00533 
00535       CopySrc() : g(-1),s(-1),src(0) {};
00536     };
00537 
00539     typedef std::map<int,CopySrc> CopyMap;
00540     
00542     typedef std::map<int,CopyMap> Copy2Map;
00543 
00550     struct Template 
00551     {
00552       std::string filename_;      
00553       std::string header_;        
00554       StringVec common_;     
00555       String2Vec strings_;   
00556       StringVecMap graphs_;  
00557       StringVec2Map sets_;   
00558       StringVec2Map params_; 
00559       String2Vec request_;   
00560       StringMap data_;       
00561       Copy2Map copy_;        
00562       std::map<int, int> ignore_; 
00563       int gpp_;              
00564       int ignores_;          
00565       int useG0_;            
00566       int valid_;            
00567     };
00568 
00574     Template tmpl_;
00575 
00577     std::vector<Graph*> graphsVec_;
00578 
00580     StringStringMap docEnvs_;
00582     StringMap myEnv_;
00583     
00585     std::string nameTmpl_;
00586 
00588     int allowPipe_;
00589 
00590   public:
00591 
00593     Save();
00594 
00596     virtual ~Save() { ; }
00597 
00599     virtual Graph *newGraph(int logplot= 0) {
00600       Graph *g= new Graph(this,logplot);
00601       if (!g) return 0;
00602       graphsVec_.push_back(g);
00603       return g;
00604     }
00605 
00611     int isCopydata(int g, int s);
00612 
00617     Data *copydata(int g, int s) 
00618     {
00619       if (isCopydata(g,s)) return tmpl_.copy_[g][s].src;
00620       return 0;
00621     }
00622 
00627     void regCopydata(int g, int s, Data* src);
00628 
00633     void clearCopydata();
00634 
00636     virtual Graph *graph(int i) 
00637     {
00638       if (i<0 || i>=int(graphsVec_.size())) return 0;
00639       return graphsVec_[i];
00640     }
00641 
00643     virtual int graphs() { return graphsVec_.size(); }
00644 
00653     void setOutputName(const std::string &name) { nameTmpl_= name; } 
00654 
00665     void enablePipe(int i) { allowPipe_= i; }
00666 
00668     int pipeEnabled() { return allowPipe_; }
00669 
00695     virtual int loadTemplate(const char *filename, int useS0= 0);
00696 
00714     virtual String2Vec templateDataRequestInfo();
00715 
00737     virtual void save();
00738   };
00739 
00740 }
00741 
00742 
00743 #endif
00744 

Generated on Fri Oct 11 22:57:57 2002 for GraceTMPL by doxygen1.2.13.1 written by Dimitri van Heesch, © 1997-2001