Function __embind_register_std_string

examples/public/basis/basis_transcoder.js:940–997

(rawType, name)

                    return new TA(buffer, data, size);
                }name = readLatin1String(name); registerType(rawType, { name, fromWireType: decodeMemoryView, argPackAdvance: 8, readValueFromPointer: decodeMemoryView }, { ignoreDuplicateRegistrations: true });
            } function __embind_register_std_string(rawType, name)
            {
                name = readLatin1String(name); const stdStringIsUTF8 = name === 'std::string';

                registerType(rawType, { name, fromWireType(value)
                {
                    const length = HEAPU32[value >> 2]; let str;

                    if (stdStringIsUTF8)
                    {
                        const endChar = HEAPU8[value + 4 + length]; let endCharSwap = 0;

                        if (endChar != 0) { endCharSwap = endChar; HEAPU8[value + 4 + length] = 0; } let decodeStartPtr = value + 4;

                        for (var i = 0; i <= length; ++i)
                        {
                            const currentBytePtr = value + 4 + i;

                            if (HEAPU8[currentBytePtr] == 0)
                            {
                                const stringSegment = UTF8ToString(decodeStartPtr);

                                if (str === undefined) { str = stringSegment; }
                                else { str += String.fromCharCode(0); str += stringSegment; }decodeStartPtr = currentBytePtr + 1;
                            }
                        } if (endCharSwap != 0) { HEAPU8[value + 4 + length] = endCharSwap; }
                    }
                    else
                    {
                        const a = new Array(length);

                        for (var i = 0; i < length; ++i) { a[i] = String.fromCharCode(HEAPU8[value + 4 + i]); }str = a.join('');
                    }_free(value);

                    return str;
                }, toWireType(destructors, value)
                {
                    if (value instanceof ArrayBuffer) { value = new Uint8Array(value); } let getLength; const valueIsOfTypeString = typeof value === 'string';

                    if (!(valueIsOfTypeString || value instanceof Uint8Array || value instanceof Uint8ClampedArray || value instanceof Int8Array)) { throwBindingError('Cannot pass non-string to std::string'); } if (stdStringIsUTF8 && valueIsOfTypeString) { getLength = function () { return lengthBytesUTF8(value); }; }
                    else { getLength = function () { return value.length; }; } const length = getLength(); const ptr = _malloc(4 + length + 1);

                    HEAPU32[ptr >> 2] = length; if (stdStringIsUTF8 && valueIsOfTypeString) { stringToUTF8(value, ptr + 4, length + 1); }
                    else
                    if (valueIsOfTypeString)
                    {
                        for (var i = 0; i < length; ++i)
                        {
                            const charCode = value.charCodeAt(i);

                            if (charCode > 255) { _free(ptr); throwBindingError('String has UTF-16 code units that do not fit in 8 bits'); }HEAPU8[ptr + 4 + i] = charCode;
                        }
                    }
                    else { for (var i = 0; i < length; ++i) { HEAPU8[ptr + 4 + i] = value[i]; } } if (destructors !== null) { destructors.push(_free, ptr); }

                    return ptr;
                }, argPackAdvance: 8, readValueFromPointer: simpleReadValueFromPointer, destructorFunction(ptr) { _free(ptr); } });
            } function __embind_register_std_wstring(rawType, charSize, name)