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(mode)
00047 TokenWriter::TokenWriter(Mode mode)
00048   : mMode(mode), mFileName(""), mColumns(80/FD_NAMELEN), mColCount(0) {
00049   switch(mode) {
00050   case Stdout: 
00051     // set up mFStream
00052     mFileName="stdout";
00053     /*
00054       try {
00055       mFStream.copyfmt(std::cout);
00056       mFStream.clear(std::cout.rdstate());
00057       typedef std::basic_ios<char> ___basic_ios_char_; // trick for vc++
00058       mFStream.___basic_ios_char_::rdbuf(std::cout.rdbuf());
00059       }
00060       catch (std::ios::failure&) {
00061       std::stringstream errstr;
00062       errstr << "Exception opening/writing file \""<< mFileName << "\"";
00063       throw Exception("TokenWriter::TokenWriter", errstr.str(), 2);
00064       }
00065       // use mFStream
00066       mpStream=&mFStream;
00067     */
00068     // use std::cout
00069     mpStream= &std::cout;
00070     mEndl=true;
00071     break;
00072   case String:
00073     // use mSStream
00074     mFileName="string";
00075     mpStream=&mSStream;
00076     mEndl=false;
00077     break;
00078   default:
00079     std::stringstream errstr;
00080     errstr << "Invalid Mode / Not Implemented";
00081     throw Exception("TokenWriter::TokenWriter", errstr.str(), 2);
00082   }
00083 }
00084 
00085 
00086 // destructor
00087 TokenWriter::~TokenWriter(void) {
00088   if(mMode==File) mFStream.close();
00089 }
00090 
00091 // Flush buffers
00092   void TokenWriter::Flush(void) {
00093   if(mMode==File) mFStream.flush();
00094   mpStream->flush();
00095 }
00096 
00097 // Str()
00098 std::string TokenWriter::Str(void) {
00099   if(mMode!=String) {
00100     std::stringstream errstr;
00101     errstr << "Not in String Mode";
00102     throw Exception("TokenWriter::Str()", errstr.str(), 2);
00103   }
00104   return mSStream.str();
00105 }
00106 
00107 // Columns()
00108 int TokenWriter::Columns(void) const {
00109   return mColumns;
00110 }
00111 
00112 // Columns()
00113 void TokenWriter::Columns(int columns) {
00114   mColumns = columns;
00115 }
00116 
00117 // Endl()
00118 void TokenWriter::Endl(void) {
00119   try{
00120     if(mEndl) *mpStream << std::endl;
00121     else *mpStream << " ";
00122   }
00123   catch (std::ios::failure&) {
00124     std::stringstream errstr;
00125     errstr << "Exception opening/writing file \"" << mFileName << "\"";
00126     throw Exception("Generator::write", errstr.str(), 2);
00127   }
00128 }
00129 
00130 // Endl(bool)
00131 void TokenWriter::Endl(bool on) {
00132   mEndl=on;
00133 }
00134 
00135 
00136 // Write(rToken)
00137 void TokenWriter::Write(Token& rToken) {
00138   FD_DV("TokenWriter::Write(token)");
00139   // if(mMode==Stdout) mpStream = &std::cout; // fix
00140   try{
00141     if ( (rToken.Type() == Token::Begin) || (rToken.Type() == Token::End) ) {
00142       if(mColCount !=0) Endl();
00143       rToken.Write(mpStream);
00144       Endl();
00145       mColCount = 0;
00146     }
00147     else {
00148       if(mColCount == mColumns) {
00149   mColCount = 0;
00150   Endl();
00151       }
00152       mColCount++;
00153       rToken.Write(mpStream);
00154       *mpStream << " ";
00155     }
00156   }
00157   catch (std::ios::failure&) {
00158     std::stringstream errstr;
00159     errstr << "Exception opening/writing file \"" << mFileName << "\"";
00160     throw Exception("TokenWriter::Write(token)", errstr.str(), 2);
00161   }
00162 }
00163 
00164 // WriteString(rName)
00165 void TokenWriter::WriteString(const std::string& rName) {
00166   if ((rName == "\n") || (rName == "\r\n")) {
00167     Endl();
00168     mColCount = 0;
00169     return;
00170   }
00171   Token token;
00172   token.SetString(rName);
00173   Write(token);
00174 }
00175 
00176 
00177 // WriteVerbatim(rName)
00178 void TokenWriter::WriteVerbatim(const std::string& rName) {
00179   FD_DV("TokenWriter::Write(token)");
00180   // if(mMode==Stdout) mpStream = &std::cout; // fix
00181   try{
00182     if(mColCount !=0) Endl();
00183     Token::WriteVerbatim(mpStream,rName);
00184     mColCount = 0;
00185   }
00186   catch (std::ios::failure&) {
00187     std::stringstream errstr;
00188     errstr << "Exception opening/writing file \"" << mFileName << "\"";
00189     throw Exception("TokenWriter::WriteVerbatim()", errstr.str(), 2);
00190   }
00191 }
00192 
00193 // WriteInteger(index)
00194 void TokenWriter::WriteInteger(Idx index) {
00195   Token token;
00196   token.SetInteger(index);
00197   Write(token);
00198 }
00199 
00200 // WriteInteger(index)
00201 void TokenWriter::WriteInteger16(long int val) {
00202   Token token;
00203   token.SetInteger16(val);
00204   Write(token);
00205 }
00206 
00207 // WriteFloat(float)
00208 void TokenWriter::WriteFloat(const double& val) {
00209   Token token;
00210   token.SetFloat(val);
00211   Write(token);
00212 }
00213 
00214 
00215 // WriteOption(rOpt)
00216 void TokenWriter::WriteOption(const std::string& rOpt) {
00217   Token token;
00218   token.SetOption(rOpt);
00219   Write(token);
00220 }
00221 
00222 
00223 // WriteBegin(rLabel)
00224 void TokenWriter::WriteBegin(const std::string& rLabel) {
00225   Token token;
00226   token.SetBegin(rLabel);
00227   Write(token);
00228 }
00229 
00230 // WriteEnd(rLabel)
00231 void TokenWriter::WriteEnd(const std::string& rLabel) {
00232   Token token;
00233   token.SetEnd(rLabel);
00234   Write(token);
00235 }
00236 
00237 // WriteComment(comment)
00238 void TokenWriter::WriteComment(const std::string& comment){
00239   if(!mEndl) return; //  no endl implies no comments
00240   try{
00241     if(mColCount!=0)  Endl();
00242     if(comment.length()==0) 
00243       *mpStream << "% ";
00244     if(comment.length()>0) 
00245     if(comment.at(0)!='%')
00246       *mpStream << "% ";
00247     *mpStream << comment;
00248     Endl();
00249     mColCount = 0;
00250   }
00251   catch (std::ios::failure&) {
00252     std::stringstream errstr;
00253     errstr << "Exception opening/writing file \"" << mFileName << "\"";
00254     throw Exception("TokenWriter::Comment", errstr.str(), 2);
00255   }
00256 }
00257 
00258 // write base64
00259 void TokenWriter::WriteBinary(const char* pData, long int len) {
00260   Token::WriteBinary(mpStream,pData,len);
00261 }
00262 
00263 // FileName()
00264 std::string TokenWriter::FileName(void) const {
00265   return mFileName;
00266 }
00267 
00268 
00269 
00270 
00271 } // namespace faudes

libFAUDES 2.16b --- 2010-9-8 --- c++ source docu by doxygen 1.6.3