自学教程：C++ CharPointer_UTF8函数代码示例

void StringArray::appendNumbersToDuplicates (bool ignoreCase,                                             bool appendNumberToFirstInstance,                                             CharPointer_UTF8 preNumberString,                                             CharPointer_UTF8 postNumberString){    if (preNumberString.getAddress() == nullptr)        preNumberString = CharPointer_UTF8 (" (");    if (postNumberString.getAddress() == nullptr)        postNumberString = CharPointer_UTF8 (")");    for (int i = 0; i < size() - 1; ++i)    {        auto& s = strings.getReference(i);        auto nextIndex = indexOf (s, ignoreCase, i + 1);        if (nextIndex >= 0)        {            auto original = s;            int number = 0;            if (appendNumberToFirstInstance)                s = original + String (preNumberString) + String (++number) + String (postNumberString);            else                ++number;            while (nextIndex >= 0)            {                set (nextIndex, (*this)[nextIndex] + String (preNumberString) + String (++number) + String (postNumberString));                nextIndex = indexOf (original, ignoreCase, nextIndex + 1);            }        }    }}

String MidiMessage::getTextFromTextMetaEvent() const{    auto textData = reinterpret_cast<const char*> (getMetaEventData());    return String (CharPointer_UTF8 (textData),                   CharPointer_UTF8 (textData + getMetaEventLength()));}

File File::getSpecialLocation (const SpecialLocationType type){    switch (type)    {        case userHomeDirectory:        {            if (const char* homeDir = getenv ("HOME"))                return File (CharPointer_UTF8 (homeDir));            if (auto* pw = getpwuid (getuid()))                return File (CharPointer_UTF8 (pw->pw_dir));            return {};        }        case userDocumentsDirectory:          return resolveXDGFolder ("XDG_DOCUMENTS_DIR", "~/Documents");        case userMusicDirectory:              return resolveXDGFolder ("XDG_MUSIC_DIR",     "~/Music");        case userMoviesDirectory:             return resolveXDGFolder ("XDG_VIDEOS_DIR",    "~/Videos");        case userPicturesDirectory:           return resolveXDGFolder ("XDG_PICTURES_DIR",  "~/Pictures");        case userDesktopDirectory:            return resolveXDGFolder ("XDG_DESKTOP_DIR",   "~/Desktop");        case userApplicationDataDirectory:    return resolveXDGFolder ("XDG_CONFIG_HOME",   "~/.config");        case commonDocumentsDirectory:        case commonApplicationDataDirectory:  return File ("/opt");        case globalApplicationsDirectory:     return File ("/usr");        case tempDirectory:        {            if (const char* tmpDir = getenv ("TMPDIR"))                return File (CharPointer_UTF8 (tmpDir));            return File ("/tmp");        }        case invokedExecutableFile:            if (juce_argv != nullptr && juce_argc > 0)                return File (CharPointer_UTF8 (juce_argv[0]));            // deliberate fall-through...        case currentExecutableFile:        case currentApplicationFile:           #if ! JUCE_STANDALONE_APPLICATION            return juce_getExecutableFile();           #endif            // deliberate fall-through if this is not a shared-library        case hostApplicationPath:        {            const File f ("/proc/self/exe");            return f.isSymbolicLink() ? f.getLinkedTarget() : juce_getExecutableFile();        }        default:            jassertfalse; // unknown type?            break;    }    return {};}

void XmlDocument::skipHeader(){    const int headerStart = input.indexOf (CharPointer_UTF8 ("<?xml"));    if (headerStart >= 0)    {        const int headerEnd = (input + headerStart).indexOf (CharPointer_UTF8 ("?>"));        if (headerEnd < 0)            return;       #if JUCE_DEBUG        const String header (input + headerStart, (size_t) (headerEnd - headerStart));        const String encoding (header.fromFirstOccurrenceOf ("encoding", false, true)                                     .fromFirstOccurrenceOf ("=", false, false)                                     .fromFirstOccurrenceOf ("/"", false, false)                                     .upToFirstOccurrenceOf ("/"", false, false).trim());        /* If you load an XML document with a non-UTF encoding type, it may have been           loaded wrongly.. Since all the files are read via the normal juce file streams,           they're treated as UTF-8, so by the time it gets to the parser, the encoding will           have been lost. Best plan is to stick to utf-8 or if you have specific files to           read, use your own code to convert them to a unicode String, and pass that to the           XML parser.        */        jassert (encoding.isEmpty() || encoding.startsWithIgnoreCase ("utf-"));       #endif        input += headerEnd + 2;    }    skipNextWhiteSpace();    const int docTypeIndex = input.indexOf (CharPointer_UTF8 ("<!DOCTYPE"));    if (docTypeIndex < 0)        return;    input += docTypeIndex + 9;    const String::CharPointerType docType (input);    int n = 1;    while (n > 0)    {        const juce_wchar c = readNextChar();        if (outOfData)            return;        if (c == '<')            ++n;        else if (c == '>')            --n;    }    dtdText = String (docType, (size_t) (input.getAddress() - (docType.getAddress() + 1))).trim();}

File File::getSpecialLocation (const SpecialLocationType type){    switch (type)    {    case userHomeDirectory:    {        const char* homeDir = getenv ("HOME");        if (homeDir)            return File (CharPointer_UTF8 (homeDir));        if (struct passwd* const pw = getpwuid (getuid()))            return File (CharPointer_UTF8 (pw->pw_dir));        return File (CharPointer_UTF8 (homeDir));    }    case userDocumentsDirectory:        return resolveXDGFolder ("XDG_DOCUMENTS_DIR", "~");    case userMusicDirectory:        return resolveXDGFolder ("XDG_MUSIC_DIR",     "~");    case userMoviesDirectory:        return resolveXDGFolder ("XDG_VIDEOS_DIR",    "~");    case userPicturesDirectory:        return resolveXDGFolder ("XDG_PICTURES_DIR",  "~");    case userDesktopDirectory:        return resolveXDGFolder ("XDG_DESKTOP_DIR",   "~/Desktop");    case userApplicationDataDirectory:        return File ("~");    case commonDocumentsDirectory:    case commonApplicationDataDirectory:        return File ("/var");    case globalApplicationsDirectory:        return File ("/usr");    case tempDirectory:    {        File tmp ("/var/tmp");        if (! tmp.isDirectory())        {            tmp = "/tmp";            if (! tmp.isDirectory())                tmp = File::getCurrentWorkingDirectory();        }        return tmp;    }    default:        bassertfalse; // unknown type?        break;    }    return File::nonexistent ();}

//==============================================================================String SystemStats::getLogonName(){    if (const char* user = getenv ("USER"))        return CharPointer_UTF8 (user);    if (struct passwd* const pw = getpwuid (getuid()))        return CharPointer_UTF8 (pw->pw_name);    return String();}

void XmlDocument::skipNextWhiteSpace(){    for (;;)    {        juce_wchar c = *input;        while (CharacterFunctions::isWhitespace (c))            c = *++input;        if (c == 0)        {            outOfData = true;            break;        }        else if (c == '<')        {            if (input[1] == '!'                 && input[2] == '-'                 && input[3] == '-')            {                input += 4;                const int closeComment = input.indexOf (CharPointer_UTF8 ("-->"));                if (closeComment < 0)                {                    outOfData = true;                    break;                }                input += closeComment + 3;                continue;            }            else if (input[1] == '?')            {                input += 2;                const int closeBracket = input.indexOf (CharPointer_UTF8 ("?>"));                if (closeBracket < 0)                {                    outOfData = true;                    break;                }                input += closeBracket + 2;                continue;            }        }        break;    }}

void FilterGraph::mouseMove (const MouseEvent &event){    Point <int> mousePos =  getMouseXYRelative();    int xPos = mousePos.getX();    float freq = xToFreq (xPos);        if (traceType == Magnitude)    {        float magnitude = (float) (filterVector [0].getResponse (freq).magnitudeValue);            for (int i = 1; i < numFilters; i++)        {            magnitude *= (float) (filterVector [i].getResponse (freq).magnitudeValue);        }            magnitude = 20 * log10 (magnitude);            setTooltip (String (freq, 1) + "Hz, " + String (magnitude, 1) + "dB");    }        if (traceType == Phase)    {        float phase = (float) (filterVector [0].getResponse (freq).phaseValue);            for (int i = 1; i < numFilters; i++)        {            phase += (float) (filterVector [i].getResponse (freq).phaseValue);        }                phase /= float_Pi;            setTooltip (String (freq, 1) + "Hz, " + String (phase, 2) + String (CharPointer_UTF8 ("/xcf/x80")) + "rad");    }}

    bool next (String& filenameFound,               bool* const isDir, bool* const isHidden, std::int64_t* const fileSize,               Time* const modTime, Time* const creationTime, bool* const isReadOnly)    {        if (dir != nullptr)        {            const char* wildcardUTF8 = nullptr;            for (;;)            {                struct dirent* const de = readdir (dir);                if (de == nullptr)                    break;                if (wildcardUTF8 == nullptr)                    wildcardUTF8 = wildCard.toUTF8();                if (fnmatch (wildcardUTF8, de->d_name, FNM_CASEFOLD) == 0)                {                    filenameFound = CharPointer_UTF8 (de->d_name);                    updateStatInfoForFile (parentDir + filenameFound, isDir, fileSize, modTime, creationTime, isReadOnly);                    if (isHidden != nullptr)                        *isHidden = filenameFound.startsWithChar ('.');                    return true;                }            }        }        return false;    }

    static String parseNameRecord (MemoryInputStream& input, const NameRecord& nameRecord,                                   const int64 directoryOffset, const int64 offsetOfStringStorage)    {        String result;        const int64 oldPos = input.getPosition();        input.setPosition (directoryOffset + offsetOfStringStorage + ByteOrder::swapIfLittleEndian (nameRecord.offsetFromStorageArea));        const int stringLength = (int) ByteOrder::swapIfLittleEndian (nameRecord.stringLength);        const int platformID = ByteOrder::swapIfLittleEndian (nameRecord.platformID);        if (platformID == 0 || platformID == 3)        {            const int numChars = stringLength / 2 + 1;            HeapBlock<uint16> buffer;            buffer.calloc (numChars + 1);            input.read (buffer, stringLength);            for (int i = 0; i < numChars; ++i)                buffer[i] = ByteOrder::swapIfLittleEndian (buffer[i]);            static_jassert (sizeof (CharPointer_UTF16::CharType) == sizeof (uint16));            result = CharPointer_UTF16 ((CharPointer_UTF16::CharType*) buffer.getData());        }        else        {            HeapBlock<char> buffer;            buffer.calloc (stringLength + 1);            input.read (buffer, stringLength);            result = CharPointer_UTF8 (buffer.getData());        }        input.setPosition (oldPos);        return result;    }

boolLV2World::isPluginSupported (const LilvPlugin* plugin){    // Required features support    LilvNodes* nodes = lilv_plugin_get_required_features (plugin);    LILV_FOREACH (nodes, iter, nodes)    {        const LilvNode* node (lilv_nodes_get (nodes, iter));        if (! isFeatureSupported (CharPointer_UTF8 (lilv_node_as_uri (node)))) {            return false; // Feature not supported        }    }    lilv_nodes_free (nodes); nodes = nullptr;            // Check this plugin's port types are supported    const uint32 numPorts = lilv_plugin_get_num_ports (plugin);    for (uint32 i = 0; i < numPorts; ++i)    {        // const LilvPort* port (lilv_plugin_get_port_by_index (plugin, i));        // nothing here yet (or ever)    }        return true;}

MainContentComponent::MainContentComponent()  : myFont (Typeface::createSystemTypefaceFor (BinaryData::myFont_ttf, BinaryData::myFont_ttfSize)),    myText (CharPointer_UTF8 ("H/xe2/x84/xae/xc5/x82/xc5/x82o W/xe2/x98/xba/xd2/x91/xc5/x82""d")){    myFont.setHeight (100.0f);    setSize (600, 400);}

StringLV2Module::getClassLabel() const{   if (const LilvPluginClass* klass = lilv_plugin_get_class (plugin))       if (const LilvNode* node = lilv_plugin_class_get_label (klass))           return CharPointer_UTF8 (lilv_node_as_string (node));   return String::empty;}

String StringPool::getPooledString (const char* const newString){    if (newString == nullptr || *newString == 0)        return String();    const ScopedLock sl (lock);    garbageCollectIfNeeded();    return addPooledString (strings, CharPointer_UTF8 (newString));}

String InputStream::readString(){    MemoryBlock buffer (256);    char* data = static_cast<char*> (buffer.getData());    size_t i = 0;    while ((data[i] = readByte()) != 0)    {        if (++i >= buffer.getSize())        {            buffer.setSize (buffer.getSize() + 512);            data = static_cast<char*> (buffer.getData());        }    }    return String (CharPointer_UTF8 (data),                   CharPointer_UTF8 (data + i));}

    bool next()    {        if (ports == nullptr || ports [index + 1] == nullptr)            return false;        name = CharPointer_UTF8 (ports[++index]);        clientName = name.upToFirstOccurrenceOf (":", false, false);        return true;    }

//==============================================================================String SystemStats::getLogonName(){    const char* user = getenv ("USER");    if (user == nullptr)        if (passwd* const pw = getpwuid (getuid()))            user = pw->pw_name;    return CharPointer_UTF8 (user);}

bool MemoryOutputStream::appendUTF8Char (juce_wchar c){    if (char* dest = prepareToWrite (CharPointer_UTF8::getBytesRequiredFor (c)))    {        CharPointer_UTF8 (dest).write (c);        return true;    }    return false;}

StringLV2Module::getAuthorName() const{   if (LilvNode* node = lilv_plugin_get_author_name (plugin))   {       String name (CharPointer_UTF8 (lilv_node_as_string (node)));       lilv_node_free (node);       return name;   }   return String::empty;}

//==============================================================================String SystemStats::getLogonName(){    const char* user = getenv ("USER");    if (user == 0)    {        struct passwd* const pw = getpwuid (getuid());        if (pw != 0)            user = pw->pw_name;    }    return CharPointer_UTF8 (user);}

const StringLV2Module::getPortName (uint32 index) const{    if (const LilvPort* port = getPort (index))    {        LilvNode* node = lilv_port_get_name (plugin, port);        const String name = CharPointer_UTF8 (lilv_node_as_string (node));        lilv_node_free (node);        return name;    }        return String::empty;}

void PluginParameter::init (const String& name_, ParameterUnit unit_, String description_,                            double value_, double min_, double max_, double default_,                            double skewFactor_, double smoothCoeff_, double step_, String unitSuffix_){	name = name_;	unit = unit_;	description = description_;	min = min_;	max = max_;	setValue (value_);	defaultValue = default_;	smoothCoeff = smoothCoeff_;	smoothValue = getValue();	skewFactor = skewFactor_;	step = step_;	unitSuffix = unitSuffix_;	// default label suffix's, these can be changed later	switch (unit)	{		case UnitPercent:       setUnitSuffix("%");                         break;		case UnitSeconds:       setUnitSuffix("s");                         break;		case UnitPhase:         setUnitSuffix(CharPointer_UTF8 ("/xc2/xb0"));      break;		case UnitHertz:         setUnitSuffix("Hz");                        break;		case UnitDecibels:      setUnitSuffix("dB");                        break;		case UnitDegrees:       setUnitSuffix(CharPointer_UTF8 ("/xc2/xb0"));      break;		case UnitMeters:        setUnitSuffix("m");                         break;		case UnitBPM:           setUnitSuffix("BPM");                       break;		case UnitMilliseconds:  setUnitSuffix("ms");                        break;		default:                                                            break;	}}

 int doFTime (CharPointer_UTF32 dest, const size_t maxChars, const String& format, const struct tm* const tm) noexcept {    #if JUCE_ANDROID     HeapBlock <char> tempDest;     tempDest.calloc (maxChars + 2);     const int result = (int) strftime (tempDest, maxChars, format.toUTF8(), tm);     if (result > 0)         dest.writeAll (CharPointer_UTF8 (tempDest.getData()));     return result;    #elif JUCE_WINDOWS     HeapBlock <wchar_t> tempDest;     tempDest.calloc (maxChars + 2);     const int result = (int) wcsftime (tempDest, maxChars, format.toWideCharPointer(), tm);     if (result > 0)         dest.writeAll (CharPointer_UTF16 (tempDest.getData()));     return result;    #else     return (int) wcsftime (dest.getAddress(), maxChars, format.toUTF32(), tm);    #endif }

    //==============================================================================    static String readResponse (const int socketHandle, const uint32 timeOutTime)    {        int bytesRead = 0, numConsecutiveLFs  = 0;        MemoryBlock buffer (1024, true);        while (numConsecutiveLFs < 2 && bytesRead < 32768                && Time::getMillisecondCounter() <= timeOutTime)        {            fd_set readbits;            FD_ZERO (&readbits);            FD_SET (socketHandle, &readbits);            struct timeval tv;            tv.tv_sec = jmax (1, (int) (timeOutTime - Time::getMillisecondCounter()) / 1000);            tv.tv_usec = 0;            if (select (socketHandle + 1, &readbits, 0, 0, &tv) <= 0)                return String::empty;  // (timeout)            buffer.ensureSize (bytesRead + 8, true);            char* const dest = (char*) buffer.getData() + bytesRead;            if (recv (socketHandle, dest, 1, 0) == -1)                return String::empty;            const char lastByte = *dest;            ++bytesRead;            if (lastByte == '/n')                ++numConsecutiveLFs;            else if (lastByte != '/r')                numConsecutiveLFs = 0;        }        const String header (CharPointer_UTF8 ((const char*) buffer.getData()));        if (header.startsWithIgnoreCase ("HTTP/"))            return header.trimEnd();        return String::empty;    }

//==============================================================================void NewComponent::paint (Graphics& g){    //[UserPrePaint] Add your own custom painting code here..    //[/UserPrePaint]    g.fillAll (Colour (0xff222222));    g.setGradientFill (ColourGradient (Colours::darkgrey,                                       128.0f, static_cast<float> (-56),                                       Colours::black,                                       128.0f, 80.0f,                                       false));    g.fillRect (0, 0, 350, 30);    g.setColour (Colour (0xffcfcfcf));    g.setFont (Font (14.00f, Font::plain));    g.drawText (TRANS("Amarras"),                27, 0, 152, 30,                Justification::centredLeft, true);    g.setColour (Colour (0xff666666));    g.setFont (Font (10.00f, Font::plain));    g.drawText (TRANS("1"),                3, 3, 13, 30,                Justification::centred, true);    g.setColour (Colour (0xff858585));    g.setFont (Font (14.00f, Font::plain));    g.drawText (CharPointer_UTF8 ("D/'Arienzo - Maur/xc3/xa9"),                185, 0, 125, 30,                Justification::centredLeft, true);    g.setColour (Colour (0xff858585));    g.setFont (Font (12.00f, Font::plain));    g.drawText (TRANS("1941"),                315, 0, 28, 30,                Justification::centredRight, true);    //[UserPaint] Add your own custom painting code here..    //[/UserPaint]}

void jojo_bang (t_jojo *x){    const ScopedLock myLock (x->lock_);         post ("Public / %s", x->public_.toString().toRawUTF8());    post ("Private / %s", x->private_.toString().toRawUTF8());        String myText (CharPointer_UTF8 ("P/xc3/xa9p/xc3/xa9 p/xc3/xa8te en ao/xc3/xbbt!"));        post ("%s", myText.toRawUTF8());        const juce::MemoryBlock blockBegin (myText.toRawUTF8(), myText.getNumBytesAsUTF8() + 1);    BigInteger bitArray;    bitArray.loadFromMemoryBlock (blockBegin);    x->public_.applyToValue (bitArray);             /* Encrypt with the public key. */    post ("%s", bitArray.toString (16).toRawUTF8());        x->private_.applyToValue (bitArray);            /* Then decrypt with the private key. */        const juce::MemoryBlock blockEnd (bitArray.toMemoryBlock());    post ("%s", blockEnd.toString().toRawUTF8());}

void MemoryOutputStream::appendUTF8Char (juce_wchar c){    CharPointer_UTF8 (prepareToWrite (CharPointer_UTF8::getBytesRequiredFor (c))).write (c);}

void XmlDocument::readEntity (String& result){    // skip over the ampersand    ++input;    if (input.compareIgnoreCaseUpTo (CharPointer_UTF8 ("amp;"), 4) == 0)    {        input += 4;        result += '&';    }    else if (input.compareIgnoreCaseUpTo (CharPointer_UTF8 ("quot;"), 5) == 0)    {        input += 5;        result += '"';    }    else if (input.compareIgnoreCaseUpTo (CharPointer_UTF8 ("apos;"), 5) == 0)    {        input += 5;        result += '/'';    }    else if (input.compareIgnoreCaseUpTo (CharPointer_UTF8 ("lt;"), 3) == 0)    {        input += 3;        result += '<';    }    else if (input.compareIgnoreCaseUpTo (CharPointer_UTF8 ("gt;"), 3) == 0)    {        input += 3;        result += '>';    }    else if (*input == '#')    {        int charCode = 0;        ++input;        if (*input == 'x' || *input == 'X')        {            ++input;            int numChars = 0;            while (input[0] != ';')            {                const int hexValue = CharacterFunctions::getHexDigitValue (input[0]);                if (hexValue < 0 || ++numChars > 8)                {                    setLastError ("illegal escape sequence", true);                    break;                }                charCode = (charCode << 4) | hexValue;                ++input;            }            ++input;        }        else if (input[0] >= '0' && input[0] <= '9')        {            int numChars = 0;            while (input[0] != ';')            {                if (++numChars > 12)                {                    setLastError ("illegal escape sequence", true);                    break;                }                charCode = charCode * 10 + ((int) input[0] - '0');                ++input;            }            ++input;        }        else        {            setLastError ("illegal escape sequence", true);            result += '&';            return;        }        result << (juce_wchar) charCode;    }    else    {        const String::CharPointerType entityNameStart (input);        const int closingSemiColon = input.indexOf ((juce_wchar) ';');        if (closingSemiColon < 0)        {            outOfData = true;            result += '&';        }        else        {            input += closingSemiColon + 1;            result += expandExternalEntity (String (entityNameStart, (size_t) closingSemiColon));        }    }//.........这里部分代码省略.........

File File::getSpecialLocation (const SpecialLocationType type){    switch (type)    {    case userHomeDirectory:    {        const char* homeDir = getenv ("HOME");        if (homeDir == nullptr)        {            struct passwd* const pw = getpwuid (getuid());            if (pw != nullptr)                homeDir = pw->pw_dir;        }        return File (CharPointer_UTF8 (homeDir));    }    case userDocumentsDirectory:    case userMusicDirectory:    case userMoviesDirectory:    case userApplicationDataDirectory:        return File ("~");    case userDesktopDirectory:        return File ("~/Desktop");    case commonApplicationDataDirectory:        return File ("/var");    case globalApplicationsDirectory:        return File ("/usr");    case tempDirectory:    {        File tmp ("/var/tmp");        if (! tmp.isDirectory())        {            tmp = "/tmp";            if (! tmp.isDirectory())                tmp = File::getCurrentWorkingDirectory();        }        return tmp;    }    case invokedExecutableFile:        if (juce_Argv0 != nullptr)            return File (CharPointer_UTF8 (juce_Argv0));        // deliberate fall-through...    case currentExecutableFile:    case currentApplicationFile:        return juce_getExecutableFile();    case hostApplicationPath:        return juce_readlink ("/proc/self/exe", juce_getExecutableFile());    default:        jassertfalse; // unknown type?        break;    }    return File::nonexistent;}

String MemoryOutputStream::toUTF8() const{    const char* const d = static_cast<const char*> (getData());    return String (CharPointer_UTF8 (d), CharPointer_UTF8 (d + getDataSize()));}