io.h

Go to the documentation of this file.

/*
* This program source code file is part of KiCad, a free EDA CAD application.
*
* Copyright The KiCad Developers, see AUTHORS.txt for contributors.
*
* This program is free software: you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation, either version 3 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
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program.  If not, see <https://www.gnu.org/licenses/>.
*/
 
#ifndef KIPLATFORM_IO_H_
#define KIPLATFORM_IO_H_
 
#include <stdio.h>
#include <cstddef>
#include <cstdint>
#include <string>
#include <vector>
 
class wxString;
class wxFileName;
 
namespace KIPLATFORM
{
namespace IO
{
    class MAPPED_FILE
    {
    public:
        explicit MAPPED_FILE( const wxString& aFileName );
        ~MAPPED_FILE();
 
        MAPPED_FILE( const MAPPED_FILE& ) = delete;
        MAPPED_FILE& operator=( const MAPPED_FILE& ) = delete;
 
        const uint8_t* Data() const { return m_data; }
        size_t         Size() const { return m_size; }
 
    private:
        void readIntoBuffer( const wxString& aFileName );
 
        const uint8_t* m_data = nullptr;
        size_t         m_size = 0;
 
#ifdef _WIN32
        void*          m_fileHandle = nullptr;
        void*          m_mapHandle = nullptr;
#else
        bool           m_isMapped = false;
#endif
 
        std::vector<uint8_t> m_fallbackBuffer;
    };

    class FILE_LOCK
    {
    public:
        enum class STATE
        {
            NONE,           
            HELD,           
            BUSY,           
            UNSUPPORTED     
        };
 
        FILE_LOCK() = default;
        ~FILE_LOCK();
 
        FILE_LOCK( FILE_LOCK&& aOther ) noexcept;
        FILE_LOCK& operator=( FILE_LOCK&& aOther ) noexcept;
 
        FILE_LOCK( const FILE_LOCK& ) = delete;
        FILE_LOCK& operator=( const FILE_LOCK& ) = delete;

        STATE Acquire( const wxString& aPath, bool& aCreated );

        bool OpenForInspect( const wxString& aPath, bool& aHeldByAnother );
 
        bool IsOpen() const;

        bool ReadAll( std::string& aContents ) const;

        bool Rewrite( const std::string& aContents );

        void Release();
 
    private:
#ifdef _WIN32
        void* m_handle = nullptr;
#else
        int   m_fd = -1;
#endif
        STATE m_state = STATE::NONE;
    };

    static constexpr size_t CLOUD_SYNC_BUFFER_SIZE = 512 * 1024;
    FILE* SeqFOpen( const wxString& aPath, const wxString& mode );

    bool DuplicatePermissions( const wxString& aSrc, const wxString& aDest );

    bool MakeWriteable( const wxString& aFilePath );

    bool IsFileHidden( const wxString& aFileName );

    void LongPathAdjustment( wxFileName& aFilename );

    long long TimestampDir( const wxString& aDirPath, const wxString& aFilespec );

    bool FlushToDisk( FILE* aFp );

    bool FlushDirectory( const wxString& aDirPath );

    bool AtomicRename( const wxString& aSrc, const wxString& aDst, wxString* aError = nullptr );

    wxString MakeSiblingTempPath( const wxString& aTargetPath );

    FILE* OpenUniqueSiblingTempFile( const wxString& aTargetPath, const wxString& aMode,
                                     wxString* aTempPathOut, wxString* aError = nullptr );

    wxString ResolveSymlinkTarget( const wxString& aPath );

    struct TARGET_ATTRS
    {
        std::uint32_t value    = 0;
        bool          captured = false;
    };

    TARGET_ATTRS CaptureTargetAttributes( const wxString& aPath );

    bool ApplyTargetAttributes( const wxString& aPath, const TARGET_ATTRS& aAttrs );

    bool CommitTempFile( const wxString& aTempPath, const wxString& aTargetPath,
                         wxString* aError = nullptr );

    bool AtomicWriteFile( const wxString& aTargetPath, const void* aData, size_t aSize,
                          wxString* aError = nullptr );
} // namespace IO
} // namespace KIPLATFORM
 
#endif // KIPLATFORM_IO_H_