KDint xmBadaStat ( const KDchar* path, struct stat* buf )
{
struct tm t;
FileAttributes attr;
DateTime dt;
result r;
r = File::GetAttributes ( path, attr );
if ( IsFailed ( r ) )
{
goto failed;
}
dt = attr.GetLastModifiedTime ( );
t.tm_year = dt.GetYear ( );
t.tm_mon = dt.GetMonth ( ) - 1;
t.tm_mday = dt.GetDay ( );
t.tm_hour = dt.GetHour ( );
t.tm_min = dt.GetMinute ( );
t.tm_sec = dt.GetSecond ( );
buf->st_mtime = mktime ( &t );
buf->st_mode = attr.IsDirectory ( ) ? 0x4000 : 0x8000;
buf->st_size = attr.GetFileSize ( );
return 0;
failed :
xmBadaSetError ( r );
return -1;
}
bool SimpleCache::GetFileForIndex(int index, ByteBuffer & data) {
String filePath;
BuildPathForFileInCache(index, filePath);
if (!File::IsFileExist(filePath)) {
return false;
}
AppLog("Reading data from cached file at %S", filePath.GetPointer());
File cachedFile;
cachedFile.Construct(filePath, L"r+");
if (IsFailed(GetLastResult())) {
AppLog("Error opening destination file in cache");
return false;
}
FileAttributes fAttributes;
File::GetAttributes(filePath, fAttributes);
data.Construct(fAttributes.GetFileSize());
cachedFile.Read(data);
AppLog("Read cache: %d bytes", data.GetCapacity());
if (IsFailed(GetLastResult())) {
AppLog("Error reading from cached file");
return false;
}
return true;
}
KDint xmBadaRename ( const KDchar* _old, const KDchar* _new )
{
FileAttributes attr;
result r;
r = File::GetAttributes ( _old, attr );
if ( IsFailed ( r ) )
{
goto failed;
}
if ( attr.IsDirectory ( ) )
{
r = Directory::Rename ( _old, _new );
}
else
{
r = File::Move ( _old, _new );
}
if ( IsFailed ( r ) )
{
goto failed;
}
return 0;
failed :
xmBadaSetError ( r );
return -1;
}
/**
adds a mnemonic tag associated with an unresolved path (which
gets resolved) to the managers known mnemonic
@param tag the mnemonic reference
@param an unresolved path name that may contain additional $ variables
@return whether or not the path was added resolved to a directory and added
to the manager's known mnemonic
*/
bool
SysPathMgr::add(
const String& tag,
const String& unresolved)
{
bool res = false;
String resolved = resolve(unresolved);
// if it does not exist create
FileAttributes attrs;
if ( !FileUtils::getAttributes( resolved, attrs ) )
{
if (!FileUtils::mkdirs( resolved ))
{
CBLOGERR(_logger, NTEXT("SysPathMgr::add: could not create directory '") + resolved + NTEXT("'"));
return false;
}
// update the file attributes with another call to get info in the directory
FileUtils::getAttributes( resolved, attrs );
}
if (!attrs.isDirectory())
{
CBLOGERR(_logger, NTEXT("SysPathMgr::add: found a file where a directory '") + resolved + NTEXT("' was expected"));
return false;
}
_paths[tag] = resolved;
return res;
}
bool ZLbadaFSManager::canRemoveFile(const std::string &path) const {
AppLog("ZLbadaFSManager::canRemoveFile %s",path.c_str());
result r = E_SUCCESS;
FileAttributes attr;
r = File::GetAttributes(path.c_str(), attr);
//TODO if(IsFailed(r)) goto CATCH;
if (!attr.IsReadOnly()) AppLog("true"); else AppLog("false");
return !attr.IsReadOnly();
// return access(parentPath(path).c_str(), W_OK) == 0;
}
int FileUtils::rmdir(
const String &dirName )
{
int res = 0;
String cleanName = FileUtils::properName( dirName );
{ // required because the directory would otherwise be in use
#if defined(_WINDOWS) || defined(WIN32)
FileIterator it(new FileIterImpWin32);
#else
FileIterator it(new FileIterImpUnix);
#endif
String deletePattern = cleanName;
deletePattern += FileUtils::PATH_SEP;
deletePattern += FileUtils::ALL_FILES_PAT;
String dataFileName;
FileIterator::Status stat = it.findFirst( deletePattern, dataFileName );
while ( (res == 0) && (stat == FileIterator::cFound) )
{
// construct the path to the target
String targetName = cleanName;
targetName += FileUtils::PATH_SEP;
targetName += dataFileName;
// check to see if the target is a directory
FileAttributes attrs;
if ( FileUtils::getAttributes( targetName, attrs ) &&
attrs.isDirectory() )
{
// if this is a directory, then call rmdir to delete
res = FileUtils::rmdir( targetName );
}
else
{
// otherwise delete all the file from this directory
res = FileUtils::fileDelete( targetName ) ? 0 : -1;
}
stat = it.findNext( dataFileName );
}
}
#if defined(_WINDOWS) || defined(WIN32)
res = _trmdir( cleanName.c_str() );
#else
// now delete the target directory
res = ::rmdir( cleanName.c_str() );
#endif
return res;
}
ArrayListT<Trip *> * IRailAPI::testRoutePlanner(){
result r = E_SUCCESS;
String fileName(L"/Home/2.xml");
File *file = new File();
FileAttributes sourcefilemeta;
File::GetAttributes(fileName, sourcefilemeta);
int filesize = sourcefilemeta.GetFileSize();
ByteBuffer buffer;
buffer.Construct(filesize);
//AppLog("Read buffer size %d", buffer.GetLimit());
r = file->Construct(fileName, L"r"); //for write: w or w+
r = file->Read(buffer); //to write: file->Write *beware of the permission w instead of r
delete file; //closes the file, there is no default close method for files, its gets closed when its scope is closed
buffer.SetPosition(0);
ArrayListT<Trip *> * test = createTripList(&buffer);
//AppLog("completed trips");
return test;
}
FileIterator::Status
FileIterImpUnix::findFirst(
const String &findStr,
FileAttributes &attrs )
{
FileIterator::Status status = FileIterator::cFindError;
closeFind();
// split the filter from the base path
StringUtils::splitBack(
FileUtils::PATH_SEP,
findStr,
&_basePath, &_filter);
// Make sure that the user has not passed us a directory
FileAttributes sourceAttrs;
if ( fpattern_isvalid(_filter.c_str()) &&
FileUtils::getAttributes(_basePath, sourceAttrs) &&
sourceAttrs.isDirectory() )
{
// have the directory, so now start returning the
// and a valid starch path - make sure that the
// path is fully resolved
char resolvedPath[MAXPATHLEN+1];
resolvedPath[0] = '\0';
if ( ::realpath(_basePath.c_str(), resolvedPath) != NULL )
{
_fd = ::opendir( resolvedPath );
if ( _fd != NULL )
{
status = findNext( attrs );
}
}
}
return status;
}
bool
FileUtils::getFile(
const String& fileName,
char*& buff,
size_t& buffSize )
{
// initialize the output parameters
buff = NULL;
buffSize = 0;
FileAttributes attrs;
if ( getAttributes( fileName, attrs ) )
{
size_t tempBuffSize = (size_t)attrs.getFileSize();
char* tempBuff = new char[ tempBuffSize ];
#ifdef __GNUG__
std::ifstream input( fileName.c_str(),
std::ios::in |
std::ios::binary );
#else
std::ifstream input( fileName.c_str(),
std::ios_base::in |
std::ios_base::binary );
#endif
if ( input.read( tempBuff, tempBuffSize ).good() )
{
buff = tempBuff;
buffSize = tempBuffSize;
}
else
{
delete [] tempBuff;
}
}
return buff != NULL;
}
void
test_fiterator()
{
#if defined(_WINDOWS) || defined(WIN32)
TCHAR winFolder[ MAX_PATH + 1 ];
if ( GetWindowsDirectory( winFolder, MAX_PATH ) > 0 )
{
FileIterator iter( new FileIterImpWin32 );
FileAttributes fileAttr;
String fileName;
String folder = winFolder;
folder += NTEXT("\\*.dll");
for ( FileIterator::Status stat = iter.findFirst( folder, fileName, &fileAttr );
stat == FileIterator::cFound;
stat = iter.findNext( fileName, &fileAttr ) )
{
COUT << fileName.c_str() << ": " << fileAttr.getFileSize() << std::endl;
}
}
#else
FileIterator iter( new FileIterImpUnix );
FileAttributes fileAttr;
String fileName;
String folder = NTEXT("/etc/*.conf");
for ( FileIterator::Status stat = iter.findFirst( folder, fileName, &fileAttr );
stat == FileIterator::cFound;
stat = iter.findNext( fileName, &fileAttr ) )
{
COUT << fileName.c_str() << ": " << fileAttr.getFileSize() << std::endl;
}
#endif
}
ZLFileInfo ZLbadaFSManager::fileInfo(const std::string &path) const {
AppLog("ZLbadaFSManager::fileInfo %s",path.c_str());
ZLFileInfo info;
//struct stat fileStat;
result r = E_SUCCESS;
FileAttributes attr;
Tizen::Base::String badaPath(path.c_str());
r = File::GetAttributes(badaPath, attr);
//TODO if(IsFailed(r)) goto CATCH;
//info.Exists = stat(path.c_str(), &fileStat) == 0; stat - не работает
info.Exists = (r==E_SUCCESS);
AppLog("ZLbadaFSManager::fileInfo r = %d", r);
if (info.Exists) {
info.Size = attr.GetFileSize();//fileStat.st_size;
//AppLog("ZLbadaFSManager::fileInfo.Size %d",fileStat.st_size);
AppLog("ZLbadaFSManager::fileInfo.Size %d",info.Size);
//AppLog("ZLbadaFSManager::fileInfo.st_mode %x",fileStat.st_mode);
info.IsDirectory = attr.IsDirectory();//S_ISDIR(fileStat.st_mode);
if (info.IsDirectory) AppLog("ZLbadaFSManager::fileInfo.IsDirectory");
}
return info;
}
int
StdFileImpl::init(
const DOMNode* config,
RefCountedPtr<SysContext>& ctx )
{
int res = -1;
if ( (config != NULL) && (config->getNodeType() == DOMNode::ELEMENT_NODE) )
{
const DOMElement* configElem = (const DOMElement*)config;
String val;
// Get the log level setting [optional]
DOMNodeList* levels = DomUtils::getNodeList( configElem, LOG_LEVEL );
if ( levels != NULL )
{
for ( XMLSize_t i = 0, sz = levels->getLength(); i < sz; i++ )
{
if ( DomUtils::getNodeValue( (DOMElement*)levels->item( i ), &val ) )
{
int level = StringUtils::toInt( val );
if ( level >= StdLogger::LOGC_ALL )
{
_logAll = true;
}
else
{
_levels.insert( level );
}
}
}
}
// get the log file path [required]
DOMElement* logFileElement = NULL;
String logFileName;
if ( DomUtils::selectSingleNode( configElem, FILE_NAME, (DOMNode**)&logFileElement ) )
{
if ( DomUtils::getNodeValue( logFileElement, &val ) )
{
RefCountedPtr<SysPathMgr> paths;
REFCOUNTED_CAST(iSysComponent, SysPathMgr, ctx->getComponent(SysPathMgr::getRegistryName()), paths);
if ( paths != NULL )
{
logFileName = paths->getPath( val );
}
else
{
logFileName = val;
}
DOMElement* numFilesElement = NULL;
DOMElement* sizeFileElement = NULL;
int numLogs = 0;
_SizePerLog = 0;
if ( DomUtils::selectSingleNode( configElem, NUM_FILES, (DOMNode**)&numFilesElement ) )
{
if (DomUtils::getNodeValue( numFilesElement, &val ) )
{
numLogs = StringUtils::toInt(val);
}
else
{
numLogs = 1;
}
}
if ( DomUtils::selectSingleNode( configElem, FILE_SIZE, (DOMNode**)&sizeFileElement ) )
{
if (DomUtils::getNodeValue( sizeFileElement, &val ) )
{
_SizePerLog = StringUtils::toLong(val);
}
}
if ( (numLogs <= 0) || (_SizePerLog <= 0) )
{
#ifdef __GNUG__
_logFile.open( logFileName.c_str(), std::ios::out | std::ios::app );
#else
_logFile.open( logFileName.c_str(), std::ios_base::out | std::ios_base::app );
#endif
_logFileNames.push_back( logFileName );
_logIndex = 0;
_SizePerLog = 0;
res = 0;
}
else
{
int i;
if ( numLogs == 1 )
{
_logFileNames.push_back( logFileName );
}
else
{
for ( i = 1; i <= numLogs; i++ )
{
_logFileNames.push_back( logFileName + StringUtils::toString(i)+ NTEXT(".txt") );
}
}
FileAttributes fattrs;
if ( !FileUtils::getAttributes( _logFileNames[0].c_str(), fattrs ) )
{
#ifdef __GNUG__
_logFile.open(_logFileNames[0].c_str(), std::ios::out | std::ios::app );
#else
_logFile.open(_logFileNames[0].c_str(), std::ios_base::out | std::ios_base::app );
#endif
_logIndex = 0;
res = 0;
}
else
{
int useindex = 0;
struct tm filetime = fattrs.getModifyTime();
time_t currtime = ::time(NULL);
double besttime = ::difftime( currtime, mktime(&filetime) );
for (i = 1; i < numLogs; i++)
{
if ( FileUtils::getAttributes( _logFileNames[i].c_str(), fattrs ) )
{
filetime = fattrs.getModifyTime();
double thisdiff = ::difftime( currtime, ::mktime(&filetime) );
if ( thisdiff < besttime )
{
besttime = thisdiff;
useindex = i;
}
}
}
FileUtils::getAttributes( _logFileNames[useindex].c_str(), fattrs );
if ( (int) fattrs.getFileSize() < _SizePerLog )
{
#ifdef __GNUG__
_logFile.open(_logFileNames[useindex].c_str(), std::ios::out | std::ios::app );
#else
_logFile.open(_logFileNames[useindex].c_str(), std::ios_base::out | std::ios_base::app );
#endif
_logIndex = useindex;
res = 0;
}
else
{
if ( (useindex + 1) >= (int)_logFileNames.size() )
{
useindex = 0;
}
else
{
useindex += 1;
}
#ifdef __GNUG__
_logFile.open(_logFileNames[useindex].c_str(), std::ios::out | std::ios::trunc );
#else
_logFile.open(_logFileNames[useindex].c_str(), std::ios_base::out | std::ios_base::trunc );
#endif
_logIndex = useindex;
res = 0;
}
}
}
}
}
}
return res;
}
bool
FileUtils::getAttributes(
const String &source,
FileAttributes &outAttrs )
{
bool res = false;
ASSERT_D( source.length() > 0 );
#if defined(_WINDOWS) || defined(WIN32)
// get the full path of the input source and get it's attributes
WIN32_FILE_ATTRIBUTE_DATA attrs;
TCHAR abspath[_MAX_PATH];
String properSource = FileUtils::properName( _tfullpath( abspath, source.c_str(), _MAX_PATH ) );
res = ::GetFileAttributesEx( properSource.c_str(), GetFileExInfoStandard, &attrs) == TRUE;
if ( res )
{
// parse out the file name
String::size_type pos = properSource.rfind(FileUtils::PATH_SEP);
if ( pos != String::npos )
{
String name = properSource.substr( pos + 1 );
outAttrs.setFileName( name );
}
else
{
outAttrs.setFileName( properSource );
}
// fill out the size and time structures
outAttrs.setFileSize( attrs.nFileSizeLow );
outAttrs.setFileSizeEx( attrs.nFileSizeHigh );
FILETIME localFileTime;
SYSTEMTIME sysTime;
struct tm tmTime;
if ( ::FileTimeToLocalFileTime( &attrs.ftCreationTime, &localFileTime ) )
{
if ( ::FileTimeToSystemTime( &localFileTime, &sysTime ) )
{
tmTime.tm_year= sysTime.wYear - 1900;
tmTime.tm_mon = sysTime.wMonth - 1;
tmTime.tm_wday = sysTime.wDayOfWeek;
tmTime.tm_mday = sysTime.wDay;
tmTime.tm_hour = sysTime.wHour;
tmTime.tm_min = sysTime.wMinute;
tmTime.tm_sec = sysTime.wSecond;
outAttrs.setCreateTime( tmTime );
}
}
if ( ::FileTimeToLocalFileTime( &attrs.ftLastWriteTime, &localFileTime ) )
{
if ( ::FileTimeToSystemTime( &localFileTime, &sysTime ) )
{
tmTime.tm_year= sysTime.wYear - 1900;
tmTime.tm_mon = sysTime.wMonth - 1;
tmTime.tm_wday = sysTime.wDayOfWeek;
tmTime.tm_mday = sysTime.wDay;
tmTime.tm_hour = sysTime.wHour;
tmTime.tm_min = sysTime.wMinute;
tmTime.tm_sec = sysTime.wSecond;
outAttrs.setModifyTime( tmTime );
}
}
// finally, fill out the attributes
outAttrs.setArchive( ( attrs.dwFileAttributes & FILE_ATTRIBUTE_ARCHIVE) == FILE_ATTRIBUTE_ARCHIVE );
outAttrs.setCompressed( ( attrs.dwFileAttributes & FILE_ATTRIBUTE_COMPRESSED) == FILE_ATTRIBUTE_COMPRESSED );
outAttrs.setDirectory( ( attrs.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY );
outAttrs.setHidden( ( attrs.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) == FILE_ATTRIBUTE_HIDDEN );
outAttrs.setOffline( ( attrs.dwFileAttributes & FILE_ATTRIBUTE_OFFLINE) == FILE_ATTRIBUTE_OFFLINE );
outAttrs.setReadonly( ( attrs.dwFileAttributes & FILE_ATTRIBUTE_READONLY) == FILE_ATTRIBUTE_READONLY );
outAttrs.setTemp( ( attrs.dwFileAttributes & FILE_ATTRIBUTE_TEMPORARY) == FILE_ATTRIBUTE_TEMPORARY );
outAttrs.setSystem( ( attrs.dwFileAttributes & FILE_ATTRIBUTE_SYSTEM) == FILE_ATTRIBUTE_SYSTEM );
}
#else
String resolvedPath = FileUtils::resolve( source );
if ( resolvedPath.length() > 0 )
{
struct stat buff;
res = ::stat( resolvedPath.c_str(), &buff ) == 0;
if ( res )
{
String theFileName;
if ( StringUtils::splitBack(
FileUtils::PATH_SEP,
resolvedPath,
NULL, &theFileName ) )
{
outAttrs.setFileName( theFileName );
}
else
{
outAttrs.setFileName( resolvedPath );
}
outAttrs.setFileSize( buff.st_size );
outAttrs.setFileSizeEx(0);
struct tm tmTime;
tmTime = *::gmtime( &buff.st_atime );
outAttrs.setCreateTime( tmTime );
tmTime = *::gmtime( &buff.st_mtime );
outAttrs.setModifyTime( tmTime );
outAttrs.setArchive( !S_ISDIR(buff.st_mode) );
outAttrs.setDirectory( S_ISDIR(buff.st_mode) );
outAttrs.setHidden( theFileName[0] == NTEXT('.') );
outAttrs.setReadonly( ( buff.st_mode & S_IWUSR) == 0 );
outAttrs.setCompressed( false );
outAttrs.setOffline( false );
outAttrs.setTemp( false );
outAttrs.setSystem( false );
}
}
#endif
return res;
}
bool
FileUtils::fileCopy(
const String &source,
const String& dest,
const bool replace )
{
ASSERT_D( source.length() > 0 );
ASSERT_D( dest.length() > 0 );
#if defined(_WINDOWS) || defined(WIN32)
return ::CopyFile( source.c_str(), dest.c_str(), replace ? FALSE : TRUE ) == TRUE;
#else
// validate the source file
FileAttributes attrs;
bool res = FileUtils::getAttributes( source, attrs );
if ( !res || attrs.isDirectory() )
{
return false;
}
// if the destination file exists, replace is false, then we don't
// allow the procedure to complete
FileAttributes destattrs;
if ( FileUtils::getAttributes( dest, destattrs ) &&
!destattrs.isDirectory() &&
(!replace || destattrs.isReadonly()) )
{
return false;
}
#ifdef __GNUG__
IFSTREAM input( source.c_str(),
std::ios::in |
std::ios::binary );
OFSTREAM output( dest.c_str(),
std::ios::out |
std::ios::binary );
#else
IFSTREAM input( source.c_str(),
std::ios_base::in |
std::ios_base::binary );
OFSTREAM output( dest.c_str(),
std::ios::out |
std::ios::binary );
#endif
if ( input.good() && output.good() )
{
std::auto_ptr<char> buff( new char[COPY_BUFF_SIZE] );
if ( buff.get() != NULL )
{
const char* pBuff = buff.get();
#ifdef __GNUG__
input.seekg( 0, std::ios::end );
int numBytesLeft = input.tellg() ;
input.seekg( 0, std::ios::beg );
#else
input.seekg( 0, std::ios_base::end );
int numBytesLeft = input.tellg() ;
input.seekg( 0, std::ios_base::beg );
#endif
while ( numBytesLeft > 0 && res )
{
int numToRead = (numBytesLeft > COPY_BUFF_SIZE) ? COPY_BUFF_SIZE : numBytesLeft;
res = ( input.read( (char*)pBuff, numToRead ) &&
output.write( pBuff, numToRead ) );
numBytesLeft -= numToRead;
}
}
if ( res )
{
res = FileUtils::setAttributes( dest, attrs );
}
}
return res;
#endif
}
int
SysPathMgr::init(
const DOMNode* config,
RefCountedPtr<SysContext>& ctx )
{
int res = -1;
REFCOUNTED_CAST(iSysComponent, StdLogger, ctx->getComponent( StdLogger::getRegistryName()), _logger);
// I expect the config node to be an element node
if ( ( config != NULL ) && ( config->getNodeType() == DOMNode::ELEMENT_NODE ) )
{
// set the root to be the current directory by default
String root(NTEXT("."));
Mapping rootAttrs;
if ( DomUtils::getNodeValue( (const DOMElement*)config, NULL, &rootAttrs ) )
{
rootAttrs.getIfAvailable(SYS_PATH_ROOTATTR, root);
}
// resolve whatever we have in the root and then verify a file does not exist
// in place of the intended directory
_root = FileUtils::resolve( root );
FileAttributes fattrs;
if ( !FileUtils::getAttributes( _root, fattrs ) )
{
if (!FileUtils::mkdirs( _root ))
{
CBLOGERR(_logger, NTEXT("SysPathMgr::init: could not create directory '") + _root + NTEXT("'"));
return -1;
}
// update the file attributes with another call to get info in the directory
FileUtils::getAttributes( _root, fattrs );
}
if (!fattrs.isDirectory())
{
CBLOGERR(_logger, NTEXT("SysPathMgr::init: found a file where a directory '") + _root + NTEXT("' was expected"));
return -1;
}
// put a special key with the root attribute in the map
_paths[ SYS_PATH_IND + SYS_PATH_ROOTATTR ] = _root;
// ok to this point, no errors
res = 0;
// iterate through the list of child elements whose tag is SYS_PATH_ENTRY
// and get the name attribute and value. If all is found properly, then
// construct a counter whose value is retrieved from the config node
DOMNodeList* children = DomUtils::getNodeList( (const DOMElement*)config, SYS_PATH_ENTRY );
if ( children != NULL )
{
for ( XMLSize_t i = 0, sz = children->getLength() ;
i < sz; i++ )
{
DOMNode* child = children->item(i);
if ( (child != NULL) && (child->getNodeType() == DOMNode::ELEMENT_NODE) )
{
String value;
Mapping attrs;
bool found = DomUtils::getNodeValue( (const DOMElement*)child, &value, &attrs );
if ( found )
{
res = 0;
String tagName;
attrs.getIfAvailable(SYS_PATH_TAGATTR, tagName);
if ( tagName.length() > 0 )
{
add( tagName, value );
}
}
}
}
}
}
return res;
}
result
CategoryItemForm::ReadCustomListItems()
{
result r = E_SUCCESS;
String dirName(L"/Home/catalog/"+dir);
Directory* pDir;
DirEnumerator* pDirEnum;
pDir = new Directory; // allocate Directory instance
// Open directory
r = pDir->Construct(dirName);
// Read all directory entries
pDirEnum = pDir->ReadN();
String contentType;
int i = 0;
while(pDirEnum->MoveNext() == E_SUCCESS) {
DirEntry dirEntry = pDirEnum->GetCurrentDirEntry();
if(dirEntry.IsNomalFile()) {
//AppLog("%S", dirEntry.GetName().GetPointer());
if(!dirEntry.GetName().Equals("category.info", false)) {
String fileName(dirName+"/"+dirEntry.GetName());
String title, desc;
String iTempStr, iTempStr2;
File file;
result r = file.Construct(fileName, L"r");
if( IsFailed(r) )
{
AppLog("File::Consturct() is failed by %s", GetErrorMessage(r));
}
FileAttributes fileAttrs;
file.GetAttributes(fileName, fileAttrs);
long long size = fileAttrs.GetFileSize();
ByteBuffer readBuffer;
readBuffer.Construct((int)size + 1);
r = file.Read(readBuffer);
if( IsFailed(r) )
{
AppLog("File::Read() is failed by %s", GetErrorMessage(r));
}
char* data = new char[readBuffer.GetLimit()+1];
readBuffer.SetPosition(0);
readBuffer.GetArray((byte*)data, 0, readBuffer.GetLimit());
data[readBuffer.GetLimit()] ='\0';
//String str = String(data);
String str;
r = StringUtil::Utf8ToString(data, str);
delete data;
if(IsFailed(r)) {
AppLog("File read error. File : %S", fileName.GetPointer());
continue;
}
file.Seek(FILESEEKPOSITION_BEGIN, 0);
file.Read(title);
r = TextPic::GetTranslated(title);
if (IsFailed(r)) {
continue;
}
int linecount = 0;
while(file.Read(iTempStr) != E_END_OF_FILE) {
linecount++;
iTempStr2.Append(iTempStr);
}
anciilist.Add(*(new String(iTempStr2)));
titlelist.Add(*(new String(title)));
filelist.Add(*(new String(fileName)));
ItemListForm::AddListItem(*CategoryList, title, iTempStr2, i++, linecount);
file.Flush();
}
}
}
delete pDirEnum;
delete pDir;
return r;
}