File.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants 
Licensee a limited, non-exclusive, non-transferable, royalty-free license 
(without the right to sublicense) to use the API solely for the purpose of 
Licensee's internal development efforts to develop applications for which 
the API was provided.
 
The above copyright notice and this permission notice shall be included in all 
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: Base
File: File
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "DLLInfo.h"
#include <NDEVR/String.h>
#include <NDEVR/Time.h>
#include <NDEVR/FileCachedData.h>
namespace NDEVR
{
    class ProgressInfo;
    class Time;
    class UUID;
    
    /**----------------------------------------------------------------------------
    \brief Logic for reading or writing to a file as well as navigating filesystems
        or other common file operations.
    ----------------------------------------------------------------------------*/
    class File : public String
    {
    public: 
        enum OpenMode : uint01
        {
              e_binary_read
            , e_binary_write
            , e_ascii_read
            , e_ascii_write
            , e_ascii_read_safe
            , e_binary_read_safe
            , e_ascii_write_safe
            , e_binary_write_safe
            , e_ascii_read_shared
            , e_undefined
        };
        enum FilePart 
        {
              e_drive          = 0x01
            , e_dir_path       = 0x02
            , e_file_name      = 0x04
            , e_file_extension = 0x08
            , e_full_path = e_drive | e_dir_path | e_file_name | e_file_extension
            , e_folder_name = 0x10
        };
    public: 
        NDEVR_BASE_API File();
        NDEVR_BASE_API File(const File& file);
        NDEVR_BASE_API File(const String& resource_name, const String& path_id);
        NDEVR_BASE_API File(File&& file) noexcept;
        NDEVR_BASE_API File(const String& full_path);
        NDEVR_BASE_API File(String&& full_path);
        NDEVR_BASE_API File(const char* full_path);
        NDEVR_BASE_API ~File();
 
        NDEVR_BASE_API bool copyTo(const File& cs, bool override_file, ProgressInfo* log = nullptr) const;
        NDEVR_BASE_API bool moveTo(File& file, bool override_file, ProgressInfo* log = nullptr, bool is_source_temp = false);
        NDEVR_BASE_API File& appendPath(const String& cs);
        [[nodiscard]] NDEVR_BASE_API String getPath(uint01 file_parts) const;
        NDEVR_BASE_API void setPath(const String& path, uint01 part);
        NDEVR_BASE_API void removeInvalidChars();
        [[nodiscard]] NDEVR_BASE_API bool exists() const;
        [[nodiscard]] NDEVR_BASE_API bool cachedExist() const;
        [[nodiscard]] NDEVR_BASE_API bool parentDirectoryExists() const;
        [[nodiscard]] NDEVR_BASE_API bool isDirectory() const;
        [[nodiscard]] NDEVR_BASE_API bool isDrive() const;
        [[nodiscard]] NDEVR_BASE_API bool isHidden() const;
        [[nodiscard]] NDEVR_BASE_API bool isOpen() const;
        
        [[nodiscard]] NDEVR_BASE_API Buffer<uint01> getData();
        [[nodiscard]] NDEVR_BASE_API String getFolderName() const;
        [[nodiscard]] NDEVR_BASE_API String getDriveDescription() const;
 
        [[nodiscard]] NDEVR_BASE_API Time getModifiedTime() const;
        [[nodiscard]] NDEVR_BASE_API Time getCreationTime() const;
        [[nodiscard]] NDEVR_BASE_API Time getAccessTime() const;
        NDEVR_BASE_API void getFileTimes(Time& modified_time, Time& creation_time, Time& access_time) const;
        NDEVR_BASE_API bool updateAccessedTime() const;
        NDEVR_BASE_API bool updateAccessedTime(Time access_time) const;
        
        NDEVR_BASE_API File& append(const String& s);
        NDEVR_BASE_API File& append(const char& s);
        NDEVR_BASE_API File getParentDirectory() const;
        NDEVR_BASE_API File findNonExistingSuitableName() const;
        NDEVR_BASE_API void expandEnvironmentalVars();
        [[nodiscard]] NDEVR_BASE_API Buffer<File, uint04, ObjectAllocator<false>> getChildren() const;
        [[nodiscard]] NDEVR_BASE_API Buffer<File, uint04, ObjectAllocator<false>> getChildrenMatching(const Buffer<String>& include_patterns, const Buffer<String>& exclude_patterns, bool recursive = false) const;
        [[nodiscard]] NDEVR_BASE_API FILE* filePtr();
        NDEVR_BASE_API FILE* open(OpenMode mode, bool append = false);
        NDEVR_BASE_API String relativePathTo(const File& reference) const;
        NDEVR_BASE_API void flush();
        NDEVR_BASE_API void close();
        NDEVR_BASE_API bool hasNullBytes(uint08 max_length = Constant<uint08>::Max);
 
        
        NDEVR_BASE_API void create(bool override_file) const;
        NDEVR_BASE_API void deleteFile(ProgressInfo* log = nullptr);
 
        NDEVR_BASE_API void throwIfNotExist() const;
 
        [[nodiscard]] NDEVR_BASE_API uint08 fileSize() const;
 
        [[nodiscard]] NDEVR_BASE_API UUID getUUID() const;
    
        NDEVR_BASE_API File& operator=(const File& value);
 
        NDEVR_BASE_API bool operator<<(const String& value);
        NDEVR_BASE_API bool operator<<(const Buffer<uint01>& values);
        NDEVR_BASE_API bool operator<<(const fltp04& value);
        NDEVR_BASE_API bool operator<<(const fltp08& value);
 
        NDEVR_BASE_API File& operator=(String& value);
        NDEVR_BASE_API File& operator=(File&& value) noexcept;
 
        NDEVR_BASE_API void setInternalVars();
        [[nodiscard]] NDEVR_BASE_API static File TempFileFolder();
        [[nodiscard]] NDEVR_BASE_API File generateTempFile() const;
 
        const String& pathID() const { return m_id; }
        String pathNameID() const;
        NDEVR_BASE_API bool isMTP() const;
        NDEVR_BASE_API bool resolveMTPPath() const;
        NDEVR_BASE_API bool resolveNameFromMTPPath();
        NDEVR_BASE_API void invalidateCache();
        NDEVR_BASE_API void updateCache() const;
        NDEVR_BASE_API const FileCachedData& currentCache() const;
        NDEVR_BASE_API void updateCache(const FileCachedData& cache);
        NDEVR_BASE_API String toDisplayString();
        NDEVR_BASE_API void setFromDisplayString(const String& display_string);
    public:
        NDEVR_BASE_API static Buffer<File, uint04, ObjectAllocator<false>> SystemDrives();
        NDEVR_BASE_API static Buffer<File, uint04, ObjectAllocator<false>> MTPDevices();
        NDEVR_BASE_API static bool doesFileExist(const String& name);
        NDEVR_BASE_API static bool typeSort(const File& i, const File& j);
        NDEVR_BASE_API static bool nameSort(const File& i, const File& j);
        NDEVR_BASE_API static bool accessSort(const File& i, const File& j);
        NDEVR_BASE_API static bool createSort(const File& i, const File& j);
        NDEVR_BASE_API static bool isPathSep(const char& path);
        NDEVR_BASE_API static bool isIDSep(const char& path);
        size_t operator()() const
        {
            return static_cast<size_t>(hash());
        }
    public:
#ifdef _WIN32
        static constexpr char PathSep = '\\';
#else
        static constexpr char PathSep = '/';
#endif
        static constexpr char ExtSep = '.';
        static constexpr char DriveSep = ':';
        static constexpr char IDSep = '|';
 
        NDEVR_BASE_API static String PathSepS;
    private:
        void checkError(uint04 error) const;
    protected:
        mutable FileCachedData m_cached_data;
        mutable String m_id;
        FILE* m_file_ptr;
        OpenMode m_open_mode;
        uint01 m_path_start;
        uint01 m_file_name_start;
        uint01 m_file_ext_start;
        mutable bool m_id_valid;
    };
    /**----------------------------------------------------------------------------
    \brief Logic for searching for files based on some criteria.
    File searches help locate files or directories within other directories.
    ----------------------------------------------------------------------------*/
    class NDEVR_BASE_API FileSearch
    {
    public:
        Buffer<File> files_recursively_to_search;
        Buffer<String> search_extensions;
        Buffer<File> excluded_list;
        uint04 max_recursion_level = Constant<uint04>::Max;
        Buffer<File> performSearch() const;
    protected:
        void performSearch(const File& current_file, Buffer<File>& files, uint04 recursion_level) const;
    };
}
 
namespace std//Define things to allow use within std libs
{
    template <>
    struct hash<NDEVR::File>
    {
        std::size_t operator()(const NDEVR::File& s) const noexcept
        {
            return static_cast<size_t>(s.hash());
        }
    };
    NDEVR_BASE_API istream& operator>>(istream& in, NDEVR::String& string);
};