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

GetDefaultValue.h

Go to the documentation of this file.
00001 
00015 #ifndef _GETDEFAULT_H_
00016 #define _GETDEFAULT_H_
00017 
00018 #include <fstream>
00019 
00020 #ifdef WIN32
00021 # include <strstrea.h>
00022 #else
00023 # include <strstream.h>
00024 #endif /* ifndef WIN32 */
00025 
00026 #include <vector>
00027 
00028 #include "HepUtilities/SimpleTokenizer.h"
00029 
00031 
00032 template<class T>
00033 T GetDefaultValue(const char* filename, const char* inName, const T& defv)
00034 {
00035    T value = defv;
00036    std::ifstream ifs(filename);
00037    
00038    String name(inName);
00039 
00040    SimpleTokenizer *next;
00041    AIDA_STD::vector<String> tokens;
00042 
00043    char buffer[512];
00044    ifs.getline(buffer,512);
00045    String *line = new String(buffer);
00046 
00047    while (!ifs.eof()) {
00048       next = new SimpleTokenizer(" :\t", "!#\n\0"); // token delimiters: <space>, ":" or <tab>
00049                                                     // terminators: "!", "#", "\n", "\0"
00050       tokens = next->tokenize(*line);
00051       if (tokens.size() > 1) {
00052         if (tokens[0] == name) {                    // requested resource found
00053          istrstream ist( tokens[1].c_str(), tokens[1].size() );
00054          ist >> value;                              // let istream do the type conversion
00055          delete next;                               // remove old tokenizer
00056          tokens.clear();
00057          break;                                     // matching item found, return to caller
00058         }
00059       }
00060       tokens.clear();
00061       delete next;                                  // remove old tokenizer
00062       
00063       delete line;                                  // get rid of old content
00064       ifs.getline(buffer,512);
00065       line = new String(buffer);
00066    }
00067 
00068    return value;
00069 }
00070 
00075 template<class T>
00076 AIDA_STD::vector<T> GetDefaultValueVector(const char* filename, const char* inName, const T& defv)
00077 {
00078    T value = defv;
00079    std::ifstream ifs(filename);
00080    
00081    String name(inName);
00082 
00083    SimpleTokenizer *next;
00084    AIDA_STD::vector<String> tokens;
00085    AIDA_STD::vector<T> ValueVector;
00086 
00087    char buffer[512];
00088    ifs.getline(buffer,512);
00089    String *line = new String(buffer);
00090 
00091    while (!ifs.eof()) {
00092       next = new SimpleTokenizer(" :\t", "!#\n\0"); // token delimiters: <space>, ":" or <tab>
00093                                                     // terminators: "!", "#", "\n", "\0"
00094       tokens = next->tokenize(*line);
00095       if (tokens.size() > 1) {
00096         if (tokens[0] == name) {                    // requested resource found
00097 
00098           // loop over tokens
00099           for (size_t i=1; i<tokens.size(); i++)
00100             {
00101               istrstream ist( tokens[i].c_str(), tokens[i].size() );
00102               ist >> value;                         // let istream do the type conversion
00103               ValueVector.push_back(value);
00104             }
00105           delete next;                              // remove old tokenizer
00106           tokens.clear();
00107           break;                                    // matching item found, return to caller
00108         }
00109       }
00110       tokens.clear();
00111       delete next;                                  // remove old tokenizer
00112       
00113       delete line;                                  // get rid of old content
00114       ifs.getline(buffer,512);
00115       line = new String(buffer);
00116    }
00117 
00118    return ValueVector;
00119 }
00120 
00129 template<class T>
00130 void GetDefaultValue(const char*  filename, const char* inName, T* value, const int nitems)
00131 {  
00132    int i;
00133    std::ifstream ifs(filename);
00134    SimpleTokenizer *next;
00135    AIDA_STD::vector<String> tokens;
00136 
00137    String name(inName);
00138 
00139    char buffer[512];
00140    ifs.getline(buffer,512);
00141    String *line = new String(buffer);
00142    
00143    while (!ifs.eof()) {
00144       next = new SimpleTokenizer(" :\t", "!#\n\0"); // token delimiters: <space>, ":" or <tab>
00145                                                     // terminators: "!", "#", "\n", "\0"
00146       tokens = next->tokenize(*line);
00147       if (tokens.size() > 1) {
00148         if (tokens[0] == name) {                    // requested resource found
00149           for (i=0; i<nitems; i++) {
00150             if (tokens.size() > size_t(i) ) {
00151               istrstream ist( tokens[i+1].c_str(), tokens[i+1].size() );
00152               ist >> value[i];                      // let istream do the type conversion
00153             }
00154           }
00155          delete next;
00156          tokens.clear();
00157          break;                                     // matching item found, return to caller
00158         }
00159       }
00160       delete next;                                  // remove old tokenizer
00161       tokens.clear();
00162 
00163       delete line;                                  // get rid of old content
00164       ifs.getline(buffer,512);
00165       line = new String(buffer);
00166    }
00167 }
00168 
00173 template<class T>
00174 AIDA_STD::vector<T> GetManyDefaultValues(const char* filename, const char* inName, const T& defv)
00175 {
00176    T value = defv;
00177    std::ifstream ifs(filename);
00178    
00179    String name(inName);
00180 
00181    SimpleTokenizer *next;
00182    AIDA_STD::vector<String> tokens;
00183    AIDA_STD::vector<T> ValueVector;
00184 
00185    char buffer[512];
00186    ifs.getline(buffer,512);
00187    String *line = new String(buffer);
00188 
00189    while (!ifs.eof()) {
00190       next = new SimpleTokenizer(" :\t", "!#\n\0"); // token delimiters: <space>, ":" or <tab>
00191                                                     // terminators: "!", "#", "\n", "\0"
00192       tokens = next->tokenize(*line);
00193       if (tokens.size() > 1) {
00194         if (tokens[0] == name) {                    // requested resource found
00195           istrstream ist( tokens[1].c_str(), tokens[1].size() );
00196           ist >> value;                             // let istream do the type conversion
00197           ValueVector.push_back(value);             // add value to vector
00198           delete next;
00199           tokens.clear();
00200         }
00201       }
00202       
00203       delete line;                                  // get rid of old content
00204       ifs.getline(buffer,512);
00205       line = new String(buffer);
00206    }
00207 
00208    return ValueVector;
00209 }
00210 
00211 
00212 #endif
00213 

Generated on Tue May 20 14:50:25 2003 for HepUtilities by doxygen1.2.14 written by Dimitri van Heesch, © 1997-2002