tokenwriter.cpp

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

Generated on Mon Nov 10 08:13:15 2008 for libFAUDES 2.11v by  doxygen 1.4.4