File indexing completed on 2025-01-19 04:25:14

0001 /*
0002  * Replacement fot QT Bindings that were removed from QT5
0003  * Copyright (C) 2020  Pedro de Carvalho Gomes <pedro.gomes@ipsoft.com>
0004  *
0005  * This program is free software: you can redistribute it and/or modify
0006  * it under the terms of the GNU General Public License as published by
0007  * the Free Software Foundation, either version 3 of the License, or
0008  * (at your option) any later version.
0009  *
0010  * This program is distributed in the hope that it will be useful,
0011  * but WITHOUT ANY WARRANTY; without even the implied warranty of
0012  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
0013  * GNU General Public License for more details.
0014  *
0015  * You should have received a copy of the GNU General Public License
0016  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
0017  */
0018 
0019 #include "CoreByteArray.h"
0020 
0021 #include <QJSEngine>
0022 
0023 using namespace QtBindings::Core;
0024 
0025 ByteArray::ByteArray()
0026 {
0027 }
0028 
0029 ByteArray::ByteArray(const char *data, int size) : QByteArray(data, size)
0030 {
0031 }
0032 
0033 ByteArray::ByteArray(int size, char ch) : QByteArray(size, ch)
0034 {
0035 }
0036 
0037 ByteArray::ByteArray(const QByteArray &other) : QObject(), QByteArray(other)
0038 {
0039 }
0040 
0041 ByteArray::ByteArray(const ByteArray &other) : QObject(), QByteArray(other)
0042 {
0043 }
0044 
0045 ByteArray::ByteArray(ByteArray &&other) noexcept : QByteArray(other)
0046 {
0047 }
0048 
0049 ByteArray::ByteArray(const QString &other) : QByteArray( other.toLatin1() )
0050 {
0051 }
0052 
0053 ByteArray &ByteArray::append(const QByteArray &ba)
0054 {
0055     QByteArray::append(ba);
0056     return *this;
0057 }
0058 
0059 ByteArray &ByteArray::append(int count, char ch)
0060 {
0061     QByteArray::append(count, ch);
0062     return *this;
0063 }
0064 
0065 ByteArray &ByteArray::append(const char *str)
0066 {
0067     QByteArray::append(str);
0068     return *this;
0069 }
0070 
0071 ByteArray &ByteArray::append(const char *str, int len)
0072 {
0073     QByteArray::append(str, len);
0074     return *this;
0075 }
0076 
0077 ByteArray &ByteArray::append(char ch)
0078 {
0079     QByteArray::append(ch);
0080     return *this;
0081 }
0082 
0083 char ByteArray::at(int i) const
0084 {
0085     return QByteArray::at(i);
0086 }
0087 
0088 QByteArray::iterator ByteArray::begin()
0089 {
0090     return QByteArray::begin();
0091 }
0092 
0093 QByteArray::const_iterator ByteArray::begin() const
0094 {
0095     return QByteArray::begin();
0096 }
0097 
0098 int ByteArray::capacity() const
0099 {
0100     return QByteArray::capacity();
0101 }
0102 
0103 QByteArray::const_iterator ByteArray::cbegin() const
0104 {
0105     return QByteArray::cbegin();
0106 }
0107 
0108 QByteArray::const_iterator ByteArray::cend() const
0109 {
0110     return QByteArray::cend();
0111 }
0112 
0113 void ByteArray::chop(int n)
0114 {
0115     QByteArray::chop(n);
0116 }
0117 
0118 void ByteArray::clear()
0119 {
0120     QByteArray::clear();
0121 }
0122 
0123 QByteArray::const_iterator ByteArray::constBegin() const
0124 {
0125     return QByteArray::constBegin();
0126 }
0127 
0128 const char *ByteArray::constData() const
0129 {
0130     return QByteArray::constData();
0131 }
0132 
0133 QByteArray::const_iterator ByteArray::constEnd() const
0134 {
0135     return QByteArray::constEnd();
0136 }
0137 
0138 bool ByteArray::contains(const QByteArray &ba) const
0139 {
0140     return QByteArray::contains(ba);
0141 }
0142 
0143 bool ByteArray::contains(const char *str) const
0144 {
0145     return QByteArray::contains(str);
0146 }
0147 
0148 bool ByteArray::contains(char ch) const
0149 {
0150     return QByteArray::contains(ch);
0151 }
0152 
0153 int ByteArray::count(const QByteArray &ba) const
0154 {
0155     return QByteArray::count(ba);
0156 }
0157 
0158 int ByteArray::count(const char *str) const
0159 {
0160     return QByteArray::count(str);
0161 }
0162 
0163 int ByteArray::count(char ch) const
0164 {
0165     return QByteArray::count(ch);
0166 }
0167 
0168 int ByteArray::count() const
0169 {
0170     return QByteArray::count();
0171 }
0172 
0173 QByteArray::const_reverse_iterator ByteArray::crbegin() const
0174 {
0175     return QByteArray::crbegin();
0176 }
0177 
0178 QByteArray::const_reverse_iterator ByteArray::crend() const
0179 {
0180     return QByteArray::crend();
0181 }
0182 
0183 char *ByteArray::data()
0184 {
0185     return QByteArray::data();
0186 }
0187 
0188 const char *ByteArray::data() const
0189 {
0190     return QByteArray::data();
0191 }
0192 
0193 QByteArray::iterator ByteArray::end()
0194 {
0195     return QByteArray::end();
0196 }
0197 
0198 QByteArray::const_iterator ByteArray::end() const
0199 {
0200     return QByteArray::end();
0201 }
0202 
0203 bool ByteArray::endsWith(const QByteArray &ba) const
0204 {
0205     return QByteArray::endsWith(ba);
0206 }
0207 
0208 bool ByteArray::endsWith(char ch) const
0209 {
0210     return QByteArray::endsWith(ch);
0211 }
0212 
0213 bool ByteArray::endsWith(const char *str) const
0214 {
0215     return QByteArray::endsWith(str);
0216 }
0217 
0218 QByteArray &ByteArray::fill(char ch, int size)
0219 {
0220     return QByteArray::fill(ch, size);
0221 }
0222 
0223 int ByteArray::indexOf(const QByteArray &ba, int from) const
0224 {
0225     return QByteArray::indexOf(ba, from);
0226 }
0227 
0228 int ByteArray::indexOf(const char *str, int from) const
0229 {
0230     return QByteArray::indexOf(str, from);
0231 }
0232 
0233 int ByteArray::indexOf(char ch, int from) const
0234 {
0235     return QByteArray::indexOf(ch, from);
0236 }
0237 
0238 ByteArray &ByteArray::insert(int i, const QByteArray &ba)
0239 {
0240     QByteArray::insert(i, ba);
0241     return *this;
0242 }
0243 
0244 ByteArray &ByteArray::insert(int i, int count, char ch)
0245 {
0246     QByteArray::insert(i, count, ch);
0247     return *this;
0248 }
0249 
0250 ByteArray &ByteArray::insert(int i, const char *str)
0251 {
0252     QByteArray::insert(i, str);
0253     return *this;
0254 }
0255 
0256 ByteArray &ByteArray::insert(int i, const char *str, int len)
0257 {
0258     QByteArray::insert(i, str, len);
0259     return *this;
0260 }
0261 
0262 ByteArray &ByteArray::insert(int i, char ch)
0263 {
0264     QByteArray::insert(i, ch);
0265     return *this;
0266 }
0267 
0268 bool ByteArray::isEmpty() const
0269 {
0270     return QByteArray::isEmpty();
0271 }
0272 
0273 bool ByteArray::isNull() const
0274 {
0275     return QByteArray::isNull();
0276 }
0277 
0278 int ByteArray::lastIndexOf(const QByteArray &ba, int from) const
0279 {
0280     return QByteArray::lastIndexOf(ba, from);
0281 }
0282 
0283 int ByteArray::lastIndexOf(const char *str, int from) const
0284 {
0285     return QByteArray::lastIndexOf(str, from);
0286 }
0287 
0288 int ByteArray::lastIndexOf(char ch, int from) const
0289 {
0290     return QByteArray::lastIndexOf(ch, from);
0291 }
0292 
0293 QByteArray ByteArray::left(int len) const
0294 {
0295     return QByteArray::left(len);
0296 }
0297 
0298 QByteArray ByteArray::leftJustified(int width, char fill, bool truncate) const
0299 {
0300     return QByteArray::leftJustified(width, fill, truncate);
0301 }
0302 
0303 int ByteArray::length() const
0304 {
0305     return QByteArray::length();
0306 }
0307 
0308 QByteArray ByteArray::mid(int pos, int len) const
0309 {
0310     return QByteArray::mid(pos, len);
0311 }
0312 
0313 ByteArray &ByteArray::prepend(const QByteArray &ba)
0314 {
0315     QByteArray::prepend(ba);
0316     return *this;
0317 }
0318 
0319 ByteArray &ByteArray::prepend(int count, char ch)
0320 {
0321     QByteArray::prepend(count, ch);
0322     return *this;
0323 }
0324 
0325 ByteArray &ByteArray::prepend(const char *str)
0326 {
0327     QByteArray::prepend(str);
0328     return *this;
0329 }
0330 
0331 ByteArray &ByteArray::prepend(const char *str, int len)
0332 {
0333     QByteArray::prepend(str, len);
0334     return *this;
0335 }
0336 
0337 ByteArray &ByteArray::prepend(char ch)
0338 {
0339     QByteArray::prepend(ch);
0340     return *this;
0341 }
0342 
0343 void ByteArray::push_back(const QByteArray &other)
0344 {
0345     QByteArray::push_back(other);
0346 }
0347 
0348 void ByteArray::push_back(const char *str)
0349 {
0350     QByteArray::push_back(str);
0351 }
0352 
0353 void ByteArray::push_back(char ch)
0354 {
0355     QByteArray::push_back(ch);
0356 }
0357 
0358 void ByteArray::push_front(const QByteArray &other)
0359 {
0360     QByteArray::push_front(other);
0361 }
0362 
0363 void ByteArray::push_front(const char *str)
0364 {
0365     QByteArray::push_front(str);
0366 }
0367 
0368 void ByteArray::push_front(char ch)
0369 {
0370     QByteArray::push_front(ch);
0371 }
0372 
0373 QByteArray::reverse_iterator ByteArray::rbegin()
0374 {
0375     return QByteArray::rbegin();
0376 }
0377 
0378 QByteArray::const_reverse_iterator ByteArray::rbegin() const
0379 {
0380     return QByteArray::rbegin();
0381 }
0382 
0383 QByteArray &ByteArray::remove(int pos, int len)
0384 {
0385     return QByteArray::remove(pos, len);
0386 }
0387 
0388 QByteArray::reverse_iterator ByteArray::rend()
0389 {
0390     return QByteArray::rend();
0391 }
0392 
0393 QByteArray::const_reverse_iterator ByteArray::rend() const
0394 {
0395     return QByteArray::rend();
0396 }
0397 
0398 QByteArray ByteArray::repeated(int times) const
0399 {
0400     return QByteArray::repeated(times);
0401 }
0402 
0403 QByteArray &ByteArray::replace(int pos, int len, const QByteArray &after)
0404 {
0405     return QByteArray::replace(pos, len, after);
0406 }
0407 
0408 QByteArray &ByteArray::replace(int pos, int len, const char *after, int alen)
0409 {
0410     return QByteArray::replace(pos, len, after, alen);
0411 }
0412 
0413 QByteArray &ByteArray::replace(int pos, int len, const char *after)
0414 {
0415     return QByteArray::replace(pos, len, after);
0416 }
0417 
0418 QByteArray &ByteArray::replace(char before, const char *after)
0419 {
0420     return QByteArray::replace(before, after);
0421 }
0422 
0423 QByteArray &ByteArray::replace(char before, const QByteArray &after)
0424 {
0425     return QByteArray::replace(before, after);
0426 }
0427 
0428 QByteArray &ByteArray::replace(const char *before, const char *after)
0429 {
0430     return QByteArray::replace(before, after);
0431 }
0432 
0433 QByteArray &ByteArray::replace(const char *before, int bsize, const char *after, int asize)
0434 {
0435     return QByteArray::replace(before, bsize, after, asize);
0436 }
0437 
0438 QByteArray &ByteArray::replace(const QByteArray &before, const QByteArray &after)
0439 {
0440     return QByteArray::replace(before, after);
0441 }
0442 
0443 QByteArray &ByteArray::replace(const QByteArray &before, const char *after)
0444 {
0445     return QByteArray::replace(before, after);
0446 }
0447 
0448 QByteArray &ByteArray::replace(const char *before, const QByteArray &after)
0449 {
0450     return QByteArray::replace(before, after);
0451 }
0452 
0453 QByteArray &ByteArray::replace(char before, char after)
0454 {
0455     return QByteArray::replace(before, after);
0456 }
0457 
0458 void ByteArray::reserve(int size)
0459 {
0460     QByteArray::reserve(size);
0461 }
0462 
0463 void ByteArray::resize(int size)
0464 {
0465     QByteArray::resize(size);
0466 }
0467 
0468 QByteArray ByteArray::right(int len) const
0469 {
0470     return QByteArray::right(len);
0471 }
0472 
0473 QByteArray ByteArray::rightJustified(int width, char fill, bool truncate) const
0474 {
0475     return QByteArray::rightJustified(width, fill, truncate);
0476 }
0477 
0478 QByteArray &ByteArray::setNum(int n, int base)
0479 {
0480     return QByteArray::setNum(n, base);
0481 }
0482 
0483 QByteArray &ByteArray::setNum(ushort n, int base)
0484 {
0485     return QByteArray::setNum(n, base);
0486 }
0487 
0488 QByteArray &ByteArray::setNum(short n, int base)
0489 {
0490     return QByteArray::setNum(n, base);
0491 }
0492 
0493 QByteArray &ByteArray::setNum(uint n, int base)
0494 {
0495     return QByteArray::setNum(n, base);
0496 }
0497 
0498 QByteArray &ByteArray::setNum(qlonglong n, int base)
0499 {
0500     return QByteArray::setNum(n, base);
0501 }
0502 
0503 QByteArray &ByteArray::setNum(qulonglong n, int base)
0504 {
0505     return QByteArray::setNum(n, base);
0506 }
0507 
0508 QByteArray &ByteArray::setNum(float n, char f, int prec)
0509 {
0510     return QByteArray::setNum(n, f, prec);
0511 }
0512 
0513 QByteArray &ByteArray::setNum(double n, char f, int prec)
0514 {
0515     return QByteArray::setNum(n, f, prec);
0516 }
0517 
0518 QByteArray &ByteArray::setRawData(const char *data, uint size)
0519 {
0520     return QByteArray::setRawData(data, size);
0521 }
0522 
0523 QByteArray ByteArray::simplified() const
0524 {
0525     return QByteArray::simplified();
0526 }
0527 
0528 int ByteArray::size() const
0529 {
0530     return QByteArray::size();
0531 }
0532 
0533 QList<QByteArray> ByteArray::split(char sep) const
0534 {
0535     return QByteArray::split(sep);
0536 }
0537 
0538 void ByteArray::squeeze()
0539 {
0540     QByteArray::squeeze();
0541 }
0542 
0543 bool ByteArray::startsWith(const QByteArray &ba) const
0544 {
0545     return QByteArray::startsWith(ba);
0546 }
0547 
0548 bool ByteArray::startsWith(char ch) const
0549 {
0550     return QByteArray::startsWith(ch);
0551 }
0552 
0553 bool ByteArray::startsWith(const char *str) const
0554 {
0555     return QByteArray::startsWith(str);
0556 }
0557 
0558 void ByteArray::swap(QByteArray &other)
0559 {
0560     QByteArray::swap(other);
0561 }
0562 
0563 QByteArray ByteArray::toBase64() const
0564 {
0565     return QByteArray::toBase64();
0566 }
0567 
0568 QByteArray ByteArray::toBase64(QByteArray::Base64Options options) const
0569 {
0570     return QByteArray::toBase64(options);
0571 }
0572 
0573 double ByteArray::toDouble(bool *ok) const
0574 {
0575     return QByteArray::toDouble(ok);
0576 }
0577 
0578 float ByteArray::toFloat(bool *ok) const
0579 {
0580     return QByteArray::toFloat(ok);
0581 }
0582 
0583 QByteArray ByteArray::toHex() const
0584 {
0585     return QByteArray::toHex();
0586 }
0587 
0588 QByteArray ByteArray::toHex(char separator) const
0589 {
0590     return QByteArray::toHex(separator);
0591 }
0592 
0593 int ByteArray::toInt(bool *ok, int base) const
0594 {
0595     return QByteArray::toInt(ok, base);
0596 }
0597 
0598 long ByteArray::toLong(bool *ok, int base) const
0599 {
0600     return QByteArray::toLong(ok, base);
0601 }
0602 
0603 qlonglong ByteArray::toLongLong(bool *ok, int base) const
0604 {
0605     return QByteArray::toLongLong(ok, base);
0606 }
0607 
0608 QByteArray ByteArray::toLower() const
0609 {
0610     return QByteArray::toLower();
0611 }
0612 
0613 QByteArray ByteArray::toPercentEncoding(const QByteArray &exclude, const QByteArray &include, char percent) const
0614 {
0615     return QByteArray::toPercentEncoding(exclude, include, percent);
0616 }
0617 
0618 short ByteArray::toShort(bool *ok, int base) const
0619 {
0620     return QByteArray::toShort(ok, base);
0621 }
0622 
0623 std::string ByteArray::toStdString() const
0624 {
0625     return QByteArray::toStdString();
0626 }
0627 
0628 uint ByteArray::toUInt(bool *ok, int base) const
0629 {
0630     return QByteArray::toUInt(ok, base);
0631 }
0632 
0633 ulong ByteArray::toULong(bool *ok, int base) const
0634 {
0635     return QByteArray::toULong(ok, base);
0636 }
0637 
0638 qulonglong ByteArray::toULongLong(bool *ok, int base) const
0639 {
0640     return QByteArray::toULongLong(ok, base);
0641 }
0642 
0643 ushort ByteArray::toUShort(bool *ok, int base) const
0644 {
0645     return QByteArray::toUShort(ok, base);
0646 }
0647 
0648 QByteArray ByteArray::toUpper() const
0649 {
0650     return QByteArray::toUpper();
0651 }
0652 
0653 QByteArray ByteArray::trimmed() const
0654 {
0655     return QByteArray::trimmed();
0656 }
0657 
0658 void ByteArray::truncate(int pos)
0659 {
0660     QByteArray::truncate(pos);
0661 }
0662 
0663 ByteArray ByteArray::fromBase64(const QByteArray &base64)
0664 {
0665     return ByteArray( QByteArray::fromBase64(base64) );
0666 }
0667 
0668 ByteArray ByteArray::fromBase64(const QByteArray &base64, QByteArray::Base64Options options)
0669 {
0670     return ByteArray( QByteArray::fromBase64(base64,options) );
0671 }
0672 
0673 ByteArray ByteArray::fromHex(const QByteArray &hexEncoded)
0674 {
0675     return ByteArray( QByteArray::fromHex(hexEncoded) );
0676 }
0677 
0678 ByteArray ByteArray::fromPercentEncoding(const QByteArray &input, char percent)
0679 {
0680     return ByteArray( QByteArray::fromPercentEncoding(input,percent) );
0681 }
0682 
0683 ByteArray ByteArray::fromRawData(const char *data, int size)
0684 {
0685     return ByteArray( QByteArray::fromRawData(data,size) );
0686 }
0687 
0688 ByteArray ByteArray::fromStdString(const std::string &str)
0689 {
0690     return ByteArray( QByteArray::fromStdString(str) );
0691 }
0692 
0693 ByteArray ByteArray::number(int n, int base)
0694 {
0695     return ByteArray( QByteArray::number(n,base) );
0696 }
0697 
0698 ByteArray ByteArray::number(uint n, int base)
0699 {
0700     return ByteArray( QByteArray::number(n,base) );
0701 }
0702 
0703 ByteArray ByteArray::number(qlonglong n, int base)
0704 {
0705     return ByteArray( QByteArray::number(n,base) );
0706 }
0707 
0708 ByteArray ByteArray::number(qulonglong n, int base)
0709 {
0710     return ByteArray( QByteArray::number(n,base) );
0711 }
0712 
0713 ByteArray ByteArray::number(double n, char f, int prec)
0714 {
0715     return ByteArray( QByteArray::number(n,f,prec) );
0716 }
0717 
0718 ByteArray &ByteArray::operator=(const ByteArray &other)
0719 {
0720     if (this != &other)
0721         QByteArray::operator=(other);
0722     return *this;
0723 }