C# Qyoto.QByteArray類代碼示例

 public static void Init(string[] argv, QByteArray appname, QByteArray catalog, KLocalizedString programName, QByteArray version)
 {
     string[] args = new string[argv.Length + 1];
     args[0] = System.Reflection.Assembly.GetExecutingAssembly().Location;
     argv.CopyTo(args, 1);
     staticInterceptor.Invoke("init$?####", "init(int, char**, const QByteArray&, const QByteArray&, const KLocalizedString&, const QByteArray&)", typeof(void), false, typeof(int), args.Length, typeof(string[]), args, typeof(QByteArray), appname, typeof(QByteArray), catalog, typeof(KLocalizedString), programName, typeof(QByteArray), version);
 }

 public static QByteArray FromArray(byte[] array)
 {
     var qba = new QByteArray(array.Length, '\0');
     Pointer<sbyte> p = qba.Data();
     for (int i = 0; i < array.Length; i++) {
         p[i] = (sbyte) array[i];
     }
     return qba;
 }

 public static byte[] ToArray(QByteArray qba)
 {
     Pointer<sbyte> p = qba.Data();
     byte[] array = new byte[qba.Size()];
     for (int i = 0; i < qba.Size(); i++) {
         array[i] = (byte) p[i];
     }
     return array;
 }

 protected override void DeleteGroupImpl(QByteArray group, uint flags)
 {
     interceptor.Invoke("deleteGroupImpl#$", "deleteGroupImpl(const QByteArray&, KConfigBase::WriteConfigFlags)", typeof(void), typeof(QByteArray), group, typeof(uint), flags);
 }

 public QSslKey(QIODevice device, QSsl.KeyAlgorithm algorithm, QSsl.EncodingFormat format, QSsl.KeyType type, QByteArray passPhrase)
     : this((Type) null)
 {
     CreateProxy();
     interceptor.Invoke("QSslKey#$$$#", "QSslKey(QIODevice*, QSsl::KeyAlgorithm, QSsl::EncodingFormat, QSsl::KeyType, const QByteArray&)", typeof(void), typeof(QIODevice), device, typeof(QSsl.KeyAlgorithm), algorithm, typeof(QSsl.EncodingFormat), format, typeof(QSsl.KeyType), type, typeof(QByteArray), passPhrase);
 }

 /// <remarks>
 ///  Creates a new session.
 /// <param> name="sessionId" The identifier for this session, will be a
 ///                   random value if empty.
 /// </param><param> name="parent" The parent object.
 /// </param></remarks>        <short>    Creates a new session.</short>
 ///         <see> defaultSession</see>
 public Session(QByteArray sessionId, QObject parent)
     : this((Type) null)
 {
     CreateProxy();
     interceptor.Invoke("Session##", "Session(const QByteArray&, QObject*)", typeof(void), typeof(QByteArray), sessionId, typeof(QObject), parent);
 }

 /// <remarks>
 ///  For writing gzip compressed files only:
 ///  set the name of the original file, to be used in the gzip header.
 /// <param> name="fileName" the name of the original file
 ///      </param></remarks>        <short>    For writing gzip compressed files only:  set the name of the original file, to be used in the gzip header.</short>
 public void SetOrigFileName(QByteArray fileName)
 {
     interceptor.Invoke("setOrigFileName#", "setOrigFileName(const QByteArray&)", typeof(void), typeof(QByteArray), fileName);
 }

 public static int Qstrcmp(string str1, QByteArray str2)
 {
     return (int) staticInterceptor.Invoke("qstrcmp$#", "qstrcmp(const char*, const QByteArray&)", typeof(int), typeof(string), str1, typeof(QByteArray), str2);
 }

 public static QDataStream Read(QDataStream arg1, QByteArray arg2)
 {
     return (QDataStream) staticInterceptor.Invoke("operator>>##", "operator>>(QDataStream&, QByteArray&)", typeof(QDataStream), typeof(QDataStream), arg1, typeof(QByteArray), arg2);
 }

 /// <remarks>
 ///  Write block
 /// <param> name="data" the data to write
 ///      </param></remarks>        <short>    Write block </short>
 public void Write(QByteArray data)
 {
     interceptor.Invoke("write#", "write(const QByteArray&)", typeof(void), typeof(QByteArray), data);
 }

 public static QByteArray QCompress(QByteArray data, int compressionLevel)
 {
     return (QByteArray) staticInterceptor.Invoke("qCompress#$", "qCompress(const QByteArray&, int)", typeof(QByteArray), typeof(QByteArray), data, typeof(int), compressionLevel);
 }

 /// <remarks>
 ///  Writes a value to the config object.
 /// <param> name="key" The key to write
 /// </param><param> name="value" The value to write
 /// </param><param> name="pFlags" The flags to use when writing this entry.
 ///      </param></remarks>        <short>    Writes a value to the config object.</short>
 public void WriteEntry(string key, QByteArray value, uint pFlags)
 {
     interceptor.Invoke("writeEntry$#$", "writeEntry(const QString&, const QByteArray&, KConfigBase::WriteConfigFlags)", typeof(void), typeof(string), key, typeof(QByteArray), value, typeof(uint), pFlags);
 }

 public QImageWriter(string fileName, QByteArray format)
     : this((Type) null)
 {
     CreateProxy();
     interceptor.Invoke("QImageWriter$#", "QImageWriter(const QString&, const QByteArray&)", typeof(void), typeof(string), fileName, typeof(QByteArray), format);
 }

 public void SetFormat(QByteArray format)
 {
     interceptor.Invoke("setFormat#", "setFormat(const QByteArray&)", typeof(void), typeof(QByteArray), format);
 }

 public bool RestoreState(QByteArray state)
 {
     return (bool) interceptor.Invoke("restoreState#", "restoreState(const QByteArray&)", typeof(bool), typeof(QByteArray), state);
 }