File.hpp

Go to the documentation of this file.

//
// BEGIN_SOFTWARE_AND_SERVICES_COPYRIGHT
//
// Copyright (C) 2010-2017 Software and Services LLC, All Rights Reserved.
//
// NOTICE:
//
// THIS SOURCE CODE BELONGS TO Software and Services LLC.
// THIS CODE IS PROPERTY OF THE COPYRIGHT HOLDER AND IS NOT TO
// BE DIVULGED OR USED BY PARTIES WHO HAVE NOT RECEIVED WRITTEN
// AUTHORIZATION FROM THE OWNER.
//
// THIS SOFTWARE AND MANUAL ARE BOTH PROTECTED BY UNITED STATES
// COPYRIGHT LAW (TITLE 17 UNITED STATES CODE). UNAUTHORIZED REPRODUCTION
// AND/OR SALE MAY RESULT IN IMPRISONMENT OF UP TO ONE YEAR AND FINES
// OF UP TO $100,000 (17 USC 506). COPYRIGHT INFRINGERS MAY ALSO
// BE SUBJECT TO CIVIL LIABILITY.
//
// THIS NOTICE AND THE ABOVE COPYRIGHT NOTICE MUST REMAIN IN ALL
// COPIES AND ANY DERIVED WORK.
//
// ALL OF THIS CODE IS ORIGINAL WORK BY THE COPYRIGHT HOLDER.
//
// THIS DOCUMENT AND THE INFORMATION CONTAINED HEREIN IS
// PROVIDED ON AN "AS IS" BASIS AND Software and Services LLC.
// DISCLAIM ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT
// NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION
// HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED
// WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR
// PURPOSE.
//
// END_SOFTWARE_AND_SERVICES_COPYRIGHT
//
#ifndef SOFTWARE_AND_SERVICES_LIBRARY_COMMON_FILE_HPP_
#define SOFTWARE_AND_SERVICES_LIBRARY_COMMON_FILE_HPP_

#ifdef WIN32
#pragma warning (disable : 4251)
#endif

#ifdef BUILDING_SAS_COMMON_LIBRARY
#include "osver.h"
#include "instance.hpp"
#include "Tokens.h"
#else
#include <SaS/Common/osver.h>
#include <SaS/Common/instance.hpp>
#include <SaS/Common/Tokens.h>
#endif

#ifndef EXPORT_COMMON
#ifdef BUILDING_SAS_COMMON_LIBRARY

#define EXPORT_COMMON EXPORT_OUT
#else

#define EXPORT_COMMON EXPORT_IN
#endif
#endif

#undef FILE_USE_STD
#ifdef FILE_USE_STD
#include <fstream>
#endif

#include <stdint.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#include <pthread.h>

#ifndef WIN32
#include <sys/ioctl.h>
#else
#ifdef BUILDING_SAS_COMMON_LIBRARY
#include "WinWrappers.hpp"
#else
#include <SaS/Common/WinWrappers.hpp>
#endif
#include <io.h>
#endif

#include <errno.h>

#ifndef EOVERFLOW

#define EOVERFLOW   EINVAL
#endif

#include <wchar.h>

#ifdef WIN32    
#ifdef mkdir
#undef mkdir
#endif
#endif

#include <stdint.h>

namespace SoftwareAndServices
{
  namespace Library
  {
    namespace Common
    {

      class EXPORT_COMMON File
    : virtual public instance<File>
      {

      public:

    File();

#ifdef FILE_USE_STD

    File(std::fstream * fs, const char * aFileName);
#endif

    File(const int fd, const char * aFileName);

    explicit File(const void * buffer, uint32_t BufferSize = 0);

    explicit File(const wchar_t * buffer, uint32_t BufferSize = 0);

    explicit File(char ** buffer, uint32_t * BufferSize = nullptr);

    explicit File(wchar_t ** buffer, uint32_t * BufferSize = nullptr);

    virtual ~File();

    void        ThrowExceptions(bool Enable);

    static bool Lock(const char * fileName);

    static bool LockFileOnly(const char * fileName);

    static bool Trylock(const char * fileName);

    static bool Unlock(const char * fileName);// UnLock DIR

    static bool UnlockFileOnly(const char * fileName);

    bool        Open(const char * file, int RWmode);

    bool        Mkdir(const char * path, mode_t mode);

    bool        Close();

    bool        Flush();

    uint32_t    CanRead();

    bool        AtEOF();

    uint32_t    Read(void * data,
                 const uint32_t Length,
                 bool force = true);

    bool        ReadLine(uint8_t ** Results,
                 uint32_t & Length,
                 bool Force = true,
                 bool DiscardEol = true);

    uint32_t    Write(const void * data,
                  const uint32_t Length);

    uint32_t    Write(const char * data);

    int     Printf(const char * Format, ...);

    enum Whence_t {

      SEEK_SET_t  = SEEK_SET,

      SEEK_CUR_t  = SEEK_CUR,

      SEEK_END_t  = SEEK_END
    };

    off_t       Lseek(off_t offset, Whence_t whence);

    off_t       Tell();

    bool        NextIsLwsp();

    char        LookNext();

    int     GetFd();

    const char      *   GetFileName() const;

    const char      *   GetBuffer() const;

    bool            IsMMapped() const;

    uint32_t        GetBufferSize() const;

    static const char * GetTopDir();

    static bool     SetTopDir(const char * theTop);

    static const char * DefaultTopDir;

    static const char * NewTmpFileExt;

    bool            Keys(const char * Private,
                     const char * Public);

    bool            Encrypt(bool DoEncryption);

      private:

    static int      _MaxBufferSize;

    static int      _CreateMode;

#ifdef FILE_USE_STD

    std::fstream    *   _Fs;
#else

    int         _Fd;        // OS file descriptor.
#endif

    const char  *   _FileName;
#ifndef WIN32

    struct stat     _StatBuf;
#else// WIN32

    struct __stat64     _StatBuf;
#endif//WIN32

    bool            _WeOpened;

    bool            _IsSocket;

    bool            _IsBuffer;

    bool            _IsFile;

    bool            _AtEOF;

    char        *   _Buf;

    char        *   _StartPtr;

    char        **  _OriginalBuf;

    uint32_t    *   _OriginalSize;

    uint32_t        _BufSize;


    uint32_t        _BCount;

    bool            _OurBuffer;

    bool            _Mmaped;

    int         _Mode;

    static const char * _TopDir;

#ifdef WIN32

    HANDLE          _FdHandle;

    HANDLE          _CreateMapHandle;
#endif

    bool            _IsClosed;

    bool            _ThrowExceptions;

    void            _BlockSigPipe();

    const char  *   _Private;

    const char  *   _Public;

    bool            _Encrypt;

    void        *   _Tls;

    void            _CloseTls();

      };
    }
  }
}

#endif // SOFTWARE_AND_SERVICES_LIBRARY_COMMON_FILE_HPP_