The qdoc manual currently claims that the command must stand on its own line.
The change follows the consistency with the rest and how the example looks like
inside the qdoc manual for this command.
Change-Id: I6b653dc95cf9d84e4adf32220dace5d313678419
Reviewed-by: Casper van Donderen <casper.vandonderen@nokia.com>
*/
-/*! \internal
+/*!
+ * \internal
* Registers a custom interpolator \a func for the specific \a interpolationType.
* The interpolator has to be registered before the animation is constructed.
* To unregister (and use the default interpolator) set \a func to 0.
Esc_JISX0208_1983,
Esc_JISX0212 };
-/*! \internal */
+/*!
+ \internal
+*/
QJisCodec::QJisCodec() : conv(QJpUnicodeConv::newConverter(QJpUnicodeConv::Default))
{
}
-/*! \internal */
+/*!
+ \internal
+*/
QJisCodec::~QJisCodec()
{
delete (QJpUnicodeConv*)conv;
-/*! \internal */
+/*!
+ \internal
+*/
int QJisCodec::_mibEnum()
{
return 39;
}
-/*! \internal */
+/*!
+ \internal
+*/
QByteArray QJisCodec::_name()
{
return "ISO-2022-JP";
*/
-/*! \internal */
+/*!
+ \internal
+*/
uint QJpUnicodeConv::asciiToUnicode(uint h, uint l) const
{
if ((h == 0) && (l < 0x80)) {
return 0x0000;
}
-/*! \internal */
+/*!
+ \internal
+*/
uint QJpUnicodeConv::jisx0201ToUnicode(uint h, uint l) const
{
if (h == 0) {
return 0x0000;
}
-/*! \internal */
+/*!
+ \internal
+*/
uint QJpUnicodeConv::jisx0201LatinToUnicode(uint h, uint l) const
{
if ((h == 0) && IsLatin(l)) {
return 0x0000;
}
-/*! \internal */
+/*!
+ \internal
+*/
uint QJpUnicodeConv::jisx0201KanaToUnicode(uint h, uint l) const
{
if ((h == 0) && IsKana(l)) {
return 0x0000;
}
-/*! \internal */
+/*!
+ \internal
+*/
uint QJpUnicodeConv::jisx0208ToUnicode(uint h, uint l) const
{
if (rule & UDC){
return jisx0208ToUnicode11(h, l);
}
-/*! \internal */
+/*!
+ \internal
+*/
uint QJpUnicodeConv::jisx0212ToUnicode(uint h, uint l) const
{
if (rule & UDC){
return jisx0212ToUnicode11(h, l);
}
-/*! \internal */
+/*!
+ \internal
+*/
uint QJpUnicodeConv::unicodeToAscii(uint h, uint l) const
{
if ((h == 0) && (l < 0x80)) {
return 0x0000;
}
-/*! \internal */
+/*!
+ \internal
+*/
uint QJpUnicodeConv::unicodeToJisx0201(uint h, uint l) const
{
uint jis;
return 0x0000;
}
-/*! \internal */
+/*!
+ \internal
+*/
uint QJpUnicodeConv::unicodeToJisx0201Latin(uint h, uint l) const
{
uint jis = unicode11ToJisx0201(h, l);
return 0x0000;
}
-/*! \internal */
+/*!
+ \internal
+*/
uint QJpUnicodeConv::unicodeToJisx0201Kana(uint h, uint l) const
{
uint jis = unicode11ToJisx0201(h, l);
return 0x0000;
}
-/*! \internal */
+/*!
+ \internal
+*/
uint QJpUnicodeConv::unicodeToJisx0208(uint h, uint l) const
{
if (rule & UDC){
return jis;
}
-/*! \internal */
+/*!
+ \internal
+*/
uint QJpUnicodeConv::unicodeToJisx0212(uint h, uint l) const
{
if (rule & UDC){
return jis;
}
-/*! \internal */
+/*!
+ \internal
+*/
uint QJpUnicodeConv::sjisToUnicode(uint h, uint l) const
{
if (h == 0) {
return 0x0000;
}
-/*! \internal */
+/*!
+ \internal
+*/
uint QJpUnicodeConv::unicodeToSjis(uint h, uint l) const
{
uint jis;
return QJpUnicodeConv::unicodeToJisx0208(h, l);
}
-/*! \internal */
+/*!
+ \internal
+*/
uint QJpUnicodeConv_Unicode_ASCII::unicodeToJisx0212(uint h, uint l) const
{
if ((h == 0x00) && (l == 0x7e)) {
return QJpUnicodeConv::unicodeToJisx0208(h, l);
}
-/*! \internal */
+/*!
+ \internal
+*/
uint QJpUnicodeConv_JISX0221_ASCII::unicodeToJisx0212(uint h, uint l) const
{
if ((h == 0x00) && (l == 0x7e)) {
return QJpUnicodeConv::unicodeToJisx0208(h, l);
}
-/*! \internal */
+/*!
+ \internal
+*/
uint QJpUnicodeConv_Sun::unicodeToJisx0212(uint h, uint l) const
{
#if 1
}
-/*! \internal */
+/*!
+ \internal
+*/
QJpUnicodeConv *QJpUnicodeConv::newConverter(int rule)
{
QByteArray env = qgetenv("UNICODEMAP_JP");
{
}
-/*! \internal
+/*!
+ \internal
\since 4.5
Determines whether the eecoder encountered a failure while decoding the input. If
an error was encountered, the produced result is undefined, and gets converted as according
}
-/*! \internal
+/*!
+ \internal
\since 4.3
Determines whether the decoder encountered a failure while decoding the input. If
an error was encountered, the produced result is undefined, and gets converted as according
qFatal("In file %s, line %d: Out of memory", n, l);
}
-/* \internal
+/*
+ \internal
Allows you to throw an exception without including <new>
Called internally from Q_CHECK_PTR on certain OS combinations
*/
QT_THROW(std::bad_alloc());
}
-/* \internal
+/*
+ \internal
Allows you to call std::terminate() without including <exception>.
Called internally from QT_TERMINATE_ON_EXCEPTION
*/
#ifndef QT_BUILD_QMAKE
-/*! \internal
+/*!
+ \internal
You cannot create a QLibraryInfo, instead only the static functions are available to query
information.
d->clearFileLists();
}
-/*! \internal
+/*!
+ \internal
*/
QDirPrivate* QDir::d_func()
{
return d->getFileTime(QAbstractFileEngine::AccessTime);
}
-/*! \internal
+/*!
+ \internal
*/
QFileInfoPrivate* QFileInfo::d_func()
{
} \
} while (0)
-/*! \internal
+/*!
+ \internal
*/
QIODevicePrivate::QIODevicePrivate()
: openMode(QIODevice::NotOpen), buffer(QIODEVICE_BUFFERSIZE),
{
}
-/*! \internal
+/*!
+ \internal
*/
QIODevicePrivate::~QIODevicePrivate()
{
d_ptr->q_ptr = this;
}
-/*! \internal
+/*!
+ \internal
*/
QIODevice::QIODevice(QIODevicePrivate &dd)
: d_ptr(&dd)
#endif
}
-/*! \internal
+/*!
+ \internal
*/
QIODevice::QIODevice(QIODevicePrivate &dd, QObject *parent)
: QObject(dd, parent)
\sa readAllStandardError(), readChannel()
*/
-/*! \internal
+/*!
+ \internal
*/
QProcessPrivate::QProcessPrivate()
{
#endif
}
-/*! \internal
+/*!
+ \internal
*/
QProcessPrivate::~QProcessPrivate()
{
stdoutChannel.process->stdinChannel.clear();
}
-/*! \internal
+/*!
+ \internal
*/
void QProcessPrivate::cleanup()
{
#endif
}
-/*! \internal
+/*!
+ \internal
*/
bool QProcessPrivate::_q_canReadStandardOutput()
{
return didRead;
}
-/*! \internal
+/*!
+ \internal
*/
bool QProcessPrivate::_q_canReadStandardError()
{
return didRead;
}
-/*! \internal
+/*!
+ \internal
*/
bool QProcessPrivate::_q_canWrite()
{
return true;
}
-/*! \internal
+/*!
+ \internal
*/
bool QProcessPrivate::_q_processDied()
{
return true;
}
-/*! \internal
+/*!
+ \internal
*/
bool QProcessPrivate::_q_startupNotification()
{
return false;
}
-/*! \internal
+/*!
+ \internal
*/
void QProcessPrivate::closeWriteChannel()
{
QTextStream *q_ptr;
};
-/*! \internal
+/*!
+ \internal
*/
QTextStreamPrivate::QTextStreamPrivate(QTextStream *q_ptr)
:
reset();
}
-/*! \internal
+/*!
+ \internal
*/
QTextStreamPrivate::~QTextStreamPrivate()
{
}
#endif
-/*! \internal
+/*!
+ \internal
*/
void QTextStreamPrivate::reset()
{
#endif
}
-/*! \internal
+/*!
+ \internal
*/
bool QTextStreamPrivate::fillReadBuffer(qint64 maxBytes)
{
return true;
}
-/*! \internal
+/*!
+ \internal
*/
void QTextStreamPrivate::resetReadBuffer()
{
readBufferStartDevicePos = (device ? device->pos() : 0);
}
-/*! \internal
+/*!
+ \internal
*/
void QTextStreamPrivate::flushWriteBuffer()
{
return ret;
}
-/*! \internal
+/*!
+ \internal
Scans no more than \a maxlen QChars in the current buffer for the
first \a delimiter. Stores a pointer to the start offset of the
return true;
}
-/*! \internal
+/*!
+ \internal
*/
inline const QChar *QTextStreamPrivate::readPtr() const
{
return readBuffer.constData() + readBufferOffset;
}
-/*! \internal
+/*!
+ \internal
*/
inline void QTextStreamPrivate::consumeLastToken()
{
lastTokenSize = 0;
}
-/*! \internal
+/*!
+ \internal
*/
inline void QTextStreamPrivate::consume(int size)
{
}
}
-/*! \internal
+/*!
+ \internal
*/
inline void QTextStreamPrivate::saveConverterState(qint64 newPos)
{
readConverterSavedStateOffset = 0;
}
-/*! \internal
+/*!
+ \internal
*/
inline void QTextStreamPrivate::restoreToSavedConverterState()
{
#endif
}
-/*! \internal
+/*!
+ \internal
*/
inline void QTextStreamPrivate::write(const QString &data)
{
}
}
-/*! \internal
+/*!
+ \internal
*/
inline bool QTextStreamPrivate::getChar(QChar *ch)
{
return true;
}
-/*! \internal
+/*!
+ \internal
*/
inline void QTextStreamPrivate::ungetChar(QChar ch)
{
readBuffer[--readBufferOffset] = ch;
}
-/*! \internal
+/*!
+ \internal
*/
inline void QTextStreamPrivate::putString(const QString &s, bool number)
{
return d->read(int(maxlen));
}
-/*! \internal
+/*!
+ \internal
*/
QTextStreamPrivate::NumberParsingStatus QTextStreamPrivate::getNumber(qulonglong *ret)
{
return npsOk;
}
-/*! \internal
+/*!
+ \internal
(hihi)
*/
bool QTextStreamPrivate::getReal(double *f)
return *this;
}
-/*! \internal
+/*!
+ \internal
*/
void QTextStreamPrivate::putNumber(qulonglong number, bool negative)
{
fast and never fails.
*/
-/*! \internal
+/*!
+ \internal
Forces a detach.
*/
}
-/*! \internal
+/*!
+ \internal
*/
QIdentityProxyModel::QIdentityProxyModel(QIdentityProxyModelPrivate &dd, QObject* parent)
: QAbstractProxyModel(dd, parent)
setArray(array);
}
-/*! \internal
+/*!
+ \internal
*/
QJsonDocument::QJsonDocument(QJsonPrivate::Data *data)
: d(data)
// ### DOC: Are these called when the _application_ starts/stops or just
// when the current _event loop_ starts/stops?
-/*! \internal */
+/*!
+ \internal
+*/
void QAbstractEventDispatcher::startingUp()
{ }
-/*! \internal */
+/*!
+ \internal
+*/
void QAbstractEventDispatcher::closingDown()
{ }
If no instance has been allocated, \c null is returned.
*/
-/*!\internal
+/*!
+ \internal
*/
QCoreApplication::QCoreApplication(QCoreApplicationPrivate &p)
: QObject(p, 0)
return false;
}
-/*!\internal
+/*!
+ \internal
Helper function called by notify()
*/
: QEvent(Timer), id(timerId)
{}
-/*! \internal
+/*!
+ \internal
*/
QTimerEvent::~QTimerEvent()
{
: QEvent(type), c(child)
{}
-/*! \internal
+/*!
+ \internal
*/
QChildEvent::~QChildEvent()
{
, level(0)
{ }
-/*! \internal */
+/*!
+ \internal
+*/
QDeferredDeleteEvent::~QDeferredDeleteEvent()
{ }
return true;
}
-/** \internal
+/**
+* \internal
* helper function for indexOf{Method,Slot,Signal}, returns the relative index of the method within
* the baseObject
* \a MethodType might be MethodSignal or MethodSlot, or 0 to match everything.
return i;
}
-/*! \internal
+/*!
+ \internal
Same as QMetaObject::indexOfSignal, but the result is the local offset to the base object.
\a baseObject will be adjusted to the enclosing QMetaObject, or 0 if the signal is not found
return ((m.handle - priv(m.mobj->d.data)->methodData) / 5) + signalOffset(m.mobj);
}
-/*! \internal
+/*!
+ \internal
\since 5.0
Returns the signal for the given meta-object \a m at \a signal_index.
}
-/*! \internal */
+/*!
+ \internal
+ */
int QMetaMethod::attributes() const
{
if (!mobj)
\snippet code/src_corelib_kernel_qmetaobject.cpp 9
*/
-/*! \internal
+/*!
+ \internal
Implementation of the fromSignal() function.
and \a data.
*/
-/*! \internal
+/*!
+ \internal
If the local_method_index is a cloned method, return the index of the original.
Example: if the index of "destroyed()" is passed, the index of "destroyed(QObject*)" is returned
Q_GLOBAL_STATIC(QReadWriteLock, customTypesLock)
#ifndef QT_NO_DATASTREAM
-/*! \internal
+/*!
+ \internal
*/
void QMetaType::registerStreamOperators(const char *typeName, SaveOperator saveOp,
LoadOperator loadOp)
registerStreamOperators(type(typeName), saveOp, loadOp);
}
-/*! \internal
+/*!
+ \internal
*/
void QMetaType::registerStreamOperators(int idx, SaveOperator saveOp,
LoadOperator loadOp)
return result;
}
-/*! \internal
+/*!
+ \internal
Similar to QMetaType::type(), but only looks in the static set of types.
*/
static inline int qMetaTypeStaticType(const char *typeName, int length)
return types[i].type;
}
-/*! \internal
+/*!
+ \internal
Similar to QMetaType::type(), but only looks in the custom set of
types, and doesn't lock the mutex.
*/
return QMetaType::UnknownType;
}
-/*! \internal
+/*!
+ \internal
This function is needed until existing code outside of qtbase
has been changed to call the new version of registerType().
return registerType(typeName, deleter, creator, qMetaTypeDestructHelper<void>, qMetaTypeConstructHelper<void>, 0, TypeFlags(), 0);
}
-/*! \internal
+/*!
+ \internal
\since 5.0
Registers a user type for marshalling, with \a typeName, a \a
}
-/*! \internal
+/*!
+ \internal
\since 5.0
Registers a user type for marshalling, with \a normalizedTypeName, a \a
return idx;
}
-/*! \internal
+/*!
+ \internal
\since 4.7
Registers a user type for marshalling, as an alias of another type (typedef)
return registerNormalizedTypedef(normalizedTypeName, aliasId);
}
-/*! \internal
+/*!
+ \internal
\since 5.0
Registers a user type for marshalling, as an alias of another type (typedef).
static QBasicMutex _q_ObjectMutexPool[131];
-/** \internal
+/**
+ * \internal
* mutex to be locked when accessing the connectionlists or the senders list
*/
static inline QMutex *signalSlotLock(const QObject *o)
delete extraData;
}
-/*!\internal
+/*!
+ \internal
For a given metaobject, compute the signal offset, and the method offset (including signals)
*/
static void computeOffsets(const QMetaObject *metaobject, int *signalOffset, int *methodOffset)
return returnValue;
}
-/*! \internal
+/*!
+ \internal
Add the connection \a c to to the list of connections of the sender's object
for the specified \a signal
}
}
-/*! \internal
+/*!
+ \internal
*/
QMetaCallEvent::QMetaCallEvent(ushort method_offset, ushort method_relative, QObjectPrivate::StaticMetaCallFunction callFunction,
const QObject *sender, int signalId,
callFunction_(callFunction), method_offset_(method_offset), method_relative_(method_relative)
{ }
-/*! \internal
+/*!
+ \internal
*/
QMetaCallEvent::QMetaCallEvent(QObject::QSlotObjectBase *slotO, const QObject *sender, int signalId,
int nargs, int *types, void **args, QSemaphore *semaphore)
slotObj_->ref.ref();
}
-/*! \internal
+/*!
+ \internal
*/
QMetaCallEvent::~QMetaCallEvent()
{
delete slotObj_;
}
-/*! \internal
+/*!
+ \internal
*/
void QMetaCallEvent::placeMetaCall(QObject *object)
{
qt_addObject(this);
}
-/*! \internal
+/*!
+ \internal
*/
QObject::QObject(QObjectPrivate &dd, QObject *parent)
: d_ptr(&dd)
}
#endif // QT_NO_REGEXP
-/*! \internal
+/*!
+ \internal
*/
QObject *qt_qFindChild_helper(const QObject *parent, const QString &name, const QMetaObject &mo, Qt::FindChildOptions options)
{
Q_UNUSED(signal);
}
-/* \internal
+/*
+ \internal
convert a signal index from the method range to the signal range
*/
static int methodIndexToSignalIndex(const QMetaObject **base, int signal_index)
return signal_index;
}
-/*!\internal
+/*!
+ \internal
\a types is a 0-terminated vector of meta types for queued
connections.
type, types));
}
-/*! \internal
+/*!
+ \internal
Same as the QMetaObject::connect, but \a signal_index must be the result of QObjectPrivate::signalIndex
method_index is relative to the rmeta metaobject, if rmeta is null, then it is absolute index
return c.take();
}
-/*!\internal
+/*!
+ \internal
*/
bool QMetaObject::disconnect(const QObject *sender, int signal_index,
const QObject *receiver, int method_index)
receiver, method_index, 0);
}
-/*!\internal
+/*!
+ \internal
Disconnect a single signal connection. If QMetaObject::connect() has been called
multiple times for the same sender, signal_index, receiver and method_index only
QMetaObjectPrivate::DisconnectOne);
}
-/*! \internal
+/*!
+ \internal
Helper function to remove the connection from the senders list and setting the receivers to 0
*/
bool QMetaObjectPrivate::disconnectHelper(QObjectPrivate::Connection *c,
return success;
}
-/*! \internal
+/*!
+ \internal
Same as the QMetaObject::disconnect, but \a signal_index must be the result of QObjectPrivate::signalIndex
*/
bool QMetaObjectPrivate::disconnect(const QObject *sender,
}
}
-/*! \internal
+/*!
+ \internal
\a signal must be in the signal index range (see QObjectPrivate::signalIndex()).
*/
QCoreApplication::postEvent(c->receiver, ev);
}
-/*!\internal
+/*!
+ \internal
*/
void QMetaObject::activate(QObject *sender, const QMetaObject *m, int local_signal_index,
void **argv)
activate(sender, QMetaObjectPrivate::signalOffset(m), local_signal_index, argv);
}
-/*!\internal
+/*!
+ \internal
*/
void QMetaObject::activate(QObject *sender, int signalOffset, int local_signal_index, void **argv)
{
}
-/*!\internal
+/*!
+ \internal
signal_index comes from indexOfMethod()
*/
void QMetaObject::activate(QObject *sender, int signal_index, void **argv)
activate(sender, mo, signal_index - mo->methodOffset(), argv);
}
-/*! \internal
+/*!
+ \internal
Implementation of QObject::senderSignalIndex()
*/
int QObjectPrivate::senderSignalIndex() const
return -1;
}
-/*! \internal
+/*!
+ \internal
Returns the signal index used in the internal connectionLists vector.
It is different from QMetaObject::indexOfSignal(): indexOfSignal is the same as indexOfMethod
}
#ifndef QT_NO_USERDATA
-/*!\internal
+/*!
+ \internal
*/
uint QObject::registerUserData()
{
return user_data_registration++;
}
-/*!\internal
+/*!
+ \internal
*/
QObjectUserData::~QObjectUserData()
{
}
-/*!\internal
+/*!
+ \internal
*/
void QObject::setUserData(uint id, QObjectUserData* data)
{
d->extraData->userData[id] = data;
}
-/*!\internal
+/*!
+ \internal
*/
QObjectUserData* QObject::userData(uint id) const
{
The connection will automatically disconnect if the sender is destroyed.
*/
-/** \internal
+/**
+ \internal
Implementation of the template version of connect
QVariant::QVariant(int typeId, const void *copy)
{ create(typeId, copy); d.is_null = false; }
-/*! \internal
+/*!
+ \internal
flags is true if it is a pointer type
*/
QVariant::QVariant(int typeId, const void *copy, uint flags)
return tp == QVariant::Double || tp == QMetaType::Float;
}
-/*! \internal
+/*!
+ \internal
*/
bool QVariant::cmp(const QVariant &v) const
{
return handlerManager[d.type]->compare(&d, &v2.d);
}
-/*! \internal
+/*!
+ \internal
*/
const void *QVariant::constData() const
\internal
*/
-/*! \internal */
+/*!
+ \internal
+*/
void* QVariant::data()
{
detach();
to determine which mutex is returned from the pool.
*/
-/*! \internal
+/*!
+ \internal
create the mutex for the given index
*/
QMutex *QMutexPool::createMutex(int index)
d->data->thread = this;
}
-/*! \internal
+/*!
+ \internal
*/
QThread::QThread(QThreadPrivate &dd, QObject *parent)
: QObject(dd, parent)
return data;
}
-/*! \internal
+/*!
+ \internal
*/
QThread::QThread(QThreadPrivate &dd, QObject *parent)
: QObject(dd, parent)
sched_yield();
}
-/* \internal
+/*
+ \internal
helper function to do thread sleeps, since usleep()/nanosleep()
aren't reliable enough (in terms of behavior and availability)
*/
static DWORD qt_adopted_thread_watcher_id = 0;
static HANDLE qt_adopted_thread_wakeup = 0;
-/*! \internal
+/*!
+ \internal
Adds an adopted thread to the list of threads that Qt watches to make sure
the thread data is properly cleaned up. This function starts the watcher
thread if necessary.
*/
-/*!\internal
-
+/*!
+ \internal
*/
QThreadPoolThread::QThreadPoolThread(QThreadPoolPrivate *manager)
:manager(manager), runnable(0)
{ }
-/* \internal
-
+/*
+ \internal
*/
void QThreadPoolThread::run()
{
}
-/* \internal
-
+/*
+ \internal
*/
QThreadPoolPrivate:: QThreadPoolPrivate()
: isExiting(false),
return activeThreadCount > maxThreadCount && (activeThreadCount - reservedThreads) > 1;
}
-/*! \internal
-
+/*!
+ \internal
*/
void QThreadPoolPrivate::startThread(QRunnable *runnable)
{
thread.take()->start();
}
-/*! \internal
+/*!
+ \internal
Makes all threads exit, waits for each tread to exit and deletes it.
*/
void QThreadPoolPrivate::reset()
return queue.isEmpty() && activeThreads == 0;
}
-/*! \internal
+/*!
+ \internal
Seaches for \a runnable in the queue, removes it from the queue and
runs it if found. This functon does not return until the runnable
has completed.
return -1;
}
-/*! \internal
+/*!
+ \internal
*/
static int qFindByteArrayBoyerMoore(
const char *haystack, int haystackLen, int haystackOffset,
hashHaystack -= (a) << sl_minus_1; \
hashHaystack <<= 1
-/*! \internal
+/*!
+ \internal
*/
int qFindByteArray(
const char *haystack0, int haystackLen, int from,
\sa toTimeSpec()
*/
-/*! \internal
+/*!
+ \internal
*/
void QDateTime::detach()
{
/*!
- \internal helper function for parseFormat. removes quotes that are
+ \internal
+
+ helper function for parseFormat. removes quotes that are
not escaped and removes the escaping on those that are escaped
*/
#ifndef QT_NO_TEXTDATE
/*!
- \internal finds the first possible monthname that \a str1 can
+ \internal
+ finds the first possible monthname that \a str1 can
match. Starting from \a index; str should already by lowered
*/
}
/*!
- \internal Get a number that str can become which is between min
+ \internal
+
+ Get a number that str can become which is between min
and max or -1 if this is not possible.
*/
}
-/*! \internal Returns true if str can be modified to represent a
+/*!
+ \internal
+
+ Returns true if str can be modified to represent a
number that is within min and max.
*/
system_data->m_language_id = 0;
}
-/*! \internal */
+/*!
+ \internal
+*/
QSystemLocale::QSystemLocale(bool)
{ }
};
#endif
-/*! \internal
+/*!
+ \internal
convert the pattern string to the RegExp syntax.
This is also used by QScriptEngine::newRegExp to convert to a pattern that JavaScriptCore can understan
*/
-/*! \internal
+/*!
+ \internal
*/
void QAbstractConcatenable::convertFromAscii(const char *a, int len, QChar *&out)
{
{
}
-/*! \internal
+/*!
+ \internal
This function is a stub for later functionality.
*/