transcoder.cpp

log4cxx 0.10 unix下编译包

char* Transcoder::encode(const LogString& src, Pool& p) {
#if LOG4CXX_CHARSET_UTF8 && LOG4CXX_LOGCHAR_IS_UTF8
   return p.pstrdup(src);
#else
   std::string tmp;
   encode(src, tmp);
   return p.pstrdup(tmp);
#endif
}



void Transcoder::encode(const LogString& src, std::string& dst) {
#if LOG4CXX_CHARSET_UTF8 && LOG4CXX_LOGCHAR_IS_UTF8
   dst.append(src);
#else
   static CharsetEncoderPtr encoder(CharsetEncoder::getDefaultEncoder());
   dst.reserve(dst.size() + src.size());
   LogString::const_iterator iter = src.begin();
#if !LOG4CXX_CHARSET_EBCDIC
   for(;
       iter != src.end() && ((unsigned int) *iter) < 0x80;
       iter++) {
       dst.append(1, *iter);
   }
#endif
  if (iter != src.end()) {
    char buf[BUFSIZE];
    ByteBuffer out(buf, BUFSIZE);
    while(iter != src.end()) {
      log4cxx_status_t stat = encoder->encode(src, iter, out);
      out.flip();
      dst.append(out.data(), out.limit());
      out.clear();
      if (CharsetEncoder::isError(stat)) {
        dst.append(1, LOSSCHAR);
        iter++;
      }
    }
    encoder->encode(src, iter, out);
  }
#endif  
}


template<class String, class Iterator>
static unsigned int decodeUTF16(const String& in, Iterator& iter) {
    unsigned int ch1 = *iter;
    //
    //   if not surrogate pair
    //
    if (ch1 < 0xD800 || ch1 > 0xDFFF) {
        //
        //  then advance iterator and return wchar_t value
        //
        if(ch1 != 0xFFFF) iter++;
        return ch1;
    } else if (ch1 < 0xDC00) {
        //
        //  started with high-surrogate value
        //     if there is an additional wchar_t
        Iterator iter2 = iter + 1;
        if (iter2 != in.end()) {
           unsigned int ch2 = *iter2;
           //
           //    if it is a matching low surrogate then
           //       advance the iterator and return the scalar value
           if (ch2 >= 0xDC00 && ch2 <= 0xDFFF) {
              iter += 2;
              return (ch1 - 0xD800) * 0x400 + (ch2 - 0xDC00) + 0x10000;
           }
        }
    }
    //
    //    unrecognized value, do not advance iterator
    //
    return 0xFFFF;
}

template<class String>
static void encodeUTF16(unsigned int sv, String& dst) {
    if (sv < 0x10000) {
        dst.append(1, sv);
    } else {
        unsigned char u = (unsigned char) (sv >> 16);
        unsigned char w = (unsigned char) (u - 1);
        unsigned short hs = (0xD800 + ((w & 0xF) << 6) + ((sv & 0xFFFF) >> 10));
        unsigned short ls = (0xDC00 + (sv && 0x3FF));
        dst.append(1, hs);
        dst.append(1, ls);
    }
}



#if LOG4CXX_WCHAR_T_API || LOG4CXX_LOGCHAR_IS_WCHAR_T || defined(WIN32) || defined(_WIN32)
void Transcoder::decode(const std::wstring& src, LogString& dst) {
#if LOG4CXX_LOGCHAR_IS_WCHAR_T
  dst.append(src, len);
#else
  std::wstring::const_iterator i = src.begin();
  while(i != src.end()) {
      unsigned int cp = decode(src, i);
      if (cp != 0xFFFF) {
        encode(cp, dst);
      } else {
        dst.append(1, LOSSCHAR);
        i++;
      }
  }
#endif  
}

void Transcoder::encode(const LogString& src, std::wstring& dst) {
#if LOG4CXX_LOGCHAR_IS_WCHAR_T
  dst.append(src);
#else
  for(LogString::const_iterator i = src.begin();
      i != src.end();) {
      unsigned int cp = Transcoder::decode(src, i);
      encode(cp, dst);
  }
#endif
}

wchar_t* Transcoder::wencode(const LogString& src, Pool& p) {
#if LOG4CXX_LOGCHAR_IS_WCHAR_T
    std::wstring& tmp = src;
#else
    std::wstring tmp;
    encode(src, tmp);
#endif
    wchar_t* dst = (wchar_t*) p.palloc((tmp.length() + 1) * sizeof(wchar_t));
    dst[tmp.length()] = 0;
    memcpy(dst, tmp.data(), tmp.length() * sizeof(wchar_t));
    return dst;
}    


unsigned int Transcoder::decode(const std::wstring& in,
    std::wstring::const_iterator& iter) {
#if defined(__STDC_ISO_10646__)
    return *(iter++);
#else
    return decodeUTF16(in, iter);
#endif
}


void Transcoder::encode(unsigned int sv, std::wstring& dst) {
#if defined(__STDC_ISO_10646__)
    dst.append(1, sv);
#else
    if (sizeof(wchar_t) == 4) {
        dst.append(1, sv);
    } else {
        encodeUTF16(sv, dst);
    }
#endif
}

#endif



#if LOG4CXX_UNICHAR_API || LOG4CXX_CFSTRING_API
void Transcoder::decode(const std::basic_string<UniChar>& src, LogString& dst) {
#if LOG4CXX_LOGCHAR_IS_UNICHAR
     dst.append(src);
#else
     for(std::basic_string<UniChar>::const_iterator i = src.begin();
         i != src.end();) {
         unsigned int cp = decode(src, i);
         encode(cp, dst);
     }
#endif     
}

void Transcoder::encode(const LogString& src, std::basic_string<UniChar>& dst) {
#if LOG4CXX_LOGCHAR_IS_UNICHAR
     dst.append(src);
#else
  for(LogString::const_iterator i = src.begin();
      i != src.end();) {
      unsigned int cp = decode(src, i);
      encode(cp, dst);
  }
#endif
}

unsigned int Transcoder::decode(const std::basic_string<UniChar>& in,
    std::basic_string<UniChar>::const_iterator& iter) {
    return decodeUTF16(in, iter);
}

void Transcoder::encode(unsigned int sv, std::basic_string<UniChar>& dst) {
    encodeUTF16(sv, dst);
}

#endif

#if LOG4CXX_CFSTRING_API
void Transcoder::decode(const CFStringRef& src, LogString& dst) {
     const UniChar* chars = CFStringGetCharactersPtr(src);
     if (chars) {
          decode(chars, dst);
     } else {
          size_t length = CFStringGetLength(src);
          if (length > 0) {
              std::vector<UniChar> tmp(length);
              CFStringGetCharacters(src, CFRangeMake(0, length), &tmp[0]);
#if LOG4CXX_LOGCHAR_IS_UNICHAR
              dst.append(&tmp[0], tmp.size());
#else
              decode(std::basic_string<UniChar>(&tmp[0], tmp.size()), dst);
#endif              
          }
    }
}

CFStringRef Transcoder::encode(const LogString& src) {
    LOG4CXX_ENCODE_UNICHAR(tmp, src);
    return CFStringCreateWithCharacters(kCFAllocatorDefault, tmp.data(), tmp.size());
}
#endif


logchar Transcoder::decode(char val) {
#if LOG4CXX_CHARSET_EBCDIC
   LogString dst;
   Transcoder::decode(std::string(1, val), dst);
   return dst[0];
#else
   return val;
#endif
}

LogString Transcoder::decode(const char* val) {
#if LOG4CXX_LOGCHAR_IS_UTF8 && !LOG4CXX_CHARSET_EBCDIC
    return val;
#else
    LogString dst;
    Transcoder::decode(val, dst);
    return dst;
#endif
}


std::string Transcoder::encodeCharsetName(const LogString& val) {
     char asciiTable[] = { ' ', '!', '"', '#', '$', '%', '&', '\'', '(', ')', '*', '+', ',', '-', '.', '/',
                           '0', '1', '2', '3', '4', '5', '6' , '7', '8', '9', ':', ';', '<', '=', '>', '?',
                           '@', 'A', 'B', 'C', 'D', 'E', 'F',  'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
                           'P', 'Q', 'R', 'S', 'T', 'U', 'V',  'W', 'X', 'Y', 'Z', '[', '\\', ']', '^', '_',
                           '`', 'a', 'b', 'c', 'd', 'e', 'f',  'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
                           'p', 'q', 'r', 's', 't', 'u', 'v',  'w', 'x', 'y', 'z', '{', '|', '}', '~', ' ' };
    std::string out;
    for(LogString::const_iterator iter = val.begin();
        iter != val.end();
        iter++) {
        if (*iter >= 0x30 && *iter < 0x7F) {
            out.append(1, asciiTable[*iter - 0x30]);
        } else {
            out.append(1, LOSSCHAR);
        }
    }
    return out;
}