org.freedesktop.dbus.Message クラス

org.freedesktop.dbus.Message の継承関係図

org.freedesktop.dbus.Message 連携図

クラス
interface	ArgumentType
interface	Endian
interface	Flags
interface	HeaderField
interface	MessageType

公開メンバ関数
long	demarshallint (byte[] buf, int ofs, int width)
void	appendint (long l, int width)
void	marshallint (long l, byte[] buf, int ofs, int width)
byte [][]	getWireData ()
String	toString ()
Object	getHeader (byte type)
void	pad (byte type)
void	append (String sig, Object... data) throws DBusException
int	align (int current, byte type)
Object []	extract (String sig, byte[] buf, int ofs) throws DBusException
Object []	extract (String sig, byte[] buf, int[] ofs) throws DBusException
String	getSource ()
String	getDestination ()
String	getInterface ()
String	getPath ()
String	getName ()
String	getSig ()
int	getFlags ()
long	getSerial ()
long	getReplySerial ()
Object []	getParameters () throws DBusException
void	setSource (String source) throws DBusException

静的公開メンバ関数
static String	getHeaderFieldName (byte field)
static long	demarshallint (byte[] buf, int ofs, byte endian, int width)
static long	demarshallintBig (byte[] buf, int ofs, int width)
static long	demarshallintLittle (byte[] buf, int ofs, int width)
static void	marshallintBig (long l, byte[] buf, int ofs, int width)
static void	marshallintLittle (long l, byte[] buf, int ofs, int width)
static int	getAlignment (byte type)

静的公開変数類
static final byte	PROTOCOL = 1

限定公開メンバ関数
	Message (byte endian, byte type, byte flags) throws DBusException
	Message ()
void	appendBytes (byte[] buf)
void	appendByte (byte b)
void	setArgs (Object[] args)

限定公開変数類
byte [][]	wiredata
long	bytecounter
Map< Byte, Object >	headers
long	serial
byte	type
byte	flags
byte	protover

静的限定公開変数類
static long	globalserial = 0

関数
void	populate (byte[] msg, byte[] headers, byte[] body) throws DBusException

静的関数
	[static initializer]

非公開メンバ関数
void	preallocate (int num)
void	ensureBuffers (int num)
int	appendone (byte[] sigb, int sigofs, Object data) throws DBusException
Object	extractone (byte[] sigb, byte[] buf, int[] ofs, boolean contained) throws DBusException

非公開変数類
boolean	big
Object []	args
byte []	body
long	bodylen = 0
int	preallocated = 0
int	paofs = 0
byte []	pabuf
int	bufferuse = 0

静的非公開変数類
static byte [][]	padding
static final int	BUFFERINCREMENT = 20

詳解

Superclass of all messages which are sent over the Bus. This class deals with all the marshalling to/from the wire format.

構築子と解体子

Message() [1/2]

org.freedesktop.dbus.Message.Message ( byte  endian, byte  type, byte  flags  ) throws DBusException

inlineprotected

Create a message; only to be called by sub-classes.

引数

endian	The endianness to create the message.
type	The message type.
flags	Any message flags.

                                                                               {
        wiredata = new byte[BUFFERINCREMENT][];
        headers = new HashMap<Byte, Object>();
        big = (Endian.BIG == endian);
        bytecounter = 0;
        synchronized (Message.class) {
            serial = ++globalserial;
        }
        if (Debug.debug) Debug.print(Debug.DEBUG, "Creating message with serial " + serial);
        this.type = type;
        this.flags = flags;
        preallocate(4);
        append("yyyy", endian, type, flags, Message.PROTOCOL);
    }

Message() [2/2]

org.freedesktop.dbus.Message.Message ( )

inlineprotected

Create a blank message. Only to be used when calling populate.

                        {
        wiredata = new byte[BUFFERINCREMENT][];
        headers = new HashMap<Byte, Object>();
        bytecounter = 0;
    }

関数詳解

[static initializer]()

org.freedesktop.dbus.Message.[static initializer] ( )

inlinestaticpackage

align()

int org.freedesktop.dbus.Message.align ( int  current, byte  type  )

inline

Align a counter to the given type.

引数

current	The current counter.
type	The type to align to.

戻り値

The new, aligned, counter.

                                             {
        if (Debug.debug) Debug.print(Debug.VERBOSE, "aligning to " + (char) type);
        int a = getAlignment(type);
        if (0 == (current % a)) return current;
        return current + (a - (current % a));
    }

append()

void org.freedesktop.dbus.Message.append ( String  sig, Object...  data  ) throws DBusException

inline

Append a series of values to the message.

引数

sig	The signature(s) of the value(s).
data	The value(s).

                                                                        {
        if (Debug.debug) Debug.print(Debug.DEBUG, "Appending sig: " + sig + " data: " + Arrays.deepToString(data));
        byte[] sigb = sig.getBytes();
        int j = 0;
        for (int i = 0; i < sigb.length; i++) {
            if (Debug.debug) Debug.print(Debug.VERBOSE, "Appending item: " + i + " " + ((char) sigb[i]) + " " + j);
            i = appendone(sigb, i, data[j++]);
        }
    }

appendByte()

void org.freedesktop.dbus.Message.appendByte ( byte  b )

inlineprotected

Appends a byte to the buffer list.

                                      {
        if (preallocated > 0) {
            pabuf[paofs++] = b;
            preallocated--;
        } else {
            if (bufferuse == wiredata.length) {
                if (Debug.debug) Debug.print(Debug.VERBOSE, "Resizing " + bufferuse);
                byte[][] temp = new byte[wiredata.length + BUFFERINCREMENT][];
                System.arraycopy(wiredata, 0, temp, 0, wiredata.length);
                wiredata = temp;
            }
            wiredata[bufferuse++] = new byte[]{b};
            bytecounter++;
        }
    }

appendBytes()

void org.freedesktop.dbus.Message.appendBytes ( byte []  buf )

inlineprotected

Appends a buffer to the buffer list.

                                           {
        if (null == buf) return;
        if (preallocated > 0) {
            if (paofs + buf.length > pabuf.length)
                throw new ArrayIndexOutOfBoundsException(MessageFormat.format(getString("arrayOutOfBounds"), new Object[]{paofs, pabuf.length, buf.length}));
            System.arraycopy(buf, 0, pabuf, paofs, buf.length);
            paofs += buf.length;
            preallocated -= buf.length;
        } else {
            if (bufferuse == wiredata.length) {
                if (Debug.debug) Debug.print(Debug.VERBOSE, "Resizing " + bufferuse);
                byte[][] temp = new byte[wiredata.length + BUFFERINCREMENT][];
                System.arraycopy(wiredata, 0, temp, 0, wiredata.length);
                wiredata = temp;
            }
            wiredata[bufferuse++] = buf;
            bytecounter += buf.length;
        }
    }

appendint()

void org.freedesktop.dbus.Message.appendint ( long  l, int  width  )

inline

Marshalls an integer of a given width and appends it to the message. Endianness is determined from the message.

引数

l	The integer to marshall.
width	The byte-width of the int.

                                             {
        byte[] buf = new byte[width];
        marshallint(l, buf, 0, width);
        appendBytes(buf);
    }

appendone()

int org.freedesktop.dbus.Message.appendone ( byte []  sigb, int  sigofs, Object  data  ) throws DBusException

inlineprivate

Appends a value to the message. The type of the value is read from a D-Bus signature and used to marshall the value.

引数

sigb	A buffer of the D-Bus signature.
sigofs	The offset into the signature corresponding to this value.
data	The value to marshall.

戻り値

The offset into the signature of the end of this value's type.

                                                                                     {
        try {
            int i = sigofs;
            if (Debug.debug) Debug.print(Debug.VERBOSE, (Object) bytecounter);
            if (Debug.debug) Debug.print(Debug.VERBOSE, "Appending type: " + ((char) sigb[i]) + " value: " + data);

            // pad to the alignment of this type.
            pad(sigb[i]);
            switch (sigb[i]) {
                case ArgumentType.BYTE:
                    appendByte(((Number) data).byteValue());
                    break;
                case ArgumentType.BOOLEAN:
                    appendint(((Boolean) data).booleanValue() ? 1 : 0, 4);
                    break;
                case ArgumentType.DOUBLE:
                    long l = Double.doubleToLongBits(((Number) data).doubleValue());
                    appendint(l, 8);
                    break;
                case ArgumentType.FLOAT:
                    int rf = Float.floatToIntBits(((Number) data).floatValue());
                    appendint(rf, 4);
                    break;
                case ArgumentType.UINT32:
                    appendint(((Number) data).longValue(), 4);
                    break;
                case ArgumentType.INT64:
                    appendint(((Number) data).longValue(), 8);
                    break;
                case ArgumentType.UINT64:
                    if (big) {
                        appendint(((UInt64) data).top(), 4);
                        appendint(((UInt64) data).bottom(), 4);
                    } else {
                        appendint(((UInt64) data).bottom(), 4);
                        appendint(((UInt64) data).top(), 4);
                    }
                    break;
                case ArgumentType.INT32:
                    appendint(((Number) data).intValue(), 4);
                    break;
                case ArgumentType.UINT16:
                    appendint(((Number) data).intValue(), 2);
                    break;
                case ArgumentType.INT16:
                    appendint(((Number) data).shortValue(), 2);
                    break;
                case ArgumentType.STRING:
                case ArgumentType.OBJECT_PATH:
                    // Strings are marshalled as a UInt32 with the length,
                    // followed by the String, followed by a null byte.
                    String payload = data.toString();
                    byte[] payloadbytes = null;
                    try {
                        payloadbytes = payload.getBytes("UTF-8");
                    } catch (UnsupportedEncodingException UEe) {
                        if (AbstractConnection.EXCEPTION_DEBUG && Debug.debug) Debug.print(UEe);
                        throw new DBusException(getString("utf8NotSupported"));
                    }
                    if (Debug.debug) Debug.print(Debug.VERBOSE, "Appending String of length " + payloadbytes.length);
                    appendint(payloadbytes.length, 4);
                    appendBytes(payloadbytes);
                    appendBytes(padding[1]);
                    //pad(ArgumentType.STRING);? do we need this?
                    break;
                case ArgumentType.SIGNATURE:
                    // Signatures are marshalled as a byte with the length,
                    // followed by the String, followed by a null byte.
                    // Signatures are generally short, so preallocate the array
                    // for the string, length and null byte.
                    if (data instanceof Type[])
                        payload = Marshalling.getDBusType((Type[]) data);
                    else
                        payload = (String) data;
                    byte[] pbytes = payload.getBytes();
                    preallocate(2 + pbytes.length);
                    appendByte((byte) pbytes.length);
                    appendBytes(pbytes);
                    appendByte((byte) 0);
                    break;
                case ArgumentType.ARRAY:
                    // Arrays are given as a UInt32 for the length in bytes,
                    // padding to the element alignment, then elements in
                    // order. The length is the length from the end of the
                    // initial padding to the end of the last element.
                    if (Debug.debug) {
                        if (data instanceof Object[])
                            Debug.print(Debug.VERBOSE, "Appending array: " + Arrays.deepToString((Object[]) data));
                    }

                    byte[] alen = new byte[4];
                    appendBytes(alen);
                    pad(sigb[++i]);
                    long c = bytecounter;

                    // optimise primatives
                    if (data.getClass().isArray() &&
                            data.getClass().getComponentType().isPrimitive()) {
                        byte[] primbuf;
                        int algn = getAlignment(sigb[i]);
                        int len = Array.getLength(data);
                        switch (sigb[i]) {
                            case ArgumentType.BYTE:
                                primbuf = (byte[]) data;
                                break;
                            case ArgumentType.INT16:
                            case ArgumentType.INT32:
                            case ArgumentType.INT64:
                                primbuf = new byte[len * algn];
                                for (int j = 0, k = 0; j < len; j++, k += algn)
                                    marshallint(Array.getLong(data, j), primbuf, k, algn);
                                break;
                            case ArgumentType.BOOLEAN:
                                primbuf = new byte[len * algn];
                                for (int j = 0, k = 0; j < len; j++, k += algn)
                                    marshallint(Array.getBoolean(data, j) ? 1 : 0, primbuf, k, algn);
                                break;
                            case ArgumentType.DOUBLE:
                                primbuf = new byte[len * algn];
                                if (data instanceof float[])
                                    for (int j = 0, k = 0; j < len; j++, k += algn)
                                        marshallint(Double.doubleToRawLongBits(((float[]) data)[j]),
                                                primbuf, k, algn);
                                else
                                    for (int j = 0, k = 0; j < len; j++, k += algn)
                                        marshallint(Double.doubleToRawLongBits(((double[]) data)[j]),
                                                primbuf, k, algn);
                                break;
                            case ArgumentType.FLOAT:
                                primbuf = new byte[len * algn];
                                for (int j = 0, k = 0; j < len; j++, k += algn)
                                    marshallint(
                                            Float.floatToRawIntBits(((float[]) data)[j]),
                                            primbuf, k, algn);
                                break;
                            default:
                                throw new MarshallingException(getString("arraySentAsNonPrimitive"));
                        }
                        appendBytes(primbuf);
                    } else if (data instanceof List) {
                        Object[] contents = ((List) data).toArray();
                        int diff = i;
                        ensureBuffers(contents.length * 4);
                        for (Object o : contents)
                            diff = appendone(sigb, i, o);
                        i = diff;
                    } else if (data instanceof Map) {
                        int diff = i;
                        ensureBuffers(((Map) data).size() * 6);
                        for (Map.Entry<Object, Object> o : ((Map<Object, Object>) data).entrySet())
                            diff = appendone(sigb, i, o);
                        if (i == diff) {
                            // advance the type parser even on 0-size arrays.
                            Vector<Type> temp = new Vector<Type>();
                            byte[] temp2 = new byte[sigb.length - diff];
                            System.arraycopy(sigb, diff, temp2, 0, temp2.length);
                            String temp3 = new String(temp2);
                            int temp4 = Marshalling.getJavaType(temp3, temp, 1);
                            diff += temp4;
                        }
                        i = diff;
                    } else {
                        Object[] contents = (Object[]) data;
                        ensureBuffers(contents.length * 4);
                        int diff = i;
                        for (Object o : contents)
                            diff = appendone(sigb, i, o);
                        i = diff;
                    }
                    if (Debug.debug)
                        Debug.print(Debug.VERBOSE, "start: " + c + " end: " + bytecounter + " length: " + (bytecounter - c));
                    marshallint(bytecounter - c, alen, 0, 4);
                    break;
                case ArgumentType.STRUCT1:
                    // Structs are aligned to 8 bytes
                    // and simply contain each element marshalled in order
                    Object[] contents;
                    if (data instanceof Container)
                        contents = ((Container) data).getParameters();
                    else
                        contents = (Object[]) data;
                    ensureBuffers(contents.length * 4);
                    int j = 0;
                    for (i++; sigb[i] != ArgumentType.STRUCT2; i++)
                        i = appendone(sigb, i, contents[j++]);
                    break;
                case ArgumentType.DICT_ENTRY1:
                    // Dict entries are the same as structs.
                    if (data instanceof Map.Entry) {
                        i++;
                        i = appendone(sigb, i, ((Map.Entry) data).getKey());
                        i++;
                        i = appendone(sigb, i, ((Map.Entry) data).getValue());
                        i++;
                    } else {
                        contents = (Object[]) data;
                        j = 0;
                        for (i++; sigb[i] != ArgumentType.DICT_ENTRY2; i++)
                            i = appendone(sigb, i, contents[j++]);
                    }
                    break;
                case ArgumentType.VARIANT:
                    // Variants are marshalled as a signature
                    // followed by the value.
                    if (data instanceof Variant) {
                        Variant var = (Variant) data;
                        appendone(new byte[]{ArgumentType.SIGNATURE}, 0, var.getSig());
                        appendone((var.getSig()).getBytes(), 0, var.getValue());
                    } else if (data instanceof Object[]) {
                        contents = (Object[]) data;
                        appendone(new byte[]{ArgumentType.SIGNATURE}, 0, contents[0]);
                        appendone(((String) contents[0]).getBytes(), 0, contents[1]);
                    } else {
                        String sig = Marshalling.getDBusType(data.getClass())[0];
                        appendone(new byte[]{ArgumentType.SIGNATURE}, 0, sig);
                        appendone((sig).getBytes(), 0, data);
                    }
                    break;
            }
            return i;
        } catch (ClassCastException CCe) {
            if (AbstractConnection.EXCEPTION_DEBUG && Debug.debug) Debug.print(Debug.ERR, CCe);
            throw new MarshallingException(MessageFormat.format(getString("unconvertableType"), new Object[]{data.getClass().getName(), sigb[sigofs]}));
        }
    }

demarshallint() [1/2]

long org.freedesktop.dbus.Message.demarshallint ( byte []  buf, int  ofs, int  width  )

inline

Demarshalls an integer of a given width from a buffer. Endianness is determined from the format of the message.

引数

buf	The buffer to demarshall from.
ofs	The offset to demarshall from.
width	The byte-width of the int.

                                                              {
        return big ? demarshallintBig(buf, ofs, width) : demarshallintLittle(buf, ofs, width);
    }

demarshallint() [2/2]

static long org.freedesktop.dbus.Message.demarshallint ( byte []  buf, int  ofs, byte  endian, int  width  )

inlinestatic

Demarshalls an integer of a given width from a buffer.

引数

buf	The buffer to demarshall from.
ofs	The offset to demarshall from.
endian	The endianness to use in demarshalling.
width	The byte-width of the int.

                                                                                  {
        return endian == Endian.BIG ? demarshallintBig(buf, ofs, width) : demarshallintLittle(buf, ofs, width);
    }

demarshallintBig()

static long org.freedesktop.dbus.Message.demarshallintBig ( byte []  buf, int  ofs, int  width  )

inlinestatic

Demarshalls an integer of a given width from a buffer using big-endian format.

引数

buf	The buffer to demarshall from.
ofs	The offset to demarshall from.
width	The byte-width of the int.

                                                                        {
        long l = 0;
        for (int i = 0; i < width; i++) {
            l <<= 8;
            l |= (buf[ofs + i] & 0xFF);
        }
        return l;
    }

demarshallintLittle()

static long org.freedesktop.dbus.Message.demarshallintLittle ( byte []  buf, int  ofs, int  width  )

inlinestatic

Demarshalls an integer of a given width from a buffer using little-endian format.

引数

buf	The buffer to demarshall from.
ofs	The offset to demarshall from.
width	The byte-width of the int.

                                                                           {
        long l = 0;
        for (int i = (width - 1); i >= 0; i--) {
            l <<= 8;
            l |= (buf[ofs + i] & 0xFF);
        }
        return l;
    }

ensureBuffers()

void org.freedesktop.dbus.Message.ensureBuffers ( int  num )

inlineprivate

Ensures there are enough free buffers.

引数

num	number of free buffers to create.

                                        {
        int increase = num - wiredata.length + bufferuse;
        if (increase > 0) {
            if (increase < BUFFERINCREMENT) increase = BUFFERINCREMENT;
            if (Debug.debug) Debug.print(Debug.VERBOSE, "Resizing " + bufferuse);
            byte[][] temp = new byte[wiredata.length + increase][];
            System.arraycopy(wiredata, 0, temp, 0, wiredata.length);
            wiredata = temp;
        }
    }

extract() [1/2]

Object [] org.freedesktop.dbus.Message.extract ( String  sig, byte []  buf, int  ofs  ) throws DBusException

inline

Demarshall values from a buffer.

引数

sig	The D-Bus signature(s) of the value(s).
buf	The buffer to demarshall from.
ofs	The offset into the data buffer to start.

戻り値

The demarshalled value(s).

                                                                                  {
        return extract(sig, buf, new int[]{0, ofs});
    }

extract() [2/2]

Object [] org.freedesktop.dbus.Message.extract ( String  sig, byte []  buf, int []  ofs  ) throws DBusException

inline

Demarshall values from a buffer.

引数

sig	The D-Bus signature(s) of the value(s).
buf	The buffer to demarshall from.
ofs	An array of two ints, the offset into the signature and the offset into the data buffer. These values will be updated to the start of the next value ofter demarshalling.

戻り値

The demarshalled value(s).

                                                                                    {
        if (Debug.debug)
            Debug.print(Debug.VERBOSE, "extract(" + sig + ",#" + buf.length + ", {" + ofs[0] + "," + ofs[1] + "}");
        Vector<Object> rv = new Vector<Object>();
        byte[] sigb = sig.getBytes();
        for (int[] i = ofs; i[0] < sigb.length; i[0]++) {
            rv.add(extractone(sigb, buf, i, false));
        }
        return rv.toArray();
    }

extractone()

Object org.freedesktop.dbus.Message.extractone ( byte []  sigb, byte []  buf, int []  ofs, boolean  contained  ) throws DBusException

inlineprivate

Demarshall one value from a buffer.

引数

sigb	A buffer of the D-Bus signature.
buf	The buffer to demarshall from.
ofs	An array of two ints, the offset into the signature buffer and the offset into the data buffer. These values will be updated to the start of the next value ofter demarshalling.
contained	converts nested arrays to Lists

戻り値

The demarshalled value.

                                                                                                          {
        if (Debug.debug)
            Debug.print(Debug.VERBOSE, "Extracting type: " + ((char) sigb[ofs[0]]) + " from offset " + ofs[1]);
        Object rv = null;
        ofs[1] = align(ofs[1], sigb[ofs[0]]);
        switch (sigb[ofs[0]]) {
            case ArgumentType.BYTE:
                rv = buf[ofs[1]++];
                break;
            case ArgumentType.UINT32:
                rv = new UInt32(demarshallint(buf, ofs[1], 4));
                ofs[1] += 4;
                break;
            case ArgumentType.INT32:
                rv = (int) demarshallint(buf, ofs[1], 4);
                ofs[1] += 4;
                break;
            case ArgumentType.INT16:
                rv = (short) demarshallint(buf, ofs[1], 2);
                ofs[1] += 2;
                break;
            case ArgumentType.UINT16:
                rv = new UInt16((int) demarshallint(buf, ofs[1], 2));
                ofs[1] += 2;
                break;
            case ArgumentType.INT64:
                rv = demarshallint(buf, ofs[1], 8);
                ofs[1] += 8;
                break;
            case ArgumentType.UINT64:
                long top;
                long bottom;
                if (big) {
                    top = demarshallint(buf, ofs[1], 4);
                    ofs[1] += 4;
                    bottom = demarshallint(buf, ofs[1], 4);
                } else {
                    bottom = demarshallint(buf, ofs[1], 4);
                    ofs[1] += 4;
                    top = demarshallint(buf, ofs[1], 4);
                }
                rv = new UInt64(top, bottom);
                ofs[1] += 4;
                break;
            case ArgumentType.DOUBLE:
                long l = demarshallint(buf, ofs[1], 8);
                ofs[1] += 8;
                rv = Double.longBitsToDouble(l);
                break;
            case ArgumentType.FLOAT:
                int rf = (int) demarshallint(buf, ofs[1], 4);
                ofs[1] += 4;
                rv = Float.intBitsToFloat(rf);
                break;
            case ArgumentType.BOOLEAN:
                rf = (int) demarshallint(buf, ofs[1], 4);
                ofs[1] += 4;
                rv = (1 == rf) ? Boolean.TRUE : Boolean.FALSE;
                break;
            case ArgumentType.ARRAY:
                long size = demarshallint(buf, ofs[1], 4);
                if (Debug.debug) Debug.print(Debug.VERBOSE, "Reading array of size: " + size);
                ofs[1] += 4;
                byte algn = (byte) getAlignment(sigb[++ofs[0]]);
                ofs[1] = align(ofs[1], sigb[ofs[0]]);
                int length = (int) (size / algn);
                if (length > DBusConnection.MAX_ARRAY_LENGTH)
                    throw new MarshallingException(getString("arrayMustNotExceed") + DBusConnection.MAX_ARRAY_LENGTH);
                // optimise primatives
                switch (sigb[ofs[0]]) {
                    case ArgumentType.BYTE:
                        rv = new byte[length];
                        System.arraycopy(buf, ofs[1], rv, 0, length);
                        ofs[1] += size;
                        break;
                    case ArgumentType.INT16:
                        rv = new short[length];
                        for (int j = 0; j < length; j++, ofs[1] += algn)
                            ((short[]) rv)[j] = (short) demarshallint(buf, ofs[1], algn);
                        break;
                    case ArgumentType.INT32:
                        rv = new int[length];
                        for (int j = 0; j < length; j++, ofs[1] += algn)
                            ((int[]) rv)[j] = (int) demarshallint(buf, ofs[1], algn);
                        break;
                    case ArgumentType.INT64:
                        rv = new long[length];
                        for (int j = 0; j < length; j++, ofs[1] += algn)
                            ((long[]) rv)[j] = demarshallint(buf, ofs[1], algn);
                        break;
                    case ArgumentType.BOOLEAN:
                        rv = new boolean[length];
                        for (int j = 0; j < length; j++, ofs[1] += algn)
                            ((boolean[]) rv)[j] = (1 == demarshallint(buf, ofs[1], algn));
                        break;
                    case ArgumentType.FLOAT:
                        rv = new float[length];
                        for (int j = 0; j < length; j++, ofs[1] += algn)
                            ((float[]) rv)[j] =
                                    Float.intBitsToFloat((int) demarshallint(buf, ofs[1], algn));
                        break;
                    case ArgumentType.DOUBLE:
                        rv = new double[length];
                        for (int j = 0; j < length; j++, ofs[1] += algn)
                            ((double[]) rv)[j] =
                                    Double.longBitsToDouble(demarshallint(buf, ofs[1], algn));
                        break;
                    case ArgumentType.DICT_ENTRY1:
                        if (0 == size) {
                            // advance the type parser even on 0-size arrays.
                            Vector<Type> temp = new Vector<Type>();
                            byte[] temp2 = new byte[sigb.length - ofs[0]];
                            System.arraycopy(sigb, ofs[0], temp2, 0, temp2.length);
                            String temp3 = new String(temp2);
                            // ofs[0] gets incremented anyway. Leave one character on the stack
                            int temp4 = Marshalling.getJavaType(temp3, temp, 1) - 1;
                            ofs[0] += temp4;
                            if (Debug.debug)
                                Debug.print(Debug.VERBOSE, "Aligned type: " + temp3 + " " + temp4 + " " + ofs[0]);
                        }
                        int ofssave = ofs[0];
                        long end = ofs[1] + size;
                        Vector<Object[]> entries = new Vector<Object[]>();
                        while (ofs[1] < end) {
                            ofs[0] = ofssave;
                            entries.add((Object[]) extractone(sigb, buf, ofs, true));
                        }
                        rv = new DBusMap<Object, Object>(entries.toArray(new Object[0][]));
                        break;
                    default:
                        if (0 == size) {
                            // advance the type parser even on 0-size arrays.
                            Vector<Type> temp = new Vector<Type>();
                            byte[] temp2 = new byte[sigb.length - ofs[0]];
                            System.arraycopy(sigb, ofs[0], temp2, 0, temp2.length);
                            String temp3 = new String(temp2);
                            // ofs[0] gets incremented anyway. Leave one character on the stack
                            int temp4 = Marshalling.getJavaType(temp3, temp, 1) - 1;
                            ofs[0] += temp4;
                            if (Debug.debug)
                                Debug.print(Debug.VERBOSE, "Aligned type: " + temp3 + " " + temp4 + " " + ofs[0]);
                        }
                        ofssave = ofs[0];
                        end = ofs[1] + size;
                        Vector<Object> contents = new Vector<Object>();
                        while (ofs[1] < end) {
                            ofs[0] = ofssave;
                            contents.add(extractone(sigb, buf, ofs, true));
                        }
                        rv = contents;
                }
                if (contained && !(rv instanceof List) && !(rv instanceof Map))
                    rv = ArrayFrob.listify(rv);
                break;
            case ArgumentType.STRUCT1:
                Vector<Object> contents = new Vector<Object>();
                while (sigb[++ofs[0]] != ArgumentType.STRUCT2)
                    contents.add(extractone(sigb, buf, ofs, true));
                rv = contents.toArray();
                break;
            case ArgumentType.DICT_ENTRY1:
                Object[] decontents = new Object[2];
                if (Debug.debug)
                    Debug.print(Debug.VERBOSE, "Extracting Dict Entry (" + Hexdump.toAscii(sigb, ofs[0], sigb.length - ofs[0]) + ") from: " + Hexdump.toHex(buf, ofs[1], buf.length - ofs[1]));
                ofs[0]++;
                decontents[0] = extractone(sigb, buf, ofs, true);
                ofs[0]++;
                decontents[1] = extractone(sigb, buf, ofs, true);
                ofs[0]++;
                rv = decontents;
                break;
            case ArgumentType.VARIANT:
                int[] newofs = new int[]{0, ofs[1]};
                String sig = (String) extract(ArgumentType.SIGNATURE_STRING, buf, newofs)[0];
                newofs[0] = 0;
                rv = new Variant<Object>(extract(sig, buf, newofs)[0], sig);
                ofs[1] = newofs[1];
                break;
            case ArgumentType.STRING:
                length = (int) demarshallint(buf, ofs[1], 4);
                ofs[1] += 4;
                try {
                    rv = new String(buf, ofs[1], length, "UTF-8");
                } catch (UnsupportedEncodingException UEe) {
                    if (AbstractConnection.EXCEPTION_DEBUG && Debug.debug) Debug.print(UEe);
                    throw new DBusException(getString("utf8NotSupported"));
                }
                ofs[1] += length + 1;
                break;
            case ArgumentType.OBJECT_PATH:
                length = (int) demarshallint(buf, ofs[1], 4);
                ofs[1] += 4;
                rv = new ObjectPath(getSource(), new String(buf, ofs[1], length));
                ofs[1] += length + 1;
                break;
            case ArgumentType.SIGNATURE:
                length = (buf[ofs[1]++] & 0xFF);
                rv = new String(buf, ofs[1], length);
                ofs[1] += length + 1;
                break;
            default:
                throw new UnknownTypeCodeException(sigb[ofs[0]]);
        }
        if (Debug.debug) if (rv instanceof Object[])
            Debug.print(Debug.VERBOSE, "Extracted: " + Arrays.deepToString((Object[]) rv) + " (now at " + ofs[1] + ")");
        else
            Debug.print(Debug.VERBOSE, "Extracted: " + rv + " (now at " + ofs[1] + ")");
        return rv;
    }

getAlignment()

static int org.freedesktop.dbus.Message.getAlignment ( byte  type )

inlinestatic

Return the alignment for a given type.

                                              {
        switch (type) {
            case 2:
            case ArgumentType.INT16:
            case ArgumentType.UINT16:
                return 2;
            case 4:
            case ArgumentType.BOOLEAN:
            case ArgumentType.FLOAT:
            case ArgumentType.INT32:
            case ArgumentType.UINT32:
            case ArgumentType.STRING:
            case ArgumentType.OBJECT_PATH:
            case ArgumentType.ARRAY:
                return 4;
            case 8:
            case ArgumentType.INT64:
            case ArgumentType.UINT64:
            case ArgumentType.DOUBLE:
            case ArgumentType.STRUCT:
            case ArgumentType.DICT_ENTRY:
            case ArgumentType.STRUCT1:
            case ArgumentType.DICT_ENTRY1:
            case ArgumentType.STRUCT2:
            case ArgumentType.DICT_ENTRY2:
                return 8;
            case 1:
            case ArgumentType.BYTE:
            case ArgumentType.SIGNATURE:
            case ArgumentType.VARIANT:
            default:
                return 1;
        }
    }

getDestination()

String org.freedesktop.dbus.Message.getDestination ( )

inline

Returns the destination of the message.

                                   {
        return (String) headers.get(HeaderField.DESTINATION);
    }

getFlags()

int org.freedesktop.dbus.Message.getFlags ( )

inline

Returns the message flags.

                          {
        return flags;
    }

getHeader()

Object org.freedesktop.dbus.Message.getHeader ( byte  type )

inline

Returns the value of the header field of a given field.

引数

type	The field to return.

戻り値

The value of the field or null if unset.

                                       {
        return headers.get(type);
    }

getHeaderFieldName()

static String org.freedesktop.dbus.Message.getHeaderFieldName ( byte  field )

inlinestatic

Returns the name of the given header field.

                                                        {
        switch (field) {
            case HeaderField.PATH:
                return "Path";
            case HeaderField.INTERFACE:
                return "Interface";
            case HeaderField.MEMBER:
                return "Member";
            case HeaderField.ERROR_NAME:
                return "Error Name";
            case HeaderField.REPLY_SERIAL:
                return "Reply Serial";
            case HeaderField.DESTINATION:
                return "Destination";
            case HeaderField.SENDER:
                return "Sender";
            case HeaderField.SIGNATURE:
                return "Signature";
            default:
                return "Invalid";
        }
    }

getInterface()

String org.freedesktop.dbus.Message.getInterface ( )

inline

Returns the interface of the message.

                                 {
        return (String) headers.get(HeaderField.INTERFACE);
    }

getName()

String org.freedesktop.dbus.Message.getName ( )

inline

Returns the member name or error name this message represents.

                            {
        if (this instanceof Error)
            return (String) headers.get(HeaderField.ERROR_NAME);
        else
            return (String) headers.get(HeaderField.MEMBER);
    }

getParameters()

Object [] org.freedesktop.dbus.Message.getParameters ( ) throws DBusException

inline

Parses and returns the parameters to this message as an Object array.

                                                         {
        if (null == args && null != body) {
            String sig = (String) headers.get(HeaderField.SIGNATURE);
            if (null != sig && 0 != body.length) {
                args = extract(sig, body, 0);
            } else args = new Object[0];
        }
        return args;
    }

getPath()

String org.freedesktop.dbus.Message.getPath ( )

inline

Returns the object path of the message.

                            {
        Object o = headers.get(HeaderField.PATH);
        if (null == o) return null;
        return o.toString();
    }

getReplySerial()

long org.freedesktop.dbus.Message.getReplySerial ( )

inline

If this is a reply to a message, this returns its serial.

戻り値

The reply serial, or 0 if it is not a reply.

                                 {
        Number l = (Number) headers.get(HeaderField.REPLY_SERIAL);
        if (null == l) return 0;
        return l.longValue();
    }

getSerial()

long org.freedesktop.dbus.Message.getSerial ( )

inline

Returns the message serial ID (unique for this connection)

戻り値

the message serial.

                            {
        return serial;
    }

getSig()

String org.freedesktop.dbus.Message.getSig ( )

inline

Returns the dbus signature of the parameters.

                           {
        return (String) headers.get(HeaderField.SIGNATURE);
    }

getSource()

String org.freedesktop.dbus.Message.getSource ( )

inline

Returns the Bus ID that sent the message.

                              {
        return (String) headers.get(HeaderField.SENDER);
    }

getWireData()

byte [][] org.freedesktop.dbus.Message.getWireData ( )

inline

                                  {
        return wiredata;
    }

marshallint()

void org.freedesktop.dbus.Message.marshallint ( long  l, byte []  buf, int  ofs, int  width  )

inline

Marshalls an integer of a given width into a buffer. Endianness is determined from the message.

引数

l	The integer to marshall.
buf	The buffer to marshall to.
ofs	The offset to marshall to.
width	The byte-width of the int.

                                                                    {
        if (big) marshallintBig(l, buf, ofs, width);
        else marshallintLittle(l, buf, ofs, width);
        if (Debug.debug) Debug.print(Debug.VERBOSE, "Marshalled int " + l + " to " + Hexdump.toHex(buf, ofs, width));
    }

marshallintBig()

static void org.freedesktop.dbus.Message.marshallintBig ( long  l, byte []  buf, int  ofs, int  width  )

inlinestatic

Marshalls an integer of a given width into a buffer using big-endian format.

引数

l	The integer to marshall.
buf	The buffer to marshall to.
ofs	The offset to marshall to.
width	The byte-width of the int.

                                                                              {
        for (int i = (width - 1); i >= 0; i--) {
            buf[i + ofs] = (byte) (l & 0xFF);
            l >>= 8;
        }
    }

marshallintLittle()

static void org.freedesktop.dbus.Message.marshallintLittle ( long  l, byte []  buf, int  ofs, int  width  )

inlinestatic

Marshalls an integer of a given width into a buffer using little-endian format.

引数

l	The integer to marshall.
buf	The buffer to demarshall to.
ofs	The offset to demarshall to.
width	The byte-width of the int.

                                                                                 {
        for (int i = 0; i < width; i++) {
            buf[i + ofs] = (byte) (l & 0xFF);
            l >>= 8;
        }
    }

pad()

void org.freedesktop.dbus.Message.pad ( byte  type )

inline

Pad the message to the proper alignment for the given type.

                               {
        if (Debug.debug) Debug.print(Debug.VERBOSE, "padding for " + (char) type);
        int a = getAlignment(type);
        if (Debug.debug) Debug.print(Debug.VERBOSE, preallocated + " " + paofs + " " + bytecounter + " " + a);
        int b = (int) ((bytecounter - preallocated) % a);
        if (0 == b) return;
        a = (a - b);
        if (preallocated > 0) {
            paofs += a;
            preallocated -= a;
        } else
            appendBytes(padding[a]);
        if (Debug.debug) Debug.print(Debug.VERBOSE, preallocated + " " + paofs + " " + bytecounter + " " + a);
    }

populate()

void org.freedesktop.dbus.Message.populate ( byte []  msg, byte []  headers, byte []  body  ) throws DBusException

inlinepackage

Create a message from wire-format data.

引数

msg	D-Bus serialized data of type yyyuu
headers	D-Bus serialized data of type a(yv)
body	D-Bus serialized data of the signature defined in headers.

                                                                                {
        big = (msg[0] == Endian.BIG);
        type = msg[1];
        flags = msg[2];
        protover = msg[3];
        wiredata[0] = msg;
        wiredata[1] = headers;
        wiredata[2] = body;
        this.body = body;
        bufferuse = 3;
        bodylen = ((Number) extract(Message.ArgumentType.UINT32_STRING, msg, 4)[0]).longValue();
        serial = ((Number) extract(Message.ArgumentType.UINT32_STRING, msg, 8)[0]).longValue();
        bytecounter = msg.length + headers.length + body.length;
        if (Debug.debug) Debug.print(Debug.VERBOSE, headers);
        Object[] hs = extract("a(yv)", headers, 0);
        if (Debug.debug) Debug.print(Debug.VERBOSE, Arrays.deepToString(hs));
        for (Object o : (Vector<Object>) hs[0]) {
            this.headers.put((Byte) ((Object[]) o)[0], ((Variant<Object>) ((Object[]) o)[1]).getValue());
        }
    }

preallocate()

void org.freedesktop.dbus.Message.preallocate ( int  num )

inlineprivate

Create a buffer of num bytes. Data is copied to this rather than added to the buffer list.

                                      {
        preallocated = 0;
        pabuf = new byte[num];
        appendBytes(pabuf);
        preallocated = num;
        paofs = 0;
    }

setArgs()

void org.freedesktop.dbus.Message.setArgs ( Object []  args )

inlineprotected

                                          {
        this.args = args;
    }

setSource()

void org.freedesktop.dbus.Message.setSource ( String  source ) throws DBusException

inline

Warning, do not use this method unless you really know what you are doing.

                                                              {
        if (null != body) {
            wiredata = new byte[BUFFERINCREMENT][];
            bufferuse = 0;
            bytecounter = 0;
            preallocate(12);
            append("yyyyuu", big ? Endian.BIG : Endian.LITTLE, type, flags, protover, bodylen, serial);
            headers.put(HeaderField.SENDER, source);
            Object[][] newhead = new Object[headers.size()][];
            int i = 0;
            for (Byte b : headers.keySet()) {
                newhead[i] = new Object[2];
                newhead[i][0] = b;
                newhead[i][1] = headers.get(b);
                i++;
            }
            append("a(yv)", (Object) newhead);
            pad((byte) 8);
            appendBytes(body);
        }
    }

toString()

String org.freedesktop.dbus.Message.toString ( )

inline

Formats the message in a human-readable format.

                             {
        StringBuffer sb = new StringBuffer();
        sb.append(getClass().getSimpleName());
        sb.append('(');
        sb.append(flags);
        sb.append(',');
        sb.append(serial);
        sb.append(')');
        sb.append(' ');
        sb.append('{');
        sb.append(' ');
        if (headers.size() == 0)
            sb.append('}');
        else {
            for (Byte field : headers.keySet()) {
                sb.append(getHeaderFieldName(field));
                sb.append('=');
                sb.append('>');
                sb.append(headers.get(field).toString());
                sb.append(',');
                sb.append(' ');
            }
            sb.setCharAt(sb.length() - 2, ' ');
            sb.setCharAt(sb.length() - 1, '}');
        }
        sb.append(' ');
        sb.append('{');
        sb.append(' ');
        Object[] args = null;
        try {
            args = getParameters();
        } catch (DBusException DBe) {
            if (AbstractConnection.EXCEPTION_DEBUG && Debug.debug) Debug.print(Debug.ERR, DBe);
        }
        if (null == args || 0 == args.length)
            sb.append('}');
        else {
            for (Object o : args) {
                if (o instanceof Object[])
                    sb.append(Arrays.deepToString((Object[]) o));
                else if (o instanceof byte[])
                    sb.append(Arrays.toString((byte[]) o));
                else if (o instanceof int[])
                    sb.append(Arrays.toString((int[]) o));
                else if (o instanceof short[])
                    sb.append(Arrays.toString((short[]) o));
                else if (o instanceof long[])
                    sb.append(Arrays.toString((long[]) o));
                else if (o instanceof boolean[])
                    sb.append(Arrays.toString((boolean[]) o));
                else if (o instanceof double[])
                    sb.append(Arrays.toString((double[]) o));
                else if (o instanceof float[])
                    sb.append(Arrays.toString((float[]) o));
                else
                    sb.append(o.toString());
                sb.append(',');
                sb.append(' ');
            }
            sb.setCharAt(sb.length() - 2, ' ');
            sb.setCharAt(sb.length() - 1, '}');
        }
        return sb.toString();
    }

メンバ詳解

args

Object [] org.freedesktop.dbus.Message.args

private

big

boolean org.freedesktop.dbus.Message.big

private

body

byte [] org.freedesktop.dbus.Message.body

private

bodylen

long org.freedesktop.dbus.Message.bodylen = 0

private

BUFFERINCREMENT

final int org.freedesktop.dbus.Message.BUFFERINCREMENT = 20

staticprivate

Steps to increment the buffer array.

bufferuse

int org.freedesktop.dbus.Message.bufferuse = 0

private

bytecounter

long org.freedesktop.dbus.Message.bytecounter

protected

flags

byte org.freedesktop.dbus.Message.flags

protected

globalserial

long org.freedesktop.dbus.Message.globalserial = 0

staticprotected

headers

Map<Byte, Object> org.freedesktop.dbus.Message.headers

protected

pabuf

byte [] org.freedesktop.dbus.Message.pabuf

private

padding

byte [][] org.freedesktop.dbus.Message.padding

staticprivate

Keep a static reference to each size of padding array to prevent allocation.

paofs

int org.freedesktop.dbus.Message.paofs = 0

private

preallocated

int org.freedesktop.dbus.Message.preallocated = 0

private

PROTOCOL

final byte org.freedesktop.dbus.Message.PROTOCOL = 1

static

The current protocol major version.

protover

byte org.freedesktop.dbus.Message.protover

protected

serial

long org.freedesktop.dbus.Message.serial

protected

type

byte org.freedesktop.dbus.Message.type

protected

wiredata

byte [][] org.freedesktop.dbus.Message.wiredata

protected

---

このクラス詳解は次のファイルから抽出されました:

• D:/AppData/doxygen/keycloak/federation/src/federation/sssd/src/main/java/org/freedesktop/dbus/Message.java