SO3Engine/SO3Utils/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) 2010 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

You may alternatively use this source under the terms of a specific version of
the OpenSpace3D Unrestricted License provided you have obtained such a license from
I-maginer.
-----------------------------------------------------------------------------
*/

#include "SO3ScolFileSystem.h"
#include <io.h>
#include "scol.h"

namespace SO3
{

//-----------------------------------------------------------------------
SO3ScolFileSystemArchive::SO3ScolFileSystemArchive(const Ogre::String& name, const Ogre::String& archType) : Ogre::Archive(name, archType)
{
  if(!is_absolute_path(name.c_str()))
  {
    // Store the Scol partition when the file is at bootstrap.
    char* tempPath = (char*) malloc(name.size()+1);
    char* tempReturnPath = (char*) malloc(SO3_MAX_PATH);

    *tempPath = *name.c_str();
    if(SPfindfile((packdir)SCgetExtra("FirstPack"), tempPath, 0, tempReturnPath) == -1)
    {
      free(tempPath);
      free(tempReturnPath);
      OGRE_EXCEPT(Ogre::Exception::ERR_FILE_NOT_FOUND, "The archive \""+ name +"\" was not found in any of the defined Scol partitions", "SO3ScolFileSystemArchive::SO3ScolFileSystemArchive");
    }

    scolPartitionPath = Ogre::String(tempReturnPath);
    free(tempReturnPath);
    free(tempPath);
  }
  else
  {
    // No Scol partition chek needed, cause the path is already absolute.
    scolPartitionPath = "";
  }
}

//-----------------------------------------------------------------------
bool SO3ScolFileSystemArchive::isCaseSensitive() const
{
  return false;
}

//-----------------------------------------------------------------------
bool SO3ScolFileSystemArchive::is_reserved_dir(const char*fn)
{
  return (fn [0] == '.' && (fn [1] == 0 || (fn [1] == '.' && fn [2] == 0)));
}

//-----------------------------------------------------------------------
bool SO3ScolFileSystemArchive::is_absolute_path(const char* path) const
{
  if(isalpha(unsigned char(path[0])) && path[1] == ':')
    return true;

  return path[0] == '/' || path[0] == '\\';
}

//-----------------------------------------------------------------------
Ogre::String SO3ScolFileSystemArchive::scolToAbsolutePath(const Ogre::String& base, const Ogre::String& name) const
{
  if(base.empty() || is_absolute_path(name.c_str()))
    return name;
  else
  { 
    return scolPartitionPath + base + '/' + name;
  }
}

//-----------------------------------------------------------------------
void SO3ScolFileSystemArchive::findFiles(const Ogre::String& pattern, bool recursive, bool dirs, Ogre::StringVector* simpleList, Ogre::FileInfoList* detailList)
{
  long 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);

  Ogre::String full_pattern = scolToAbsolutePath(mName, pattern);

  lHandle = _findfirst(full_pattern.c_str(), &tagData);
  res = 0;
  while (lHandle != -1 && res != -1)
  {
    if((dirs == ((tagData.attrib & _A_SUBDIR) != 0)) &&
                   ((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)
  {
    Ogre::String base_dir = mName;
    if(!directory.empty ())
    {
      base_dir = scolToAbsolutePath(mName, directory);
      // Remove the last '/'
      base_dir.erase (base_dir.length () - 1);
    }
    base_dir.append ("/*");

    // 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.c_str (), &tagData);
    res = 0;
    while (lHandle != -1 && res != -1)
    {
      if((tagData.attrib & _A_SUBDIR) &&
         ((tagData.attrib & _A_HIDDEN) == 0 ) &&
         !is_reserved_dir (tagData.name))
      {
        // recurse
        base_dir = directory;
        base_dir.append (tagData.name).append (mask);
        findFiles(base_dir, recursive, dirs, simpleList, detailList);
      }
      res = _findnext( lHandle, &tagData );
    }
    
    // Close if we found any files
    if(lHandle != -1)
      _findclose(lHandle);
  }
}

//-----------------------------------------------------------------------
SO3ScolFileSystemArchive::~SO3ScolFileSystemArchive()
{
    unload();
}

//-----------------------------------------------------------------------
void SO3ScolFileSystemArchive::load()
{
    // do nothing here, what has to be said will be said later
}

//-----------------------------------------------------------------------
void SO3ScolFileSystemArchive::unload()
{
    // nothing to see here, move along
}

//-----------------------------------------------------------------------
// If our ogre is anterior to v1.7
#if OGRE_VERSION < ((1 << 16) | (7 << 8) | 0)
Ogre::DataStreamPtr SO3ScolFileSystemArchive::open(const Ogre::String& filename) const
#else
Ogre::DataStreamPtr SO3ScolFileSystemArchive::open(const Ogre::String& filename, bool readOnly) const
#endif
{
  Ogre::String full_path = scolToAbsolutePath(mName, filename);

  // Use filesystem to determine size 
  // (quicker than streaming to the end and back)
  struct stat tagStat;
  int ret = stat(full_path.c_str(), &tagStat);
  assert(ret == 0 && "Problem getting file size" );

  // Always open in binary mode
  std::ifstream *origStream = OGRE_NEW_T(std::ifstream, Ogre::MEMCATEGORY_GENERAL)();
  origStream->open(full_path.c_str(), std::ios::in | std::ios::binary);

  // Should check ensure open succeeded, in case fail for some reason.
  if(origStream->fail())
  {
      OGRE_DELETE_T(origStream, basic_ifstream, Ogre::MEMCATEGORY_GENERAL);
      OGRE_EXCEPT(Ogre::Exception::ERR_FILE_NOT_FOUND, "Cannot open file: " + filename, "SO3ScolFileSystemArchive::open");
  }

  // Construct return stream, tell it to delete on destroy
  Ogre::FileStreamDataStream* stream = OGRE_NEW Ogre::FileStreamDataStream(filename, origStream, tagStat.st_size, true);
  return Ogre::DataStreamPtr(stream);
}

//-----------------------------------------------------------------------
Ogre::StringVectorPtr SO3ScolFileSystemArchive::list(bool recursive, bool dirs)
{
        // directory change requires locking due to saved returns
        // Note that we have to tell the SharedPtr to use OGRE_DELETE_T not OGRE_DELETE by passing category
  Ogre::StringVectorPtr ret(OGRE_NEW_T(Ogre::StringVector, Ogre::MEMCATEGORY_GENERAL)(), Ogre::SPFM_DELETE_T);

  findFiles("*", recursive, dirs, ret.getPointer(), 0);

  return ret;
}

//-----------------------------------------------------------------------
Ogre::FileInfoListPtr SO3ScolFileSystemArchive::listFileInfo(bool recursive, bool dirs)
{
        // Note that we have to tell the SharedPtr to use OGRE_DELETE_T not OGRE_DELETE by passing category
  Ogre::FileInfoListPtr ret(OGRE_NEW_T(Ogre::FileInfoList, Ogre::MEMCATEGORY_GENERAL)(), Ogre::SPFM_DELETE_T);

  findFiles("*", recursive, dirs, 0, ret.getPointer());

  return ret;
}

//-----------------------------------------------------------------------
Ogre::StringVectorPtr SO3ScolFileSystemArchive::find(const Ogre::String& pattern, bool recursive, bool dirs)
{
        // Note that we have to tell the SharedPtr to use OGRE_DELETE_T not OGRE_DELETE by passing category
        Ogre::StringVectorPtr ret(OGRE_NEW_T(Ogre::StringVector, Ogre::MEMCATEGORY_GENERAL)(), Ogre::SPFM_DELETE_T);

  findFiles(pattern, recursive, dirs, ret.getPointer(), 0);

  return ret;
}

//-----------------------------------------------------------------------
// If our ogre is anterior to v1.7
#if OGRE_VERSION < ((1 << 16) | (7 << 8) | 0)
  Ogre::FileInfoListPtr SO3ScolFileSystemArchive::findFileInfo(const Ogre::String& pattern, bool recursive, bool dirs)
#else
  Ogre::FileInfoListPtr SO3ScolFileSystemArchive::findFileInfo(const Ogre::String& pattern, bool recursive, bool dirs) const
#endif
{
        // Note that we have to tell the SharedPtr to use OGRE_DELETE_T not OGRE_DELETE by passing category
        Ogre::FileInfoListPtr ret(OGRE_NEW_T(Ogre::FileInfoList, Ogre::MEMCATEGORY_GENERAL)(), Ogre::SPFM_DELETE_T);

  const_cast <SO3ScolFileSystemArchive*> (this)->findFiles(pattern, recursive, dirs, 0, ret.getPointer());
  return ret;
}

//-----------------------------------------------------------------------
bool SO3ScolFileSystemArchive::exists(const Ogre::String& filename)
{
  Ogre::String full_path = scolToAbsolutePath(mName, filename);

  struct stat tagStat;
  bool ret = (stat(full_path.c_str(), &tagStat) == 0);

  // stat will return true if the filename is absolute, but we need to check
        // the file is actually in this archive
  if(ret && is_absolute_path(filename.c_str()))
        {
                // only valid if full path starts with our base
                // case insensitive on windows
                Ogre::String lowerCaseName = mName;
                Ogre::StringUtil::toLowerCase(lowerCaseName);
                ret = Ogre::StringUtil::startsWith(full_path, lowerCaseName, true);

    /*// case sensitive
                ret = Ogre::Ogre::StringUtil::startsWith(full_path, mName, false);*/
        }

        return ret;
}

//---------------------------------------------------------------------
time_t SO3ScolFileSystemArchive::getModifiedTime(const Ogre::String& filename)
{
        Ogre::String full_path = scolToAbsolutePath(mName, filename);

        struct stat tagStat;
        bool ret = (stat(full_path.c_str(), &tagStat) == 0);

        if(ret)
                return tagStat.st_mtime;
        else
                return 0;
}

}

---