SO3ScolFileSystem.cpp

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com
 
Copyright (c) 2012 I-maginer
 
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.
 
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt
 
-----------------------------------------------------------------------------
*/
 
#include <scolPlugin.h>
#include "SO3Utils/SO3ScolFileSystem.h"
 
//TODO use boost file system
#ifdef _WIN32
  #include <io.h>
#else
  #include "OgreSearchOps.h"
  #include <sys/param.h>
  #include <sys/stat.h>
  #define MAX_PATH MAXPATHLEN
#endif
 
#include <boost/filesystem.hpp>
 
namespace SO3
{
#ifdef ANDROID
static std::map< Ogre::String, std::vector< Ogre::String > > mApkFiles;
 
static bool IsFolderParsed(Ogre::String Folder)
{
  bool parsed = false;
  //force lowercase
  Ogre::StringUtil::toLowerCase(Folder);
  boost::filesystem::path filedir(Folder);
  if (filedir.has_filename())
    filedir = filedir.parent_path();
 
  std::map< Ogre::String, std::vector< Ogre::String > >::iterator iter = mApkFiles.find(filedir.generic_string());
  if (iter != mApkFiles.end())
    parsed = true;
  //else
    //Ogre::LogManager::getSingleton().getDefaultLog()->logMessage("[DEBUG] ::IsFolderParsed not parser yet : " + Folder);
 
  return parsed;
}
 
static void ParseFolder(AAssetManager* AssetMgr, Ogre::String Folder)
{
  std::vector<Ogre::String> mFilenames;
  //force lowercase
  Ogre::StringUtil::toLowerCase(Folder);
  boost::filesystem::path filedir(Folder);
  if (filedir.has_filename())
    filedir = filedir.parent_path();
 
  //Ogre::LogManager::getSingleton().getDefaultLog()->logMessage("[DEBUG] ::ParseFolder : " + filedir.generic_string());
  AAssetDir* dir = AAssetManager_openDir(AssetMgr, filedir.generic_string().c_str());
  const char* fileName = NULL;
  while ((fileName = AAssetDir_getNextFileName(dir)) != NULL)
  {
    //force lowercase
    Ogre::String fname(fileName);
    Ogre::StringUtil::toLowerCase(fname);
    mFilenames.push_back(fname);
    //Ogre::LogManager::getSingleton().getDefaultLog()->logMessage("[DEBUG] ::ParseFolder : " + fname);
  }
 
  mApkFiles.insert(std::make_pair(filedir.generic_string(), mFilenames));
  AAssetDir_close(dir);
}
#endif
 
bool SO3ScolFileSystemArchive::msIgnoreHidden = true;
 
//-----------------------------------------------------------------------
SO3ScolFileSystemArchive::SO3ScolFileSystemArchive(const Ogre::String& name, const Ogre::String& archType, bool readOnly)
: Ogre::Archive(name, archType)
{
  // Even failed attempt to write to read only location violates Apple AppStore validation process.
  // And successful writing to some probe file does not prove that whole location with subfolders
  // is writable. Therefore we accept read only flag from outside and do not try to be too smart.
  mReadOnly = readOnly;
 
#ifdef ANDROID
  mAssetManager = 0;
  mApk = false;
 
  if (mName.size() > 0 && mName[0] == '/')
    mName.erase(mName.begin());
 
  if ((mName.compare(0, 4, "apk/") == 0) || (mName.compare(0, 4, "APK/") == 0))
  {
    mReadOnly = true;
    mName = mName.substr(4);
    mPathPreFix = mName;
 
    struct android_app* androidApp = (struct android_app*)SCgetExtra("this_inst");
    if (androidApp != NULL)
    {
      mAssetManager = androidApp->activity->assetManager;
    }
    mApk = true;
  }
 
  /*
  if (mApk && !IsFolderParsed(mName))
  {
    struct android_app* androidApp = (struct android_app*)SCgetExtra("this_inst");
    if (androidApp != NULL)
    {      
      ParseFolder(mAssetManager, mName);
    }
  }*/
#endif
}
 
//-----------------------------------------------------------------------
bool SO3ScolFileSystemArchive::isCaseSensitive(void) const
{
#ifdef _WIN32
  return false;
#else
  return true;
#endif
}
 
//-----------------------------------------------------------------------
#ifdef ANDROID
bool SO3ScolFileSystemArchive::isApk(void) const
{
  return mApk;
}
#endif
 
//-----------------------------------------------------------------------
bool SO3ScolFileSystemArchive::is_reserved_dir(const char *fn)
{
  return (fn[0] == '.' && (fn[1] == 0 || (fn[1] == '.' && fn[2] == 0)));
}
 
//-----------------------------------------------------------------------
boost::filesystem::path SO3ScolFileSystemArchive::concatenate_path(const Ogre::String base, const Ogre::String name)
{
  boost::filesystem::path out = base;
  if (base.empty() || boost::filesystem::path(name).is_absolute())
    out = name;
  else
    out /= name;
 
  return out;
}
 
//-----------------------------------------------------------------------
void SO3ScolFileSystemArchive::findFiles(const Ogre::String& pattern, bool recursive,
  bool dirs, Ogre::StringVector* simpleList, Ogre::FileInfoList* detailList) const
{
  intptr_t lHandle, res;
  struct _finddata_t tagData;
 
  // pattern can contain a directory name, separate it from mask
  size_t pos1 = pattern.rfind('/');
  size_t pos2 = pattern.rfind('\\');
  if (pos1 == pattern.npos || ((pos2 != pattern.npos) && (pos1 < pos2)))
    pos1 = pos2;
  Ogre::String directory;
  if (pos1 != pattern.npos)
    directory = pattern.substr(0, pos1 + 1);
 
  boost::filesystem::path full_pattern = concatenate_path(mName, pattern);
 
  lHandle = _findfirst(full_pattern.generic_string().c_str(), &tagData);
  res = 0;
  while (lHandle != -1 && res != -1)
  {
    if ((dirs == ((tagData.attrib & _A_SUBDIR) != 0)) &&
      (!msIgnoreHidden || (tagData.attrib & _A_HIDDEN) == 0) &&
      (!dirs || !is_reserved_dir(tagData.name)))
    {
      if (simpleList)
      {
        simpleList->push_back(directory + tagData.name);
      }
      else if (detailList)
      {
        Ogre::FileInfo fi;
        fi.archive = this;
        fi.filename = directory + tagData.name;
        fi.basename = tagData.name;
        fi.path = directory;
        fi.compressedSize = tagData.size;
        fi.uncompressedSize = tagData.size;
        detailList->push_back(fi);
      }
    }
    res = _findnext(lHandle, &tagData);
  }
  // Close if we found any files
  if (lHandle != -1)
    _findclose(lHandle);
 
  // Now find directories
  if (recursive)
  {
    boost::filesystem::path base_dir = mName;
    if (!directory.empty())
    {
      base_dir = concatenate_path(mName, directory);
    }
    base_dir /= "*";
 
    // Remove directory name from pattern
    Ogre::String mask("/");
    if (pos1 != pattern.npos)
      mask.append(pattern.substr(pos1 + 1));
    else
      mask.append(pattern);
 
    lHandle = _findfirst(base_dir.generic_string().c_str(), &tagData);
    res = 0;
    while (lHandle != -1 && res != -1)
    {
      if ((tagData.attrib & _A_SUBDIR) &&
        (!msIgnoreHidden || (tagData.attrib & _A_HIDDEN) == 0) &&
        !is_reserved_dir(tagData.name))
      {
        // recurse
        base_dir = directory;
        base_dir /= tagData.name;
        base_dir.append(mask);
 
        findFiles(base_dir.generic_string(), recursive, dirs, simpleList, detailList);
      }
      res = _findnext(lHandle, &tagData);
    }
    // Close if we found any files
    if (lHandle != -1)
      _findclose(lHandle);
  }
}
 
//-----------------------------------------------------------------------
SO3ScolFileSystemArchive::~SO3ScolFileSystemArchive()
{
#ifdef ANDROID
  mApkFiles.clear();
#endif
 
  unload();
}
 
//-----------------------------------------------------------------------
void SO3ScolFileSystemArchive::load()
{
  // nothing to do here
}
 
//-----------------------------------------------------------------------
void SO3ScolFileSystemArchive::unload()
{
  // nothing to see here, move along
}
 
//-----------------------------------------------------------------------
Ogre::DataStreamPtr SO3ScolFileSystemArchive::open(const Ogre::String& filename, bool readOnly) const
{
  MMechostr(MSKDEBUG, ">>> Open archive : %s\n", filename.c_str());
#ifdef ANDROID
  if (isApk())
  {
    Ogre::String fname = filename;
 
    if ((fname.compare(0, 4, "apk/") == 0) || (fname.compare(0, 4, "APK/") == 0))
      fname = fname.substr(4);
    else
      fname = mPathPreFix + fname;
 
    Ogre::DataStreamPtr stream;
    AAsset* asset = AAssetManager_open(mAssetManager, fname.c_str(), AASSET_MODE_BUFFER);
    //try lowercase
    if (!asset)
    {
      Ogre::StringUtil::toLowerCase(fname);
      asset = AAssetManager_open(mAssetManager, fname.c_str(), AASSET_MODE_UNKNOWN);
    }
 
    if (asset)
    {
      off_t length = AAsset_getLength(asset);
      void* membuf = OGRE_MALLOC(length, Ogre::MEMCATEGORY_GENERAL);
      memcpy(membuf, AAsset_getBuffer(asset), length);
      AAsset_close(asset);
 
      stream = Ogre::DataStreamPtr(new Ogre::MemoryDataStream(membuf, length, true, true));
    }
    return stream;
  }
#endif
 
  boost::filesystem::path full_path = concatenate_path(mName, filename);
  try
  {
    if (!boost::filesystem::exists(full_path))
    {
      //try lowercase
      if (isCaseSensitive())
      {
        Ogre::String lfilename = filename;
        Ogre::StringUtil::toLowerCase(lfilename);
        full_path = concatenate_path(mName, lfilename);
        if (!boost::filesystem::exists(full_path))
        {
          OGRE_EXCEPT(Ogre::Exception::ERR_FILE_NOT_FOUND,
            "Cannot open file: " + filename,
            "SO3ScolFileSystemArchive::open");
        }
      }
      else
      {
        OGRE_EXCEPT(Ogre::Exception::ERR_FILE_NOT_FOUND,
            "Cannot open file: " + filename,
            "SO3ScolFileSystemArchive::open");
      }
    }
  }
  catch (std::exception &)
  {
    OGRE_EXCEPT(Ogre::Exception::ERR_FILE_NOT_FOUND,
      "Cannot open file: " + filename,
      "SO3ScolFileSystemArchive::open");
  }
 
  // Use filesystem to determine size
  // (quicker than streaming to the end and back)
  struct stat tagStat;
  int ret = stat(full_path.generic_string().c_str(), &tagStat);
  assert(ret == 0 && "Problem getting file size");
  (void)ret;  // Silence warning
 
  // Always open in binary mode
  // Also, always include reading
  std::ios::openmode mode = std::ios::in | std::ios::binary;
  std::istream* baseStream = 0;
  std::ifstream* roStream = 0;
  std::fstream* rwStream = 0;
 
  if (!readOnly && isReadOnly())
  {
    OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS,
      "Cannot open a file in read-write mode in a read-only archive",
      "SO3ScolFileSystemArchive::open");
  }
 
  if (!readOnly)
  {
    mode |= std::ios::out;
    rwStream = OGRE_NEW_T(std::fstream, Ogre::MEMCATEGORY_GENERAL)();
    rwStream->open(full_path.c_str(), mode);
    baseStream = rwStream;
  }
  else
  {
    roStream = OGRE_NEW_T(std::ifstream, Ogre::MEMCATEGORY_GENERAL)();
    roStream->open(full_path.c_str(), mode);
    baseStream = roStream;
  }
 
 
  // Should check ensure open succeeded, in case fail for some reason.
  if (baseStream->fail())
  {
    OGRE_DELETE_T(roStream, basic_ifstream, Ogre::MEMCATEGORY_GENERAL);
    OGRE_DELETE_T(rwStream, basic_fstream, Ogre::MEMCATEGORY_GENERAL);
    OGRE_EXCEPT(Ogre::Exception::ERR_FILE_NOT_FOUND,
      "Cannot open file: " + filename,
      "SO3ScolFileSystemArchive::open");
  }
 
  Ogre::FileStreamDataStream* stream = 0;
  if (rwStream)
  {
    // use the writeable stream
    stream = OGRE_NEW Ogre::FileStreamDataStream(filename,
      rwStream, (size_t)tagStat.st_size, true);
  }
  else
  {
    // read-only stream
    stream = OGRE_NEW Ogre::FileStreamDataStream(filename,
      roStream, (size_t)tagStat.st_size, true);
  }
  return Ogre::DataStreamPtr(stream);
}
 
//---------------------------------------------------------------------
Ogre::DataStreamPtr SO3ScolFileSystemArchive::create(const Ogre::String& filename)
{
  if (isReadOnly())
  {
    OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS,
      "Cannot create a file in a read-only archive",
      "SO3ScolFileSystemArchive::remove");
  }
 
  boost::filesystem::path full_path = concatenate_path(mName, filename);
 
  // Always open in binary mode
  // Also, always include reading
  std::ios::openmode mode = std::ios::out | std::ios::binary;
  std::fstream* rwStream = OGRE_NEW_T(std::fstream, Ogre::MEMCATEGORY_GENERAL)();
  rwStream->open(full_path.c_str(), mode);
 
  // Should check ensure open succeeded, in case fail for some reason.
  if (rwStream->fail())
  {
    OGRE_DELETE_T(rwStream, basic_fstream, Ogre::MEMCATEGORY_GENERAL);
    OGRE_EXCEPT(Ogre::Exception::ERR_FILE_NOT_FOUND,
      "Cannot open file: " + filename,
      "SO3ScolFileSystemArchive::create");
  }
 
  Ogre::FileStreamDataStream* stream = OGRE_NEW Ogre::FileStreamDataStream(filename,
    rwStream, 0, true);
 
  return Ogre::DataStreamPtr(stream);
}
 
//---------------------------------------------------------------------
void SO3ScolFileSystemArchive::remove(const Ogre::String& filename)
{
  if (isReadOnly())
  {
    OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS,
      "Cannot remove a file from a read-only archive",
      "SO3ScolFileSystemArchive::remove");
  }
 
  boost::filesystem::path full_path = concatenate_path(mName, filename);
  try
  {
    if (!boost::filesystem::exists(full_path))
    {
      //try lowercase
      if (isCaseSensitive())
      {
        Ogre::String lfilename = filename;
        Ogre::StringUtil::toLowerCase(lfilename);
        full_path = concatenate_path(mName, lfilename);
        if (!boost::filesystem::exists(full_path))
        {
          OGRE_EXCEPT(Ogre::Exception::ERR_FILE_NOT_FOUND,
            "Cannot open file: " + filename,
            "SO3ScolFileSystemArchive::remove");
        }
      }
      else
      {
        OGRE_EXCEPT(Ogre::Exception::ERR_FILE_NOT_FOUND,
          "Cannot open file: " + filename,
          "SO3ScolFileSystemArchive::remove");
      }
    }
  }
  catch (std::exception&)
  {
    OGRE_EXCEPT(Ogre::Exception::ERR_FILE_NOT_FOUND,
      "Cannot open file: " + filename,
      "SO3ScolFileSystemArchive::remove");
  }
 
  ::remove(full_path.generic_string().c_str());
}
 
//-----------------------------------------------------------------------
Ogre::StringVectorPtr SO3ScolFileSystemArchive::list(bool recursive, bool dirs) const
{
#ifdef ANDROID
  if (isApk())
  {
    if (!IsFolderParsed(mName))
      ParseFolder(mAssetManager, mName);
 
    Ogre::StringVectorPtr files(new Ogre::StringVector);
    boost::filesystem::path filedir(mName);
    if (filedir.has_filename())
      filedir = filedir.parent_path();
 
    //force lowercase
    Ogre::String fdir(filedir.generic_string().c_str());
    Ogre::StringUtil::toLowerCase(fdir);
 
    std::map<Ogre::String, std::vector< Ogre::String > >::iterator iter = mApkFiles.find(fdir);
    std::vector< Ogre::String > fileList = iter->second;
    for (size_t i = 0; i < fileList.size(); i++)
    {
      files->push_back(fileList[i]);
    }
    return files;
  }
#endif
 
  // directory change requires locking due to saved returns
  auto ret = std::make_shared<Ogre::StringVector>();
  findFiles("*", recursive, dirs, ret.get(), 0);
 
  return ret;
}
 
//-----------------------------------------------------------------------
Ogre::FileInfoListPtr SO3ScolFileSystemArchive::listFileInfo(bool recursive, bool dirs) const
{
#ifdef ANDROID
  if (isApk())
  {
    if (!IsFolderParsed(mName))
      ParseFolder(mAssetManager, mName);
 
    Ogre::FileInfoListPtr files(new Ogre::FileInfoList);
    boost::filesystem::path filedir(mName);
    if (filedir.has_filename())
      filedir = filedir.parent_path();
 
    //force lowercase
    Ogre::String fdir(filedir.generic_string().c_str());
    Ogre::StringUtil::toLowerCase(fdir);
 
    std::map<Ogre::String, std::vector< Ogre::String > >::iterator iter = mApkFiles.find(fdir);
    std::vector< Ogre::String > fileList = iter->second;
    for (size_t i = 0; i < fileList.size(); i++)
    {
      AAsset* asset = AAssetManager_open(mAssetManager, (mPathPreFix + fileList[i]).c_str(), AASSET_MODE_UNKNOWN);
 
      //try lowercase
      if (!asset)
      {
        Ogre::String lowername = mPathPreFix + fileList[i];
        Ogre::StringUtil::toLowerCase(lowername);
        asset = AAssetManager_open(mAssetManager, lowername.c_str(), AASSET_MODE_UNKNOWN);
      }
 
      if (asset)
      {
        Ogre::FileInfo info;
        info.archive = this;
        info.filename = fileList[i];
        info.path = mName;
        info.basename = fileList[i];
        info.compressedSize = AAsset_getLength(asset);
        info.uncompressedSize = info.compressedSize;
        files->push_back(info);
        AAsset_close(asset);
      }
    }
    return files;
  }
#endif
 
  auto ret = std::make_shared<Ogre::FileInfoList>();
  findFiles("*", recursive, dirs, 0, ret.get());
 
  return ret;
}
 
//-----------------------------------------------------------------------
Ogre::StringVectorPtr SO3ScolFileSystemArchive::find(const Ogre::String& pattern, bool recursive, bool dirs) const
{
#ifdef ANDROID
  if (isApk())
  {
    auto ret = std::make_shared<Ogre::StringVector>();
    Ogre::String fname = pattern;
 
    if ((fname.compare(0, 4, "apk/") == 0) || (fname.compare(0, 4, "APK/") == 0))
      fname = fname.substr(4);
    else
      fname = mPathPreFix + fname;
 
    AAsset* asset = AAssetManager_open(mAssetManager, fname.c_str(), AASSET_MODE_UNKNOWN);
    //try lowercase
    if (!asset)
    {
      Ogre::StringUtil::toLowerCase(fname);
      asset = AAssetManager_open(mAssetManager, fname.c_str(), AASSET_MODE_UNKNOWN);
    }
    if (asset)
    {
      ret->push_back(pattern);
      AAsset_close(asset);
    }
 
    if (ret->empty())
      Ogre::LogManager::getSingleton().getDefaultLog()->logMessage("[WARNING] ::find Could not find the files in APK with pattern : " + pattern);
    return ret;
  }
#endif
 
  auto ret = std::make_shared<Ogre::StringVector>();
  findFiles(pattern, recursive, dirs, ret.get(), 0);
 
  //retry lowercase
  if (isCaseSensitive() && ret->empty())
  {
    Ogre::String lpattern = pattern;
    Ogre::StringUtil::toLowerCase(lpattern);
    findFiles(lpattern, recursive, dirs, ret.get(), 0);
  }
  return ret;
}
 
//-----------------------------------------------------------------------
Ogre::FileInfoListPtr SO3ScolFileSystemArchive::findFileInfo(const Ogre::String& pattern, bool recursive, bool dirs) const
{
#ifdef ANDROID
  if (isApk())
  {
    auto ret = std::make_shared<Ogre::FileInfoList>();
    Ogre::String fname = pattern;
 
    if ((fname.compare(0, 4, "apk/") == 0) || (fname.compare(0, 4, "APK/") == 0))
      fname = fname.substr(4);
    else
      fname = mPathPreFix + fname;
 
    AAsset* asset = AAssetManager_open(mAssetManager, fname.c_str(), AASSET_MODE_UNKNOWN);
    //try lowercase
    if (!asset)
    {
      Ogre::StringUtil::toLowerCase(fname);
      asset = AAssetManager_open(mAssetManager, fname.c_str(), AASSET_MODE_UNKNOWN);
    }
    if (asset)
    {
      Ogre::FileInfo info;
      info.archive = this;
      info.filename = pattern;
      info.path = mName;
      info.basename = pattern;
      info.compressedSize = AAsset_getLength(asset);
      info.uncompressedSize = info.compressedSize;
      ret->push_back(info);
      AAsset_close(asset);
    }
 
    if (ret->empty())
      Ogre::LogManager::getSingleton().getDefaultLog()->logMessage("[WARNING] ::findFileInfo Could not find the files in APK with pattern : " + pattern);
    return ret;
  }
#endif
 
  auto ret = std::make_shared<Ogre::FileInfoList>();
  findFiles(pattern, recursive, dirs, 0, ret.get());
 
  //retry lowercase
  if (isCaseSensitive() && ret->empty())
  {
    Ogre::String lpattern = pattern;
    Ogre::StringUtil::toLowerCase(lpattern);
    findFiles(lpattern, recursive, dirs, 0, ret.get());
  }
  return ret;
}
 
//-----------------------------------------------------------------------
bool SO3ScolFileSystemArchive::exists(const Ogre::String& filename) const
{
#ifdef ANDROID
  if (isApk())
  {
    Ogre::String fname = filename;
 
    if ((fname.compare(0, 4, "apk/") == 0) || (fname.compare(0, 4, "APK/") == 0))
      fname = fname.substr(4);
    else
      fname = mPathPreFix + fname;
 
    AAsset* asset = AAssetManager_open(mAssetManager, fname.c_str(), AASSET_MODE_UNKNOWN);
    //try lowercase
    if (!asset)
    {
      Ogre::StringUtil::toLowerCase(fname);
      asset = AAssetManager_open(mAssetManager, fname.c_str(), AASSET_MODE_UNKNOWN);
    }
    if (asset)
    {
      AAsset_close(asset);
      //MMechostr(MSKDEBUG, ">>> Found path : from %s > %s", mPathPreFix.c_str(), fname.c_str());
      return true;
    }
    return false;
  }
#endif
 
  boost::filesystem::path full_path = concatenate_path(mName, filename);
  try
  {
    if (boost::filesystem::exists(full_path))
    {
      return true;
    }
    else
    {
      //try lowercase
      if (isCaseSensitive())
      {
        Ogre::String lfilename = filename;
        Ogre::StringUtil::toLowerCase(lfilename);
        full_path = concatenate_path(mName, lfilename);
        if (boost::filesystem::exists(full_path))
        {
          return true;
        }
      }
      else
        return false;
    }
  }
  catch (std::exception&)
  {
    return false;
  }
 
/*
#ifdef ANDROID
    if (ret)
      MMechostr(MSKDEBUG, ">>> Found path : from %s > %s", mPathPreFix.c_str(), full_path.c_str());
#endif
*/
 
  return false;
}
 
//---------------------------------------------------------------------
time_t SO3ScolFileSystemArchive::getModifiedTime(const Ogre::String& filename) const
{
#ifdef ANDROID
  if (isApk())
    return 0;
#endif
 
  boost::filesystem::path full_path = concatenate_path(mName, filename);
  try
  {
    if (!boost::filesystem::exists(full_path))
    {
      //try lowercase
      if (isCaseSensitive())
      {
        Ogre::String lfilename = filename;
        Ogre::StringUtil::toLowerCase(lfilename);
        full_path = concatenate_path(mName, lfilename);
        if (!boost::filesystem::exists(full_path))
        {
          return 0;
        }
      }
      else
        return 0;
    }
  }
  catch (std::exception&)
  {
    return 0;
  }
 
  struct stat tagStat;
  bool ret = (stat(full_path.generic_string().c_str(), &tagStat) == 0);
 
  if (ret)
  {
    return tagStat.st_mtime;
  }
  else
  {
    return 0;
  }
}
 
//-----------------------------------------------------------------------
const Ogre::String& SO3ScolFileSystemArchiveFactory::getType(void) const
{
  static Ogre::String name = "ScolFileSystem";
  return name;
}
 
}