libFAUDES

Sections

Index

tokenwriter.cpp

Go to the documentation of this file.
00001 /** @file 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 "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 // Str()
00092 std::string TokenWriter::Str(void) {
00093   if(mMode!=String) {
00094     std::stringstream errstr;
00095     errstr << "Not in String Mode";
00096     throw Exception("TokenWriter::Str()", errstr.str(), 2);
00097   }
00098   return mSStream.str();
00099 }
00100 
00101 // Columns()
00102 int TokenWriter::Columns(void) const {
00103   return mColumns;
00104 }
00105 
00106 // Columns()
00107 void TokenWriter::Columns(int columns) {
00108   mColumns = columns;
00109 }
00110 
00111 // Endl()
00112 void TokenWriter::Endl(void) {
00113   try{
00114     if(mEndl) *mpStream << std::endl;
00115     else *mpStream << " ";
00116   }
00117   catch (std::ios::failure&) {
00118     std::stringstream errstr;
00119     errstr << "Exception opening/writing file \"" << mFileName << "\"";
00120     throw Exception("Generator::write", errstr.str(), 2);
00121   }
00122 }
00123 
00124 // Endl(bool)
00125 void TokenWriter::Endl(bool on) {
00126   mEndl=on;
00127 }
00128 
00129 
00130 // Write(rToken)
00131 void TokenWriter::Write(Token& rToken) {
00132   FD_DV("TokenWriter::Write(token)");
00133   // if(mMode==Stdout) mpStream = &std::cout; // fix
00134   try{
00135     if ( (rToken.Type() == Token::Begin) || (rToken.Type() == Token::End) ) {
00136       if(mColCount !=0) Endl();
00137       rToken.Write(mpStream);
00138       Endl();
00139       mColCount = 0;
00140     }
00141     else {
00142       if(mColCount == mColumns) {
00143   mColCount = 0;
00144   Endl();
00145       }
00146       mColCount++;
00147       rToken.Write(mpStream);
00148       *mpStream << " ";
00149     }
00150   }
00151   catch (std::ios::failure&) {
00152     std::stringstream errstr;
00153     errstr << "Exception opening/writing file \"" << mFileName << "\"";
00154     throw Exception("TokenWriter::Write(token)", errstr.str(), 2);
00155   }
00156 }
00157 
00158 // WriteString(rName)
00159 void TokenWriter::WriteString(const std::string& rName) {
00160   if ((rName == "\n") || (rName == "\r\n")) {
00161     Endl();
00162     mColCount = 0;
00163     return;
00164   }
00165   Token token;
00166   token.SetString(rName);
00167   Write(token);
00168 }
00169 
00170 
00171 // WriteInteger(index)
00172 void TokenWriter::WriteInteger(Idx index) {
00173   Token token;
00174   token.SetInteger(index);
00175   Write(token);
00176 }
00177 
00178 // WriteInteger(index)
00179 void TokenWriter::WriteInteger16(long int val) {
00180   Token token;
00181   token.SetInteger16(val);
00182   Write(token);
00183 }
00184 
00185 // WriteFloat(float)
00186 void TokenWriter::WriteFloat(const double& val) {
00187   Token token;
00188   token.SetFloat(val);
00189   Write(token);
00190 }
00191 
00192 
00193 // WriteOption(rOpt)
00194 void TokenWriter::WriteOption(const std::string& rOpt) {
00195   Token token;
00196   token.SetOption(rOpt);
00197   Write(token);
00198 }
00199 
00200 
00201 // WriteBegin(rLabel)
00202 void TokenWriter::WriteBegin(const std::string& rLabel) {
00203   Token token;
00204   token.SetBegin(rLabel);
00205   Write(token);
00206 }
00207 
00208 // WriteEnd(rLabel)
00209 void TokenWriter::WriteEnd(const std::string& rLabel) {
00210   Token token;
00211   token.SetEnd(rLabel);
00212   Write(token);
00213 }
00214 
00215 // WriteComment(comment)
00216 void TokenWriter::WriteComment(const std::string& comment){
00217   if(!mEndl) return; //  no endl implies no comments
00218   try{
00219     if(mColCount!=0)  Endl();
00220     if(comment.length()==0) 
00221       *mpStream << "% ";
00222     if(comment.length()>0) 
00223     if(comment.at(0)!='%')
00224       *mpStream << "% ";
00225     *mpStream << comment;
00226     Endl();
00227     mColCount = 0;
00228   }
00229   catch (std::ios::failure&) {
00230     std::stringstream errstr;
00231     errstr << "Exception opening/writing file \"" << mFileName << "\"";
00232     throw Exception("TokenWriter::Comment", errstr.str(), 2);
00233   }
00234 }
00235 
00236 // write base64
00237 void TokenWriter::WriteBinary(const char* pData, long int len) {
00238   Token::WriteBinary(mpStream,pData,len);
00239 }
00240 
00241 // FileName()
00242 std::string TokenWriter::FileName(void) const {
00243   return mFileName;
00244 }
00245 
00246 
00247 
00248 
00249 } // namespace faudes

libFAUDES 2.14g --- 2009-12-3 --- c++ source docu by doxygen 1.5.6