dyld3/shared-cache/StringUtils.h

   1 /*
   2  * Copyright (c) 2017 Apple Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. Please obtain a copy of the License at
  10  * http://www.opensource.apple.com/apsl/ and read it before using this
  11  * file.
  12  *
  13  * The Original Code and all software distributed under the License are
  14  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  15  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  16  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  18  * Please see the License for the specific language governing rights and
  19  * limitations under the License.
  20  *
  21  * @APPLE_LICENSE_HEADER_END@
  22  */
  23
  24
  25 #ifndef StringUtils_h
  26 #define StringUtils_h
  27
  28 #include <string>
  29
  30 inline bool startsWith(const std::string& str, const std::string& prefix)
  31 {
  32     return std::mismatch(prefix.begin(), prefix.end(), str.begin()).first == prefix.end();
  33 }
  34
  35 inline bool endsWith(const std::string& str, const std::string& suffix)
  36 {
  37     std::size_t index = str.find(suffix, str.size() - suffix.size());
  38     return (index != std::string::npos);
  39 }
  40
  41 inline bool contains(const std::string& str, const std::string& search)
  42 {
  43     std::size_t index = str.find(search);
  44     return (index != std::string::npos);
  45 }
  46
  47 inline char hexDigit(uint8_t value)
  48 {
  49     if ( value < 10 )
  50         return '0' + value;
  51     else
  52         return 'a' + value - 10;
  53 }
  54
  55 inline void bytesToHex(const uint8_t* bytes, size_t byteCount, char buffer[])
  56 {
  57     char* p = buffer;
  58     for (int i=0; i < byteCount; ++i) {
  59         *p++ = hexDigit(bytes[i] >> 4);
  60         *p++ = hexDigit(bytes[i] & 0x0F);
  61     }
  62     *p++ =  '\0';
  63 }
  64
  65 inline uint8_t hexCharToUInt(const char hexByte, uint8_t& value) {
  66     if (hexByte >= '0' && hexByte <= '9') {
  67         value = hexByte - '0';
  68         return true;
  69     } else if (hexByte >= 'A' && hexByte <= 'F') {
  70         value = hexByte - 'A' + 10;
  71         return true;
  72     } else if (hexByte >= 'a' && hexByte <= 'f') {
  73         value = hexByte - 'a' + 10;
  74         return true;
  75     }
  76
  77     return false;
  78 }
  79
  80 inline uint64_t hexToUInt64(const char* startHexByte, const char** endHexByte) {
  81     if (startHexByte == nullptr)
  82         return 0;
  83     uint64_t retval = 0;
  84     if (startHexByte[0] == '0' &&  startHexByte[1] == 'x') {
  85         startHexByte +=2;
  86     }
  87     *endHexByte = startHexByte + 16;
  88
  89     //FIXME overrun?
  90     for (uint32_t i = 0; i < 16; ++i) {
  91         uint8_t value;
  92         if (!hexCharToUInt(startHexByte[i], value)) {
  93             *endHexByte = &startHexByte[i];
  94             break;
  95         }
  96         retval = (retval << 4) + value;
  97     }
  98     return retval;
  99 }
 100
 101 inline bool hexToBytes(const char* startHexByte, uint32_t length, uint8_t buffer[]) {
 102     if (startHexByte == nullptr)
 103         return false;
 104     const char *currentHexByte = startHexByte;
 105     for (uint32_t i = 0; i < length; ++i) {
 106         uint8_t value;
 107         if (!hexCharToUInt(currentHexByte[i], value)) {
 108             return false;
 109         }
 110         if (i%2 == 0) {
 111             buffer[i/2] = value << 4;
 112         } else {
 113             buffer[(i-1)/2] |= value;
 114         }
 115     }
 116     return true;
 117 }
 118
 119 #endif // StringUtils_h
 120