diff -r f5050f1da672 -r 04becd199f91 javacommons/fileutils/src/fileutilities.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/javacommons/fileutils/src/fileutilities.cpp Tue Apr 27 16:30:29 2010 +0300 @@ -0,0 +1,356 @@ +/* +* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Contains implementation of FileUtilities + * +*/ + + +#include +#include +#include +#include +#include + +#include "logger.h" +#include "javaoslayer.h" +#include "javacommonutils.h" +#include "fileutilities.h" + +using namespace java::fileutils; +using namespace java::util; + +OS_EXPORT bool FileUtilities::isFile(const std::wstring& aPath) +{ + JELOG2(EJavaFile); + char* utf8Name = JavaCommonUtils::wstringToUtf8(aPath); + struct stat fileStat; + int error = lstat(utf8Name, &fileStat); + + bool retValue = false; + + // If there was no error, then go ahead and retrieve the data out of struct. + if (0 == error) + { + mode_t mode = fileStat.st_mode; + + if (S_ISREG(mode)) + { // If it is regular file, return true. + retValue = true; + } + } + else + { + LOG1(EJavaFile, EInfo, + "FileUtilities::isFile: Unable to stat file: %s", utf8Name); + } + + // Deallocate utf8 name + delete[] utf8Name; + return retValue; +} + +OS_EXPORT bool FileUtilities::isDirectory(const std::wstring& aPath) +{ + JELOG2(EJavaFile); + char* utf8Name = JavaCommonUtils::wstringToUtf8(aPath); + struct stat fileStat; + int error = lstat(utf8Name, &fileStat); + bool retValue = false; + + // If there was no error, then go ahead and retrieve the data out of struct. + if (0 == error) + { + mode_t mode = fileStat.st_mode; + + if (S_ISDIR(mode)) + { + // If it is directory, return true. + retValue = true; + } + } + else + { + LOG1(EJavaFile, EInfo, + "FileUtilities::isDirectory: Unable to stat file: %s", utf8Name); + } + + // Deallocate utf8 name + delete[] utf8Name; + return retValue; +} + +OS_EXPORT bool FileUtilities::exists(const std::wstring& aPath) +{ + JELOG2(EJavaFile); + char* utf8Name = JavaCommonUtils::wstringToUtf8(aPath); + bool retValue = false; + + struct stat fileStat; + + // We try to stat the file, if it succeeds, then we can say it exists. + // When we try to stat, the file is not opened. So, even if access restrictions + // are present, we can still know if it exists. + int error = lstat(utf8Name, &fileStat); + if (0 == error) + { + retValue = true; + } + else + { + LOG1(EJavaFile, EInfo, "FileUtilities::exists: Unable to stat file %s", + utf8Name); + } + + delete[] utf8Name; + return retValue; +} + +OS_EXPORT bool FileUtilities::canRead(const std::wstring& aPath) +{ + JELOG2(EJavaFile); + char* utf8Name = JavaCommonUtils::wstringToUtf8(aPath); + bool retValue = false; + + struct stat fileStat; + int error = lstat(utf8Name, &fileStat); + + if (0 == error) + { + mode_t curMode = fileStat.st_mode; + + if (curMode & (S_IRUSR)) + { + retValue = true; + } + } + else + { + LOG1(EJavaFile, EInfo, + "FileUtilities::canRead: Unable to check access for %s", + utf8Name); + } + + delete[] utf8Name; + return retValue; +} + +OS_EXPORT bool FileUtilities::canWrite(const std::wstring& aPath) +{ + JELOG2(EJavaFile); + char* utf8Name = JavaCommonUtils::wstringToUtf8(aPath); + bool retValue = false; + + struct stat fileStat; + int error = lstat(utf8Name, &fileStat); + + if (0 == error) + { + mode_t curMode = fileStat.st_mode; + + if (curMode & (S_IWUSR)) + { + retValue = true; + } + } + else + { + LOG2( + EJavaFile, + EInfo, + "FileUtilities::canWrite: Unable to check access for %s: Error: %d", + utf8Name, errno); + } + + delete[] utf8Name; + return retValue; +} + +OS_EXPORT long FileUtilities::fileSize(const std::wstring& aPath) +{ + JELOG2(EJavaFile); + char* utf8Name = JavaCommonUtils::wstringToUtf8(aPath); + + struct stat fileStat; + int error = lstat(utf8Name, &fileStat); + + long retValue = 0; + if (0 == error) + { + retValue = fileStat.st_size; + } + else + { + ELOG2(EJavaFile, + "FileUtilities::fileSize: Unable to stat file %s: errno: ", + utf8Name, errno); + + delete[] utf8Name; + int error = errno; + throw error; + } + + delete[] utf8Name; + return retValue; +} + +OS_EXPORT long FileUtilities::lastModified(const std::wstring& aPath) +{ + JELOG2(EJavaFile); + char* utf8Name = JavaCommonUtils::wstringToUtf8(aPath); + + struct stat fileStat; + int error = lstat(utf8Name, &fileStat); + + long retValue = 0; + if (0 == error) + { + retValue = fileStat.st_mtime; + } + else + { + ELOG2( + EJavaFile, + "FileUtilities::lastModified: Error stating file. return = 0 %s: errno: ", + utf8Name, errno); + retValue = 0; + } + + delete[] utf8Name; + return retValue; +} + +OS_EXPORT long FileUtilities::getDirSize(const std::wstring& origDirName, + const bool includeSubDirs) +{ + JELOG2(EJavaFile); + + long totalSize = 0; + char* multiByteDirName = java::util::JavaCommonUtils::wstringToUtf8( + origDirName); + std::string dirName(multiByteDirName); + std::stack subDirs; + subDirs.push(dirName); + + while (!subDirs.empty()) + { + //while stack not empty, keep stating files + dirName = subDirs.top(); + subDirs.pop(); + DIR* wDirHandle = opendir(dirName.c_str()); + if (wDirHandle) + { + struct dirent* dir = readdir(wDirHandle); + while (dir) + { + //dirName = subDirs.top(); + std::string name(dirName); + name += "/"; + name += std::string(dir->d_name); + + LOG1(EJavaFile, EInfo, + " FileUtilities::getDirSize(): Stating %s", + name.c_str()); + struct stat buf; + if (stat(name.c_str(), &buf) == 0) + { + totalSize += buf.st_size; + + if (includeSubDirs && S_ISDIR(buf.st_mode)) + { + //if it is directory, put it onto stack + subDirs.push(name); + } + } + dir = readdir(wDirHandle); + } + closedir(wDirHandle); + } + } + + delete[] multiByteDirName; //JavaCommonUtils Allocates Memory + return totalSize; +} + +OS_EXPORT std::list FileUtilities::getDirContentsList(const std::wstring& dirName) +{ + JELOG2(EJavaFile); + std::list contentList; + std::wstring stringContents = getDirContents(dirName); + + wchar_t* delim = L"*"; + wchar_t* last; + wchar_t* tok; + wchar_t* stringToTokenize = new wchar_t[ stringContents.length()+1 ]; + wcscpy(stringToTokenize, stringContents.c_str()); + + for (tok = wcstok(stringToTokenize,delim,&last); tok!=NULL; + tok = wcstok(NULL, delim, &last)) + { + LOG1(EJavaFile, EInfo, " FileUtilities::getDirContentsList(): Adding %S", tok); + contentList.push_back(std::wstring(tok)); + } + + delete[] stringToTokenize; + return contentList; +} + +OS_EXPORT int FileUtilities::makeDirAll(const std::wstring& aDirPath) +{ + JELOG2(EJavaFile); + bool ableToOpen = true; + std::wstring path; + wchar_t *last, *tok, *delim =L"/" ; + wchar_t *stringToTokenize = new wchar_t[aDirPath.length()+ 1]; + wcscpy(stringToTokenize, aDirPath.c_str()); + + for (tok = wcstok(stringToTokenize,delim,&last); tok!=NULL; + tok = wcstok(NULL, delim, &last)) + { + path += std::wstring(tok); + path += L"/"; + char *dirName = JavaCommonUtils::wstringToUtf8(path); + if (ableToOpen) + { + if (!opendir(dirName)) + { + ableToOpen = false; + if (mkdir(dirName,0666)<0) + { + WLOG1(EJavaFile,"FileUtilities::makeDirAll: Directory Creation Failed : %s",dirName); + delete[] dirName; + delete[] stringToTokenize; + return -1; + } + } + } + else + { + if (mkdir(dirName,0666)<0) + { + ELOG1(EJavaFile, "FileUtilities::makeDirAll: Directory Creation Failed : %s",dirName); + delete[] dirName; + delete[] stringToTokenize; + return -1; + } + } + delete[] dirName; + } + delete[] stringToTokenize; + return 0; +} + +OS_EXPORT std::wstring FileUtilities::getDirContents(const std::wstring& aDirName) +{ + return getDirContents(aDirName, true); +}