src/main/cpp/file.cpp

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <log4cxx/logstring.h>
#include <log4cxx/file.h>
#include <apr_file_io.h>
#include <apr_file_info.h>
#include <log4cxx/helpers/transcoder.h>
#include <log4cxx/helpers/pool.h>
#include <assert.h>
#include <log4cxx/helpers/exception.h>

using namespace log4cxx;
using namespace log4cxx::helpers;

File::File() {
}

template<class S>
static LogString decodeLS(const S* src) {
    LogString dst;
    if (src != 0) {
      Transcoder::decode(src, dst);
    }
    return dst;
}

template<class S>
static LogString decodeLS(const std::basic_string<S>& src) {
    LogString dst;
    Transcoder::decode(src, dst);
    return dst;
}


File::File(const std::string& name1)
  : path(decodeLS(name1)) {
}

File::File(const char* name1)
  : path(decodeLS(name1)) {
}

#if LOG4CXX_WCHAR_T_API
File::File(const std::wstring& name1)
   : path(decodeLS(name1)) {
}

File::File(const wchar_t* name1)
   : path(decodeLS(name1)) {
}
#endif

#if LOG4CXX_UNICHAR_API
File::File(const std::basic_string<UniChar>& name1)
   : path(decodeLS(name1)) {
}

File::File(const UniChar* name1)
   : path(decodeLS(name1)) {
}
#endif

#if LOG4CXX_CFSTRING_API
File::File(const CFStringRef& name1)
   : path(decodeLS(name1)) {
}
#endif

File::File(const File& src)
  : path(src.path) {
}

File& File::operator=(const File& src) {
  if (this == &src) return *this;

  path.assign(src.path);

  return *this;
}


File::~File() {
}


LogString File::getPath() const {
    return path;
}

File& File::setPath(const LogString& newName) {
    path.assign(newName);
    return *this;
}

LogString File::getName() const {
    const logchar slashes[] = { 0x2F, 0x5C, 0 };
    size_t lastSlash = path.find_last_of(slashes);
    if (lastSlash != LogString::npos) {
        return path.substr(lastSlash+1);
    }
    return path;
}

char* File::getPath(Pool& p) const {
    int style = APR_FILEPATH_ENCODING_UNKNOWN;
    apr_filepath_encoding(&style, p.getAPRPool());
    char* retval = NULL;
    if (style == APR_FILEPATH_ENCODING_UTF8) {
        retval = Transcoder::encodeUTF8(path, p);
    } else {
        retval = Transcoder::encode(path, p);
    }
    return retval;
}

log4cxx_status_t File::open(apr_file_t** file, int flags,
      int perm, Pool& p) const {
    return apr_file_open(file, getPath(p), flags, perm, p.getAPRPool());
}



bool File::exists(Pool& p) const {
  apr_finfo_t finfo;
  apr_status_t rv = apr_stat(&finfo, getPath(p),
        0, p.getAPRPool());
  return rv == APR_SUCCESS;
}

char* File::convertBackSlashes(char* src) {
  for(char* c = src; *c != 0; c++) {
   if(*c == '\\') {
      *c = '/';
   }
  }
  return src;
}

bool File::deleteFile(Pool& p) const {
  apr_status_t rv = apr_file_remove(convertBackSlashes(getPath(p)),
        p.getAPRPool());
  return rv == APR_SUCCESS;
}

bool File::renameTo(const File& dest, Pool& p) const {
  apr_status_t rv = apr_file_rename(convertBackSlashes(getPath(p)),
        convertBackSlashes(dest.getPath(p)),
        p.getAPRPool());
  return rv == APR_SUCCESS;
}


size_t File::length(Pool& pool) const {
  apr_finfo_t finfo;
  apr_status_t rv = apr_stat(&finfo, getPath(pool),
        APR_FINFO_SIZE, pool.getAPRPool());
  if (rv == APR_SUCCESS) {
    return (size_t) finfo.size;
  }
  return 0;
}


log4cxx_time_t File::lastModified(Pool& pool) const {
  apr_finfo_t finfo;
  apr_status_t rv = apr_stat(&finfo, getPath(pool),
        APR_FINFO_MTIME, pool.getAPRPool());
  if (rv == APR_SUCCESS) {
    return finfo.mtime;
  }
  return 0;
}


std::vector<LogString> File::list(Pool& p) const {
    apr_dir_t *dir;
    apr_finfo_t entry;
    std::vector<LogString> filenames;

    apr_status_t stat = apr_dir_open(&dir,
        convertBackSlashes(getPath(p)),
        p.getAPRPool());
    if(stat == APR_SUCCESS) {
        int style = APR_FILEPATH_ENCODING_UNKNOWN;
        apr_filepath_encoding(&style, p.getAPRPool());
        stat = apr_dir_read(&entry, APR_FINFO_DIRENT, dir);
        while(stat == APR_SUCCESS) {
            if (entry.name != NULL) {
               LogString filename;
               if(style == APR_FILEPATH_ENCODING_UTF8) {
                 Transcoder::decodeUTF8(entry.name, filename);
               } else {
                   Transcoder::decode(entry.name, filename);
               }
               filenames.push_back(filename);
            }
            stat = apr_dir_read(&entry, APR_FINFO_DIRENT, dir);
        }
        stat = apr_dir_close(dir);
    }
    return filenames;
}

LogString File::getParent(Pool&) const {
     LogString::size_type slashPos = path.rfind(LOG4CXX_STR('/'));
     LogString::size_type backPos = path.rfind(LOG4CXX_STR('\\'));
     if (slashPos == LogString::npos) {
         slashPos = backPos;
     } else {
         if (backPos != LogString::npos && backPos > slashPos) {
             slashPos = backPos;
         }
     }
     LogString parent;
     if (slashPos != LogString::npos && slashPos > 0) {
          parent.assign(path, 0, slashPos);
     }
     return parent;
}

bool File::mkdirs(Pool& p) const {
     apr_status_t stat = apr_dir_make_recursive(convertBackSlashes(getPath(p)),
          APR_OS_DEFAULT, p.getAPRPool());
     return stat == APR_SUCCESS;
}