FileInfo.h

Go to the documentation of this file.

//     ____   ______ __
//    / __ \ / ____// /
//   / /_/ // /    / /
//  / ____// /___ / /___   PixInsight Class Library
// /_/     \____//_____/   PCL 2.7.0
// ----------------------------------------------------------------------------
// pcl/FileInfo.h - Released 2024-06-18T15:48:54Z
// ----------------------------------------------------------------------------
// This file is part of the PixInsight Class Library (PCL).
// PCL is a multiplatform C++ framework for development of PixInsight modules.
//
// Copyright (c) 2003-2024 Pleiades Astrophoto S.L. All Rights Reserved.
//
// Redistribution and use in both source and binary forms, with or without
// modification, is permitted provided that the following conditions are met:
//
// 1. All redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//
// 2. All 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.
//
// 3. Neither the names "PixInsight" and "Pleiades Astrophoto", nor the names
//    of their contributors, may be used to endorse or promote products derived
//    from this software without specific prior written permission. For written
//    permission, please contact info@pixinsight.com.
//
// 4. All products derived from this software, in any form whatsoever, must
//    reproduce the following acknowledgment in the end-user documentation
//    and/or other materials provided with the product:
//
//    "This product is based on software from the PixInsight project, developed
//    by Pleiades Astrophoto and its contributors (https://pixinsight.com/)."
//
//    Alternatively, if that is where third-party acknowledgments normally
//    appear, this acknowledgment must be reproduced in the product itself.
//
// THIS SOFTWARE IS PROVIDED BY PLEIADES ASTROPHOTO AND ITS 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 PLEIADES ASTROPHOTO OR ITS
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, BUSINESS
// INTERRUPTION; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; AND LOSS OF USE,
// DATA OR PROFITS) 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 __PCL_FileInfo_h
#define __PCL_FileInfo_h
 
 
#include <pcl/Defs.h>
#include <pcl/Diagnostics.h>
 
#include <pcl/Flags.h>
#include <pcl/String.h>
 
namespace pcl
{
 
// ----------------------------------------------------------------------------
 
namespace FileAttribute
{
   enum mask_type
   {
      /*
       * File type.
       */
      Block          = 0x00000001,  // Block special
      Character      = 0x00000002,  // Character special
      FIFO           = 0x00000004,  // FIFO special
      Regular        = 0x00000008,  // Regular file
      Directory      = 0x00000010,  // Directory
      SymbolicLink   = 0x00000020,  // Symbolic link
      Socket         = 0x00000040,  // Socket
      FileType       = 0x000000FF,
 
      /*
       * File attributes.
       * These are Windows-exclusive, except ReadOnly and Hidden, which we
       * emulate on UNIX and Linux.
       */
      Archive        = 0x00001000,  // File is archived
      Compressed     = 0x00002000,  // File is compressed
      Encrypted      = 0x00004000,  // File is encrypted
      Hidden         = 0x00008000,  // File is hidden
      ReadOnly       = 0x00010000,  // File is read-only
      System         = 0x00020000,  // File is a system file
      Temporary      = 0x00040000,  // File is a temporary file
      FileAttributes = 0x000FF000,
 
      /*
       * File permissions.
       */
      Read           = 0x00100000,  // Owner can read
      Write          = 0x00200000,  // Owner can write
      Execute        = 0x00400000,  // Owner can execute/search
      ReadGroup      = 0x01000000,  // Group can read
      WriteGroup     = 0x02000000,  // Group can write
      ExecuteGroup   = 0x04000000,  // Group can execute/search
      ReadOthers     = 0x10000000,  // Others can read
      WriteOthers    = 0x20000000,  // Others can write
      ExecuteOthers  = 0x40000000,  // Others can execute/search
      FilePermissions= 0xFFF00000
   };
}
 
using FileAttributes = Flags<FileAttribute::mask_type>;
 
// ----------------------------------------------------------------------------
 
struct FileTime
{
   uint16   year         : 16; 
   uint8    month        :  4; 
   uint8    day          :  5; 
   uint8    hour         :  5; 
   int                   :  2;
   uint8    minute       :  6; 
   uint8    second       :  6; 
   int                   :  4;
   uint16   milliseconds : 10; 
   int                   :  6;
 
   bool operator ==( const FileTime& t ) const
   {
      return second == t.second && minute == t.minute && hour == t.hour &&
             day == t.day && month == t.month && year == t.year &&
             milliseconds == t.milliseconds;
   }
 
   bool operator <( const FileTime& t ) const
   {
      if ( year != t.year )
         return year < t.year;
      if ( month != t.month )
         return month < t.month;
      if ( day != t.day )
         return day < t.day;
      if ( hour != t.hour )
         return hour < t.hour;
      if ( minute != t.minute )
         return minute < t.minute;
      if ( second != t.second )
         return second < t.second;
      if ( milliseconds != t.milliseconds )
         return milliseconds < t.milliseconds;
      return false;
   }
 
   double ToJD() const;
 
   double DaysSinceEpoch() const
   {
      return ToJD() - 2440587.5;
   }
 
   double SecondsSinceEpoch() const
   {
      return 86400*DaysSinceEpoch();
   }
};
 
// ----------------------------------------------------------------------------
 
class PCL_CLASS FileInfo
{
public:
 
   FileInfo()
   {
      Clear();
   }
 
   FileInfo( const String& path )
   {
      Refresh( path );
   }
 
   FileInfo( const FileInfo& ) = default;
 
   virtual ~FileInfo()
   {
   }
 
   FileInfo& operator =( const FileInfo& ) = default;
 
   const String& Path() const
   {
      return m_path;
   }
 
   String Drive() const;
 
   String Directory() const;
 
   String Name() const;
 
   String Extension() const;
 
   String Suffix() const
   {
      return Extension();
   }
 
   String CompleteSuffix() const;
 
   String NameAndExtension() const;
 
   String NameAndSuffix() const
   {
      return NameAndExtension();
   }
 
   bool Exists() const
   {
      return m_exists;
   }
 
   const FileAttributes& Attributes() const
   {
      return m_attributes;
   }
 
   bool IsDirectory() const
   {
      return m_attributes.IsFlagSet( FileAttribute::Directory );
   }
 
   bool IsFile() const
   {
      return m_attributes.IsFlagSet( FileAttribute::Regular );
   }
 
   bool IsSymbolicLink() const
   {
      return m_attributes.IsFlagSet( FileAttribute::SymbolicLink );
   }
 
   String SymbolicLinkTarget() const;
 
   bool IsHidden() const
   {
      return m_attributes.IsFlagSet( FileAttribute::Hidden );
   }
 
   bool IsReadable() const
   {
      return m_readable;
   }
 
   bool IsWritable() const
   {
      return m_writable;
   }
 
   bool IsExecutable() const
   {
      return m_executable;
   }
 
   fsize_type Size() const
   {
      return m_size;
   }
 
   int NumberOfHardLinks() const
   {
      return m_numberOfHardLinks;
   }
 
   int UserId() const
   {
      return m_userId;
   }
 
   int GroupId() const
   {
      return m_groupId;
   }
 
   const FileTime& TimeCreated() const
   {
      return m_created;
   }
 
   const FileTime& LastAccessed() const
   {
      return m_lastAccessed;
   }
 
   const FileTime& LastModified() const
   {
      return m_lastModified;
   }
 
   void Refresh();
 
   void Refresh( const String& path );
 
   void Clear();
 
private:
 
   String         m_path;              // full file or directory path
   FileAttributes m_attributes;        // item attributes
   fsize_type     m_size;              // file size in bytes
   int            m_numberOfHardLinks; // number of existing hard links to this file
   int            m_userId;            // user id of the file owner
   int            m_groupId;           // group id of the file owner
   FileTime       m_created;           // creation time
   FileTime       m_lastAccessed;      // time of last access
   FileTime       m_lastModified;      // time of last change
   bool           m_exists;            // item exists
   bool           m_readable;          // caller has read permission
   bool           m_writable;          // caller has write permission
   bool           m_executable;        // caller has execute permission
 
   // Clears everything but *preserves* m_path
   void ClearInfo();
};
 
using FileInfoList = Array<FileInfo>;
 
// ----------------------------------------------------------------------------
 
} // pcl
 
#endif  // __PCL_FileInfo_h
 
// ----------------------------------------------------------------------------
// EOF pcl/FileInfo.h - Released 2024-06-18T15:48:54Z