File.h

/*--------------------------------------------------------------------------------------------
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/StringView.h>
#include <NDEVR/FileCachedData.h>
#include <NDEVR/InfoPipe.h>
namespace NDEVR
{
    typedef AlocatingAlignedBuffer<File, 64> FileBuffer; 
    class InfoPipe;
    class Time;
    class UUID;
    class StringView;
    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_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 
        };
    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 explicit File(const String& full_path);
        NDEVR_BASE_API File(const StringView& full_path);
        NDEVR_BASE_API explicit File(String&& full_path);
        NDEVR_BASE_API ~File();
        NDEVR_BASE_API void setFolderName(const StringView& folder_name);
        NDEVR_BASE_API bool copyTo(const File& cs, bool override_file, LogPtr log = LogPtr()) const;
        NDEVR_BASE_API bool moveTo(File& file, bool override_file, LogPtr log = LogPtr(), bool is_source_temp = false);
        NDEVR_BASE_API File& appendPath(const StringView& cs);
        NDEVR_BASE_API File& appendPath(const String& cs);
        NDEVR_BASE_API File& appendPath(const char* cs);
        [[nodiscard]] NDEVR_BASE_API StringView getPath(uint01 file_parts) const;
        NDEVR_BASE_API void setPath(const StringView& 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 HighCapacityBuffer<uint01> getDataExtended();
        [[nodiscard]] NDEVR_BASE_API StringView getFolderName(bool trailing_mark = false) 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 StringView& 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 FileBuffer getChildren() const;
        [[nodiscard]] NDEVR_BASE_API FileBuffer getChildrenMatching(const StringView& include_pattern, bool recursive = false, uint04 max_count = Constant<uint04>::Max) const;
        [[nodiscard]] NDEVR_BASE_API FileBuffer getChildrenMatching(const Buffer<String>& include_patterns, bool recursive = false, uint04 max_count = Constant<uint04>::Max) const;
        [[nodiscard]] NDEVR_BASE_API FileBuffer getChildrenMatching(const Buffer<String>& include_patterns, const Buffer<String>& exclude_patterns, bool recursive = false, uint04 max_count = Constant<uint04>::Max) const;
        [[nodiscard]] NDEVR_BASE_API FileBuffer getChildrenMatching(const Buffer<StringView>& include_patterns, bool recursive = false, uint04 max_count = Constant<uint04>::Max) const;
        [[nodiscard]] NDEVR_BASE_API FileBuffer getChildrenMatching(const Buffer<StringView>& include_patterns, const Buffer<StringView>& exclude_patterns, bool recursive = false, uint04 max_count = Constant<uint04>::Max) const;
        [[nodiscard]] NDEVR_BASE_API FILE* filePtr() const;
        NDEVR_BASE_API FILE* open(OpenMode mode, bool append = false);
        NDEVR_BASE_API void removeOpenOwnership();
        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 makeReadOnly(bool read_only);

        NDEVR_BASE_API void create(bool override_file) const;
        NDEVR_BASE_API void deleteFile(LogPtr log = LogPtr());

        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 StringView& value);
        NDEVR_BASE_API bool operator<<(const Buffer<uint01>& values);
        NDEVR_BASE_API bool operator<<(const HighCapacityBuffer<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 File generateTempFile() const;

        const String& pathID() const { return m_id; }
        StringView 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 StringView& display_string);
        NDEVR_BASE_API uint08 availableDiskSpace(bool privelaged = true) const;
        size_t operator()() const
        {
            return static_cast<size_t>(hash());
        }
    public:
        [[nodiscard]] NDEVR_BASE_API static File TempFileFolder();
        [[nodiscard]] NDEVR_BASE_API static String FileSizeToString(uint08 file_size);
        [[nodiscard]] NDEVR_BASE_API static FileBuffer SystemDrives();
        [[nodiscard]] NDEVR_BASE_API static FileBuffer MTPDevices();
        [[nodiscard]] NDEVR_BASE_API static bool DoesFileExist(const String& name);
        [[nodiscard]] NDEVR_BASE_API static bool typeSort(const File& i, const File& j);
        [[nodiscard]] NDEVR_BASE_API static bool nameSort(const File& i, const File& j);
        [[nodiscard]] NDEVR_BASE_API static bool accessSort(const File& i, const File& j);
        [[nodiscard]] NDEVR_BASE_API static bool createSort(const File& i, const File& j);
        [[nodiscard]] NDEVR_BASE_API static bool isPathSep(const char& path);
        [[nodiscard]] NDEVR_BASE_API static bool isIDSep(const char& path);
    public:
#ifdef _WIN32
        static constexpr char PathSep = '\\';         
        static constexpr StringView PathSepS = "\\";   
#else
        static constexpr char PathSep = '/';           
        static constexpr StringView PathSepS = "/";    
#endif
        static constexpr char ExtSep = '.';    
        static constexpr char DriveSep = ':';  
        static constexpr char IDSep = '|';     
    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;               
    };

    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 File& s) const noexcept
        {
            return static_cast<size_t>(s.hash());
        }
    };
    NDEVR_BASE_API istream& operator>>(istream& in, StringView& string);
};