cpp/include/IcePatch2/Util.h

   1 // **********************************************************************
   2 //
   3 // Copyright (c) 2003-2011 ZeroC, Inc. All rights reserved.
   4 //
   5 // This copy of Ice is licensed to you under the terms described in the
   6 // ICE_LICENSE file included in this distribution.
   7 //
   8 // **********************************************************************
   9
  10 #ifndef ICE_PATCH2_UTIL_H
  11 #define ICE_PATCH2_UTIL_H
  12
  13 #include <Ice/Ice.h>
  14 #include <IcePatch2/FileInfo.h>
  15 #include <stdio.h>
  16
  17 namespace IcePatch2
  18 {
  19
  20 ICE_PATCH2_API extern const char* checksumFile;
  21 ICE_PATCH2_API extern const char* logFile;
  22
  23 ICE_PATCH2_API std::string lastError();
  24
  25 ICE_PATCH2_API std::string bytesToString(const Ice::ByteSeq&);
  26 ICE_PATCH2_API Ice::ByteSeq stringToBytes(const std::string&);
  27
  28 ICE_PATCH2_API std::string simplify(const std::string&);
  29
  30 ICE_PATCH2_API bool isRoot(const std::string&);
  31
  32 ICE_PATCH2_API std::string getSuffix(const std::string&);
  33 ICE_PATCH2_API std::string getWithoutSuffix(const std::string&);
  34 ICE_PATCH2_API bool ignoreSuffix(const std::string&);
  35
  36 ICE_PATCH2_API std::string getBasename(const std::string&);
  37 ICE_PATCH2_API std::string getDirname(const std::string&);
  38
  39 ICE_PATCH2_API void rename(const std::string&, const std::string&);
  40
  41 ICE_PATCH2_API void remove(const std::string&);
  42 ICE_PATCH2_API void removeRecursive(const std::string&);
  43
  44 ICE_PATCH2_API Ice::StringSeq readDirectory(const std::string&);
  45
  46 ICE_PATCH2_API void createDirectory(const std::string&);
  47 ICE_PATCH2_API void createDirectoryRecursive(const std::string&);
  48
  49 ICE_PATCH2_API void compressBytesToFile(const std::string&, const Ice::ByteSeq&, Ice::Int);
  50 ICE_PATCH2_API void decompressFile(const std::string&);
  51 ICE_PATCH2_API void setFileFlags(const std::string&, const FileInfo&);
  52
  53 struct FileInfoEqual: public std::binary_function<const FileInfo&, const FileInfo&, bool>
  54 {
  55     bool
  56     operator()(const FileInfo& lhs, const FileInfo& rhs)
  57     {
  58         if(lhs.path != rhs.path)
  59         {
  60             return false;
  61         }
  62
  63         //
  64         // For the size portion of the comparison, we only distinquish
  65         // between file (size >= 0) and directory (size == -1). We do
  66         // not take the actual size into account, as it might be set
  67         // to 0 if no compressed file is available.
  68         //
  69         Ice::Int lsz = lhs.size > 0 ? 0 : lhs.size;
  70         Ice::Int rsz = rhs.size > 0 ? 0 : rhs.size;
  71         if(lsz != rsz)
  72         {
  73             return false;
  74         }
  75
  76         if(lhs.executable != rhs.executable)
  77         {
  78             return false;
  79         }
  80
  81         return lhs.checksum == rhs.checksum;
  82     }
  83 };
  84
  85 struct FileInfoWithoutFlagsLess: public std::binary_function<const FileInfo&, const FileInfo&, bool>
  86 {
  87     bool
  88     operator()(const FileInfo& lhs, const FileInfo& rhs)
  89     {
  90         return compareWithoutFlags(lhs, rhs) < 0;
  91     }
  92
  93     int
  94     compareWithoutFlags(const FileInfo& lhs, const FileInfo& rhs)
  95     {
  96         if(lhs.path < rhs.path)
  97         {
  98             return -1;
  99         }
 100         else if(rhs.path < lhs.path)
 101         {
 102             return 1;
 103         }
 104
 105         //
 106         // For the size portion of the comparison, we only distinquish
 107         // between file (size >= 0) and directory (size == -1). We do
 108         // not take the actual size into account, as it might be set
 109         // to 0 if no compressed file is available.
 110         //
 111         Ice::Int lsz = lhs.size > 0 ? 0 : lhs.size;
 112         Ice::Int rsz = rhs.size > 0 ? 0 : rhs.size;
 113         if(lsz < rsz)
 114         {
 115             return -1;
 116         }
 117         else if(rsz < lsz)
 118         {
 119             return 1;
 120         }
 121
 122         if(lhs.checksum < rhs.checksum)
 123         {
 124             return -1;
 125         }
 126         else if(rhs.checksum < lhs.checksum)
 127         {
 128             return 1;
 129         }
 130
 131         return 0;
 132     }
 133 };
 134
 135 struct FileInfoLess : public FileInfoWithoutFlagsLess
 136 {
 137     bool
 138     operator()(const FileInfo& lhs, const FileInfo& rhs)
 139     {
 140         int rc = compareWithoutFlags(lhs, rhs);
 141         if(rc < 0)
 142         {
 143             return true;
 144         }
 145         else if(rc > 0)
 146         {
 147             return false;
 148         }
 149
 150         return lhs.executable < rhs.executable;
 151     }
 152 };
 153
 154 class ICE_PATCH2_API GetFileInfoSeqCB
 155 {
 156 public:
 157
 158     virtual ~GetFileInfoSeqCB() { }
 159
 160     virtual bool remove(const std::string&) = 0;
 161     virtual bool checksum(const std::string&) = 0;
 162     virtual bool compress(const std::string&) = 0;
 163 };
 164
 165 ICE_PATCH2_API bool getFileInfoSeq(const std::string&, int, GetFileInfoSeqCB*, FileInfoSeq&);
 166 ICE_PATCH2_API bool getFileInfoSeqSubDir(const std::string&, const std::string&, int, GetFileInfoSeqCB*, FileInfoSeq&);
 167
 168 ICE_PATCH2_API void saveFileInfoSeq(const std::string&, const FileInfoSeq&);
 169 ICE_PATCH2_API void loadFileInfoSeq(const std::string&, FileInfoSeq&);
 170
 171 ICE_PATCH2_API bool readFileInfo(FILE*, FileInfo&);
 172 ICE_PATCH2_API bool writeFileInfo(FILE*, const FileInfo&);
 173
 174 struct FileTree1
 175 {
 176     FileInfoSeq files;
 177     Ice::ByteSeq checksum;
 178 };
 179
 180 typedef std::vector<FileTree1> FileTree1Seq;
 181
 182 struct FileTree0
 183 {
 184     FileTree1Seq nodes;
 185     Ice::ByteSeq checksum;
 186 };
 187
 188 ICE_PATCH2_API void getFileTree0(const FileInfoSeq&, FileTree0&);
 189
 190 }
 191
 192 #endif