fivedev/harbour-core
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
0937c773fbfe7acb9bc0e495a93c9ad1d1ca9bf2
harbour-core/harbour/contrib/hbqt/qtcore/QByteArray.cpp
Pritpal Bedi 0937c773fb 2010-07-11 22:35 UTC-0800 Pritpal Bedi (bedipritpal@hotmail.com) 
* contrib/hbqt/filelist.mk
  * contrib/hbqt/generator/hbqtgen.prg
  * contrib/hbqt/generator/qt45.qtp
  * contrib/hbqt/hbqt.ch
  * contrib/hbqt/hbqt.h
  * contrib/hbqt/hbqt.hbp
  * contrib/hbqt/hbqt_garbage.h
  + contrib/hbqt/hbqt_hbqabstractitemmodel.cpp
  + contrib/hbqt/hbqt_hbqabstractitemmodel.h
  * contrib/hbqt/qtcore/filelist.hbm
  * contrib/hbqt/qtcore/filelist.mk
  + contrib/hbqt/qth/HBQAbstractItemModel.qth
  * contrib/hbxbp/xbpbrowse.prg

    + Applied patch provided by Bacco, thanks.
      This implements one more member to the structure
      which will help simplifying many complex structures in hbQT.

  * Regenerated: *.cpp
2010-07-12 05:48:44 +00:00

1560 lines
49 KiB
C++
Raw Blame History

/*
* $Id$
*/
/* -------------------------------------------------------------------- */
/* WARNING: Automatically generated source file. DO NOT EDIT! */
/* Instead, edit corresponding .qth file, */
/* or the generator tool itself, and run regenarate. */
/* -------------------------------------------------------------------- */
/*
* Harbour Project source code:
* QT wrapper main header
*
* Copyright 2009-2010 Pritpal Bedi <pritpal@vouchcac.com>
*
* Copyright 2009 Marcos Antonio Gambeta <marcosgambeta at gmail dot com>
* www - http://harbour-project.org
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this software; see the file COPYING. If not, write to
* the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/).
*
* As a special exception, the Harbour Project gives permission for
* additional uses of the text contained in its release of Harbour.
*
* The exception is that, if you link the Harbour libraries with other
* files to produce an executable, this does not by itself cause the
* resulting executable to be covered by the GNU General Public License.
* Your use of that executable is in no way restricted on account of
* linking the Harbour library code into it.
*
* This exception does not however invalidate any other reasons why
* the executable file might be covered by the GNU General Public License.
*
* This exception applies only to the code released by the Harbour
* Project under the name Harbour. If you copy code from other
* Harbour Project or Free Software Foundation releases into a copy of
* Harbour, as the General Public License permits, the exception does
* not apply to the code that you add in this way. To avoid misleading
* anyone as to the status of such modified files, you must delete
* this exception notice from them.
*
* If you write modifications of your own for Harbour, it is your choice
* whether to permit this exception to apply to your modifications.
* If you do not wish that, delete this exception notice.
*
*/
/*----------------------------------------------------------------------*/
#include "../hbqt.h"
/*----------------------------------------------------------------------*/
#if QT_VERSION >= 0x040500
/*----------------------------------------------------------------------*/
#include <QtCore/QPointer>
#include <QtCore/QByteArray>
/* QByteArray ()
* QByteArray ( const char * str )
* QByteArray ( const char * data, int size )
* QByteArray ( int size, char ch )
* QByteArray ( const QByteArray & other )
* ~QByteArray ()
*/
typedef struct
{
QByteArray * ph;
bool bNew;
QT_G_FUNC_PTR func;
int type;
} QGC_POINTER_QByteArray;
QT_G_FUNC( hbqt_gcRelease_QByteArray )
{
QGC_POINTER * p = ( QGC_POINTER * ) Cargo;
if( p && p->bNew )
{
if( p->ph )
{
HB_TRACE( HB_TR_DEBUG, ( "ph=%p _rel_QByteArray /.\\", p->ph ) );
delete ( ( QByteArray * ) p->ph );
HB_TRACE( HB_TR_DEBUG, ( "ph=%p YES_rel_QByteArray \\./", p->ph ) );
p->ph = NULL;
}
else
{
HB_TRACE( HB_TR_DEBUG, ( "ph=%p DEL_rel_QByteArray : Object already deleted!", p->ph ) );
p->ph = NULL;
}
}
else
{
HB_TRACE( HB_TR_DEBUG, ( "ph=%p PTR_rel_QByteArray : Object not created with new=true", p->ph ) );
p->ph = NULL;
}
}
void * hbqt_gcAllocate_QByteArray( void * pObj, bool bNew )
{
QGC_POINTER * p = ( QGC_POINTER * ) hb_gcAllocate( sizeof( QGC_POINTER ), hbqt_gcFuncs() );
p->ph = ( QByteArray * ) pObj;
p->bNew = bNew;
p->func = hbqt_gcRelease_QByteArray;
p->type = QT_TYPE_QByteArray;
if( bNew )
{
HB_TRACE( HB_TR_DEBUG, ( "ph=%p _new_QByteArray", pObj ) );
}
else
{
HB_TRACE( HB_TR_DEBUG, ( "ph=%p NOT_new_QByteArray", pObj ) );
}
return p;
}
HB_FUNC( QT_QBYTEARRAY )
{
QByteArray * pObj = NULL;
pObj = new QByteArray() ;
hb_retptrGC( hbqt_gcAllocate_QByteArray( ( void * ) pObj, true ) );
}
/*
* QByteArray & append ( const QByteArray & ba )
*/
HB_FUNC( QT_QBYTEARRAY_APPEND )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->append( *hbqt_par_QByteArray( 2 ) ) ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_APPEND FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->append( *hbqt_par_QByteArray( 2 ) ) ), true ) ); p is NULL" ) );
}
}
/*
* QByteArray & append ( const QString & str )
*/
HB_FUNC( QT_QBYTEARRAY_APPEND_1 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->append( hbqt_par_QString( 2 ) ) ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_APPEND_1 FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->append( hbqt_par_QString( 2 ) ) ), true ) ); p is NULL" ) );
}
}
/*
* QByteArray & append ( const char * str )
*/
HB_FUNC( QT_QBYTEARRAY_APPEND_2 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->append( hbqt_par_char( 2 ) ) ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_APPEND_2 FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->append( hbqt_par_char( 2 ) ) ), true ) ); p is NULL" ) );
}
}
/*
* QByteArray & append ( const char * str, int len )
*/
HB_FUNC( QT_QBYTEARRAY_APPEND_3 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->append( hbqt_par_char( 2 ), hb_parni( 3 ) ) ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_APPEND_3 FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->append( hbqt_par_char( 2 ), hb_parni( 3 ) ) ), true ) ); p is NULL" ) );
}
}
/*
* QByteArray & append ( char ch )
*/
HB_FUNC( QT_QBYTEARRAY_APPEND_4 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->append( ( char ) hb_parni( 2 ) ) ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_APPEND_4 FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->append( ( char ) hb_parni( 2 ) ) ), true ) ); p is NULL" ) );
}
}
/*
* char at ( int i ) const
*/
HB_FUNC( QT_QBYTEARRAY_AT )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retni( ( p )->at( hb_parni( 2 ) ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_AT FP=hb_retni( ( p )->at( hb_parni( 2 ) ) ); p is NULL" ) );
}
}
/*
* int capacity () const
*/
HB_FUNC( QT_QBYTEARRAY_CAPACITY )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retni( ( p )->capacity() );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_CAPACITY FP=hb_retni( ( p )->capacity() ); p is NULL" ) );
}
}
/*
* void chop ( int n )
*/
HB_FUNC( QT_QBYTEARRAY_CHOP )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
( p )->chop( hb_parni( 2 ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_CHOP FP=( p )->chop( hb_parni( 2 ) ); p is NULL" ) );
}
}
/*
* void clear ()
*/
HB_FUNC( QT_QBYTEARRAY_CLEAR )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
( p )->clear();
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_CLEAR FP=( p )->clear(); p is NULL" ) );
}
}
/*
* const char * constData () const
*/
HB_FUNC( QT_QBYTEARRAY_CONSTDATA )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retc( ( p )->constData() );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_CONSTDATA FP=hb_retc( ( p )->constData() ); p is NULL" ) );
}
}
/*
* int count ( const QByteArray & ba ) const
*/
HB_FUNC( QT_QBYTEARRAY_COUNT )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retni( ( p )->count( *hbqt_par_QByteArray( 2 ) ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_COUNT FP=hb_retni( ( p )->count( *hbqt_par_QByteArray( 2 ) ) ); p is NULL" ) );
}
}
/*
* int count ( const char * str ) const
*/
HB_FUNC( QT_QBYTEARRAY_COUNT_1 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retni( ( p )->count( hbqt_par_char( 2 ) ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_COUNT_1 FP=hb_retni( ( p )->count( hbqt_par_char( 2 ) ) ); p is NULL" ) );
}
}
/*
* int count ( char ch ) const
*/
HB_FUNC( QT_QBYTEARRAY_COUNT_2 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retni( ( p )->count( ( char ) hb_parni( 2 ) ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_COUNT_2 FP=hb_retni( ( p )->count( ( char ) hb_parni( 2 ) ) ); p is NULL" ) );
}
}
/*
* int count () const
*/
HB_FUNC( QT_QBYTEARRAY_COUNT_3 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retni( ( p )->count() );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_COUNT_3 FP=hb_retni( ( p )->count() ); p is NULL" ) );
}
}
/*
* char * data ()
*/
HB_FUNC( QT_QBYTEARRAY_DATA )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retc( ( p )->data() );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_DATA FP=hb_retc( ( p )->data() ); p is NULL" ) );
}
}
/*
* const char * data () const
*/
HB_FUNC( QT_QBYTEARRAY_DATA_1 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retc( ( p )->data() );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_DATA_1 FP=hb_retc( ( p )->data() ); p is NULL" ) );
}
}
/*
* bool endsWith ( const QByteArray & ba ) const
*/
HB_FUNC( QT_QBYTEARRAY_ENDSWITH )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retl( ( p )->endsWith( *hbqt_par_QByteArray( 2 ) ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_ENDSWITH FP=hb_retl( ( p )->endsWith( *hbqt_par_QByteArray( 2 ) ) ); p is NULL" ) );
}
}
/*
* bool endsWith ( const char * str ) const
*/
HB_FUNC( QT_QBYTEARRAY_ENDSWITH_1 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retl( ( p )->endsWith( hbqt_par_char( 2 ) ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_ENDSWITH_1 FP=hb_retl( ( p )->endsWith( hbqt_par_char( 2 ) ) ); p is NULL" ) );
}
}
/*
* bool endsWith ( char ch ) const
*/
HB_FUNC( QT_QBYTEARRAY_ENDSWITH_2 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retl( ( p )->endsWith( ( char ) hb_parni( 2 ) ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_ENDSWITH_2 FP=hb_retl( ( p )->endsWith( ( char ) hb_parni( 2 ) ) ); p is NULL" ) );
}
}
/*
* QByteArray & fill ( char ch, int size = -1 )
*/
HB_FUNC( QT_QBYTEARRAY_FILL )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->fill( ( char ) hb_parni( 2 ), hb_parnidef( 3, -1 ) ) ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_FILL FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->fill( ( char ) hb_parni( 2 ), hb_parnidef( 3, -1 ) ) ), true ) ); p is NULL" ) );
}
}
/*
* int indexOf ( const QByteArray & ba, int from = 0 ) const
*/
HB_FUNC( QT_QBYTEARRAY_INDEXOF )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retni( ( p )->indexOf( *hbqt_par_QByteArray( 2 ), hb_parni( 3 ) ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_INDEXOF FP=hb_retni( ( p )->indexOf( *hbqt_par_QByteArray( 2 ), hb_parni( 3 ) ) ); p is NULL" ) );
}
}
/*
* int indexOf ( const QString & str, int from = 0 ) const
*/
HB_FUNC( QT_QBYTEARRAY_INDEXOF_1 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retni( ( p )->indexOf( hbqt_par_QString( 2 ), hb_parni( 3 ) ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_INDEXOF_1 FP=hb_retni( ( p )->indexOf( hbqt_par_QString( 2 ), hb_parni( 3 ) ) ); p is NULL" ) );
}
}
/*
* int indexOf ( const char * str, int from = 0 ) const
*/
HB_FUNC( QT_QBYTEARRAY_INDEXOF_2 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retni( ( p )->indexOf( hbqt_par_char( 2 ), hb_parni( 3 ) ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_INDEXOF_2 FP=hb_retni( ( p )->indexOf( hbqt_par_char( 2 ), hb_parni( 3 ) ) ); p is NULL" ) );
}
}
/*
* int indexOf ( char ch, int from = 0 ) const
*/
HB_FUNC( QT_QBYTEARRAY_INDEXOF_3 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retni( ( p )->indexOf( ( char ) hb_parni( 2 ), hb_parni( 3 ) ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_INDEXOF_3 FP=hb_retni( ( p )->indexOf( ( char ) hb_parni( 2 ), hb_parni( 3 ) ) ); p is NULL" ) );
}
}
/*
* QByteArray & insert ( int i, const QByteArray & ba )
*/
HB_FUNC( QT_QBYTEARRAY_INSERT )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->insert( hb_parni( 2 ), *hbqt_par_QByteArray( 3 ) ) ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_INSERT FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->insert( hb_parni( 2 ), *hbqt_par_QByteArray( 3 ) ) ), true ) ); p is NULL" ) );
}
}
/*
* QByteArray & insert ( int i, const QString & str )
*/
HB_FUNC( QT_QBYTEARRAY_INSERT_1 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->insert( hb_parni( 2 ), hbqt_par_QString( 3 ) ) ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_INSERT_1 FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->insert( hb_parni( 2 ), hbqt_par_QString( 3 ) ) ), true ) ); p is NULL" ) );
}
}
/*
* QByteArray & insert ( int i, const char * str )
*/
HB_FUNC( QT_QBYTEARRAY_INSERT_2 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->insert( hb_parni( 2 ), hbqt_par_char( 3 ) ) ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_INSERT_2 FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->insert( hb_parni( 2 ), hbqt_par_char( 3 ) ) ), true ) ); p is NULL" ) );
}
}
/*
* QByteArray & insert ( int i, char ch )
*/
HB_FUNC( QT_QBYTEARRAY_INSERT_3 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->insert( hb_parni( 2 ), ( char ) hb_parni( 3 ) ) ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_INSERT_3 FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->insert( hb_parni( 2 ), ( char ) hb_parni( 3 ) ) ), true ) ); p is NULL" ) );
}
}
/*
* bool isEmpty () const
*/
HB_FUNC( QT_QBYTEARRAY_ISEMPTY )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retl( ( p )->isEmpty() );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_ISEMPTY FP=hb_retl( ( p )->isEmpty() ); p is NULL" ) );
}
}
/*
* bool isNull () const
*/
HB_FUNC( QT_QBYTEARRAY_ISNULL )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retl( ( p )->isNull() );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_ISNULL FP=hb_retl( ( p )->isNull() ); p is NULL" ) );
}
}
/*
* int lastIndexOf ( const QByteArray & ba, int from = -1 ) const
*/
HB_FUNC( QT_QBYTEARRAY_LASTINDEXOF )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retni( ( p )->lastIndexOf( *hbqt_par_QByteArray( 2 ), hb_parnidef( 3, -1 ) ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_LASTINDEXOF FP=hb_retni( ( p )->lastIndexOf( *hbqt_par_QByteArray( 2 ), hb_parnidef( 3, -1 ) ) ); p is NULL" ) );
}
}
/*
* int lastIndexOf ( const QString & str, int from = -1 ) const
*/
HB_FUNC( QT_QBYTEARRAY_LASTINDEXOF_1 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retni( ( p )->lastIndexOf( hbqt_par_QString( 2 ), hb_parnidef( 3, -1 ) ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_LASTINDEXOF_1 FP=hb_retni( ( p )->lastIndexOf( hbqt_par_QString( 2 ), hb_parnidef( 3, -1 ) ) ); p is NULL" ) );
}
}
/*
* int lastIndexOf ( const char * str, int from = -1 ) const
*/
HB_FUNC( QT_QBYTEARRAY_LASTINDEXOF_2 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retni( ( p )->lastIndexOf( hbqt_par_char( 2 ), hb_parnidef( 3, -1 ) ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_LASTINDEXOF_2 FP=hb_retni( ( p )->lastIndexOf( hbqt_par_char( 2 ), hb_parnidef( 3, -1 ) ) ); p is NULL" ) );
}
}
/*
* int lastIndexOf ( char ch, int from = -1 ) const
*/
HB_FUNC( QT_QBYTEARRAY_LASTINDEXOF_3 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retni( ( p )->lastIndexOf( ( char ) hb_parni( 2 ), hb_parnidef( 3, -1 ) ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_LASTINDEXOF_3 FP=hb_retni( ( p )->lastIndexOf( ( char ) hb_parni( 2 ), hb_parnidef( 3, -1 ) ) ); p is NULL" ) );
}
}
/*
* QByteArray left ( int len ) const
*/
HB_FUNC( QT_QBYTEARRAY_LEFT )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->left( hb_parni( 2 ) ) ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_LEFT FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->left( hb_parni( 2 ) ) ), true ) ); p is NULL" ) );
}
}
/*
* QByteArray leftJustified ( int width, char fill = ' ', bool truncate = false ) const
*/
HB_FUNC( QT_QBYTEARRAY_LEFTJUSTIFIED )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->leftJustified( hb_parni( 2 ), ( char ) hb_parni( 3 ), hb_parl( 4 ) ) ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_LEFTJUSTIFIED FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->leftJustified( hb_parni( 2 ), ( char ) hb_parni( 3 ), hb_parl( 4 ) ) ), true ) ); p is NULL" ) );
}
}
/*
* int length () const
*/
HB_FUNC( QT_QBYTEARRAY_LENGTH )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retni( ( p )->length() );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_LENGTH FP=hb_retni( ( p )->length() ); p is NULL" ) );
}
}
/*
* QByteArray mid ( int pos, int len = -1 ) const
*/
HB_FUNC( QT_QBYTEARRAY_MID )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->mid( hb_parni( 2 ), hb_parnidef( 3, -1 ) ) ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_MID FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->mid( hb_parni( 2 ), hb_parnidef( 3, -1 ) ) ), true ) ); p is NULL" ) );
}
}
/*
* QByteArray & prepend ( const QByteArray & ba )
*/
HB_FUNC( QT_QBYTEARRAY_PREPEND )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->prepend( *hbqt_par_QByteArray( 2 ) ) ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_PREPEND FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->prepend( *hbqt_par_QByteArray( 2 ) ) ), true ) ); p is NULL" ) );
}
}
/*
* QByteArray & prepend ( const char * str )
*/
HB_FUNC( QT_QBYTEARRAY_PREPEND_1 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->prepend( hbqt_par_char( 2 ) ) ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_PREPEND_1 FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->prepend( hbqt_par_char( 2 ) ) ), true ) ); p is NULL" ) );
}
}
/*
* QByteArray & prepend ( char ch )
*/
HB_FUNC( QT_QBYTEARRAY_PREPEND_2 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->prepend( ( char ) hb_parni( 2 ) ) ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_PREPEND_2 FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->prepend( ( char ) hb_parni( 2 ) ) ), true ) ); p is NULL" ) );
}
}
/*
* void push_back ( const QByteArray & other )
*/
HB_FUNC( QT_QBYTEARRAY_PUSH_BACK )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
( p )->push_back( *hbqt_par_QByteArray( 2 ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_PUSH_BACK FP=( p )->push_back( *hbqt_par_QByteArray( 2 ) ); p is NULL" ) );
}
}
/*
* void push_back ( const char * str )
*/
HB_FUNC( QT_QBYTEARRAY_PUSH_BACK_1 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
( p )->push_back( hbqt_par_char( 2 ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_PUSH_BACK_1 FP=( p )->push_back( hbqt_par_char( 2 ) ); p is NULL" ) );
}
}
/*
* void push_back ( char ch )
*/
HB_FUNC( QT_QBYTEARRAY_PUSH_BACK_2 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
( p )->push_back( ( char ) hb_parni( 2 ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_PUSH_BACK_2 FP=( p )->push_back( ( char ) hb_parni( 2 ) ); p is NULL" ) );
}
}
/*
* void push_front ( const QByteArray & other )
*/
HB_FUNC( QT_QBYTEARRAY_PUSH_FRONT )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
( p )->push_front( *hbqt_par_QByteArray( 2 ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_PUSH_FRONT FP=( p )->push_front( *hbqt_par_QByteArray( 2 ) ); p is NULL" ) );
}
}
/*
* void push_front ( const char * str )
*/
HB_FUNC( QT_QBYTEARRAY_PUSH_FRONT_1 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
( p )->push_front( hbqt_par_char( 2 ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_PUSH_FRONT_1 FP=( p )->push_front( hbqt_par_char( 2 ) ); p is NULL" ) );
}
}
/*
* void push_front ( char ch )
*/
HB_FUNC( QT_QBYTEARRAY_PUSH_FRONT_2 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
( p )->push_front( ( char ) hb_parni( 2 ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_PUSH_FRONT_2 FP=( p )->push_front( ( char ) hb_parni( 2 ) ); p is NULL" ) );
}
}
/*
* QByteArray & remove ( int pos, int len )
*/
HB_FUNC( QT_QBYTEARRAY_REMOVE )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->remove( hb_parni( 2 ), hb_parni( 3 ) ) ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_REMOVE FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->remove( hb_parni( 2 ), hb_parni( 3 ) ) ), true ) ); p is NULL" ) );
}
}
/*
* QByteArray repeated ( int times ) const
*/
HB_FUNC( QT_QBYTEARRAY_REPEATED )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->repeated( hb_parni( 2 ) ) ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_REPEATED FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->repeated( hb_parni( 2 ) ) ), true ) ); p is NULL" ) );
}
}
/*
* QByteArray & replace ( int pos, int len, const QByteArray & after )
*/
HB_FUNC( QT_QBYTEARRAY_REPLACE )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->replace( hb_parni( 2 ), hb_parni( 3 ), *hbqt_par_QByteArray( 4 ) ) ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_REPLACE FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->replace( hb_parni( 2 ), hb_parni( 3 ), *hbqt_par_QByteArray( 4 ) ) ), true ) ); p is NULL" ) );
}
}
/*
* QByteArray & replace ( int pos, int len, const char * after )
*/
HB_FUNC( QT_QBYTEARRAY_REPLACE_1 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->replace( hb_parni( 2 ), hb_parni( 3 ), hbqt_par_char( 4 ) ) ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_REPLACE_1 FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->replace( hb_parni( 2 ), hb_parni( 3 ), hbqt_par_char( 4 ) ) ), true ) ); p is NULL" ) );
}
}
/*
* QByteArray & replace ( const QByteArray & before, const QByteArray & after )
*/
HB_FUNC( QT_QBYTEARRAY_REPLACE_2 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->replace( *hbqt_par_QByteArray( 2 ), *hbqt_par_QByteArray( 3 ) ) ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_REPLACE_2 FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->replace( *hbqt_par_QByteArray( 2 ), *hbqt_par_QByteArray( 3 ) ) ), true ) ); p is NULL" ) );
}
}
/*
* QByteArray & replace ( const char * before, const QByteArray & after )
*/
HB_FUNC( QT_QBYTEARRAY_REPLACE_3 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->replace( hbqt_par_char( 2 ), *hbqt_par_QByteArray( 3 ) ) ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_REPLACE_3 FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->replace( hbqt_par_char( 2 ), *hbqt_par_QByteArray( 3 ) ) ), true ) ); p is NULL" ) );
}
}
/*
* QByteArray & replace ( const char * before, int bsize, const char * after, int asize )
*/
HB_FUNC( QT_QBYTEARRAY_REPLACE_4 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->replace( hbqt_par_char( 2 ), hb_parni( 3 ), hbqt_par_char( 4 ), hb_parni( 5 ) ) ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_REPLACE_4 FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->replace( hbqt_par_char( 2 ), hb_parni( 3 ), hbqt_par_char( 4 ), hb_parni( 5 ) ) ), true ) ); p is NULL" ) );
}
}
/*
* QByteArray & replace ( const QByteArray & before, const char * after )
*/
HB_FUNC( QT_QBYTEARRAY_REPLACE_5 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->replace( *hbqt_par_QByteArray( 2 ), hbqt_par_char( 3 ) ) ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_REPLACE_5 FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->replace( *hbqt_par_QByteArray( 2 ), hbqt_par_char( 3 ) ) ), true ) ); p is NULL" ) );
}
}
/*
* QByteArray & replace ( const QString & before, const QByteArray & after )
*/
HB_FUNC( QT_QBYTEARRAY_REPLACE_6 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->replace( hbqt_par_QString( 2 ), *hbqt_par_QByteArray( 3 ) ) ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_REPLACE_6 FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->replace( hbqt_par_QString( 2 ), *hbqt_par_QByteArray( 3 ) ) ), true ) ); p is NULL" ) );
}
}
/*
* QByteArray & replace ( const QString & before, const char * after )
*/
HB_FUNC( QT_QBYTEARRAY_REPLACE_7 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->replace( hbqt_par_QString( 2 ), hbqt_par_char( 3 ) ) ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_REPLACE_7 FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->replace( hbqt_par_QString( 2 ), hbqt_par_char( 3 ) ) ), true ) ); p is NULL" ) );
}
}
/*
* QByteArray & replace ( const char * before, const char * after )
*/
HB_FUNC( QT_QBYTEARRAY_REPLACE_8 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->replace( hbqt_par_char( 2 ), hbqt_par_char( 3 ) ) ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_REPLACE_8 FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->replace( hbqt_par_char( 2 ), hbqt_par_char( 3 ) ) ), true ) ); p is NULL" ) );
}
}
/*
* QByteArray & replace ( char before, const QByteArray & after )
*/
HB_FUNC( QT_QBYTEARRAY_REPLACE_9 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->replace( ( char ) hb_parni( 2 ), *hbqt_par_QByteArray( 3 ) ) ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_REPLACE_9 FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->replace( ( char ) hb_parni( 2 ), *hbqt_par_QByteArray( 3 ) ) ), true ) ); p is NULL" ) );
}
}
/*
* QByteArray & replace ( char before, const QString & after )
*/
HB_FUNC( QT_QBYTEARRAY_REPLACE_10 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->replace( ( char ) hb_parni( 2 ), hbqt_par_QString( 3 ) ) ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_REPLACE_10 FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->replace( ( char ) hb_parni( 2 ), hbqt_par_QString( 3 ) ) ), true ) ); p is NULL" ) );
}
}
/*
* QByteArray & replace ( char before, const char * after )
*/
HB_FUNC( QT_QBYTEARRAY_REPLACE_11 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->replace( ( char ) hb_parni( 2 ), hbqt_par_char( 3 ) ) ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_REPLACE_11 FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->replace( ( char ) hb_parni( 2 ), hbqt_par_char( 3 ) ) ), true ) ); p is NULL" ) );
}
}
/*
* QByteArray & replace ( char before, char after )
*/
HB_FUNC( QT_QBYTEARRAY_REPLACE_12 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->replace( ( char ) hb_parni( 2 ), ( char ) hb_parni( 3 ) ) ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_REPLACE_12 FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->replace( ( char ) hb_parni( 2 ), ( char ) hb_parni( 3 ) ) ), true ) ); p is NULL" ) );
}
}
/*
* void reserve ( int size )
*/
HB_FUNC( QT_QBYTEARRAY_RESERVE )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
( p )->reserve( hb_parni( 2 ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_RESERVE FP=( p )->reserve( hb_parni( 2 ) ); p is NULL" ) );
}
}
/*
* void resize ( int size )
*/
HB_FUNC( QT_QBYTEARRAY_RESIZE )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
( p )->resize( hb_parni( 2 ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_RESIZE FP=( p )->resize( hb_parni( 2 ) ); p is NULL" ) );
}
}
/*
* QByteArray right ( int len ) const
*/
HB_FUNC( QT_QBYTEARRAY_RIGHT )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->right( hb_parni( 2 ) ) ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_RIGHT FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->right( hb_parni( 2 ) ) ), true ) ); p is NULL" ) );
}
}
/*
* QByteArray rightJustified ( int width, char fill = ' ', bool truncate = false ) const
*/
HB_FUNC( QT_QBYTEARRAY_RIGHTJUSTIFIED )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->rightJustified( hb_parni( 2 ), ( char ) hb_parni( 3 ), hb_parl( 4 ) ) ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_RIGHTJUSTIFIED FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->rightJustified( hb_parni( 2 ), ( char ) hb_parni( 3 ), hb_parl( 4 ) ) ), true ) ); p is NULL" ) );
}
}
/*
* QByteArray & setNum ( int n, int base = 10 )
*/
HB_FUNC( QT_QBYTEARRAY_SETNUM )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->setNum( hb_parni( 2 ), hb_parnidef( 3, 10 ) ) ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_SETNUM FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->setNum( hb_parni( 2 ), hb_parnidef( 3, 10 ) ) ), true ) ); p is NULL" ) );
}
}
/*
* QByteArray & setNum ( uint n, int base = 10 )
*/
HB_FUNC( QT_QBYTEARRAY_SETNUM_1 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->setNum( hb_parni( 2 ), hb_parnidef( 3, 10 ) ) ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_SETNUM_1 FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->setNum( hb_parni( 2 ), hb_parnidef( 3, 10 ) ) ), true ) ); p is NULL" ) );
}
}
/*
* QByteArray & setNum ( short n, int base = 10 )
*/
HB_FUNC( QT_QBYTEARRAY_SETNUM_2 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->setNum( hb_parni( 2 ), hb_parnidef( 3, 10 ) ) ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_SETNUM_2 FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->setNum( hb_parni( 2 ), hb_parnidef( 3, 10 ) ) ), true ) ); p is NULL" ) );
}
}
/*
* QByteArray & setNum ( ushort n, int base = 10 )
*/
HB_FUNC( QT_QBYTEARRAY_SETNUM_3 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->setNum( hb_parni( 2 ), hb_parnidef( 3, 10 ) ) ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_SETNUM_3 FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->setNum( hb_parni( 2 ), hb_parnidef( 3, 10 ) ) ), true ) ); p is NULL" ) );
}
}
/*
* QByteArray & setNum ( qlonglong n, int base = 10 )
*/
HB_FUNC( QT_QBYTEARRAY_SETNUM_4 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->setNum( ( qlonglong ) hb_parnint( 2 ), hb_parnidef( 3, 10 ) ) ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_SETNUM_4 FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->setNum( ( qlonglong ) hb_parnint( 2 ), hb_parnidef( 3, 10 ) ) ), true ) ); p is NULL" ) );
}
}
/*
* QByteArray & setNum ( qulonglong n, int base = 10 )
*/
HB_FUNC( QT_QBYTEARRAY_SETNUM_5 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->setNum( ( qulonglong ) hb_parnint( 2 ), hb_parnidef( 3, 10 ) ) ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_SETNUM_5 FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->setNum( ( qulonglong ) hb_parnint( 2 ), hb_parnidef( 3, 10 ) ) ), true ) ); p is NULL" ) );
}
}
/*
* QByteArray & setNum ( double n, char f = 'g', int prec = 6 )
*/
HB_FUNC( QT_QBYTEARRAY_SETNUM_6 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->setNum( hb_parnd( 2 ), ( char ) hb_parni( 3 ), hb_parnidef( 4, 6 ) ) ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_SETNUM_6 FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->setNum( hb_parnd( 2 ), ( char ) hb_parni( 3 ), hb_parnidef( 4, 6 ) ) ), true ) ); p is NULL" ) );
}
}
/*
* QByteArray & setNum ( float n, char f = 'g', int prec = 6 )
*/
HB_FUNC( QT_QBYTEARRAY_SETNUM_7 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->setNum( hb_parnd( 2 ), ( char ) hb_parni( 3 ), hb_parnidef( 4, 6 ) ) ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_SETNUM_7 FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->setNum( hb_parnd( 2 ), ( char ) hb_parni( 3 ), hb_parnidef( 4, 6 ) ) ), true ) ); p is NULL" ) );
}
}
/*
* QByteArray simplified () const
*/
HB_FUNC( QT_QBYTEARRAY_SIMPLIFIED )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->simplified() ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_SIMPLIFIED FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->simplified() ), true ) ); p is NULL" ) );
}
}
/*
* int size () const
*/
HB_FUNC( QT_QBYTEARRAY_SIZE )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retni( ( p )->size() );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_SIZE FP=hb_retni( ( p )->size() ); p is NULL" ) );
}
}
/*
* QList<QByteArray> split ( char sep ) const
*/
HB_FUNC( QT_QBYTEARRAY_SPLIT )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QList( new QList<QByteArray>( ( p )->split( ( char ) hb_parni( 2 ) ) ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_SPLIT FP=hb_retptrGC( hbqt_gcAllocate_QList( new QList<QByteArray>( ( p )->split( ( char ) hb_parni( 2 ) ) ), true ) ); p is NULL" ) );
}
}
/*
* void squeeze ()
*/
HB_FUNC( QT_QBYTEARRAY_SQUEEZE )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
( p )->squeeze();
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_SQUEEZE FP=( p )->squeeze(); p is NULL" ) );
}
}
/*
* bool startsWith ( const QByteArray & ba ) const
*/
HB_FUNC( QT_QBYTEARRAY_STARTSWITH )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retl( ( p )->startsWith( *hbqt_par_QByteArray( 2 ) ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_STARTSWITH FP=hb_retl( ( p )->startsWith( *hbqt_par_QByteArray( 2 ) ) ); p is NULL" ) );
}
}
/*
* bool startsWith ( const char * str ) const
*/
HB_FUNC( QT_QBYTEARRAY_STARTSWITH_1 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retl( ( p )->startsWith( hbqt_par_char( 2 ) ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_STARTSWITH_1 FP=hb_retl( ( p )->startsWith( hbqt_par_char( 2 ) ) ); p is NULL" ) );
}
}
/*
* bool startsWith ( char ch ) const
*/
HB_FUNC( QT_QBYTEARRAY_STARTSWITH_2 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retl( ( p )->startsWith( ( char ) hb_parni( 2 ) ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_STARTSWITH_2 FP=hb_retl( ( p )->startsWith( ( char ) hb_parni( 2 ) ) ); p is NULL" ) );
}
}
/*
* QByteArray toBase64 () const
*/
HB_FUNC( QT_QBYTEARRAY_TOBASE64 )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->toBase64() ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_TOBASE64 FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->toBase64() ), true ) ); p is NULL" ) );
}
}
/*
* double toDouble ( bool * ok = 0 ) const
*/
HB_FUNC( QT_QBYTEARRAY_TODOUBLE )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
bool iOk = 0;
if( p )
hb_retnd( ( p )->toDouble( &iOk ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_TODOUBLE FP=hb_retnd( ( p )->toDouble( &iOk ) ); p is NULL" ) );
}
hb_stornl( iOk, 2 );
}
/*
* float toFloat ( bool * ok = 0 ) const
*/
HB_FUNC( QT_QBYTEARRAY_TOFLOAT )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
bool iOk = 0;
if( p )
hb_retnd( ( p )->toFloat( &iOk ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_TOFLOAT FP=hb_retnd( ( p )->toFloat( &iOk ) ); p is NULL" ) );
}
hb_stornl( iOk, 2 );
}
/*
* QByteArray toHex () const
*/
HB_FUNC( QT_QBYTEARRAY_TOHEX )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->toHex() ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_TOHEX FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->toHex() ), true ) ); p is NULL" ) );
}
}
/*
* int toInt ( bool * ok = 0, int base = 10 ) const
*/
HB_FUNC( QT_QBYTEARRAY_TOINT )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
bool iOk = 0;
if( p )
hb_retni( ( p )->toInt( &iOk, hb_parnidef( 3, 10 ) ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_TOINT FP=hb_retni( ( p )->toInt( &iOk, hb_parnidef( 3, 10 ) ) ); p is NULL" ) );
}
hb_stornl( iOk, 2 );
}
/*
* long toLong ( bool * ok = 0, int base = 10 ) const
*/
HB_FUNC( QT_QBYTEARRAY_TOLONG )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
bool iOk = 0;
if( p )
hb_retnint( ( p )->toLong( &iOk, hb_parnidef( 3, 10 ) ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_TOLONG FP=hb_retnint( ( p )->toLong( &iOk, hb_parnidef( 3, 10 ) ) ); p is NULL" ) );
}
hb_stornl( iOk, 2 );
}
/*
* qlonglong toLongLong ( bool * ok = 0, int base = 10 ) const
*/
HB_FUNC( QT_QBYTEARRAY_TOLONGLONG )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
bool iOk = 0;
if( p )
hb_retnint( ( p )->toLongLong( &iOk, hb_parnidef( 3, 10 ) ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_TOLONGLONG FP=hb_retnint( ( p )->toLongLong( &iOk, hb_parnidef( 3, 10 ) ) ); p is NULL" ) );
}
hb_stornl( iOk, 2 );
}
/*
* QByteArray toLower () const
*/
HB_FUNC( QT_QBYTEARRAY_TOLOWER )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->toLower() ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_TOLOWER FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->toLower() ), true ) ); p is NULL" ) );
}
}
/*
* QByteArray toPercentEncoding ( const QByteArray & exclude = QByteArray(), const QByteArray & include = QByteArray(), char percent = '%' ) const
*/
HB_FUNC( QT_QBYTEARRAY_TOPERCENTENCODING )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->toPercentEncoding( ( HB_ISPOINTER( 2 ) ? *hbqt_par_QByteArray( 2 ) : QByteArray() ), ( HB_ISPOINTER( 3 ) ? *hbqt_par_QByteArray( 3 ) : QByteArray() ), ( char ) hb_parni( 4 ) ) ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_TOPERCENTENCODING FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->toPercentEncoding( ( HB_ISPOINTER( 2 ) ? *hbqt_par_QByteArray( 2 ) : QByteArray() ), ( HB_ISPOINTER( 3 ) ? *hbqt_par_QByteArray( 3 ) : QByteArray() ), ( char ) hb_parni( 4 ) ) ), true ) ); p is NULL" ) );
}
}
/*
* short toShort ( bool * ok = 0, int base = 10 ) const
*/
HB_FUNC( QT_QBYTEARRAY_TOSHORT )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
bool iOk = 0;
if( p )
hb_retni( ( p )->toShort( &iOk, hb_parnidef( 3, 10 ) ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_TOSHORT FP=hb_retni( ( p )->toShort( &iOk, hb_parnidef( 3, 10 ) ) ); p is NULL" ) );
}
hb_stornl( iOk, 2 );
}
/*
* uint toUInt ( bool * ok = 0, int base = 10 ) const
*/
HB_FUNC( QT_QBYTEARRAY_TOUINT )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
bool iOk = 0;
if( p )
hb_retni( ( p )->toUInt( &iOk, hb_parnidef( 3, 10 ) ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_TOUINT FP=hb_retni( ( p )->toUInt( &iOk, hb_parnidef( 3, 10 ) ) ); p is NULL" ) );
}
hb_stornl( iOk, 2 );
}
/*
* ulong toULong ( bool * ok = 0, int base = 10 ) const
*/
HB_FUNC( QT_QBYTEARRAY_TOULONG )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
bool iOk = 0;
if( p )
hb_retnint( ( p )->toULong( &iOk, hb_parnidef( 3, 10 ) ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_TOULONG FP=hb_retnint( ( p )->toULong( &iOk, hb_parnidef( 3, 10 ) ) ); p is NULL" ) );
}
hb_stornl( iOk, 2 );
}
/*
* qulonglong toULongLong ( bool * ok = 0, int base = 10 ) const
*/
HB_FUNC( QT_QBYTEARRAY_TOULONGLONG )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
bool iOk = 0;
if( p )
hb_retnint( ( p )->toULongLong( &iOk, hb_parnidef( 3, 10 ) ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_TOULONGLONG FP=hb_retnint( ( p )->toULongLong( &iOk, hb_parnidef( 3, 10 ) ) ); p is NULL" ) );
}
hb_stornl( iOk, 2 );
}
/*
* ushort toUShort ( bool * ok = 0, int base = 10 ) const
*/
HB_FUNC( QT_QBYTEARRAY_TOUSHORT )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
bool iOk = 0;
if( p )
hb_retni( ( p )->toUShort( &iOk, hb_parnidef( 3, 10 ) ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_TOUSHORT FP=hb_retni( ( p )->toUShort( &iOk, hb_parnidef( 3, 10 ) ) ); p is NULL" ) );
}
hb_stornl( iOk, 2 );
}
/*
* QByteArray toUpper () const
*/
HB_FUNC( QT_QBYTEARRAY_TOUPPER )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->toUpper() ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_TOUPPER FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->toUpper() ), true ) ); p is NULL" ) );
}
}
/*
* QByteArray trimmed () const
*/
HB_FUNC( QT_QBYTEARRAY_TRIMMED )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->trimmed() ), true ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_TRIMMED FP=hb_retptrGC( hbqt_gcAllocate_QByteArray( new QByteArray( ( p )->trimmed() ), true ) ); p is NULL" ) );
}
}
/*
* void truncate ( int pos )
*/
HB_FUNC( QT_QBYTEARRAY_TRUNCATE )
{
QByteArray * p = hbqt_par_QByteArray( 1 );
if( p )
( p )->truncate( hb_parni( 2 ) );
else
{
HB_TRACE( HB_TR_DEBUG, ( "............................... F=QT_QBYTEARRAY_TRUNCATE FP=( p )->truncate( hb_parni( 2 ) ); p is NULL" ) );
}
}
/*----------------------------------------------------------------------*/
#endif /* #if QT_VERSION >= 0x040500 */
/*----------------------------------------------------------------------*/
Reference in New Issue View Git Blame Copy Permalink