]> SALOME platform Git repositories - modules/med.git/blob - src/MEDLoader/MEDLoaderBase.cxx
Salome HOME
Windows porting on swig2.0.9
[modules/med.git] / src / MEDLoader / MEDLoaderBase.cxx
1 // Copyright (C) 2007-2013  CEA/DEN, EDF R&D
2 //
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Lesser General Public
5 // License as published by the Free Software Foundation; either
6 // version 2.1 of the License.
7 //
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11 // Lesser General Public License for more details.
12 //
13 // You should have received a copy of the GNU Lesser General Public
14 // License along with this library; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
16 //
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
18 //
19 // Author : Anthony Geay (CEA/DEN)
20
21 #include "MEDLoaderBase.hxx"
22 #include "InterpKernelException.hxx"
23
24 #include <sstream>
25 #include <fstream>
26 #include <cstring>
27 #include <iostream>
28
29 const char MEDLoaderBase::WHITE_SPACES[]=" \n";
30
31 int MEDLoaderBase::getStatusOfFile(const char *fileName)
32 {
33   std::ifstream ifs;
34   ifs.open(fileName);
35   if((ifs.rdstate() & std::ifstream::failbit)!=0)
36     {
37       ifs.close();
38       return NOT_EXIST;
39     }
40   std::ofstream ofs(fileName,std::ios_base::app);
41   if((ofs.rdstate() & std::ofstream::failbit)!=0)
42     {
43       return EXIST_RDONLY;
44     }
45   return EXIST_RW;
46 }
47
48 char *MEDLoaderBase::buildEmptyString(int lgth)
49 {
50   char *ret=new char[lgth+1];
51   std::fill(ret,ret+lgth,' ');
52   ret[lgth]='\0';
53   return ret;
54 }
55
56 void MEDLoaderBase::getDirAndBaseName(const std::string& fullName, std::string& dirName, std::string& baseName) throw(INTERP_KERNEL::Exception)
57 {
58   std::size_t pos=fullName.find_last_of(getPathSep());
59   if(pos!=std::string::npos)
60     {
61       dirName=fullName.substr(0,pos);
62       baseName=fullName.substr(pos+1);
63     }
64   else
65     {
66       dirName.clear();
67       baseName=fullName;
68     }
69 }
70
71 std::string MEDLoaderBase::joinPath(const std::string& dirName, const std::string& baseName) throw(INTERP_KERNEL::Exception)
72 {
73   if(!dirName.empty())
74     return dirName+getPathSep()+baseName;
75   else
76     return baseName;
77 }
78
79 std::string MEDLoaderBase::getPathSep() throw(INTERP_KERNEL::Exception)
80 {
81 #ifndef WIN32
82   return std::string("/");
83 #else
84   return std::string("\\");
85 #endif
86 }
87
88 std::string MEDLoaderBase::buildUnionUnit(const char *name, int nameLgth, const char *unit, int unitLgth)
89 {
90   std::string ret(buildStringFromFortran(name,nameLgth));
91   std::string unitCpp(buildStringFromFortran(unit,unitLgth));
92   if(unitCpp[0]=='\0')
93     return ret;
94   ret+=" [";
95   ret+=unitCpp;
96   ret+="]";
97   return ret;
98 }
99
100 void MEDLoaderBase::splitIntoNameAndUnit(const std::string& s, std::string& name, std::string& unit)
101 {
102   std::string::size_type f1=s.find_first_of('[');
103   std::string::size_type f2=s.find_last_of(']');
104   if(f1!=std::string::npos && f2!=std::string::npos)
105     {
106       if(f1<f2)
107         {
108           name=s.substr(0,f1);
109           unit=s.substr(f1+1,f2-f1-1);
110           strip(name);
111           strip(unit);
112           return;
113         }
114     }
115   name=s;
116   unit="";
117 }
118
119 void MEDLoaderBase::strip(std::string& s)
120 {
121   std::string::size_type f1=s.find_first_not_of(' ');
122   if(f1==std::string::npos)
123     {
124       s="";
125       return ;
126     }
127   std::string::size_type f2=s.find_last_not_of(' ');
128   s=s.substr(f1,f2-f1+1);
129 }
130
131 /*!
132  * This method operates a safe copy from 'src' to 'dest' by checking the size of 'src' before trying to copy.
133  * If size of 'src' string is higher than 'maxLgth' the behaviour is dependant from 'behaviour' parameter.
134  * If 'behaviour' equals 0 an exception is thrown. If 'behaviour' equals 1 an attempt of zipping of string will be done
135  * ( see zipString to have more details).
136  */
137 void MEDLoaderBase::safeStrCpy(const char *src, int maxLgth, char *dest, int behaviour) throw(INTERP_KERNEL::Exception)
138 {
139   if((int)strlen(src)>maxLgth)
140     {
141       if(behaviour==0 || behaviour>1)
142         {
143           std::ostringstream oss; oss << "A string : \"" << src << "\" has been detected to be too long for MED File ( > " << maxLgth << ") !";
144           throw INTERP_KERNEL::Exception(oss.str().c_str());
145         }
146       else if(behaviour==1)
147         {
148           std::string s=zipString(src,maxLgth);
149           std::cerr << "A string : \"" << src << "\" has been detected to be too long for MED File ( > " << maxLgth << ") : ";
150           std::cerr << "zipping to : " << s << "\n";
151           strcpy(dest,s.c_str());
152           return ;
153         }
154     }
155   strcpy(dest,src);
156 }
157
158 /*!
159  * This method is equivalent to MEDLoaderBase::safeStrCpy except that here no '\0' car is put.
160  * This method should be used for multi string in one string.
161  */
162 void MEDLoaderBase::safeStrCpy2(const char *src, int maxLgth, char *dest, int behaviour) throw(INTERP_KERNEL::Exception)
163 {
164   if((int)strlen(src)>maxLgth)
165     {
166       if(behaviour==0 || behaviour>1)
167         {
168           std::ostringstream oss; oss << "A string : \"" << src << "\" has been detected to be too long for MED File ( > " << maxLgth << ") !";
169           throw INTERP_KERNEL::Exception(oss.str().c_str());
170         }
171       else if(behaviour==1)
172         {
173           std::string s=zipString(src,maxLgth);
174           std::cerr << "A string : \"" << src << "\" has been detected to be too long for MED File ( > " << maxLgth << ") : ";
175           std::cerr << "zipping to : " << s << "\n";
176           strcpy(dest,s.c_str());
177           return ;
178         }
179     }
180   int n=strlen(src);
181   strncpy(dest,src,n);
182 }
183
184 std::string MEDLoaderBase::buildStringFromFortran(const char *expr, int lgth)
185 {
186   std::string ret(expr,lgth);
187   std::string whiteSpaces(WHITE_SPACES);
188   std::size_t lgthReal=strlen(ret.c_str());
189   std::string ret2=ret.substr(0,lgthReal);
190   std::size_t found=ret2.find_last_not_of(whiteSpaces);
191   if (found!=std::string::npos)
192     ret2.erase(found+1);
193   else
194     ret2.clear();//ret is all whitespace
195   return ret2;
196 }
197
198 /*!
199  * This method given the target size to respect 'sizeToRespect' tries to reduce size of 'src' string.
200  * This method uses several soft methods to do its job. But if it fails a simple cut of string will be performed.
201  */
202 std::string MEDLoaderBase::zipString(const char *src, int sizeToRespect)
203 {
204   std::string s(src);
205   strip(s);
206   if((int)s.length()<=sizeToRespect)
207     return s;
208   s=src;
209   zipEqualConsChar(s,3);
210   if((int)s.length()<=sizeToRespect)
211     return s;
212   s=src;
213   zipEqualConsChar(s,2);
214   if((int)s.length()<=sizeToRespect)
215     return s;
216   s=src;
217   return s.substr(0,sizeToRespect);
218 }
219
220 /*!
221  * This method see if there is in 's' more than 'minConsSmChar' consecutive same character.
222  * If yes, the group will be zipped using only one character for this group.
223  * If no such group is found, s remains unchanged.
224  */
225 void MEDLoaderBase::zipEqualConsChar(std::string& s, int minConsSmChar)
226 {
227   for(std::string::iterator it=s.begin();it!=s.end();it++)
228     {
229       char tmp=*it;
230       int sz=1;
231       for(std::string::iterator it2=it+1;it2!=s.end() && *it2==tmp;it2++)
232         sz++;
233       if(sz>=minConsSmChar)
234         s.erase(it+1,it+sz);
235     }
236 }
237