libFAUDES

Sections

Index

cfl_tokenwriter.cpp

Go to the documentation of this file.
00001 /** @file cfl_tokenwriter.cpp @brief Class TokenWriter */
00002 
00003 /* FAU Discrete Event Systems Library (libfaudes)
00004 
00005 Copyright (C) 2006  Bernd Opitz
00006 Copyright (C) 2006  Thomas Moor
00007 Exclusive copyright is granted to Klaus Schmidt
00008 
00009 This library is free software; you can redistribute it and/or
00010 modify it under the terms of the GNU Lesser General Public
00011 License as published by the Free Software Foundation; either
00012 version 2.1 of the License, or (at your option) any later version.
00013 
00014 This library is distributed in the hope that it will be useful,
00015 but WITHOUT ANY WARRANTY; without even the implied warranty of
00016 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00017 Lesser General Public License for more details.
00018 
00019 You should have received a copy of the GNU Lesser General Public
00020 License along with this library; if not, write to the Free Software
00021 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
00022 
00023 
00024 #include "cfl_tokenwriter.h"
00025 
00026 namespace faudes {
00027 
00028 // TokenWriter(rFilename, openmode)
00029 TokenWriter::TokenWriter(const std::string& rFilename, std::ios::openmode openmode) 
00030   : mMode(File), mFileName(rFilename), mColumns(80/FD_NAMELEN), mColCount(0) {
00031   // set up mFStream
00032   mFStream.exceptions(std::ios::badbit|std::ios::failbit);
00033   try{
00034     mFStream.open(rFilename.c_str(), openmode); 
00035   }
00036   catch (std::ios::failure&) {
00037     std::stringstream errstr;
00038     errstr << "Exception opening/writing file \""<< rFilename << "\"";
00039     throw Exception("TokenWriter::TokenWriter", errstr.str(), 2);
00040   }
00041   // use mFStream
00042   mpStream=&mFStream;      
00043   mEndl=true;
00044 }
00045 
00046 // TokenWriter(rFilename, doctype)
00047 TokenWriter::TokenWriter(const std::string& rFilename, const std::string& ftype) 
00048   : mMode(XmlFile), mFileName(rFilename), mColumns(80/FD_NAMELEN), mColCount(0) {
00049   // set up mFStream
00050   mFStream.exceptions(std::ios::badbit|std::ios::failbit);
00051   try{
00052     mFStream.open(rFilename.c_str(), std::ios::out|std::ios::trunc); 
00053     mFStream << "<?xml version=\"1.0\" encoding=\"ISO-8859-1\" standalone=\"no\"?>" << std::endl;
00054     if(ftype!="") 
00055     if(ftype!="Void") {
00056       std::string dtdfile=ftype;
00057       std::transform(dtdfile.begin(), dtdfile.end(), dtdfile.begin(), tolower);
00058       dtdfile=dtdfile+".dtd";
00059       mFStream << "<!DOCTYPE " << ftype << " SYSTEM \"" << dtdfile << "\">" << std::endl;
00060     }
00061   }
00062   catch (std::ios::failure&) {
00063     std::stringstream errstr;
00064     errstr << "Exception opening/writing xml file \""<< rFilename << "\"";
00065     throw Exception("TokenWriter::TokenWriter", errstr.str(), 2);
00066   }
00067   // use mFStream
00068   mpStream=&mFStream;      
00069   mEndl=true;
00070 }
00071 
00072 // TokenWriter(mode)
00073 TokenWriter::TokenWriter(Mode mode)
00074   : mMode(mode), mFileName(""), mColumns(80/FD_NAMELEN), mColCount(0) {
00075   switch(mode) {
00076   case Stdout: 
00077     // set up mFStream
00078     mFileName="stdout";
00079     /*
00080       try {
00081       mFStream.copyfmt(std::cout);
00082       mFStream.clear(std::cout.rdstate());
00083       typedef std::basic_ios<char> ___basic_ios_char_; // trick for vc++
00084       mFStream.___basic_ios_char_::rdbuf(std::cout.rdbuf());
00085       }
00086       catch (std::ios::failure&) {
00087       std::stringstream errstr;
00088       errstr << "Exception opening/writing file \""<< mFileName << "\"";
00089       throw Exception("TokenWriter::TokenWriter", errstr.str(), 2);
00090       }
00091       // use mFStream
00092       mpStream=&mFStream;
00093     */
00094     // use std::cout
00095     mpStream= &std::cout;
00096     mEndl=true;
00097     break;
00098   case String:
00099     // use mSStream
00100     mFileName="string";
00101     mpStream=&mSStream;
00102     mEndl=false;
00103     break;
00104   default:
00105     std::stringstream errstr;
00106     errstr << "Invalid Mode / Not Implemented";
00107     throw Exception("TokenWriter::TokenWriter", errstr.str(), 2);
00108   }
00109 }
00110 
00111 
00112 // destructor
00113 TokenWriter::~TokenWriter(void) {
00114   if(mMode==File) mFStream.close();
00115 }
00116 
00117 // Flush buffers
00118   void TokenWriter::Flush(void) {
00119   if(mMode==File) mFStream.flush();
00120   mpStream->flush();
00121 }
00122 
00123 // Str()
00124 std::string TokenWriter::Str(void) {
00125   if(mMode!=String) {
00126     std::stringstream errstr;
00127     errstr << "Not in String Mode";
00128     throw Exception("TokenWriter::Str()", errstr.str(), 2);
00129   }
00130   return mSStream.str();
00131 }
00132 
00133 // Columns()
00134 int TokenWriter::Columns(void) const {
00135   return mColumns;
00136 }
00137 
00138 // Columns()
00139 void TokenWriter::Columns(int columns) {
00140   mColumns = columns;
00141 }
00142 
00143 // Endl()
00144 void TokenWriter::Endl(void) {
00145   try{
00146     if(mEndl) *mpStream << std::endl;
00147     else *mpStream << " ";
00148   }
00149   catch (std::ios::failure&) {
00150     std::stringstream errstr;
00151     errstr << "Exception opening/writing file \"" << mFileName << "\"";
00152     throw Exception("Generator::write", errstr.str(), 2);
00153   }
00154 }
00155 
00156 // Endl(bool)
00157 void TokenWriter::Endl(bool on) {
00158   mEndl=on;
00159 }
00160 
00161 
00162 // Write(rToken)
00163 void TokenWriter::Write(const Token& rToken) {
00164   FD_DV("TokenWriter::Write(token)");
00165   // if(mMode==Stdout) mpStream = &std::cout; // fix
00166   try{
00167     if(rToken.IsBegin() || rToken.IsEnd()) {
00168       if(mColCount !=0) Endl();
00169       rToken.Write(mpStream);
00170       Endl();
00171       mColCount = 0;
00172     }
00173     else {
00174       if(mColCount == mColumns) {
00175   mColCount = 0;
00176   Endl();
00177       }
00178       mColCount++;
00179       rToken.Write(mpStream);
00180       *mpStream << " ";
00181     }
00182   }
00183   catch (std::ios::failure&) {
00184     std::stringstream errstr;
00185     errstr << "Exception opening/writing file \"" << mFileName << "\"";
00186     throw Exception("TokenWriter::Write(token)", errstr.str(), 2);
00187   }
00188 }
00189 
00190 // WriteString(rName)
00191 void TokenWriter::WriteString(const std::string& rName) {
00192   if ((rName == "\n") || (rName == "\r\n")) {
00193     Endl();
00194     mColCount = 0;
00195     return;
00196   }
00197   Token token;
00198   token.SetString(rName);
00199   Write(token);
00200 }
00201 
00202 
00203 // WriteText(rBegin,rText)
00204 void TokenWriter::WriteText(const Token& rBeginTag, const std::string& rText) {
00205   if(!rBeginTag.IsBegin() || rBeginTag.IsEnd()) {
00206     std::stringstream errstr;
00207     errstr << "Invalid begin token while writing file \"" << mFileName << "\"";
00208     throw Exception("TokenWriter::WriteText(label,text)", errstr.str(), 2);
00209   }
00210   try {
00211     Write(rBeginTag);
00212     Token::WriteEscapedString(mpStream,rText);
00213     Endl();
00214     WriteEnd(rBeginTag.StringValue());
00215   } 
00216   catch (std::ios::failure&) {
00217     std::stringstream errstr;
00218     errstr << "Exception opening/writing file \"" << mFileName << "\"";
00219     throw Exception("TokenWriter::WriteText(label,text)", errstr.str(), 2);
00220   }
00221 }
00222 
00223 
00224 // WriteText(rLabel,rText)
00225 void TokenWriter::WriteText(const std::string& rLabel, const std::string& rText) {
00226   Token btag;
00227   btag.SetBegin(rLabel);
00228   WriteText(btag,rText);
00229 }
00230 
00231 
00232 // WriteVerbatim(rName)
00233 void TokenWriter::WriteVerbatim(const std::string& rName) {
00234   FD_DV("TokenWriter::Write(token)");
00235   // if(mMode==Stdout) mpStream = &std::cout; // fix
00236   try{
00237     if(mColCount !=0) Endl();
00238     Token::WriteVerbatim(mpStream,rName);
00239     mColCount = 0;
00240   }
00241   catch (std::ios::failure&) {
00242     std::stringstream errstr;
00243     errstr << "Exception opening/writing file \"" << mFileName << "\"";
00244     throw Exception("TokenWriter::WriteVerbatim()", errstr.str(), 2);
00245   }
00246 }
00247 
00248 // WriteInteger(index)
00249 void TokenWriter::WriteInteger(Idx index) {
00250   Token token;
00251   token.SetInteger(index);
00252   Write(token);
00253 }
00254 
00255 // WriteInteger(index)
00256 void TokenWriter::WriteInteger16(long int val) {
00257   Token token;
00258   token.SetInteger16(val);
00259   Write(token);
00260 }
00261 
00262 // WriteFloat(float)
00263 void TokenWriter::WriteFloat(const double& val) {
00264   Token token;
00265   token.SetFloat(val);
00266   Write(token);
00267 }
00268 
00269 
00270 // WriteOption(rOpt)
00271 void TokenWriter::WriteOption(const std::string& rOpt) {
00272   Token token;
00273   token.SetOption(rOpt);
00274   Write(token);
00275 }
00276 
00277 
00278 // WriteBegin(rLabel)
00279 void TokenWriter::WriteBegin(const std::string& rLabel) {
00280   Token token;
00281   token.SetBegin(rLabel);
00282   Write(token);
00283 }
00284 
00285 // WriteEnd(rLabel)
00286 void TokenWriter::WriteEnd(const std::string& rLabel) {
00287   Token token;
00288   token.SetEnd(rLabel);
00289   Write(token);
00290 }
00291 
00292 // WriteBegin(rLabel)
00293 void TokenWriter::WriteEmpty(const std::string& rLabel) {
00294   Token token;
00295   token.SetEmpty(rLabel);
00296   Write(token);
00297 }
00298 
00299 // WriteComment(comment)
00300 void TokenWriter::WriteComment(const std::string& comment){
00301   // auto xml 
00302   if(mMode==XmlFile) { WriteXmlComment(comment); return; }
00303   // no endl ... no comment
00304   if(!mEndl) return; 
00305   try{
00306     if(mColCount!=0)  Endl();
00307     // fix comment indicator
00308     if(comment.length()==0) 
00309       *mpStream << "% ";
00310     if(comment.length()>0) 
00311     if(comment.at(0)!='%')
00312       *mpStream << "% ";
00313     // xml/endl escape
00314     std::string::const_iterator cit=comment.begin(); 
00315     for(;cit!=comment.end(); cit++) {
00316       if(*cit=='<') 
00317         { *mpStream << "&lt;"; continue;}
00318       if(*cit=='>') 
00319         { *mpStream << "&gt;"; continue;}
00320       if(*cit=='&') 
00321        { *mpStream << "&amp;"; continue;}
00322       if(*cit=='\n') 
00323        { *mpStream << " "; continue;}
00324       if(*cit=='\r') 
00325        { ; continue;}
00326       *mpStream << *cit;
00327     }
00328     // done
00329     Endl();
00330     mColCount = 0;
00331   }
00332   catch (std::ios::failure&) {
00333     std::stringstream errstr;
00334     errstr << "Exception opening/writing file \"" << mFileName << "\"";
00335     throw Exception("TokenWriter::Comment", errstr.str(), 2);
00336   }
00337 }
00338 
00339 // WriteXmlComment(comment)
00340 void TokenWriter::WriteXmlComment(const std::string& comment){
00341   if(!mEndl) return; //  no endl implies no comments
00342   try{
00343     if(mColCount!=0)  Endl();
00344     // begin tag
00345     *mpStream << "<!-- ";
00346     // test for multiline
00347     static const std::string newline="\n\r";
00348     if(comment.find_first_of(newline)!=std::string::npos) 
00349       Endl();
00350     // xml/endl escape
00351     std::string::const_iterator cit=comment.begin(); 
00352     for(;cit!=comment.end(); cit++) {
00353       if(*cit=='>') 
00354         { *mpStream << "&gt;"; continue;}
00355       *mpStream << *cit;
00356     }
00357     // end tag
00358     *mpStream << " -->";
00359     // done
00360     Endl();
00361     mColCount = 0;
00362   }
00363   catch (std::ios::failure&) {
00364     std::stringstream errstr;
00365     errstr << "Exception opening/writing file \"" << mFileName << "\"";
00366     throw Exception("TokenWriter::Comment", errstr.str(), 2);
00367   }
00368 }
00369 
00370 // write base64
00371 void TokenWriter::WriteBinary(const char* pData, long int len) {
00372   Token::WriteBinary(mpStream,pData,len);
00373 }
00374 
00375 // FileName()
00376 std::string TokenWriter::FileName(void) const {
00377   return mFileName;
00378 }
00379 
00380 
00381 
00382 
00383 } // namespace faudes

libFAUDES 2.18b --- 2010-12-17 --- c++ source docu by doxygen 1.6.3