---

/include/recls/cpp/fileentry.hpp

Go to the documentation of this file.

/* 
 * File:        recls/cpp/fileentry.hpp
 *
 * Purpose:     recls C++ mapping - FileEntry class.
 *
 * Created:     18th August 2003
 * Updated:     15th March 2005
 *
 * Home:        http://recls.org/
 *
 * Copyright 2003-2005, Matthew Wilson and Synesis Software
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without 
 * modification, are permitted provided that the following conditions are met:
 *
 * - Redistributions of source code must retain the above copyright notice, this
 *   list of conditions and the following disclaimer. 
 * - Redistributions in binary form must reproduce the above copyright notice,
 *   this list of conditions and the following disclaimer in the documentation
 *   and/or other materials provided with the distribution.
 * - Neither the name(s) of Matthew Wilson and Synesis Software nor the names of
 *   any contributors may be used to endorse or promote products derived from
 *   this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 * 


#ifndef RECLS_INCL_RECLS_CPP_HPP_FILEENTRY
#define RECLS_INCL_RECLS_CPP_HPP_FILEENTRY

/* File version */
#ifndef RECLS_DOCUMENTATION_SKIP_SECTION
# define RECLS_VER_RECLS_CPP_HPP_FILEENTRY_MAJOR    2
# define RECLS_VER_RECLS_CPP_HPP_FILEENTRY_MINOR    2
# define RECLS_VER_RECLS_CPP_HPP_FILEENTRY_REVISION 1
# define RECLS_VER_RECLS_CPP_HPP_FILEENTRY_EDIT     27
#endif /* !RECLS_DOCUMENTATION_SKIP_SECTION */

/* 
 * Includes
 */

#include <recls/cpp/recls.hpp>      // reclspp root header
#include <recls_assert.h>
#include <stlsoft.h>
#include <stlsoft_operator_bool.h>  // For operator bool() stuff
#if defined(RECLS_PLATFORM_IS_WIN32)
# include <winstl_file_path_buffer.h>
#elif defined(RECLS_PLATFORM_IS_UNIX)
# include <unixstl_file_path_buffer.h>
#else
# error Platform not (yet) recognised
#endif /* platform */

/* 
 * Namespace
 */

#if !defined(RECLS_NO_NAMESPACE)
namespace recls
{

namespace cpp
{
#endif /* !RECLS_NO_NAMESPACE */

#if defined(RECLS_PLATFORM_IS_WIN32)
typedef winstl::basic_file_path_buffer<recls_char_t>    file_path_buffer;
#elif defined(RECLS_PLATFORM_IS_UNIX)
typedef unixstl::basic_file_path_buffer<recls_char_t>   file_path_buffer;
#else
# error Platform not (yet) recognised
#endif /* platform */

/* 
 * Forward declarations
 */

class FileEntry;
class FileSearch;

/* 
 * Classes
 */

class DirectoryParts
{
public:
    typedef recls_char_t    char_type;
    typedef DirectoryParts  class_type;

// Construction
private:
    friend class FileEntry;
    DirectoryParts(recls_info_t info);

public:
    DirectoryParts();
    DirectoryParts(DirectoryParts const &rhs);
    ~DirectoryParts();

    DirectoryParts &operator =(DirectoryParts const &rhs);


public:
    size_t      size() const;
    string_t    operator [](size_t index) const;


// Implementation
private:
    static recls_info_t copy_info_(recls_info_t info);

// Members
private:
    recls_info_t    m_info;
};

class FileEntry
{
public:
    typedef recls_char_t    char_type;
    typedef FileEntry       class_type;

// Construction
private:
    friend class Search;
    FileEntry(recls_info_t info);

public:
    FileEntry();
    FileEntry(FileEntry const &rhs);
    ~FileEntry();

    FileEntry &operator =(FileEntry const &rhs);

private:
    STLSOFT_DEFINE_OPERATOR_BOOL_TYPES(class_type, boolean_generator_type, boolean_type);
public:
    operator boolean_type() const
    {
        return boolean_generator_type::translate(NULL != m_info);
    }

#ifndef STLSOFT_CF_OPERATOR_NOT_VIA_OPERATOR_POINTER_TO_MEMBER_SUPPORT

    bool operator !() const;
#endif /* !STLSOFT_CF_OPERATOR_NOT_VIA_OPERATOR_POINTER_TO_MEMBER_SUPPORT */


public:
#ifndef RECLS_PURE_API

    char_type const     *c_str() const;
#endif /* !RECLS_PURE_API */

    string_t            GetPath() const;
#ifdef RECLS_PLATFORM_API_WIN32

    char_type           GetDrive() const;
#endif /* RECLS_PLATFORM_API_WIN32 */

    string_t            GetDirectory() const;
    string_t            GetDirectoryPath() const;
#if defined(RECLS_DOCUMENTATION_SKIP_SECTION) || \
    (   RECLS_VER_MAJOR > 1 || \
        RECLS_VER_MINOR >= 6)

    string_t            GetUNCDrive() const;
#endif /* recls 1.6.x */

    DirectoryParts      GetDirectoryParts() const;
    string_t            GetFile() const;
    string_t            GetShortFile() const;
    string_t            GetFileName() const;
    string_t            GetFileExt() const;

    recls_time_t        GetCreationTime() const;
    recls_time_t        GetModificationTime() const;
    recls_time_t        GetLastAccessTime() const;
    recls_time_t        GetLastStatusChangeTime() const;

    recls_filesize_t    GetSize() const;

    recls_bool_t        IsReadOnly() const;
    recls_bool_t        IsDirectory() const;
    recls_bool_t        IsLink() const;
#if defined(RECLS_DOCUMENTATION_SKIP_SECTION) || \
    (   RECLS_VER_MAJOR > 1 || \
        RECLS_VER_MINOR >= 6)

    recls_bool_t        IsUNC() const;
#endif /* recls 1.6.x */


// Implementation
private:
    static recls_info_t copy_info_(recls_info_t info);
#ifdef RECLS_PURE_API
    // Note: this has to be inside the class because GCC is a real dummy n this regard.
    static string_t     get_string_(size_t (RECLS_CALLCONV_DEFAULT *pfn)(recls_info_t, recls_char_t *, size_t), recls_info_t info);
    {
        file_path_buffer    buffer;
        size_t              cch =   pfn(info, &buffer[0], buffer.size());

        return string_t(&buffer[0], cch);
    }
#endif /* RECLS_PURE_API */

// Members
private:
    recls_info_t    m_info;
};

/* 
 * Shims
 */

#ifndef RECLS_PURE_API
inline FileEntry::char_type const *c_str_ptr(FileEntry const &fe)
{
    return fe.c_str();
}
#endif /* !RECLS_PURE_API */

/* 
 * Implementation
 */

inline /* static */ recls_info_t DirectoryParts::copy_info_(recls_info_t info)
{
    recls_info_t    newInfo;

    if( NULL == info ||
        RECLS_FAILED(Recls_CopyDetails(info, &newInfo)))
    {
        newInfo = NULL;
    }

    return newInfo;
}

inline DirectoryParts::DirectoryParts(recls_info_t info)
    : m_info(copy_info_(info))
{}

inline DirectoryParts::DirectoryParts()
    : m_info(NULL)
{}

inline DirectoryParts::DirectoryParts(DirectoryParts const &rhs)
    : m_info(copy_info_(rhs.m_info))
{}

inline DirectoryParts::~DirectoryParts()
{
    Recls_CloseDetails(m_info);
}

inline DirectoryParts &DirectoryParts::operator =(DirectoryParts const &rhs)
{
    Recls_CloseDetails(m_info);

    m_info = copy_info_(rhs.m_info);

    return *this;
}

inline size_t DirectoryParts::size() const
{
    return Recls_GetDirectoryPartProperty(m_info, -1, NULL, 0);
}

inline string_t DirectoryParts::operator [](size_t index) const
{
    file_path_buffer    dirPart;

    recls_assert(NULL != m_info);
    recls_assert(index < size());

    return RECLS_SUCCEEDED(Recls_GetDirectoryPartProperty(m_info, index, &dirPart[0], dirPart.size())) ? string_t(dirPart.c_str()) : string_t();
}

inline /* static */ recls_info_t FileEntry::copy_info_(recls_info_t info)
{
    recls_info_t    newInfo;

    if( NULL == info ||
        RECLS_FAILED(Recls_CopyDetails(info, &newInfo)))
    {
        newInfo = NULL;
    }

    return newInfo;
}

inline FileEntry::FileEntry(recls_info_t info)
    : m_info(info)
{}

inline FileEntry::FileEntry()
    : m_info(NULL)
{}

inline FileEntry::FileEntry(FileEntry const &rhs)
    : m_info(copy_info_(rhs.m_info))
{}

inline FileEntry::~FileEntry()
{
    if(NULL != m_info)
    {
        Recls_CloseDetails(m_info);
    }
}

inline FileEntry &FileEntry::operator =(FileEntry const &rhs)
{
    Recls_CloseDetails(m_info);

    m_info = copy_info_(rhs.m_info);

    return *this;
}

#ifndef STLSOFT_CF_OPERATOR_NOT_VIA_OPERATOR_POINTER_TO_MEMBER_SUPPORT
inline bool FileEntry::operator !() const
{
    return (*this) ? false : true;
}
#endif /* !STLSOFT_CF_OPERATOR_NOT_VIA_OPERATOR_POINTER_TO_MEMBER_SUPPORT */


#ifndef RECLS_PURE_API
inline FileEntry::char_type const *FileEntry::c_str() const
{
    return (NULL != m_info) ? m_info->path.begin : "";
}
#endif /* !RECLS_PURE_API */

inline string_t FileEntry::GetPath() const
{
    recls_assert(NULL != m_info);

#ifdef RECLS_PURE_API
    return get_string_(Recls_GetPathProperty, m_info);
#else /* ? RECLS_PURE_API */
    return string_t(m_info->path.begin, m_info->path.end);
#endif /* RECLS_PURE_API */
}

#ifdef RECLS_PLATFORM_API_WIN32
inline FileEntry::char_type FileEntry::GetDrive() const
{
    char_type chDrive;

    return (Recls_GetDriveProperty(m_info, &chDrive), chDrive);
}
#endif /* RECLS_PLATFORM_API_WIN32 */

inline string_t FileEntry::GetDirectory() const
{
    recls_assert(NULL != m_info);

#ifdef RECLS_PURE_API
    return get_string_(Recls_GetDirectoryProperty, m_info);
#else /* ? RECLS_PURE_API */
    return string_t(m_info->directory.begin, m_info->directory.end);
#endif /* RECLS_PURE_API */
}

inline string_t FileEntry::GetDirectoryPath() const
{
    recls_assert(NULL != m_info);

#ifdef RECLS_PURE_API
    return get_string_(Recls_GetDirectoryPathProperty, m_info);
#else /* ? RECLS_PURE_API */
    return string_t(m_info->path.begin, m_info->directory.end);
#endif /* RECLS_PURE_API */
}

#if defined(RECLS_DOCUMENTATION_SKIP_SECTION) || \
    (   RECLS_VER_MAJOR > 1 || \
        RECLS_VER_MINOR >= 6)
inline string_t FileEntry::GetUNCDrive() const
{
    recls_assert(NULL != m_info);

#if 0
    if(!IsUNC())
    {
        return string_t();
    }
    else
    {
#ifdef RECLS_PURE_API
        string_t    directoryPath   =   GetDirectoryPath();
        size_t      directoryLen    =   Recls_GetDirectoryProperty(m_info, NULL, 0);

        return string_t(directoryPath, 0, directoryPath.length() - directoryLen);
#else /* ? RECLS_PURE_API */
        return string_t(m_info->path.begin, m_info->directory.begin);
#endif /* RECLS_PURE_API */
    }
#else /* ? 0 */
# ifdef RECLS_PURE_API
    return get_string_(Recls_GetUNCDriveProperty, m_info);
# else /* ? RECLS_PURE_API */
    return string_t(m_info->path.begin, m_info->directory.begin);
# endif /* RECLS_PURE_API */
#endif /* 0 */
}
#endif /* recls 1.6.x */

inline DirectoryParts FileEntry::GetDirectoryParts() const
{
    recls_assert(NULL != m_info);

    return DirectoryParts(m_info);
}

inline string_t FileEntry::GetFile() const
{
    recls_assert(NULL != m_info);

#ifdef RECLS_PURE_API
    return get_string_(Recls_GetFileProperty, m_info);
#else /* ? RECLS_PURE_API */
    recls_assert(m_info->fileName.begin <= m_info->fileExt.end);
    return string_t(m_info->fileName.begin, m_info->fileExt.end);
#endif /* RECLS_PURE_API */
}

inline string_t FileEntry::GetShortFile() const
{
#ifdef RECLS_PLATFORM_API_WIN32
    recls_assert(NULL != m_info);

    return string_t(m_info->shortFile.begin, m_info->shortFile.end);
#else
    return GetFile();
#endif /* RECLS_PLATFORM_API_WIN32 */
}

inline string_t FileEntry::GetFileName() const
{
    recls_assert(NULL != m_info);

#ifdef RECLS_PURE_API
    return get_string_(Recls_GetFileNameProperty, m_info);
#else /* ? RECLS_PURE_API */
    return string_t(m_info->fileName.begin, m_info->fileName.end);
#endif /* RECLS_PURE_API */
}

inline string_t FileEntry::GetFileExt() const
{
    recls_assert(NULL != m_info);

#ifdef RECLS_PURE_API
    return get_string_(Recls_GetFileExtProperty, m_info);
#else /* ? RECLS_PURE_API */
    return string_t(m_info->fileExt.begin, m_info->fileExt.end);
#endif /* RECLS_PURE_API */
}

inline recls_time_t FileEntry::GetCreationTime() const
{
    recls_assert(NULL != m_info);

    return Recls_GetCreationTime(m_info);
}

inline recls_time_t FileEntry::GetModificationTime() const
{
    recls_assert(NULL != m_info);

    return Recls_GetModificationTime(m_info);
}

inline recls_time_t FileEntry::GetLastAccessTime() const
{
    recls_assert(NULL != m_info);

    return Recls_GetLastAccessTime(m_info);
}

inline recls_time_t FileEntry::GetLastStatusChangeTime() const
{
    recls_assert(NULL != m_info);

    return Recls_GetLastStatusChangeTime(m_info);
}

inline recls_filesize_t FileEntry::GetSize() const
{
    recls_assert(NULL != m_info);

#ifdef RECLS_PURE_API
    recls_filesize_t    size;

    return (Recls_GetSizeProperty(m_info, &size), size);
#else /* ? RECLS_PURE_API */
    return m_info->size;
#endif /* RECLS_PURE_API */
}

inline recls_bool_t FileEntry::IsReadOnly() const
{
    recls_assert(NULL != m_info);

    return Recls_IsFileReadOnly(m_info);
}

inline recls_bool_t FileEntry::IsDirectory() const
{
    recls_assert(NULL != m_info);

    return Recls_IsFileDirectory(m_info);
}

inline recls_bool_t FileEntry::IsLink() const
{
    recls_assert(NULL != m_info);

    return Recls_IsFileLink(m_info);
}

#if defined(RECLS_DOCUMENTATION_SKIP_SECTION) || \
    (   RECLS_VER_MAJOR > 1 || \
        RECLS_VER_MINOR >= 6)
inline recls_bool_t FileEntry::IsUNC() const
{
    recls_assert(NULL != m_info);

    return Recls_IsFileUNC(m_info);
}
#endif /* recls 1.6.x */

/* 
 * Namespace
 */

#if !defined(RECLS_NO_NAMESPACE)
} /* namespace cpp */
} /* namespace recls */
#endif /* !RECLS_NO_NAMESPACE */

/* 

#endif /* !RECLS_INCL_RECLS_CPP_HPP_FILEENTRY */

/* 

recls Library documentation © Synesis Software Pty Ltd, 2001-2005