Back to index

salome-kernel  6.5.0
SALOMEDSImpl_AttributeParameter.cxx
Go to the documentation of this file.
00001 // Copyright (C) 2007-2012  CEA/DEN, EDF R&D, OPEN CASCADE
00002 //
00003 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
00004 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
00005 //
00006 // This library is free software; you can redistribute it and/or
00007 // modify it under the terms of the GNU Lesser General Public
00008 // License as published by the Free Software Foundation; either
00009 // version 2.1 of the License.
00010 //
00011 // This library is distributed in the hope that it will be useful,
00012 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00013 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00014 // Lesser General Public License for more details.
00015 //
00016 // You should have received a copy of the GNU Lesser General Public
00017 // License along with this library; if not, write to the Free Software
00018 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
00019 //
00020 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
00021 //
00022 
00023 //  File   : SALOMEDSImpl_AttributeParameter.cxx
00024 //  Author : Sergey RUIN
00025 //  Module : SALOME
00026 //
00027 #include "SALOMEDSImpl_AttributeParameter.hxx"
00028 
00029 #include <stdio.h>
00030 #include <stdlib.h>
00031 #include <sstream>
00032 #include <sstream>
00033 
00034 
00035 // Purpose: Each character in the string is replaced by 3 characters: '%' and hex number 
00036 //          of the character (2 characters)
00037 std::string convertString(const std::string& S)
00038 {
00039   int length = S.size();
00040   const char *s = S.c_str();
00041   char *c = new char[3], *buffer = new char[length*3+1];
00042   buffer[length*3] = (char)0;
00043   for(int i = 0, pos = 0; i<length; i++, pos+=3) {
00044     int val = (int)s[i];
00045     buffer[pos] = '%';
00046     sprintf(c, "%.2x", val);
00047     buffer[pos+1] = c[0]; 
00048     buffer[pos+2] = c[1];
00049   }
00050 
00051   std::string RS(buffer); 
00052   delete c;
00053   delete buffer;
00054   return RS;
00055 }
00056 
00057 //Restors a string converted by the function convertString
00058 std::string restoreString(const std::string& S)
00059 {
00060   int length = S.size();
00061   char *c = new char[3], *buffer = new char[length/3+1];
00062   buffer[length/3] = (char)0;
00063   const char *s = S.c_str();
00064   for(int i = 0, pos = 0; i<length; i+=3, pos++) {
00065     c[0] = s[i+1];
00066     c[1] = s[i+2];
00067     c[2] = (char)0;
00068     int val = strtol(c, NULL, 16);
00069     buffer[pos] = (char)val;
00070   }
00071 
00072   std::string RS(buffer); 
00073   delete c;
00074   delete buffer;
00075   return RS;
00076 }
00077 
00078 //=======================================================================
00083 //=======================================================================
00084 const std::string& SALOMEDSImpl_AttributeParameter::GetID ()
00085 {
00086   static std::string ParemeterID ("BA75F3A1-E40B-46b8-8D24-B1D3C3BB1A8C");
00087   return ParemeterID;
00088 }   
00089 
00090 //=======================================================================
00095 //=======================================================================
00096 SALOMEDSImpl_AttributeParameter* SALOMEDSImpl_AttributeParameter::Set (const DF_Label& L) 
00097 {
00098   SALOMEDSImpl_AttributeParameter* A = NULL;
00099   if (!(A=(SALOMEDSImpl_AttributeParameter*)L.FindAttribute(SALOMEDSImpl_AttributeParameter::GetID()))) {
00100     A = new  SALOMEDSImpl_AttributeParameter(); 
00101     L.AddAttribute(A);
00102   }
00103 
00104   return A;
00105 }
00106 
00107 //=======================================================================
00112 //=======================================================================
00113 void SALOMEDSImpl_AttributeParameter::SetInt(const std::string& theID, const int& theValue)
00114 {
00115   CheckLocked();
00116 
00117   if(theID.size() == 0) return;
00118 
00119   Backup();
00120 
00121   _ints[theID] = theValue;
00122 
00123   SetModifyFlag(); 
00124 }
00125 
00126 //=======================================================================
00131 //=======================================================================
00132 int SALOMEDSImpl_AttributeParameter::GetInt(const std::string& theID)
00133 {
00134   if(!IsSet(theID, PT_INTEGER)) throw DFexception("Invalid ID");
00135   return _ints[theID];
00136 }
00137 
00138 //=======================================================================
00143 //=======================================================================
00144 void SALOMEDSImpl_AttributeParameter::SetReal(const std::string& theID, const double& theValue)
00145 {
00146   CheckLocked();
00147 
00148   if(theID.size() == 0) return;
00149 
00150   Backup();
00151 
00152   _reals[theID] = theValue;
00153 
00154   SetModifyFlag(); 
00155 }
00156 
00157 //=======================================================================
00162 //=======================================================================
00163 double SALOMEDSImpl_AttributeParameter::GetReal(const std::string& theID)
00164 {
00165   if(!IsSet(theID, PT_REAL)) throw DFexception("Invalid ID");
00166   return _reals[theID];
00167 }
00168 
00169 //=======================================================================
00174 //=======================================================================
00175 void SALOMEDSImpl_AttributeParameter::SetString(const std::string& theID, const std::string& theValue)
00176 {
00177   CheckLocked();
00178 
00179   if(theID.size() == 0) return;
00180 
00181   Backup();
00182 
00183   _strings[theID] = theValue;
00184 
00185   SetModifyFlag(); 
00186 }
00187 
00188 //=======================================================================
00193 //=======================================================================
00194 std::string SALOMEDSImpl_AttributeParameter::GetString(const std::string& theID)
00195 {
00196   if(!IsSet(theID, PT_STRING)) throw DFexception("Invalid ID");
00197   return _strings[theID];
00198 }
00199 
00200 //=======================================================================
00205 //=======================================================================
00206 void SALOMEDSImpl_AttributeParameter::SetBool(const std::string& theID, const bool& theValue)
00207 {
00208   CheckLocked();
00209 
00210   if(theID.size() == 0) return;
00211 
00212   Backup();
00213 
00214   _bools[theID] = theValue;
00215 
00216   SetModifyFlag(); 
00217 }
00218 
00219 //=======================================================================
00224 //=======================================================================
00225 bool SALOMEDSImpl_AttributeParameter::GetBool(const std::string& theID)
00226 {
00227   if(!IsSet(theID, PT_BOOLEAN)) throw DFexception("Invalid ID");
00228   return _bools[theID];
00229 }
00230 
00231 //=======================================================================
00236 //=======================================================================
00237 void SALOMEDSImpl_AttributeParameter::SetRealArray(const std::string& theID, const std::vector<double>& theArray)
00238 {
00239   CheckLocked();
00240 
00241   if(theID.size() == 0) return;
00242 
00243   Backup();
00244 
00245   _realarrays[theID] = theArray;
00246 
00247   SetModifyFlag(); 
00248 }
00249 
00250 //=======================================================================
00255 //=======================================================================
00256 std::vector<double> SALOMEDSImpl_AttributeParameter::GetRealArray(const std::string& theID)
00257 {
00258   if(!IsSet(theID, PT_REALARRAY)) throw DFexception("Invalid ID");
00259   return _realarrays[theID];
00260 }
00261  
00262 
00263 //=======================================================================
00268 //=======================================================================
00269 void SALOMEDSImpl_AttributeParameter::SetIntArray(const std::string& theID, const std::vector<int>& theArray)
00270 {
00271   CheckLocked();
00272 
00273   if(theID.size() == 0) return;
00274 
00275   Backup();
00276 
00277   _intarrays[theID] = theArray;
00278 
00279   SetModifyFlag(); 
00280 }
00281 
00282 //=======================================================================
00287 //=======================================================================
00288 std::vector<int> SALOMEDSImpl_AttributeParameter::GetIntArray(const std::string& theID)
00289 {
00290   if(!IsSet(theID, PT_INTARRAY)) throw DFexception("Invalid ID");
00291   return _intarrays[theID];
00292 }
00293  
00294 
00295 //=======================================================================
00300 //=======================================================================
00301 void SALOMEDSImpl_AttributeParameter::SetStrArray(const std::string& theID, const std::vector<std::string>& theArray)
00302 {
00303   CheckLocked();
00304 
00305   if(theID.size() == 0) return;
00306 
00307   Backup();
00308 
00309   _strarrays[theID] = theArray;
00310 
00311   SetModifyFlag(); 
00312 }
00313 
00314 //=======================================================================
00319 //=======================================================================
00320 std::vector<std::string> SALOMEDSImpl_AttributeParameter::GetStrArray(const std::string& theID)
00321 {
00322   if(!IsSet(theID, PT_STRARRAY)) throw DFexception("Invalid ID");
00323   return _strarrays[theID];
00324 }
00325  
00326 
00327 //=======================================================================
00333 //=======================================================================
00334 bool SALOMEDSImpl_AttributeParameter::IsSet(const std::string& theID, const Parameter_Types theType)
00335 {
00336   switch(theType) {
00337   case PT_INTEGER: {
00338     if(_ints.find(theID) != _ints.end()) return true;
00339     break;
00340   }
00341   case PT_REAL: {
00342     if(_reals.find(theID) != _reals.end()) return true;
00343     break;
00344   }
00345   case PT_BOOLEAN: {
00346     if(_bools.find(theID) != _bools.end()) return true;
00347     break;
00348   }
00349   case PT_STRING: {
00350     if(_strings.find(theID) != _strings.end()) return true;
00351     break;
00352   }
00353   case PT_REALARRAY: {
00354     if(_realarrays.find(theID) != _realarrays.end()) return true;
00355     break;
00356   }
00357   case PT_INTARRAY: {
00358     if(_intarrays.find(theID) != _intarrays.end()) return true;
00359     break;
00360   }
00361   case PT_STRARRAY: {
00362     if(_strarrays.find(theID) != _strarrays.end()) return true;
00363     break;
00364   }
00365   default: return false;
00366   }
00367 
00368   return false;
00369 }
00370 
00371 //=======================================================================
00376 //=======================================================================
00377 bool SALOMEDSImpl_AttributeParameter::RemoveID(const std::string& theID, const Parameter_Types theType)
00378 {
00379   Backup();
00380   SetModifyFlag(); 
00381 
00382   switch(theType) {
00383   case PT_INTEGER: {
00384     if(_ints.erase(theID)) return true;
00385     break;
00386   }
00387   case PT_REAL: {
00388     if(_reals.erase(theID)) return true;
00389     break;
00390   }
00391   case PT_BOOLEAN: {
00392     if(_bools.erase(theID)) return true;
00393     break;
00394   }
00395   case PT_STRING: {
00396     if(_strings.erase(theID)) return true;
00397     break;
00398   }
00399   case PT_REALARRAY: {
00400     if(_realarrays.erase(theID)) return true;
00401     break;
00402   }
00403   case PT_INTARRAY: {
00404     if(_intarrays.erase(theID)) return true;
00405     break;
00406   }
00407   case PT_STRARRAY: {
00408     if(_strarrays.erase(theID)) return true;
00409     break;
00410   }
00411   default: return false;
00412   }
00413 
00414 
00415   return false;
00416 }
00417 
00418 
00419 //=======================================================================
00424 //=======================================================================
00425 SALOMEDSImpl_AttributeParameter* SALOMEDSImpl_AttributeParameter::GetFather()
00426 {
00427   SALOMEDSImpl_AttributeParameter* aFather;
00428   DF_Label L = Label();
00429   if(L.IsRoot()) return aFather;
00430 
00431   while(!L.IsRoot()) {
00432     L = L.Father();
00433     if((aFather=(SALOMEDSImpl_AttributeParameter*)L.FindAttribute(SALOMEDSImpl_AttributeParameter::GetID()))) break; 
00434   }
00435 
00436   return aFather;
00437 }
00438 
00439 //=======================================================================
00444 //=======================================================================
00445 bool SALOMEDSImpl_AttributeParameter::HasFather()
00446 {
00447   DF_Label L = Label();
00448   if(L.IsRoot()) return false;
00449   while(!L.IsRoot()) {
00450     L = L.Father();
00451     if(L.IsAttribute(SALOMEDSImpl_AttributeParameter::GetID())) return true; 
00452   }
00453 
00454   return false;
00455 }
00456 
00457 //=======================================================================
00462 //=======================================================================
00463 bool SALOMEDSImpl_AttributeParameter::IsRoot()
00464 {
00465   return ((HasFather())?false:true);
00466 }           
00467 
00468 //=======================================================================
00473 //=======================================================================
00474 void SALOMEDSImpl_AttributeParameter::Clear()
00475 {
00476   Backup();
00477 
00478   _ints.clear();
00479   _reals.clear();
00480   _bools.clear();
00481   _strings.clear();
00482   _realarrays.clear();
00483   _intarrays.clear();
00484   _strarrays.clear();
00485 
00486   SetModifyFlag(); 
00487 }
00488 
00489 //=======================================================================
00494 //=======================================================================
00495 std::vector<std::string> SALOMEDSImpl_AttributeParameter::GetIDs(const Parameter_Types theType)
00496 {
00497   
00498   std::vector<std::string> anArray;
00499   int i = 0;
00500 
00501   switch(theType) {
00502   case PT_INTEGER: {
00503     if(_ints.size()) {
00504       anArray.resize(_ints.size());
00505       for(std::map<std::string,int>::const_iterator p = _ints.begin(); p != _ints.end(); p++, i++) 
00506         anArray[i] =  p->first;
00507     }
00508     break;
00509   }
00510   case PT_REAL: {
00511     if(_reals.size()) {
00512       anArray.resize(_reals.size());
00513       for(std::map<std::string,double>::const_iterator p = _reals.begin(); p != _reals.end(); p++, i++) 
00514         anArray[i] = p->first;
00515     }
00516     break;
00517   }
00518   case PT_BOOLEAN: {
00519     if(_bools.size()) {
00520       anArray.resize(_bools.size());
00521       for(std::map<std::string,bool>::const_iterator p = _bools.begin(); p != _bools.end(); p++, i++) 
00522         anArray[i] = p->first;
00523     }
00524     break;
00525   }
00526   case PT_STRING: {
00527     if(_strings.size()) {
00528       anArray.resize(_strings.size());
00529       for(std::map<std::string,std::string>::const_iterator p = _strings.begin(); p!= _strings.end(); p++) 
00530         anArray[i] = p->first;
00531     }
00532     break;
00533   }
00534   case PT_REALARRAY: {
00535     if(_realarrays.size()) {
00536       anArray.resize(_realarrays.size());
00537       for(std::map< std::string, std::vector<double> >::const_iterator p = _realarrays.begin(); p!= _realarrays.end(); p++) 
00538         anArray[i] = p->first;
00539     }
00540     break;
00541   }
00542   case PT_INTARRAY: {
00543     if(_intarrays.size()) {
00544       anArray.resize(_intarrays.size());
00545       for(std::map< std::string, std::vector<int> >::const_iterator p = _intarrays.begin(); p!= _intarrays.end(); p++) 
00546         anArray[i] = p->first;
00547     }
00548     break;
00549   }
00550   case PT_STRARRAY: {
00551     if(_strarrays.size()) {
00552       anArray.resize(_strarrays.size());
00553       for(std::map< std::string, std::vector<std::string> >::const_iterator p = _strarrays.begin(); p!= _strarrays.end(); p++) 
00554         anArray[i] = p->first;
00555     }
00556     break;
00557   }
00558   default: return anArray;
00559   }
00560 
00561   return anArray;
00562 }
00563 
00564 //=======================================================================
00569 //=======================================================================
00570 const std::string& SALOMEDSImpl_AttributeParameter::ID () const { return GetID(); } 
00571 
00572 
00573 DF_Attribute* SALOMEDSImpl_AttributeParameter::NewEmpty () const
00574 {  
00575   return new SALOMEDSImpl_AttributeParameter(); 
00576 }
00577 
00578 //=======================================================================
00583 //=======================================================================
00584 void SALOMEDSImpl_AttributeParameter::Restore(DF_Attribute* with) 
00585 {
00586   SALOMEDSImpl_AttributeParameter* A = dynamic_cast<SALOMEDSImpl_AttributeParameter*>(with);
00587   _ints.clear();
00588   _reals.clear();
00589   _bools.clear();
00590   _strings.clear();
00591   _realarrays.clear();
00592   _intarrays.clear();
00593   _strarrays.clear();
00594   
00595   for(std::map<std::string,int>::const_iterator p = A->_ints.begin(); p!= A->_ints.end(); p++)
00596     if(p->first.size()) _ints[p->first] = p->second;
00597   for(std::map<std::string,double>::const_iterator p = A->_reals.begin(); p!= A->_reals.end(); p++) 
00598     if(p->first.size()) _reals[p->first] = p->second;
00599   for(std::map<std::string,bool>::const_iterator p = A->_bools.begin(); p!= A->_bools.end(); p++) 
00600     if(p->first.size()) _bools[p->first] = p->second;
00601   for(std::map<std::string,std::string>::const_iterator p = A->_strings.begin(); p!= A->_strings.end(); p++) 
00602     if(p->first.size()) _strings[p->first] = p->second;
00603   for(std::map< std::string,std::vector<double> >::const_iterator p = A->_realarrays.begin(); p!= A->_realarrays.end(); p++) 
00604     if(p->first.size()) _realarrays[p->first] = p->second;  
00605   for(std::map< std::string,std::vector<int> >::const_iterator p = A->_intarrays.begin(); p!= A->_intarrays.end(); p++) 
00606     if(p->first.size()) _intarrays[p->first] = p->second;  
00607   for(std::map< std::string,std::vector<std::string> >::const_iterator p = A->_strarrays.begin(); p!= A->_strarrays.end(); p++) 
00608     if(p->first.size()) _strarrays[p->first] = p->second; 
00609 }
00610 
00611 //=======================================================================
00616 //=======================================================================
00617 void SALOMEDSImpl_AttributeParameter::Paste (DF_Attribute* into)
00618 {
00619   into->Restore(this);
00620 }
00621 
00622 //=======================================================================
00627 //=======================================================================
00628 std::string SALOMEDSImpl_AttributeParameter::Save() 
00629 { 
00630   std::ostringstream buffer;
00631   char *tmpBuffer = new char[255];
00632 
00633   buffer << _ints.size() << " ";
00634 
00635   for(std::map<std::string,int>::const_iterator p = _ints.begin(); p != _ints.end(); p++) {
00636     buffer << convertString(p->first) << " " << p->second << " ";
00637   }
00638 
00639   buffer << _reals.size() << " ";
00640   for(std::map<std::string,double>::const_iterator p =_reals.begin(); p != _reals.end(); p++) {
00641     sprintf(tmpBuffer, "%.64e", p->second);
00642     buffer << convertString(p->first) << " " << tmpBuffer << " ";
00643   }
00644 
00645   buffer << _bools.size() << " ";
00646   for(std::map<std::string,bool>::const_iterator p = _bools.begin(); p != _bools.end(); p++) {
00647      buffer << convertString(p->first) << " " << p->second << " ";
00648   }
00649 
00650   buffer << _strings.size() << " ";
00651   for(std::map<std::string,std::string>::const_iterator p = _strings.begin(); p != _strings.end(); p++) {
00652     buffer << convertString(p->first) << " " <<  convertString(p->second) << " ";
00653   }
00654 
00655   buffer << _realarrays.size() << " ";
00656   for(std::map< std::string,std::vector<double> >::const_iterator p = _realarrays.begin(); p != _realarrays.end(); p++) {
00657     std::vector<double> v(p->second);
00658     sprintf(tmpBuffer, " %s %d ", convertString(p->first).c_str(), v.size());
00659     buffer << tmpBuffer;
00660     for(int i = 0; i<v.size(); i++) {
00661       sprintf(tmpBuffer, " %.64e ", v[i]);
00662       buffer << tmpBuffer;
00663     }
00664   }
00665 
00666   buffer << _intarrays.size() << " ";
00667   for(std::map< std::string,std::vector<int> >::const_iterator p = _intarrays.begin(); p != _intarrays.end(); p++) {
00668     std::vector<int> v(p->second);
00669     sprintf(tmpBuffer, " %s %d ", convertString(p->first).c_str(), v.size());
00670     buffer << tmpBuffer;
00671     for(int i = 0; i<v.size(); i++) {
00672       sprintf(tmpBuffer, " %d ", v[i]);
00673       buffer << tmpBuffer;
00674     }
00675   }
00676 
00677   buffer << _strarrays.size() << " ";
00678   for(std::map< std::string,std::vector<std::string> >::const_iterator p = _strarrays.begin(); p != _strarrays.end(); p++) {
00679     std::vector<std::string> v(p->second);
00680     sprintf(tmpBuffer, " %s %d ", convertString(p->first).c_str(), v.size());
00681     buffer << tmpBuffer;
00682     for(int i = 0; i<v.size(); i++) {
00683       buffer << " " << convertString(v[i]) << " ";
00684     }
00685   }
00686 
00687   delete tmpBuffer;
00688 
00689   std::string AS = buffer.str();
00690 
00691   return AS; 
00692 }
00693 
00694 //=======================================================================
00699 //=======================================================================
00700 void SALOMEDSImpl_AttributeParameter::Load(const std::string& theValue) 
00701 { 
00702   Backup();
00703 
00704   _ints.clear();
00705   _reals.clear();
00706   _bools.clear();
00707   _strings.clear();
00708   _realarrays.clear();
00709   _intarrays.clear();
00710 
00711   std::istringstream buffer(theValue.c_str());
00712 
00713   int size, val, ival;
00714   double val2;
00715   std::string s, id;
00716 
00717   buffer >> size;
00718   for(int i = 1; i<=size; i++) {
00719     buffer >> id >> val;
00720     _ints[restoreString(id)] = val;
00721   }
00722 
00723   buffer >> size;
00724   for(int i = 1; i<=size; i++) {
00725     buffer >> id >> val2;
00726     _reals[restoreString(id)] = val2;
00727   }
00728 
00729   buffer >> size;
00730   for(int i = 1; i<=size; i++) {
00731     buffer >> id >> val;
00732     _bools[restoreString(id)] = val;
00733   }
00734 
00735   buffer >> size;
00736   for(int i = 1; i<=size; i++) {
00737     buffer >> id >> s;
00738     _strings[restoreString(id)] = restoreString(s);
00739   }
00740   
00741   buffer >> size;
00742   for(int i = 1; i<=size; i++) {
00743     buffer >> id >> val;
00744     std::vector<double> v;
00745     v.resize(val);
00746     for(int j = 0; j<val; j++) {
00747       buffer >> val2;
00748       v[j] = val2;
00749     }
00750     _realarrays[restoreString(id)] = v;
00751   }
00752 
00753   buffer >> size;
00754   for(int i = 1; i<=size; i++) {
00755     buffer >> id >> val;
00756     std::vector<int> v;
00757     v.resize(val);
00758     for(int j = 0; j<val; j++) {
00759       buffer >> ival;
00760       v[j] = ival;
00761     }
00762     _intarrays[restoreString(id)] = v;
00763   }
00764   
00765   buffer >> size;
00766   for(int i = 1; i<=size; i++) {
00767     buffer >> id >> val;
00768     std::vector<std::string> v;
00769     v.resize(val);
00770     for(int j = 0; j<val; j++) {
00771       buffer >> s;
00772       v[j] = restoreString(s);
00773     }
00774     _strarrays[restoreString(id)] = v;
00775   }
00776 }