libFAUDES

Sections

Index

cfl_basevector.cpp

Go to the documentation of this file.
00001 /** @file cfl_basevector.cpp @brief  */
00002 
00003 /* FAU Discrete Event Systems Library (libfaudes)
00004 
00005    Copyright (C) 2006  Bernd Opitz
00006    Copyright (C) 2007  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 #include "cfl_basevector.h"
00024 #include "cfl_nameset.h"
00025 
00026 namespace faudes {
00027 
00028 
00029 /*
00030 ******************************************************************************************
00031 ******************************************************************************************
00032 ******************************************************************************************
00033 
00034 Implementation of TBaseVector
00035 
00036 ******************************************************************************************
00037 ******************************************************************************************
00038 ******************************************************************************************
00039 */
00040 
00041 // faudes type std
00042 FAUDES_TYPE_IMPLEMENTATION(vBaseVector,Type)
00043 
00044 
00045 // vBaseVector()
00046 vBaseVector::vBaseVector(void) :
00047   Type()
00048 {
00049   FD_DC("vBaseVector(" << this << ")::vBaseVector()");
00050   // my members
00051   mMyName="Vector";
00052 }
00053 
00054   
00055 // vBaseVector(filename)
00056 vBaseVector::vBaseVector(const std::string& rFileName, const std::string& rLabel)  :
00057   Type()
00058 {
00059   FD_DC("vBaseVector(" << this << ")::vBaseVector()");
00060   // other members
00061   mMyName="Vector";
00062   // do read;
00063   Read(rFileName,rLabel);  
00064 }
00065 
00066 
00067 // vBaseVector(rOtherSet)
00068 vBaseVector::vBaseVector(const vBaseVector& rOtherVector) : 
00069   Type(rOtherVector)
00070 {
00071   FD_DC("vBaseVector(" << this << ")::vBaseVector(rOtherVector " << &rOtherVector << "): copy construct");
00072   DoAssign(rOtherVector);
00073 }
00074 
00075 // destructor
00076 vBaseVector::~vBaseVector(void) {
00077   FD_DC("vBaseVector(" << this << ")::~vBaseVector()");
00078   // delete entries
00079   for(Position pos=0; pos<mVector.size(); pos++) 
00080     if(mVector[pos].mMine) delete mVector[pos].pElement;
00081   // done
00082   FD_DC("vBaseVector(" << this << ")::~vBaseVector(): done");
00083 }
00084 
00085 
00086 // element prototype
00087 const Type* vBaseVector::Elementp(void) const {
00088   static Type proto;
00089   return &proto;
00090 }
00091 
00092 // element prototype
00093 const Type& vBaseVector::Element(void) const {
00094   return *Elementp();
00095 }
00096 
00097 // element factory
00098 Type* vBaseVector::NewElement(void) {
00099   return Element().New();
00100 }
00101 
00102 // test element type
00103 bool vBaseVector::ElementTry(const Type& rElement) const {
00104   return Elementp()->Cast(&rElement)!=NULL;
00105 }
00106 
00107 // assignment (here, we know the type to match)
00108 vBaseVector& vBaseVector::DoAssign(const vBaseVector& rSourceVector) {
00109   FD_DC("vBaseVector(" << this << ")::DoAssign(rOtherVector " << &rSourceVector << ")");
00110   // bail out on selfref
00111   if(this==&rSourceVector) return *this;
00112   // virtual clear
00113   Clear();
00114   // allocate
00115   mVector.resize(rSourceVector.Size());
00116   // copy entries
00117   for(Position pos=0; pos<mVector.size(); pos++) {
00118     mVector[pos].pElement = rSourceVector.mVector[pos].pElement->Copy();
00119     mVector[pos].mMine=true;
00120     mVector[pos].mFileName="";
00121   }
00122   // done
00123   FD_DC("vBaseVector(" << this << ")::DoAssign(rOtherVector " << &rSourceVector << "): done");
00124   return *this;
00125 }
00126 
00127 // clear
00128 void vBaseVector::Clear(void) {
00129   // delete entries
00130   for(Position pos=0; pos<mVector.size(); pos++) {
00131     if(mVector[pos].mMine) delete mVector[pos].pElement;
00132   }
00133   // resize
00134   mVector.resize(0);
00135 }
00136 
00137 
00138 // Name
00139 const std::string& vBaseVector::Name(void) const {
00140   return mMyName;
00141 }
00142     
00143 // Name
00144 void vBaseVector::Name(const std::string& rName) {
00145   mMyName = rName;
00146 }
00147   
00148 // Size()
00149 Idx vBaseVector::Size(void) const {
00150   return (Idx) mVector.size();
00151 }
00152 
00153 // Size(idx)
00154 void vBaseVector::Size(Idx len) {
00155   FD_DC("vBaseVector(" << this << ")::Size(..): from " << mVector.size() << " to " << len);
00156   // record
00157   Position olen=mVector.size();
00158   // delete
00159   for(Position pos=len; pos<olen; pos++) 
00160     if(mVector[pos].mMine) delete mVector[pos].pElement;
00161   // allocate
00162   mVector.resize(len);
00163   // initialize
00164   for(Position pos=olen; pos < len; pos++) {
00165     mVector[pos].pElement = NewElement();
00166     mVector[pos].mMine=true;
00167     mVector[pos].mFileName = "";
00168   }
00169   // done
00170   FD_DC("vBaseVector(" << this << ")::Size(..): done");
00171 }
00172 
00173 
00174 // Empty()
00175 bool vBaseVector::Empty(void) const {
00176   return mVector.empty();
00177 }
00178 
00179 
00180 // At()
00181 const Type& vBaseVector::At(const Position& pos) const {
00182 #ifdef FAUDES_CHECKED
00183   if(pos<0 || pos >= mVector.size()) {
00184     std::stringstream errstr;
00185     errstr << "index out of range" << std::endl;
00186     throw Exception("vBaseVector::At", errstr.str(), 62);
00187   }
00188 #endif
00189   return *mVector[pos].pElement;
00190 }
00191 
00192 // At()
00193 Type& vBaseVector::At(const Position& pos) {
00194 #ifdef FAUDES_CHECKED
00195   if(pos<0 || pos >= mVector.size()) {
00196     std::stringstream errstr;
00197     errstr << "index out of range" << std::endl;
00198     throw Exception("vBaseVector::At", errstr.str(), 62);
00199   }
00200 #endif
00201   return *mVector[pos].pElement;
00202 }
00203 
00204 
00205 
00206 // replace (copy)
00207 void vBaseVector::Replace(const Position& pos, const Type& rElem) {
00208 #ifdef FAUDES_CHECKED
00209   if(pos<0 || pos >= mVector.size()) {
00210     std::stringstream errstr;
00211     errstr << "index out of range" << std::endl;
00212     throw Exception("vBaseVector::At", errstr.str(), 62);
00213   }
00214 #endif
00215   if(!ElementTry(rElem)) {
00216     std::stringstream errstr;
00217     errstr << "cannot cast element " << std::endl;
00218     throw Exception("vBaseVector::Replace(pos,elem)", errstr.str(), 63);
00219   }
00220   iterator pit=mVector.begin()+pos;
00221   if(pit->mMine) delete pit->pElement;
00222   pit->pElement=rElem.Copy();
00223   pit->mMine=true;
00224   pit->mFileName="";
00225 }
00226 
00227 // replace (take)
00228 void vBaseVector::Replace(const Position& pos, Type* pElem) {
00229 #ifdef FAUDES_CHECKED
00230   if(pos<0 || pos >= mVector.size()) {
00231     std::stringstream errstr;
00232     errstr << "index out of range" << std::endl;
00233     throw Exception("vBaseVector::At", errstr.str(), 62);
00234   }
00235 #endif
00236   if(!ElementTry(*pElem)) {
00237     std::stringstream errstr;
00238     errstr << "cannot cast element " << std::endl;
00239     throw Exception("vBaseVector::Replace(pos,elem)", errstr.str(), 63);
00240   }
00241   iterator pit=mVector.begin()+pos;
00242   if(pit->mMine) delete pit->pElement;
00243   pit->pElement=pElem;
00244   pit->mMine=false;
00245   pit->mFileName="";
00246 }
00247 
00248 // replace (file)
00249 void vBaseVector::Replace(const Position& pos, const std::string& rFileName) {
00250 #ifdef FAUDES_CHECKED
00251   if(pos<0 || pos >= mVector.size()) {
00252     std::stringstream errstr;
00253     errstr << "index out of range" << std::endl;
00254     throw Exception("vBaseVector::At", errstr.str(), 62);
00255   }
00256 #endif
00257   iterator pit=mVector.begin()+pos;
00258   if(pit->mMine) delete pit->pElement;
00259   pit->pElement = NewElement();
00260   pit->mMine=true;
00261   pit->pElement->Read(rFileName);
00262   pit->mFileName=rFileName;
00263 }
00264 
00265 // erase
00266 void vBaseVector::Erase(const Position& pos) {
00267 #ifdef FAUDES_CHECKED
00268   if(pos<0 || pos >= mVector.size()) {
00269     std::stringstream errstr;
00270     errstr << "index out of range" << std::endl;
00271     throw Exception("vBaseVector::At", errstr.str(), 62);
00272   }
00273 #endif
00274   iterator pit=mVector.begin()+pos;
00275   if(pit->mMine) delete pit->pElement;
00276   mVector.erase(pit);
00277 }
00278 
00279 
00280 // insert (copy)
00281 void vBaseVector::Insert(const Position& pos, const Type& rElem) {
00282 #ifdef FAUDES_CHECKED
00283   if(pos<0 || pos > mVector.size()) {
00284     std::stringstream errstr;
00285     errstr << "index out of range" << std::endl;
00286     throw Exception("vBaseVector::At", errstr.str(), 62);
00287   }
00288 #endif
00289   if(!ElementTry(rElem)) {
00290     std::stringstream errstr;
00291     errstr << "cannot cast element " << std::endl;
00292     throw Exception("vBaseVector::Insert(pos,elem)", errstr.str(), 63);
00293   }
00294   ElementRecord elem;
00295   elem.pElement = rElem.Copy();
00296   elem.mMine=true;
00297   elem.mFileName="";
00298   iterator pit=mVector.begin()+pos;
00299   mVector.insert(pit,elem);
00300 }
00301  
00302 // insert (take)
00303 void vBaseVector::Insert(const Position& pos, Type* pElem) {
00304 #ifdef FAUDES_CHECKED
00305   if(pos<0 || pos > mVector.size()) {
00306     std::stringstream errstr;
00307     errstr << "index out of range" << std::endl;
00308     throw Exception("vBaseVector::At", errstr.str(), 62);
00309   }
00310 #endif
00311   if(!ElementTry(*pElem)) {
00312     std::stringstream errstr;
00313     errstr << "cannot cast element " << std::endl;
00314     throw Exception("vBaseVector::Insert(pos,elem)", errstr.str(), 63);
00315   }
00316   ElementRecord elem;
00317   elem.pElement = pElem;
00318   elem.mMine=false;
00319   elem.mFileName="";
00320   iterator pit=mVector.begin()+pos;
00321   mVector.insert(pit,elem);
00322 }
00323  
00324 // insert (file)
00325 void vBaseVector::Insert(const Position& pos, const std::string& rFileName) {
00326 #ifdef FAUDES_CHECKED
00327   if(pos<0 || pos > mVector.size()) {
00328     std::stringstream errstr;
00329     errstr << "index out of range" << std::endl;
00330     throw Exception("vBaseVector::At", errstr.str(), 62);
00331   }
00332 #endif
00333   ElementRecord elem;
00334   elem.pElement =NewElement();
00335   elem.mMine=true;
00336   elem.pElement->Read(rFileName);
00337   elem.mFileName=rFileName;
00338   iterator pit=mVector.begin()+pos;
00339   mVector.insert(pit,elem);
00340 }
00341  
00342 
00343 // append (copy)
00344 void vBaseVector::PushBack(const Type& rElem) {
00345   if(!ElementTry(rElem)) {
00346     std::stringstream errstr;
00347     errstr << "cannot cast element " << std::endl;
00348     throw Exception("vBaseVector::PushBack(elem)", errstr.str(), 63);
00349   }
00350   ElementRecord elem;
00351   elem.pElement = rElem.Copy();
00352   elem.mMine=true;
00353   elem.mFileName="";
00354   mVector.push_back(elem);
00355 }
00356  
00357 // append (take)
00358 void vBaseVector::PushBack(Type* pElem) {
00359   if(!ElementTry(*pElem)) {
00360     std::stringstream errstr;
00361     errstr << "cannot cast element " << std::endl;
00362     throw Exception("vBaseVector::PushBack(elem)", errstr.str(), 63);
00363   }
00364   ElementRecord elem;
00365   elem.pElement = pElem;
00366   elem.mMine=false;
00367   elem.mFileName="";
00368   mVector.push_back(elem);
00369 }
00370  
00371 // append (file)
00372  void vBaseVector::PushBack(const std::string& rFileName) {
00373   ElementRecord elem;
00374   elem.pElement = NewElement();
00375   elem.mMine=true;
00376   elem.pElement->Read(rFileName);
00377   elem.mFileName=rFileName;
00378   mVector.push_back(elem);
00379 }
00380  
00381 
00382 // append (copy)
00383 void vBaseVector::Append(const Type& rElem) {
00384   PushBack(rElem);
00385 }
00386 
00387 // append (take)
00388 void vBaseVector::Append(Type* pElem) {
00389   PushBack(pElem);
00390 }
00391 
00392 // append (file)
00393 void vBaseVector::Append(const std::string& rFileName) {
00394   PushBack(rFileName);
00395 }
00396  
00397 
00398 // FilenameAt()
00399 const std::string& vBaseVector::FilenameAt(const Position& pos) const {
00400 #ifdef FAUDES_CHECKED
00401   if(pos<0 || pos >= mVector.size()) {
00402     std::stringstream errstr;
00403     errstr << "index out of range" << std::endl;
00404     throw Exception("vBaseVector::FilenameAt", errstr.str(), 62);
00405   }
00406 #endif
00407   return mVector[pos].mFileName;
00408 }
00409 
00410 // FilenameAt()
00411 void vBaseVector::FilenameAt(const Position& pos, const std::string& rFileName) {
00412 #ifdef FAUDES_CHECKED
00413   if(pos<0 || pos >= mVector.size()) {
00414     std::stringstream errstr;
00415     errstr << "index out of range" << std::endl;
00416     throw Exception("vBaseVector::FilenameAt", errstr.str(), 62);
00417   }
00418 #endif
00419   mVector[pos].mFileName = rFileName;
00420 }
00421 
00422 // take ownership
00423 void vBaseVector::TakeCopies(void) {
00424   iterator pit=mVector.begin();
00425   for(;pit!=mVector.end();++pit) {
00426     if(pit->mMine) continue;
00427     pit->pElement=pit->pElement->Copy();
00428     pit->mMine=true;
00429   }
00430 }
00431 
00432 // take ownership
00433 void vBaseVector::TakeOwnership(void) {
00434   iterator pit=mVector.begin();
00435   for(;pit!=mVector.end();++pit) 
00436     pit->mMine=true;
00437 }
00438 
00439 // DoWrite(tw, label, context)
00440 void vBaseVector::DoWrite(TokenWriter& rTw, const std::string& rLabel, const Type* pContext) const {
00441   // figure whether we write individual files
00442   bool ifiles=true;
00443   if(rTw.DestMode()!=TokenWriter::File) ifiles=false;
00444   for(Position pos=0; pos<mVector.size() && ifiles; pos++) 
00445     if(mVector[pos].mFileName=="") ifiles=false;
00446   // extract base directory
00447   std::string dirname="";
00448   if(rTw.DestMode()==TokenWriter::File) 
00449     dirname = ExtractDirectory(rTw.FileName());
00450   // have a section
00451   std::string label=rLabel;
00452   if(label=="") label="Vector"; 
00453   FD_DC("vBaseVector(" << this << ")::DoWrite(..): section " << label << " #" << Size());
00454   rTw.WriteBegin(label);
00455   for(Position pos=0; pos<mVector.size(); pos++) {
00456     // just stream tokens
00457     if(!ifiles) {
00458       mVector[pos].pElement->Write(rTw,"",pContext);
00459       continue;
00460     } 
00461     // write individual files
00462     std::string filename= ExtractFilename(mVector[pos].mFileName);
00463     rTw.WriteString(filename);
00464     mVector[pos].pElement->Write(PrependDirectory(dirname,filename),"",pContext);    
00465   }
00466   rTw.WriteEnd(label);
00467 }
00468 
00469 
00470 // DoDWrite(tw,rLabel,context)
00471 void vBaseVector::DoDWrite(TokenWriter& rTw,const std::string& rLabel, const Type* pContext) const {
00472   std::string label=rLabel;
00473   if(label=="") label="Vector"; 
00474   FD_DC("vBaseVector(" << this << ")::DoDWrite(..): section " << label << " #" << Size());
00475   rTw.WriteBegin(label);
00476   for(Position pos=0; pos<mVector.size(); pos++) {
00477     mVector[pos].pElement->DWrite(rTw,"",pContext);
00478   }
00479   rTw.WriteEnd(label);
00480 }
00481 
00482 
00483 // DoSWrite(tw)
00484 void vBaseVector::DoSWrite(TokenWriter& rTw) const {
00485   FD_DC("vBaseVector(" << this << ")::DoSWrite(..)");
00486   rTw.WriteComment(" Vector Size: "+ ToStringInteger(Size()));
00487   for(Position pos=0; pos<mVector.size(); pos++) {
00488     rTw.WriteComment(" Vector Entry " + ToStringInteger(pos));
00489     mVector[pos].pElement->SWrite(rTw);
00490   }
00491   rTw.WriteComment("");
00492 }
00493 
00494 
00495 // DoRead(rTr, rLabel, pContext)
00496 void vBaseVector::DoRead(TokenReader& rTr, const std::string& rLabel, const Type* pContext) {
00497   //prepare token
00498   Token token;
00499   //prepare string 
00500   std::string filename = "";      
00501   std::string dirname = "";       
00502   std::string path;               
00503   // have default section
00504   std::string label=rLabel;
00505   if(label=="") label="Vector"; 
00506   Name(label);
00507   rTr.SeekBegin(label); 
00508   // fill my entries from token stream
00509   while(!rTr.Eos(label)){
00510     //peek token
00511     rTr.Peek(token);
00512     // if Token is a String we assume its the name of a file containing a device
00513     if(token.Type()==Token::String) {
00514       //read Token
00515       rTr.Get(token);
00516       // read relative filename
00517       filename = token.StringValue();
00518       // build up path to base-file
00519       if(rTr.SourceMode()==TokenReader::File) dirname = ExtractDirectory(rTr.FileName());
00520       //build up path to specified file
00521       path = dirname.append(filename);
00522       //insert device
00523       Insert(mVector.size(),path);
00524       continue;
00525     }
00526     // if its not a file it has to be an entry
00527     else if(token.Type()==Token::Begin) {
00528       // prepare
00529       Type* elemp = NewElement();
00530       // read entry
00531       elemp->Read(rTr);
00532       // insert device mDevices
00533       Insert(mVector.size(),elemp);
00534       // fix ownership
00535       (--mVector.end())->mMine=true;
00536       continue;
00537     }
00538     // token mismatch
00539     std::stringstream errstr;
00540     errstr << "token mismatch" << std::endl;
00541     throw Exception("vBaseVector::At", errstr.str(), 50);
00542   } 
00543   // done
00544   rTr.SeekEnd(label); 
00545 }
00546 
00547 
00548 
00549 
00550 } // namespace faudes
00551 

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