C++ constData函数代码示例

static void
print_message_to_buffer(const QModelIndex &idx, GtkTextBuffer *buffer)
{
    if (idx.isValid()) {
        auto message = idx.data().value<QString>().toUtf8();
        auto sender = idx.data(static_cast<int>(Media::TextRecording::Role::AuthorDisplayname)).value<QString>().toUtf8();

        GtkTextIter iter;

        /* unless its the very first message, insert a new line */
        if (idx.row() != 0) {
            gtk_text_buffer_get_end_iter(buffer, &iter);
            gtk_text_buffer_insert(buffer, &iter, "\n", -1);
        }

        auto format_sender = g_strconcat(sender.constData(), ": ", NULL);
        gtk_text_buffer_get_end_iter(buffer, &iter);
        gtk_text_buffer_insert_with_tags_by_name(buffer, &iter,
                                                 format_sender, -1,
                                                 "bold", NULL);
        g_free(format_sender);

        /* if the sender name is too long, insert a new line after it */
        if (sender.length() > 20) {
            gtk_text_buffer_get_end_iter(buffer, &iter);
            gtk_text_buffer_insert(buffer, &iter, "\n", -1);
        }

        gtk_text_buffer_get_end_iter(buffer, &iter);
        gtk_text_buffer_insert(buffer, &iter, message.constData(), -1);

    } else {
        g_warning("QModelIndex in im model is not valid");
    }
}

void writeVector(QDataStream& out, char ch, QVector<T> vec) {
    // Minimum number of bytes to consider compressing
    const int ATTEMPT_COMPRESSION_THRESHOLD_BYTES = 2000;

    out.device()->write(&ch, 1);
    out << (int32_t)vec.length();

    auto data { QByteArray::fromRawData((const char*)vec.constData(), vec.length() * sizeof(T)) };

    if (data.size() >= ATTEMPT_COMPRESSION_THRESHOLD_BYTES) {
        auto compressedDataWithLength { qCompress(data) };

        // qCompress packs a length uint32 at the beginning of the buffer, but the FBX format
        // does not expect it. This removes it.
        auto compressedData = QByteArray::fromRawData(
            compressedDataWithLength.constData() + sizeof(uint32_t), compressedDataWithLength.size() - sizeof(uint32_t));

        if (compressedData.size() < data.size()) {
            out << FBX_PROPERTY_COMPRESSED_FLAG;
            out << (int32_t)compressedData.size();
            out.writeRawData(compressedData.constData(), compressedData.size());
            return;
        }
    }

    out << FBX_PROPERTY_UNCOMPRESSED_FLAG;
    out << (int32_t)0;
    out.writeRawData(data.constData(), data.size());
}

double Q3CString::toDouble(bool *ok) const
{
    char *end;
    double val = strtod(constData() ? constData() : "", &end);
    if (ok)
        *ok = (constData() && *constData() && (end == 0 || *end == '\0'));
    return val;
}

time_t Path::lastModified() const
{
    struct stat st;
    if (stat(constData(), &st) == -1) {
        warning("Stat failed for %s", constData());
        return 0;
    }
    return st.st_mtime;
}

QString DefaultDemangler::demangle(const QString &symbol) const {
    int status;
    auto byteArray = symbol.toLatin1();
    if (auto output = std::unique_ptr<char[], FreeDeleter>(__cxa_demangle(byteArray.constData(), nullptr, nullptr, &status))) {
        return QLatin1String(output.get());
    } else if (auto output = std::unique_ptr<char[], FreeDeleter>(__unDName(nullptr, byteArray.constData(), 0, 0))) {
        return QLatin1String(output.get());
    } else {
        return QString();
    }
}

uint64_t Path::lastModifiedMs() const
{
    struct stat st;
    if (stat(constData(), &st) == -1) {
        warning("Stat failed for %s", constData());
        return 0;
    }
#ifdef HAVE_STATMTIM
    return st.st_mtim.tv_sec * static_cast<uint64_t>(1000) + st.st_mtim.tv_nsec / static_cast<uint64_t>(1000000);
#else
    return st.st_mtime * static_cast<uint64_t>(1000);
#endif
}

bool Path::resolve(ResolveMode mode, const Path &cwd, bool *changed)
{
    if (changed)
        *changed = false;
    if (startsWith('~')) {
        wordexp_t exp_result;
        wordexp(constData(), &exp_result, 0);
        operator=(exp_result.we_wordv[0]);
        wordfree(&exp_result);
    }
    if (*this == ".")
        clear();
    if (mode == MakeAbsolute) {
        if (isAbsolute())
            return true;
        const Path copy = (cwd.isEmpty() ? Path::pwd() : cwd.ensureTrailingSlash()) + *this;
        if (copy.exists()) {
            if (changed)
                *changed = true;
            operator=(copy);
            return true;
        }
        return false;
    }

    if (!cwd.isEmpty() && !isAbsolute()) {
        Path copy = cwd + '/' + *this;
        if (copy.resolve(RealPath, Path(), changed)) {
            operator=(copy);
            return true;
        }
    }

    {
        char buffer[PATH_MAX + 2];
        if (realpath(constData(), buffer)) {
            if (isDir()) {
                const int len = strlen(buffer);
                assert(buffer[len] != '/');
                buffer[len] = '/';
                buffer[len + 1] = '\0';
            }
            if (changed && strcmp(buffer, constData()))
                *changed = true;
            String::operator=(buffer);
            return true;
        }
    }

    return false;
}

void GLRasterTexture::initializeGL(bool coreProfile) {
    if(m_data.size() == 0) return;
    m_program = new QOpenGLShaderProgram;
    m_program->addShaderFromSourceCode(QOpenGLShader::Vertex, coreProfile ? vertexShaderSourceCore : vertexShaderSource);
    m_program->addShaderFromSourceCode(QOpenGLShader::Fragment, coreProfile ? fragmentShaderSourceCore : fragmentShaderSource);
    m_program->bindAttributeLocation("vertex", 0);
    m_program->bindAttributeLocation("texCoord", 1);
    m_program->link();

    m_program->bind();
    m_projMatrixLoc = m_program->uniformLocation("projMatrix");
    m_mvMatrixLoc = m_program->uniformLocation("mvMatrix");
    m_textureSamplerLoc = m_program->uniformLocation("texture");

    m_vao.create();
    QOpenGLVertexArrayObject::Binder vaoBinder(&m_vao);

    // Setup our vertex buffer object.
    m_vbo.create();
    m_vbo.bind();
    m_vbo.allocate(constData(), m_count * sizeof(GLfloat));

    // Store the vertex attribute bindings for the program.
    setupVertexAttribs();

    m_program->setUniformValue(m_textureSamplerLoc, 0);

    m_program->release();
    m_built = true;
}

const char * Path::extension() const
{
    const int dot = lastIndexOf('.');
    if (dot == -1 || dot + 1 == size())
        return 0;
    return constData() + dot + 1;
}

ulong Q3CString::toULong(bool *ok) const
{
    const char *p = constData();
    ulong val=0;
    const ulong max_mult = 429496729;
    bool is_ok = false;
    if (!p)
        goto bye;
    while (isspace((uchar) *p))                // skip leading space
        p++;
    if (*p == '+')
        p++;
    if (!isdigit((uchar) *p))
        goto bye;
    while (isdigit((uchar) *p)) {
        if (val > max_mult || (val == max_mult && (*p-'0') > 5))
            goto bye;
        val = 10*val + (*p++ - '0');
    }
    while (isspace((uchar) *p))                // skip trailing space
        p++;
    if (*p == '\0')
        is_ok = true;
bye:
    if (ok)
        *ok = is_ok;
    return is_ok ? val : 0;
}

BomAsciiCheckResult
checkForBomAndNonAscii(QString const &fileName) {
  QFile file{fileName};
  if (!file.open(QIODevice::ReadOnly))
    return {};

  auto content = file.readAll();
  file.close();

  auto result   = BomAsciiCheckResult{};
  auto dataSize = content.size();
  auto dataPtr  = reinterpret_cast<unsigned char const *>(content.constData());
  auto dataEnd  = dataPtr + dataSize;

  mm_text_io_c::detect_byte_order_marker(dataPtr, dataSize, result.byteOrder, result.bomLength);

  dataPtr += result.bomLength;

  while (dataPtr < dataEnd) {
    if (*dataPtr > 127) {
      result.containsNonAscii = true;
      break;
    }

    ++dataPtr;
  }

  return result;
}

Path Path::toTilde() const
{
    const Path home = Path::home();
    if (startsWith(home))
        return String::format<64>("~/%s", constData() + home.size());
    return *this;
}

int main (int argc, char *argv[]) 
{
    if (!preprocessCommands(&argc, argv, NULL, NULL)) {
    	xexit(0); 
	}

    printf("Resource Reading...\n");
    ResourceSource* res = setupParameters(true, &argc, argv);

    ConstData constData(*res);
    Intervals intervals(*res);
    BeamParams beamParams(*res);

    FILE* massOut = openOutDataFile(*res, "mass_out");
    FILE* crossSectionOut = openOutDataFile(*res, "total_cross_section_out");
    printFileHeaders(massOut, crossSectionOut);

    printf("Main loop...\n");
    DataSeparator massSeparator(massOut), csSeparator(crossSectionOut);
    loopMassMuTan(constData, intervals, beamParams, massSeparator, csSeparator,
                  massOut, crossSectionOut);
    printf("Resource releasing...\n");

    fclose(crossSectionOut);
    fclose(massOut);

    delete res;

    printf("Done...\n");
    xexit(0);

}

const char * Path::fileName(int *len) const
{
    const int idx = lastIndexOf('/') + 1;
    if (len)
        *len = size() - idx;
    return constData() + idx;
}

bool Path::resolve(ResolveMode mode, const Path &cwd)
{
    if (mode == MakeAbsolute) {
        if (isAbsolute())
            return true;
        const Path copy = (cwd.isEmpty() ? Path::pwd() : cwd) + *this;
        if (copy.exists()) {
            operator=(copy);
            return true;
        }
        return false;
    } else {
        if (!cwd.isEmpty() && !isAbsolute()) {
            Path copy = cwd + '/' + *this;
            if (copy.resolve(RealPath)) {
                operator=(copy);
                return true;
            }
        }

        {
            char buffer[PATH_MAX + 2];
            if (realpath(constData(), buffer)) {
                String::operator=(buffer);
                return true;
            }
        }
    }
    return false;
}