00001 /* 00002 * Copyright 1999-2004 The Apache Software Foundation. 00003 * 00004 * Licensed under the Apache License, Version 2.0 (the "License"); 00005 * you may not use this file except in compliance with the License. 00006 * You may obtain a copy of the License at 00007 * 00008 * http://www.apache.org/licenses/LICENSE-2.0 00009 * 00010 * Unless required by applicable law or agreed to in writing, software 00011 * distributed under the License is distributed on an "AS IS" BASIS, 00012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 00013 * See the License for the specific language governing permissions and 00014 * limitations under the License. 00015 */ 00016 #if !defined(DIRECTORY_ENUMERATOR_HEADER_GUARD_1357924680) 00017 #define DIRECTORY_ENUMERATOR_HEADER_GUARD_1357924680 00018 00019 00020 00021 // Base header file. Must be first. 00022 #include <xalanc/PlatformSupport/PlatformSupportDefinitions.hpp> 00023 00024 00025 00026 #if defined(_MSC_VER) 00027 #include <io.h> 00028 #else 00029 #include <unistd.h> 00030 #include <dirent.h> 00031 #include <sys/stat.h> 00032 #include <errno.h> 00033 00034 extern int errno; 00035 00036 #endif 00037 00038 00039 00040 #include <functional> 00041 #include <iterator> 00042 00043 00044 #include <xalanc/PlatformSupport/XalanFileOutputStream.hpp> 00045 #include <xalanc/PlatformSupport/DOMStringHelper.hpp> 00046 #include <xalanc/PlatformSupport/XalanUnicode.hpp> 00047 00048 00049 00050 XALAN_CPP_NAMESPACE_BEGIN 00051 00052 00053 00054 #if defined(_MSC_VER) 00055 00056 struct FindFileStruct : public _wfinddata_t 00057 { 00058 00059 enum eAttributes 00060 { 00061 eAttributeArchive = _A_ARCH, 00062 eAttributeDirectory = _A_SUBDIR, 00063 eAttributeHidden = _A_HIDDEN, 00064 eAttributeNormal = _A_NORMAL, 00065 eReadOnly = _A_RDONLY, 00066 eSystem = _A_SYSTEM 00067 }; 00068 00069 public: 00070 00076 const XalanDOMChar* 00077 getName() const 00078 { 00079 return name; 00080 } 00081 00087 bool 00088 isDirectory() const 00089 { 00090 return attrib & eAttributeDirectory ? true : false; 00091 } 00092 00093 bool 00094 isSelfOrParent() const 00095 { 00096 if (isDirectory() == false) 00097 { 00098 return false; 00099 } 00100 else if (name[0] == '.') 00101 { 00102 if (name[1] == '\0') 00103 { 00104 return true; 00105 } 00106 else if (name[1] == '.' && 00107 name[2] == '\0') 00108 { 00109 return true; 00110 } 00111 else 00112 { 00113 return false; 00114 } 00115 } 00116 else 00117 { 00118 return false; 00119 } 00120 } 00121 }; 00122 00123 #else 00124 00125 struct FindFileStruct : public dirent 00126 { 00127 public: 00128 00134 const char* getName() const 00135 { 00136 return d_name; 00137 } 00138 00144 bool isDirectory() const 00145 { 00146 00147 struct stat stat_Info; 00148 int retCode = stat (d_name, &stat_Info); 00149 00150 if ( retCode == -1 ) 00151 { 00152 XalanDOMString theBuffer(XalanMemMgrs::getDefaultXercesMemMgr()); 00153 typedef XalanFileOutputStream::XalanFileOutputStreamOpenException XalanStatDirectoryException; 00154 throw XalanStatDirectoryException( XalanDOMString(d_name, XalanMemMgrs::getDefaultXercesMemMgr()), errno , theBuffer); 00155 } 00156 00157 return S_ISDIR(stat_Info.st_mode); 00158 00159 } 00160 00161 bool 00162 isSelfOrParent() const 00163 { 00164 if (isDirectory() == false) 00165 { 00166 return false; 00167 } 00168 else if (d_name[0] == '.') 00169 { 00170 if (d_name[1] == '\0') 00171 { 00172 return true; 00173 } 00174 else if (d_name[1] == '.' && 00175 d_name[2] == '\0') 00176 { 00177 return true; 00178 } 00179 else 00180 { 00181 return false; 00182 } 00183 } 00184 else 00185 { 00186 return false; 00187 } 00188 } 00189 }; 00190 00191 #endif 00192 00193 00194 00195 #if defined(XALAN_NO_STD_NAMESPACE) 00196 struct DirectoryFilterPredicate : public unary_function<FindFileStruct, bool> 00197 #else 00198 struct DirectoryFilterPredicate : public std::unary_function<FindFileStruct, bool> 00199 #endif 00200 { 00201 result_type 00202 operator()(const argument_type& theFindData) const 00203 { 00204 return theFindData.isDirectory(); 00205 } 00206 }; 00207 00208 00209 00210 #if defined(XALAN_NO_STD_NAMESPACE) 00211 struct FilesOnlyFilterPredicate : public unary_function<FindFileStruct, bool> 00212 #else 00213 struct FilesOnlyFilterPredicate : public std::unary_function<FindFileStruct, bool> 00214 #endif 00215 { 00216 result_type 00217 operator()(const argument_type& theFindData) const 00218 { 00219 DirectoryFilterPredicate theDirectoryPredicate; 00220 00221 return !theDirectoryPredicate(theFindData); 00222 00223 } 00224 }; 00225 00226 00227 00228 template<class OutputIteratorType, 00229 class FilterPredicateType, 00230 class StringType, 00231 class StringConversionFunction> 00232 void 00233 EnumerateDirectory( 00234 const StringType& theFullSearchSpec, 00235 OutputIteratorType theOutputIterator, 00236 FilterPredicateType theFilterPredicate, 00237 StringConversionFunction theConversionFunction, 00238 #if defined(XALAN_TEMPLATE_FUNCTION_NO_DEFAULT_PARAMETERS) 00239 bool fIncludeSelfAndParent) 00240 #else 00241 bool fIncludeSelfAndParent = false) 00242 #endif 00243 { 00244 MemoryManagerType& theManager = XalanMemMgrs::getDefaultXercesMemMgr(); 00245 #if defined(_MSC_VER) 00246 FindFileStruct theFindData; 00247 00248 #ifdef _WIN64 00249 typedef intptr_t theHandleType; 00250 #else 00251 typedef long theHandleType; 00252 #endif 00253 00254 #pragma warning(push) 00255 #pragma warning(disable: 4244) 00256 theHandleType theSearchHandle = _wfindfirst(const_cast<wchar_t*>(theConversionFunction(theFullSearchSpec)), 00257 &theFindData); 00258 #pragma warning(pop) 00259 00260 if (theSearchHandle != -1) 00261 { 00262 00263 try 00264 { 00265 do 00266 { 00267 if ((fIncludeSelfAndParent == true || theFindData.isSelfOrParent() == false) && 00268 theFilterPredicate(theFindData) == true) 00269 { 00270 *theOutputIterator = StringType(theFindData.getName(), theManager); 00271 } 00272 } 00273 while(_wfindnext(theSearchHandle, 00274 &theFindData) == 0); 00275 } 00276 catch(...) 00277 { 00278 _findclose(theSearchHandle); 00279 00280 throw; 00281 } 00282 00283 _findclose(theSearchHandle); 00284 } 00285 00286 00287 #else 00288 00289 CharVectorType theTargetVector(theManager); 00290 00291 TranscodeToLocalCodePage(theFullSearchSpec, theTargetVector, false); 00292 00293 const CharVectorType::size_type theSize = theTargetVector.size(); 00294 int indexSuffix=0, indexName=0; 00295 bool target_Dir = false; 00296 00297 if (theSize > 0) 00298 { 00299 if (theTargetVector.back() == '*') 00300 { 00301 target_Dir = true; 00302 theTargetVector.pop_back(); 00303 00304 if (theSize == 1) 00305 { 00306 theTargetVector.push_back('.'); 00307 } 00308 00309 } 00310 else 00311 { 00312 target_Dir = false; 00313 00314 while(theTargetVector.back() != '*') 00315 { 00316 theTargetVector.pop_back(); 00317 indexSuffix++; 00318 } 00319 00320 theTargetVector.pop_back(); 00321 while(theTargetVector.back() != '/') 00322 { 00323 theTargetVector.pop_back(); 00324 indexName++; 00325 } 00326 } 00327 00328 theTargetVector.push_back('\0'); 00329 00330 const char* const theSpec = c_str(theTargetVector); 00331 assert(theSpec != 0); 00332 00333 XalanDOMString theName(theManager); 00334 XalanDOMString theSuffix(theManager); 00335 if ( !target_Dir ) 00336 { 00337 #if defined(XALAN_STRICT_ANSI_HEADERS) 00338 using std::strlen; 00339 #endif 00340 00341 int lenSpec = strlen(theSpec); 00342 theFullSearchSpec.substr(theName, lenSpec, indexName); 00343 theFullSearchSpec.substr(theSuffix, lenSpec+indexName+1, indexSuffix); 00344 } 00345 00346 DIR* const theDirectory = opendir(theSpec); 00347 00348 if (theDirectory != 0) 00349 { 00350 chdir(theSpec); 00351 try 00352 { 00353 const FindFileStruct* theEntry = 00354 (FindFileStruct*)readdir(theDirectory); 00355 00356 while(theEntry != 0) 00357 { 00358 if ((fIncludeSelfAndParent == true || theEntry->isSelfOrParent() == false)) 00359 { 00360 if (theFilterPredicate(*theEntry) == true) 00361 { 00362 if( target_Dir ) 00363 { 00364 *theOutputIterator = StringType(theEntry->getName(), theManager); 00365 } 00366 else 00367 { 00368 XalanDOMString Getname(theEntry->getName(), theManager); 00369 int Check_1 = Getname.compare(theName); 00370 XalanDOMString GetnameSuffix(theManager); 00371 Getname.substr(GetnameSuffix, Getname.size() -indexSuffix, indexSuffix); 00372 int Check_2 = GetnameSuffix.compare(theSuffix); 00373 if ( Check_1 == 1 && (!Check_2) ) 00374 { 00375 *theOutputIterator = StringType(theEntry->getName(), theManager); 00376 } 00377 } 00378 } 00379 } 00380 theEntry = (FindFileStruct*)readdir(theDirectory); 00381 } //while 00382 }//try 00383 00384 catch(...) 00385 { 00386 closedir(theDirectory); 00387 00388 throw; 00389 } 00390 if( target_Dir ) 00391 chdir(".."); 00392 else 00393 chdir("../.."); 00394 closedir(theDirectory); 00395 } 00396 } 00397 00398 #endif 00399 } 00400 00401 00402 00403 template<class OutputIteratorType, 00404 class FilterPredicateType, 00405 class StringType, 00406 class StringConversionFunction> 00407 void 00408 EnumerateDirectory( 00409 const StringType& theDirectory, 00410 const StringType& theSearchSpec, 00411 OutputIteratorType theOutputIterator, 00412 FilterPredicateType theFilterPredicate, 00413 StringConversionFunction theConversionFunction, 00414 #if defined(XALAN_TEMPLATE_FUNCTION_NO_DEFAULT_PARAMETERS) 00415 bool fIncludeSelfAndParent) 00416 #else 00417 bool fIncludeSelfAndParent = false) 00418 #endif 00419 { 00420 MemoryManagerType& theManager = XalanMemMgrs::getDefaultXercesMemMgr(); 00421 00422 StringType theFullSearchSpec(theDirectory, theManager); 00423 00424 theFullSearchSpec += theSearchSpec; 00425 00426 EnumerateDirectory(theFullSearchSpec, theOutputIterator, theFilterPredicate, theConversionFunction, fIncludeSelfAndParent); 00427 } 00428 00429 00430 00431 #if defined(XALAN_NO_DEFAULT_TEMPLATE_ARGUMENTS) 00432 template<class CollectionType, class StringType> 00433 struct DirectoryEnumeratorFunctor 00434 { 00435 CollectionType 00436 operator()(const StringType& theDirectory) const 00437 { 00438 CollectionType theCollection; 00439 00440 operator()(theDirectory, 00441 theCollection); 00442 00443 return theCollection; 00444 } 00445 00446 void 00447 operator()( 00448 const StringType&, 00449 const CollectionType&) const 00450 { 00451 } 00452 }; 00453 #else 00454 template<class CollectionType, 00455 class StringType = XalanDOMString, 00456 class FilterPredicateType = FilesOnlyFilterPredicate, 00457 class StringConversionFunction = c_wstr_functor> 00458 #if defined(XALAN_NO_STD_NAMESPACE) 00459 struct DirectoryEnumeratorFunctor : public unary_function<StringType, CollectionType> 00460 #else 00461 struct DirectoryEnumeratorFunctor : public std::unary_function<StringType, CollectionType> 00462 #endif 00463 { 00464 #if defined(XALAN_NO_STD_NAMESPACE) 00465 typedef unary_function<StringType, CollectionType> BaseClassType; 00466 #else 00467 typedef std::unary_function<StringType, CollectionType> BaseClassType; 00468 #endif 00469 00470 typedef typename BaseClassType::result_type result_type; 00471 typedef typename BaseClassType::argument_type argument_type; 00472 00473 explicit 00474 DirectoryEnumeratorFunctor(bool fIncludeSelfAndParent = false) : 00475 m_includeSelfAndParent(fIncludeSelfAndParent) 00476 { 00477 } 00478 00479 void 00480 operator()( 00481 const argument_type& theFullSearchSpec, 00482 CollectionType& theCollection) const 00483 { 00484 XALAN_USING_STD(back_inserter) 00485 00486 EnumerateDirectory( 00487 theFullSearchSpec, 00488 XALAN_STD_QUALIFIER back_inserter(theCollection), 00489 m_filterPredicate, 00490 m_conversionFunction, 00491 m_includeSelfAndParent); 00492 } 00493 00494 result_type 00495 operator()(const argument_type& theFullSearchSpec) const 00496 { 00497 result_type theCollection; 00498 00499 operator()( 00500 theFullSearchSpec, 00501 theCollection); 00502 00503 return theCollection; 00504 } 00505 00506 void 00507 operator()( 00508 const argument_type& theDirectory, 00509 const argument_type& theSearchSpec, 00510 CollectionType& theCollection) const 00511 { 00512 EnumerateDirectory( 00513 theDirectory, 00514 theSearchSpec, 00515 XALAN_STD_QUALIFIER back_inserter(theCollection), 00516 m_filterPredicate, 00517 m_conversionFunction, 00518 m_includeSelfAndParent); 00519 } 00520 00521 result_type 00522 operator()( 00523 const argument_type& theDirectory, 00524 const argument_type& theSearchSpec) const 00525 { 00526 result_type theCollection; 00527 00528 operator()( 00529 theDirectory, 00530 theSearchSpec, 00531 theCollection); 00532 00533 return theCollection; 00534 } 00535 00536 private: 00537 00538 FilterPredicateType m_filterPredicate; 00539 00540 StringConversionFunction m_conversionFunction; 00541 00542 const bool m_includeSelfAndParent; 00543 }; 00544 #endif 00545 00546 00547 00548 XALAN_CPP_NAMESPACE_END 00549 00550 00551 00552 #endif // DIRECTORY_ENUMERATOR_HEADER_GUARD_1357924680
Doxygen and GraphViz are used to generate this API documentation from the Xalan-C header files.
![]() |
Xalan-C++ XSLT Processor Version 1.9 |
|