Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-07-01 20:43:39 +01:00
Code Issues Projects Releases Packages Wiki Activity
servo/tests/wpt/web-platform-tests/resources/chromium/device.mojom.js

3424 lines
116 KiB
JavaScript
Raw Blame History

// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
'use strict';
(function() {
var mojomId = 'device/usb/public/mojom/device.mojom';
if (mojo.internal.isMojomLoaded(mojomId)) {
console.warn('The following mojom is loaded multiple times: ' + mojomId);
return;
}
mojo.internal.markMojomLoaded(mojomId);
var bindings = mojo;
var associatedBindings = mojo;
var codec = mojo.internal;
var validator = mojo.internal;
var exports = mojo.internal.exposeNamespace('device.mojom');
var string16$ =
mojo.internal.exposeNamespace('mojo.common.mojom');
if (mojo.config.autoLoadMojomDeps) {
mojo.internal.loadMojomIfNecessary(
'mojo/public/mojom/base/string16.mojom', '../../../../mojo/public/mojom/base/string16.mojom.js');
}
var UsbOpenDeviceError = {};
UsbOpenDeviceError.OK = 0;
UsbOpenDeviceError.ACCESS_DENIED = UsbOpenDeviceError.OK + 1;
UsbOpenDeviceError.ALREADY_OPEN = UsbOpenDeviceError.ACCESS_DENIED + 1;
UsbOpenDeviceError.isKnownEnumValue = function(value) {
switch (value) {
case 0:
case 1:
case 2:
return true;
}
return false;
};
UsbOpenDeviceError.validate = function(enumValue) {
var isExtensible = false;
if (isExtensible || this.isKnownEnumValue(enumValue))
return validator.validationError.NONE;
return validator.validationError.UNKNOWN_ENUM_VALUE;
};
var UsbTransferDirection = {};
UsbTransferDirection.INBOUND = 0;
UsbTransferDirection.OUTBOUND = UsbTransferDirection.INBOUND + 1;
UsbTransferDirection.isKnownEnumValue = function(value) {
switch (value) {
case 0:
case 1:
return true;
}
return false;
};
UsbTransferDirection.validate = function(enumValue) {
var isExtensible = false;
if (isExtensible || this.isKnownEnumValue(enumValue))
return validator.validationError.NONE;
return validator.validationError.UNKNOWN_ENUM_VALUE;
};
var UsbControlTransferType = {};
UsbControlTransferType.STANDARD = 0;
UsbControlTransferType.CLASS = UsbControlTransferType.STANDARD + 1;
UsbControlTransferType.VENDOR = UsbControlTransferType.CLASS + 1;
UsbControlTransferType.RESERVED = UsbControlTransferType.VENDOR + 1;
UsbControlTransferType.isKnownEnumValue = function(value) {
switch (value) {
case 0:
case 1:
case 2:
case 3:
return true;
}
return false;
};
UsbControlTransferType.validate = function(enumValue) {
var isExtensible = false;
if (isExtensible || this.isKnownEnumValue(enumValue))
return validator.validationError.NONE;
return validator.validationError.UNKNOWN_ENUM_VALUE;
};
var UsbControlTransferRecipient = {};
UsbControlTransferRecipient.DEVICE = 0;
UsbControlTransferRecipient.INTERFACE = UsbControlTransferRecipient.DEVICE + 1;
UsbControlTransferRecipient.ENDPOINT = UsbControlTransferRecipient.INTERFACE + 1;
UsbControlTransferRecipient.OTHER = UsbControlTransferRecipient.ENDPOINT + 1;
UsbControlTransferRecipient.isKnownEnumValue = function(value) {
switch (value) {
case 0:
case 1:
case 2:
case 3:
return true;
}
return false;
};
UsbControlTransferRecipient.validate = function(enumValue) {
var isExtensible = false;
if (isExtensible || this.isKnownEnumValue(enumValue))
return validator.validationError.NONE;
return validator.validationError.UNKNOWN_ENUM_VALUE;
};
var UsbTransferType = {};
UsbTransferType.CONTROL = 0;
UsbTransferType.ISOCHRONOUS = UsbTransferType.CONTROL + 1;
UsbTransferType.BULK = UsbTransferType.ISOCHRONOUS + 1;
UsbTransferType.INTERRUPT = UsbTransferType.BULK + 1;
UsbTransferType.isKnownEnumValue = function(value) {
switch (value) {
case 0:
case 1:
case 2:
case 3:
return true;
}
return false;
};
UsbTransferType.validate = function(enumValue) {
var isExtensible = false;
if (isExtensible || this.isKnownEnumValue(enumValue))
return validator.validationError.NONE;
return validator.validationError.UNKNOWN_ENUM_VALUE;
};
var UsbTransferStatus = {};
UsbTransferStatus.COMPLETED = 0;
UsbTransferStatus.TRANSFER_ERROR = UsbTransferStatus.COMPLETED + 1;
UsbTransferStatus.TIMEOUT = UsbTransferStatus.TRANSFER_ERROR + 1;
UsbTransferStatus.CANCELLED = UsbTransferStatus.TIMEOUT + 1;
UsbTransferStatus.STALLED = UsbTransferStatus.CANCELLED + 1;
UsbTransferStatus.DISCONNECT = UsbTransferStatus.STALLED + 1;
UsbTransferStatus.BABBLE = UsbTransferStatus.DISCONNECT + 1;
UsbTransferStatus.SHORT_PACKET = UsbTransferStatus.BABBLE + 1;
UsbTransferStatus.PERMISSION_DENIED = UsbTransferStatus.SHORT_PACKET + 1;
UsbTransferStatus.isKnownEnumValue = function(value) {
switch (value) {
case 0:
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
case 8:
return true;
}
return false;
};
UsbTransferStatus.validate = function(enumValue) {
var isExtensible = false;
if (isExtensible || this.isKnownEnumValue(enumValue))
return validator.validationError.NONE;
return validator.validationError.UNKNOWN_ENUM_VALUE;
};
function UsbEndpointInfo(values) {
this.initDefaults_();
this.initFields_(values);
}
UsbEndpointInfo.prototype.initDefaults_ = function() {
this.endpointNumber = 0;
this.direction = 0;
this.type = 0;
this.packetSize = 0;
};
UsbEndpointInfo.prototype.initFields_ = function(fields) {
for(var field in fields) {
if (this.hasOwnProperty(field))
this[field] = fields[field];
}
};
UsbEndpointInfo.validate = function(messageValidator, offset) {
var err;
err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
if (err !== validator.validationError.NONE)
return err;
var kVersionSizes = [
{version: 0, numBytes: 24}
];
err = messageValidator.validateStructVersion(offset, kVersionSizes);
if (err !== validator.validationError.NONE)
return err;
// validate UsbEndpointInfo.direction
err = messageValidator.validateEnum(offset + codec.kStructHeaderSize + 4, UsbTransferDirection);
if (err !== validator.validationError.NONE)
return err;
// validate UsbEndpointInfo.type
err = messageValidator.validateEnum(offset + codec.kStructHeaderSize + 8, UsbTransferType);
if (err !== validator.validationError.NONE)
return err;
return validator.validationError.NONE;
};
UsbEndpointInfo.encodedSize = codec.kStructHeaderSize + 16;
UsbEndpointInfo.decode = function(decoder) {
var packed;
var val = new UsbEndpointInfo();
var numberOfBytes = decoder.readUint32();
var version = decoder.readUint32();
val.endpointNumber = decoder.decodeStruct(codec.Uint8);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
val.direction = decoder.decodeStruct(codec.Int32);
val.type = decoder.decodeStruct(codec.Int32);
val.packetSize = decoder.decodeStruct(codec.Uint32);
return val;
};
UsbEndpointInfo.encode = function(encoder, val) {
var packed;
encoder.writeUint32(UsbEndpointInfo.encodedSize);
encoder.writeUint32(0);
encoder.encodeStruct(codec.Uint8, val.endpointNumber);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.encodeStruct(codec.Int32, val.direction);
encoder.encodeStruct(codec.Int32, val.type);
encoder.encodeStruct(codec.Uint32, val.packetSize);
};
function UsbAlternateInterfaceInfo(values) {
this.initDefaults_();
this.initFields_(values);
}
UsbAlternateInterfaceInfo.prototype.initDefaults_ = function() {
this.alternateSetting = 0;
this.classCode = 0;
this.subclassCode = 0;
this.protocolCode = 0;
this.interfaceName = null;
this.endpoints = null;
};
UsbAlternateInterfaceInfo.prototype.initFields_ = function(fields) {
for(var field in fields) {
if (this.hasOwnProperty(field))
this[field] = fields[field];
}
};
UsbAlternateInterfaceInfo.validate = function(messageValidator, offset) {
var err;
err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
if (err !== validator.validationError.NONE)
return err;
var kVersionSizes = [
{version: 0, numBytes: 32}
];
err = messageValidator.validateStructVersion(offset, kVersionSizes);
if (err !== validator.validationError.NONE)
return err;
// validate UsbAlternateInterfaceInfo.interfaceName
err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 8, string16$.String16, true);
if (err !== validator.validationError.NONE)
return err;
// validate UsbAlternateInterfaceInfo.endpoints
err = messageValidator.validateArrayPointer(offset + codec.kStructHeaderSize + 16, 8, new codec.PointerTo(UsbEndpointInfo), false, [0], 0);
if (err !== validator.validationError.NONE)
return err;
return validator.validationError.NONE;
};
UsbAlternateInterfaceInfo.encodedSize = codec.kStructHeaderSize + 24;
UsbAlternateInterfaceInfo.decode = function(decoder) {
var packed;
var val = new UsbAlternateInterfaceInfo();
var numberOfBytes = decoder.readUint32();
var version = decoder.readUint32();
val.alternateSetting = decoder.decodeStruct(codec.Uint8);
val.classCode = decoder.decodeStruct(codec.Uint8);
val.subclassCode = decoder.decodeStruct(codec.Uint8);
val.protocolCode = decoder.decodeStruct(codec.Uint8);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
val.interfaceName = decoder.decodeStructPointer(string16$.String16);
val.endpoints = decoder.decodeArrayPointer(new codec.PointerTo(UsbEndpointInfo));
return val;
};
UsbAlternateInterfaceInfo.encode = function(encoder, val) {
var packed;
encoder.writeUint32(UsbAlternateInterfaceInfo.encodedSize);
encoder.writeUint32(0);
encoder.encodeStruct(codec.Uint8, val.alternateSetting);
encoder.encodeStruct(codec.Uint8, val.classCode);
encoder.encodeStruct(codec.Uint8, val.subclassCode);
encoder.encodeStruct(codec.Uint8, val.protocolCode);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.encodeStructPointer(string16$.String16, val.interfaceName);
encoder.encodeArrayPointer(new codec.PointerTo(UsbEndpointInfo), val.endpoints);
};
function UsbInterfaceInfo(values) {
this.initDefaults_();
this.initFields_(values);
}
UsbInterfaceInfo.prototype.initDefaults_ = function() {
this.interfaceNumber = 0;
this.alternates = null;
};
UsbInterfaceInfo.prototype.initFields_ = function(fields) {
for(var field in fields) {
if (this.hasOwnProperty(field))
this[field] = fields[field];
}
};
UsbInterfaceInfo.validate = function(messageValidator, offset) {
var err;
err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
if (err !== validator.validationError.NONE)
return err;
var kVersionSizes = [
{version: 0, numBytes: 24}
];
err = messageValidator.validateStructVersion(offset, kVersionSizes);
if (err !== validator.validationError.NONE)
return err;
// validate UsbInterfaceInfo.alternates
err = messageValidator.validateArrayPointer(offset + codec.kStructHeaderSize + 8, 8, new codec.PointerTo(UsbAlternateInterfaceInfo), false, [0], 0);
if (err !== validator.validationError.NONE)
return err;
return validator.validationError.NONE;
};
UsbInterfaceInfo.encodedSize = codec.kStructHeaderSize + 16;
UsbInterfaceInfo.decode = function(decoder) {
var packed;
var val = new UsbInterfaceInfo();
var numberOfBytes = decoder.readUint32();
var version = decoder.readUint32();
val.interfaceNumber = decoder.decodeStruct(codec.Uint8);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
val.alternates = decoder.decodeArrayPointer(new codec.PointerTo(UsbAlternateInterfaceInfo));
return val;
};
UsbInterfaceInfo.encode = function(encoder, val) {
var packed;
encoder.writeUint32(UsbInterfaceInfo.encodedSize);
encoder.writeUint32(0);
encoder.encodeStruct(codec.Uint8, val.interfaceNumber);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.encodeArrayPointer(new codec.PointerTo(UsbAlternateInterfaceInfo), val.alternates);
};
function UsbConfigurationInfo(values) {
this.initDefaults_();
this.initFields_(values);
}
UsbConfigurationInfo.prototype.initDefaults_ = function() {
this.configurationValue = 0;
this.configurationName = null;
this.interfaces = null;
};
UsbConfigurationInfo.prototype.initFields_ = function(fields) {
for(var field in fields) {
if (this.hasOwnProperty(field))
this[field] = fields[field];
}
};
UsbConfigurationInfo.validate = function(messageValidator, offset) {
var err;
err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
if (err !== validator.validationError.NONE)
return err;
var kVersionSizes = [
{version: 0, numBytes: 32}
];
err = messageValidator.validateStructVersion(offset, kVersionSizes);
if (err !== validator.validationError.NONE)
return err;
// validate UsbConfigurationInfo.configurationName
err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 8, string16$.String16, true);
if (err !== validator.validationError.NONE)
return err;
// validate UsbConfigurationInfo.interfaces
err = messageValidator.validateArrayPointer(offset + codec.kStructHeaderSize + 16, 8, new codec.PointerTo(UsbInterfaceInfo), false, [0], 0);
if (err !== validator.validationError.NONE)
return err;
return validator.validationError.NONE;
};
UsbConfigurationInfo.encodedSize = codec.kStructHeaderSize + 24;
UsbConfigurationInfo.decode = function(decoder) {
var packed;
var val = new UsbConfigurationInfo();
var numberOfBytes = decoder.readUint32();
var version = decoder.readUint32();
val.configurationValue = decoder.decodeStruct(codec.Uint8);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
val.configurationName = decoder.decodeStructPointer(string16$.String16);
val.interfaces = decoder.decodeArrayPointer(new codec.PointerTo(UsbInterfaceInfo));
return val;
};
UsbConfigurationInfo.encode = function(encoder, val) {
var packed;
encoder.writeUint32(UsbConfigurationInfo.encodedSize);
encoder.writeUint32(0);
encoder.encodeStruct(codec.Uint8, val.configurationValue);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.encodeStructPointer(string16$.String16, val.configurationName);
encoder.encodeArrayPointer(new codec.PointerTo(UsbInterfaceInfo), val.interfaces);
};
function UsbDeviceInfo(values) {
this.initDefaults_();
this.initFields_(values);
}
UsbDeviceInfo.prototype.initDefaults_ = function() {
this.guid = null;
this.usbVersionMajor = 0;
this.usbVersionMinor = 0;
this.usbVersionSubminor = 0;
this.classCode = 0;
this.subclassCode = 0;
this.protocolCode = 0;
this.vendorId = 0;
this.productId = 0;
this.deviceVersionMajor = 0;
this.deviceVersionMinor = 0;
this.deviceVersionSubminor = 0;
this.activeConfiguration = 0;
this.manufacturerName = null;
this.productName = null;
this.serialNumber = null;
this.configurations = null;
};
UsbDeviceInfo.prototype.initFields_ = function(fields) {
for(var field in fields) {
if (this.hasOwnProperty(field))
this[field] = fields[field];
}
};
UsbDeviceInfo.validate = function(messageValidator, offset) {
var err;
err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
if (err !== validator.validationError.NONE)
return err;
var kVersionSizes = [
{version: 0, numBytes: 64}
];
err = messageValidator.validateStructVersion(offset, kVersionSizes);
if (err !== validator.validationError.NONE)
return err;
// validate UsbDeviceInfo.guid
err = messageValidator.validateStringPointer(offset + codec.kStructHeaderSize + 0, false)
if (err !== validator.validationError.NONE)
return err;
// validate UsbDeviceInfo.manufacturerName
err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 24, string16$.String16, true);
if (err !== validator.validationError.NONE)
return err;
// validate UsbDeviceInfo.productName
err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 32, string16$.String16, true);
if (err !== validator.validationError.NONE)
return err;
// validate UsbDeviceInfo.serialNumber
err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 40, string16$.String16, true);
if (err !== validator.validationError.NONE)
return err;
// validate UsbDeviceInfo.configurations
err = messageValidator.validateArrayPointer(offset + codec.kStructHeaderSize + 48, 8, new codec.PointerTo(UsbConfigurationInfo), false, [0], 0);
if (err !== validator.validationError.NONE)
return err;
return validator.validationError.NONE;
};
UsbDeviceInfo.encodedSize = codec.kStructHeaderSize + 56;
UsbDeviceInfo.decode = function(decoder) {
var packed;
var val = new UsbDeviceInfo();
var numberOfBytes = decoder.readUint32();
var version = decoder.readUint32();
val.guid = decoder.decodeStruct(codec.String);
val.usbVersionMajor = decoder.decodeStruct(codec.Uint8);
val.usbVersionMinor = decoder.decodeStruct(codec.Uint8);
val.usbVersionSubminor = decoder.decodeStruct(codec.Uint8);
val.classCode = decoder.decodeStruct(codec.Uint8);
val.subclassCode = decoder.decodeStruct(codec.Uint8);
val.protocolCode = decoder.decodeStruct(codec.Uint8);
val.vendorId = decoder.decodeStruct(codec.Uint16);
val.productId = decoder.decodeStruct(codec.Uint16);
val.deviceVersionMajor = decoder.decodeStruct(codec.Uint8);
val.deviceVersionMinor = decoder.decodeStruct(codec.Uint8);
val.deviceVersionSubminor = decoder.decodeStruct(codec.Uint8);
val.activeConfiguration = decoder.decodeStruct(codec.Uint8);
decoder.skip(1);
decoder.skip(1);
val.manufacturerName = decoder.decodeStructPointer(string16$.String16);
val.productName = decoder.decodeStructPointer(string16$.String16);
val.serialNumber = decoder.decodeStructPointer(string16$.String16);
val.configurations = decoder.decodeArrayPointer(new codec.PointerTo(UsbConfigurationInfo));
return val;
};
UsbDeviceInfo.encode = function(encoder, val) {
var packed;
encoder.writeUint32(UsbDeviceInfo.encodedSize);
encoder.writeUint32(0);
encoder.encodeStruct(codec.String, val.guid);
encoder.encodeStruct(codec.Uint8, val.usbVersionMajor);
encoder.encodeStruct(codec.Uint8, val.usbVersionMinor);
encoder.encodeStruct(codec.Uint8, val.usbVersionSubminor);
encoder.encodeStruct(codec.Uint8, val.classCode);
encoder.encodeStruct(codec.Uint8, val.subclassCode);
encoder.encodeStruct(codec.Uint8, val.protocolCode);
encoder.encodeStruct(codec.Uint16, val.vendorId);
encoder.encodeStruct(codec.Uint16, val.productId);
encoder.encodeStruct(codec.Uint8, val.deviceVersionMajor);
encoder.encodeStruct(codec.Uint8, val.deviceVersionMinor);
encoder.encodeStruct(codec.Uint8, val.deviceVersionSubminor);
encoder.encodeStruct(codec.Uint8, val.activeConfiguration);
encoder.skip(1);
encoder.skip(1);
encoder.encodeStructPointer(string16$.String16, val.manufacturerName);
encoder.encodeStructPointer(string16$.String16, val.productName);
encoder.encodeStructPointer(string16$.String16, val.serialNumber);
encoder.encodeArrayPointer(new codec.PointerTo(UsbConfigurationInfo), val.configurations);
};
function UsbControlTransferParams(values) {
this.initDefaults_();
this.initFields_(values);
}
UsbControlTransferParams.prototype.initDefaults_ = function() {
this.type = 0;
this.recipient = 0;
this.request = 0;
this.value = 0;
this.index = 0;
};
UsbControlTransferParams.prototype.initFields_ = function(fields) {
for(var field in fields) {
if (this.hasOwnProperty(field))
this[field] = fields[field];
}
};
UsbControlTransferParams.validate = function(messageValidator, offset) {
var err;
err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
if (err !== validator.validationError.NONE)
return err;
var kVersionSizes = [
{version: 0, numBytes: 24}
];
err = messageValidator.validateStructVersion(offset, kVersionSizes);
if (err !== validator.validationError.NONE)
return err;
// validate UsbControlTransferParams.type
err = messageValidator.validateEnum(offset + codec.kStructHeaderSize + 0, UsbControlTransferType);
if (err !== validator.validationError.NONE)
return err;
// validate UsbControlTransferParams.recipient
err = messageValidator.validateEnum(offset + codec.kStructHeaderSize + 4, UsbControlTransferRecipient);
if (err !== validator.validationError.NONE)
return err;
return validator.validationError.NONE;
};
UsbControlTransferParams.encodedSize = codec.kStructHeaderSize + 16;
UsbControlTransferParams.decode = function(decoder) {
var packed;
var val = new UsbControlTransferParams();
var numberOfBytes = decoder.readUint32();
var version = decoder.readUint32();
val.type = decoder.decodeStruct(codec.Int32);
val.recipient = decoder.decodeStruct(codec.Int32);
val.request = decoder.decodeStruct(codec.Uint8);
decoder.skip(1);
val.value = decoder.decodeStruct(codec.Uint16);
val.index = decoder.decodeStruct(codec.Uint16);
decoder.skip(1);
decoder.skip(1);
return val;
};
UsbControlTransferParams.encode = function(encoder, val) {
var packed;
encoder.writeUint32(UsbControlTransferParams.encodedSize);
encoder.writeUint32(0);
encoder.encodeStruct(codec.Int32, val.type);
encoder.encodeStruct(codec.Int32, val.recipient);
encoder.encodeStruct(codec.Uint8, val.request);
encoder.skip(1);
encoder.encodeStruct(codec.Uint16, val.value);
encoder.encodeStruct(codec.Uint16, val.index);
encoder.skip(1);
encoder.skip(1);
};
function UsbIsochronousPacket(values) {
this.initDefaults_();
this.initFields_(values);
}
UsbIsochronousPacket.prototype.initDefaults_ = function() {
this.length = 0;
this.transferredLength = 0;
this.status = 0;
};
UsbIsochronousPacket.prototype.initFields_ = function(fields) {
for(var field in fields) {
if (this.hasOwnProperty(field))
this[field] = fields[field];
}
};
UsbIsochronousPacket.validate = function(messageValidator, offset) {
var err;
err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
if (err !== validator.validationError.NONE)
return err;
var kVersionSizes = [
{version: 0, numBytes: 24}
];
err = messageValidator.validateStructVersion(offset, kVersionSizes);
if (err !== validator.validationError.NONE)
return err;
// validate UsbIsochronousPacket.status
err = messageValidator.validateEnum(offset + codec.kStructHeaderSize + 8, UsbTransferStatus);
if (err !== validator.validationError.NONE)
return err;
return validator.validationError.NONE;
};
UsbIsochronousPacket.encodedSize = codec.kStructHeaderSize + 16;
UsbIsochronousPacket.decode = function(decoder) {
var packed;
var val = new UsbIsochronousPacket();
var numberOfBytes = decoder.readUint32();
var version = decoder.readUint32();
val.length = decoder.decodeStruct(codec.Uint32);
val.transferredLength = decoder.decodeStruct(codec.Uint32);
val.status = decoder.decodeStruct(codec.Int32);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
return val;
};
UsbIsochronousPacket.encode = function(encoder, val) {
var packed;
encoder.writeUint32(UsbIsochronousPacket.encodedSize);
encoder.writeUint32(0);
encoder.encodeStruct(codec.Uint32, val.length);
encoder.encodeStruct(codec.Uint32, val.transferredLength);
encoder.encodeStruct(codec.Int32, val.status);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
};
function UsbDevice_Open_Params(values) {
this.initDefaults_();
this.initFields_(values);
}
UsbDevice_Open_Params.prototype.initDefaults_ = function() {
};
UsbDevice_Open_Params.prototype.initFields_ = function(fields) {
for(var field in fields) {
if (this.hasOwnProperty(field))
this[field] = fields[field];
}
};
UsbDevice_Open_Params.validate = function(messageValidator, offset) {
var err;
err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
if (err !== validator.validationError.NONE)
return err;
var kVersionSizes = [
{version: 0, numBytes: 8}
];
err = messageValidator.validateStructVersion(offset, kVersionSizes);
if (err !== validator.validationError.NONE)
return err;
return validator.validationError.NONE;
};
UsbDevice_Open_Params.encodedSize = codec.kStructHeaderSize + 0;
UsbDevice_Open_Params.decode = function(decoder) {
var packed;
var val = new UsbDevice_Open_Params();
var numberOfBytes = decoder.readUint32();
var version = decoder.readUint32();
return val;
};
UsbDevice_Open_Params.encode = function(encoder, val) {
var packed;
encoder.writeUint32(UsbDevice_Open_Params.encodedSize);
encoder.writeUint32(0);
};
function UsbDevice_Open_ResponseParams(values) {
this.initDefaults_();
this.initFields_(values);
}
UsbDevice_Open_ResponseParams.prototype.initDefaults_ = function() {
this.error = 0;
};
UsbDevice_Open_ResponseParams.prototype.initFields_ = function(fields) {
for(var field in fields) {
if (this.hasOwnProperty(field))
this[field] = fields[field];
}
};
UsbDevice_Open_ResponseParams.validate = function(messageValidator, offset) {
var err;
err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
if (err !== validator.validationError.NONE)
return err;
var kVersionSizes = [
{version: 0, numBytes: 16}
];
err = messageValidator.validateStructVersion(offset, kVersionSizes);
if (err !== validator.validationError.NONE)
return err;
// validate UsbDevice_Open_ResponseParams.error
err = messageValidator.validateEnum(offset + codec.kStructHeaderSize + 0, UsbOpenDeviceError);
if (err !== validator.validationError.NONE)
return err;
return validator.validationError.NONE;
};
UsbDevice_Open_ResponseParams.encodedSize = codec.kStructHeaderSize + 8;
UsbDevice_Open_ResponseParams.decode = function(decoder) {
var packed;
var val = new UsbDevice_Open_ResponseParams();
var numberOfBytes = decoder.readUint32();
var version = decoder.readUint32();
val.error = decoder.decodeStruct(codec.Int32);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
return val;
};
UsbDevice_Open_ResponseParams.encode = function(encoder, val) {
var packed;
encoder.writeUint32(UsbDevice_Open_ResponseParams.encodedSize);
encoder.writeUint32(0);
encoder.encodeStruct(codec.Int32, val.error);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
};
function UsbDevice_Close_Params(values) {
this.initDefaults_();
this.initFields_(values);
}
UsbDevice_Close_Params.prototype.initDefaults_ = function() {
};
UsbDevice_Close_Params.prototype.initFields_ = function(fields) {
for(var field in fields) {
if (this.hasOwnProperty(field))
this[field] = fields[field];
}
};
UsbDevice_Close_Params.validate = function(messageValidator, offset) {
var err;
err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
if (err !== validator.validationError.NONE)
return err;
var kVersionSizes = [
{version: 0, numBytes: 8}
];
err = messageValidator.validateStructVersion(offset, kVersionSizes);
if (err !== validator.validationError.NONE)
return err;
return validator.validationError.NONE;
};
UsbDevice_Close_Params.encodedSize = codec.kStructHeaderSize + 0;
UsbDevice_Close_Params.decode = function(decoder) {
var packed;
var val = new UsbDevice_Close_Params();
var numberOfBytes = decoder.readUint32();
var version = decoder.readUint32();
return val;
};
UsbDevice_Close_Params.encode = function(encoder, val) {
var packed;
encoder.writeUint32(UsbDevice_Close_Params.encodedSize);
encoder.writeUint32(0);
};
function UsbDevice_Close_ResponseParams(values) {
this.initDefaults_();
this.initFields_(values);
}
UsbDevice_Close_ResponseParams.prototype.initDefaults_ = function() {
};
UsbDevice_Close_ResponseParams.prototype.initFields_ = function(fields) {
for(var field in fields) {
if (this.hasOwnProperty(field))
this[field] = fields[field];
}
};
UsbDevice_Close_ResponseParams.validate = function(messageValidator, offset) {
var err;
err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
if (err !== validator.validationError.NONE)
return err;
var kVersionSizes = [
{version: 0, numBytes: 8}
];
err = messageValidator.validateStructVersion(offset, kVersionSizes);
if (err !== validator.validationError.NONE)
return err;
return validator.validationError.NONE;
};
UsbDevice_Close_ResponseParams.encodedSize = codec.kStructHeaderSize + 0;
UsbDevice_Close_ResponseParams.decode = function(decoder) {
var packed;
var val = new UsbDevice_Close_ResponseParams();
var numberOfBytes = decoder.readUint32();
var version = decoder.readUint32();
return val;
};
UsbDevice_Close_ResponseParams.encode = function(encoder, val) {
var packed;
encoder.writeUint32(UsbDevice_Close_ResponseParams.encodedSize);
encoder.writeUint32(0);
};
function UsbDevice_SetConfiguration_Params(values) {
this.initDefaults_();
this.initFields_(values);
}
UsbDevice_SetConfiguration_Params.prototype.initDefaults_ = function() {
this.value = 0;
};
UsbDevice_SetConfiguration_Params.prototype.initFields_ = function(fields) {
for(var field in fields) {
if (this.hasOwnProperty(field))
this[field] = fields[field];
}
};
UsbDevice_SetConfiguration_Params.validate = function(messageValidator, offset) {
var err;
err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
if (err !== validator.validationError.NONE)
return err;
var kVersionSizes = [
{version: 0, numBytes: 16}
];
err = messageValidator.validateStructVersion(offset, kVersionSizes);
if (err !== validator.validationError.NONE)
return err;
return validator.validationError.NONE;
};
UsbDevice_SetConfiguration_Params.encodedSize = codec.kStructHeaderSize + 8;
UsbDevice_SetConfiguration_Params.decode = function(decoder) {
var packed;
var val = new UsbDevice_SetConfiguration_Params();
var numberOfBytes = decoder.readUint32();
var version = decoder.readUint32();
val.value = decoder.decodeStruct(codec.Uint8);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
return val;
};
UsbDevice_SetConfiguration_Params.encode = function(encoder, val) {
var packed;
encoder.writeUint32(UsbDevice_SetConfiguration_Params.encodedSize);
encoder.writeUint32(0);
encoder.encodeStruct(codec.Uint8, val.value);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
};
function UsbDevice_SetConfiguration_ResponseParams(values) {
this.initDefaults_();
this.initFields_(values);
}
UsbDevice_SetConfiguration_ResponseParams.prototype.initDefaults_ = function() {
this.success = false;
};
UsbDevice_SetConfiguration_ResponseParams.prototype.initFields_ = function(fields) {
for(var field in fields) {
if (this.hasOwnProperty(field))
this[field] = fields[field];
}
};
UsbDevice_SetConfiguration_ResponseParams.validate = function(messageValidator, offset) {
var err;
err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
if (err !== validator.validationError.NONE)
return err;
var kVersionSizes = [
{version: 0, numBytes: 16}
];
err = messageValidator.validateStructVersion(offset, kVersionSizes);
if (err !== validator.validationError.NONE)
return err;
return validator.validationError.NONE;
};
UsbDevice_SetConfiguration_ResponseParams.encodedSize = codec.kStructHeaderSize + 8;
UsbDevice_SetConfiguration_ResponseParams.decode = function(decoder) {
var packed;
var val = new UsbDevice_SetConfiguration_ResponseParams();
var numberOfBytes = decoder.readUint32();
var version = decoder.readUint32();
packed = decoder.readUint8();
val.success = (packed >> 0) & 1 ? true : false;
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
return val;
};
UsbDevice_SetConfiguration_ResponseParams.encode = function(encoder, val) {
var packed;
encoder.writeUint32(UsbDevice_SetConfiguration_ResponseParams.encodedSize);
encoder.writeUint32(0);
packed = 0;
packed |= (val.success & 1) << 0
encoder.writeUint8(packed);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
};
function UsbDevice_ClaimInterface_Params(values) {
this.initDefaults_();
this.initFields_(values);
}
UsbDevice_ClaimInterface_Params.prototype.initDefaults_ = function() {
this.interfaceNumber = 0;
};
UsbDevice_ClaimInterface_Params.prototype.initFields_ = function(fields) {
for(var field in fields) {
if (this.hasOwnProperty(field))
this[field] = fields[field];
}
};
UsbDevice_ClaimInterface_Params.validate = function(messageValidator, offset) {
var err;
err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
if (err !== validator.validationError.NONE)
return err;
var kVersionSizes = [
{version: 0, numBytes: 16}
];
err = messageValidator.validateStructVersion(offset, kVersionSizes);
if (err !== validator.validationError.NONE)
return err;
return validator.validationError.NONE;
};
UsbDevice_ClaimInterface_Params.encodedSize = codec.kStructHeaderSize + 8;
UsbDevice_ClaimInterface_Params.decode = function(decoder) {
var packed;
var val = new UsbDevice_ClaimInterface_Params();
var numberOfBytes = decoder.readUint32();
var version = decoder.readUint32();
val.interfaceNumber = decoder.decodeStruct(codec.Uint8);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
return val;
};
UsbDevice_ClaimInterface_Params.encode = function(encoder, val) {
var packed;
encoder.writeUint32(UsbDevice_ClaimInterface_Params.encodedSize);
encoder.writeUint32(0);
encoder.encodeStruct(codec.Uint8, val.interfaceNumber);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
};
function UsbDevice_ClaimInterface_ResponseParams(values) {
this.initDefaults_();
this.initFields_(values);
}
UsbDevice_ClaimInterface_ResponseParams.prototype.initDefaults_ = function() {
this.success = false;
};
UsbDevice_ClaimInterface_ResponseParams.prototype.initFields_ = function(fields) {
for(var field in fields) {
if (this.hasOwnProperty(field))
this[field] = fields[field];
}
};
UsbDevice_ClaimInterface_ResponseParams.validate = function(messageValidator, offset) {
var err;
err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
if (err !== validator.validationError.NONE)
return err;
var kVersionSizes = [
{version: 0, numBytes: 16}
];
err = messageValidator.validateStructVersion(offset, kVersionSizes);
if (err !== validator.validationError.NONE)
return err;
return validator.validationError.NONE;
};
UsbDevice_ClaimInterface_ResponseParams.encodedSize = codec.kStructHeaderSize + 8;
UsbDevice_ClaimInterface_ResponseParams.decode = function(decoder) {
var packed;
var val = new UsbDevice_ClaimInterface_ResponseParams();
var numberOfBytes = decoder.readUint32();
var version = decoder.readUint32();
packed = decoder.readUint8();
val.success = (packed >> 0) & 1 ? true : false;
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
return val;
};
UsbDevice_ClaimInterface_ResponseParams.encode = function(encoder, val) {
var packed;
encoder.writeUint32(UsbDevice_ClaimInterface_ResponseParams.encodedSize);
encoder.writeUint32(0);
packed = 0;
packed |= (val.success & 1) << 0
encoder.writeUint8(packed);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
};
function UsbDevice_ReleaseInterface_Params(values) {
this.initDefaults_();
this.initFields_(values);
}
UsbDevice_ReleaseInterface_Params.prototype.initDefaults_ = function() {
this.interfaceNumber = 0;
};
UsbDevice_ReleaseInterface_Params.prototype.initFields_ = function(fields) {
for(var field in fields) {
if (this.hasOwnProperty(field))
this[field] = fields[field];
}
};
UsbDevice_ReleaseInterface_Params.validate = function(messageValidator, offset) {
var err;
err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
if (err !== validator.validationError.NONE)
return err;
var kVersionSizes = [
{version: 0, numBytes: 16}
];
err = messageValidator.validateStructVersion(offset, kVersionSizes);
if (err !== validator.validationError.NONE)
return err;
return validator.validationError.NONE;
};
UsbDevice_ReleaseInterface_Params.encodedSize = codec.kStructHeaderSize + 8;
UsbDevice_ReleaseInterface_Params.decode = function(decoder) {
var packed;
var val = new UsbDevice_ReleaseInterface_Params();
var numberOfBytes = decoder.readUint32();
var version = decoder.readUint32();
val.interfaceNumber = decoder.decodeStruct(codec.Uint8);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
return val;
};
UsbDevice_ReleaseInterface_Params.encode = function(encoder, val) {
var packed;
encoder.writeUint32(UsbDevice_ReleaseInterface_Params.encodedSize);
encoder.writeUint32(0);
encoder.encodeStruct(codec.Uint8, val.interfaceNumber);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
};
function UsbDevice_ReleaseInterface_ResponseParams(values) {
this.initDefaults_();
this.initFields_(values);
}
UsbDevice_ReleaseInterface_ResponseParams.prototype.initDefaults_ = function() {
this.success = false;
};
UsbDevice_ReleaseInterface_ResponseParams.prototype.initFields_ = function(fields) {
for(var field in fields) {
if (this.hasOwnProperty(field))
this[field] = fields[field];
}
};
UsbDevice_ReleaseInterface_ResponseParams.validate = function(messageValidator, offset) {
var err;
err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
if (err !== validator.validationError.NONE)
return err;
var kVersionSizes = [
{version: 0, numBytes: 16}
];
err = messageValidator.validateStructVersion(offset, kVersionSizes);
if (err !== validator.validationError.NONE)
return err;
return validator.validationError.NONE;
};
UsbDevice_ReleaseInterface_ResponseParams.encodedSize = codec.kStructHeaderSize + 8;
UsbDevice_ReleaseInterface_ResponseParams.decode = function(decoder) {
var packed;
var val = new UsbDevice_ReleaseInterface_ResponseParams();
var numberOfBytes = decoder.readUint32();
var version = decoder.readUint32();
packed = decoder.readUint8();
val.success = (packed >> 0) & 1 ? true : false;
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
return val;
};
UsbDevice_ReleaseInterface_ResponseParams.encode = function(encoder, val) {
var packed;
encoder.writeUint32(UsbDevice_ReleaseInterface_ResponseParams.encodedSize);
encoder.writeUint32(0);
packed = 0;
packed |= (val.success & 1) << 0
encoder.writeUint8(packed);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
};
function UsbDevice_SetInterfaceAlternateSetting_Params(values) {
this.initDefaults_();
this.initFields_(values);
}
UsbDevice_SetInterfaceAlternateSetting_Params.prototype.initDefaults_ = function() {
this.interfaceNumber = 0;
this.alternateSetting = 0;
};
UsbDevice_SetInterfaceAlternateSetting_Params.prototype.initFields_ = function(fields) {
for(var field in fields) {
if (this.hasOwnProperty(field))
this[field] = fields[field];
}
};
UsbDevice_SetInterfaceAlternateSetting_Params.validate = function(messageValidator, offset) {
var err;
err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
if (err !== validator.validationError.NONE)
return err;
var kVersionSizes = [
{version: 0, numBytes: 16}
];
err = messageValidator.validateStructVersion(offset, kVersionSizes);
if (err !== validator.validationError.NONE)
return err;
return validator.validationError.NONE;
};
UsbDevice_SetInterfaceAlternateSetting_Params.encodedSize = codec.kStructHeaderSize + 8;
UsbDevice_SetInterfaceAlternateSetting_Params.decode = function(decoder) {
var packed;
var val = new UsbDevice_SetInterfaceAlternateSetting_Params();
var numberOfBytes = decoder.readUint32();
var version = decoder.readUint32();
val.interfaceNumber = decoder.decodeStruct(codec.Uint8);
val.alternateSetting = decoder.decodeStruct(codec.Uint8);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
return val;
};
UsbDevice_SetInterfaceAlternateSetting_Params.encode = function(encoder, val) {
var packed;
encoder.writeUint32(UsbDevice_SetInterfaceAlternateSetting_Params.encodedSize);
encoder.writeUint32(0);
encoder.encodeStruct(codec.Uint8, val.interfaceNumber);
encoder.encodeStruct(codec.Uint8, val.alternateSetting);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
};
function UsbDevice_SetInterfaceAlternateSetting_ResponseParams(values) {
this.initDefaults_();
this.initFields_(values);
}
UsbDevice_SetInterfaceAlternateSetting_ResponseParams.prototype.initDefaults_ = function() {
this.success = false;
};
UsbDevice_SetInterfaceAlternateSetting_ResponseParams.prototype.initFields_ = function(fields) {
for(var field in fields) {
if (this.hasOwnProperty(field))
this[field] = fields[field];
}
};
UsbDevice_SetInterfaceAlternateSetting_ResponseParams.validate = function(messageValidator, offset) {
var err;
err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
if (err !== validator.validationError.NONE)
return err;
var kVersionSizes = [
{version: 0, numBytes: 16}
];
err = messageValidator.validateStructVersion(offset, kVersionSizes);
if (err !== validator.validationError.NONE)
return err;
return validator.validationError.NONE;
};
UsbDevice_SetInterfaceAlternateSetting_ResponseParams.encodedSize = codec.kStructHeaderSize + 8;
UsbDevice_SetInterfaceAlternateSetting_ResponseParams.decode = function(decoder) {
var packed;
var val = new UsbDevice_SetInterfaceAlternateSetting_ResponseParams();
var numberOfBytes = decoder.readUint32();
var version = decoder.readUint32();
packed = decoder.readUint8();
val.success = (packed >> 0) & 1 ? true : false;
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
return val;
};
UsbDevice_SetInterfaceAlternateSetting_ResponseParams.encode = function(encoder, val) {
var packed;
encoder.writeUint32(UsbDevice_SetInterfaceAlternateSetting_ResponseParams.encodedSize);
encoder.writeUint32(0);
packed = 0;
packed |= (val.success & 1) << 0
encoder.writeUint8(packed);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
};
function UsbDevice_Reset_Params(values) {
this.initDefaults_();
this.initFields_(values);
}
UsbDevice_Reset_Params.prototype.initDefaults_ = function() {
};
UsbDevice_Reset_Params.prototype.initFields_ = function(fields) {
for(var field in fields) {
if (this.hasOwnProperty(field))
this[field] = fields[field];
}
};
UsbDevice_Reset_Params.validate = function(messageValidator, offset) {
var err;
err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
if (err !== validator.validationError.NONE)
return err;
var kVersionSizes = [
{version: 0, numBytes: 8}
];
err = messageValidator.validateStructVersion(offset, kVersionSizes);
if (err !== validator.validationError.NONE)
return err;
return validator.validationError.NONE;
};
UsbDevice_Reset_Params.encodedSize = codec.kStructHeaderSize + 0;
UsbDevice_Reset_Params.decode = function(decoder) {
var packed;
var val = new UsbDevice_Reset_Params();
var numberOfBytes = decoder.readUint32();
var version = decoder.readUint32();
return val;
};
UsbDevice_Reset_Params.encode = function(encoder, val) {
var packed;
encoder.writeUint32(UsbDevice_Reset_Params.encodedSize);
encoder.writeUint32(0);
};
function UsbDevice_Reset_ResponseParams(values) {
this.initDefaults_();
this.initFields_(values);
}
UsbDevice_Reset_ResponseParams.prototype.initDefaults_ = function() {
this.success = false;
};
UsbDevice_Reset_ResponseParams.prototype.initFields_ = function(fields) {
for(var field in fields) {
if (this.hasOwnProperty(field))
this[field] = fields[field];
}
};
UsbDevice_Reset_ResponseParams.validate = function(messageValidator, offset) {
var err;
err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
if (err !== validator.validationError.NONE)
return err;
var kVersionSizes = [
{version: 0, numBytes: 16}
];
err = messageValidator.validateStructVersion(offset, kVersionSizes);
if (err !== validator.validationError.NONE)
return err;
return validator.validationError.NONE;
};
UsbDevice_Reset_ResponseParams.encodedSize = codec.kStructHeaderSize + 8;
UsbDevice_Reset_ResponseParams.decode = function(decoder) {
var packed;
var val = new UsbDevice_Reset_ResponseParams();
var numberOfBytes = decoder.readUint32();
var version = decoder.readUint32();
packed = decoder.readUint8();
val.success = (packed >> 0) & 1 ? true : false;
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
return val;
};
UsbDevice_Reset_ResponseParams.encode = function(encoder, val) {
var packed;
encoder.writeUint32(UsbDevice_Reset_ResponseParams.encodedSize);
encoder.writeUint32(0);
packed = 0;
packed |= (val.success & 1) << 0
encoder.writeUint8(packed);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
};
function UsbDevice_ClearHalt_Params(values) {
this.initDefaults_();
this.initFields_(values);
}
UsbDevice_ClearHalt_Params.prototype.initDefaults_ = function() {
this.endpoint = 0;
};
UsbDevice_ClearHalt_Params.prototype.initFields_ = function(fields) {
for(var field in fields) {
if (this.hasOwnProperty(field))
this[field] = fields[field];
}
};
UsbDevice_ClearHalt_Params.validate = function(messageValidator, offset) {
var err;
err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
if (err !== validator.validationError.NONE)
return err;
var kVersionSizes = [
{version: 0, numBytes: 16}
];
err = messageValidator.validateStructVersion(offset, kVersionSizes);
if (err !== validator.validationError.NONE)
return err;
return validator.validationError.NONE;
};
UsbDevice_ClearHalt_Params.encodedSize = codec.kStructHeaderSize + 8;
UsbDevice_ClearHalt_Params.decode = function(decoder) {
var packed;
var val = new UsbDevice_ClearHalt_Params();
var numberOfBytes = decoder.readUint32();
var version = decoder.readUint32();
val.endpoint = decoder.decodeStruct(codec.Uint8);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
return val;
};
UsbDevice_ClearHalt_Params.encode = function(encoder, val) {
var packed;
encoder.writeUint32(UsbDevice_ClearHalt_Params.encodedSize);
encoder.writeUint32(0);
encoder.encodeStruct(codec.Uint8, val.endpoint);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
};
function UsbDevice_ClearHalt_ResponseParams(values) {
this.initDefaults_();
this.initFields_(values);
}
UsbDevice_ClearHalt_ResponseParams.prototype.initDefaults_ = function() {
this.success = false;
};
UsbDevice_ClearHalt_ResponseParams.prototype.initFields_ = function(fields) {
for(var field in fields) {
if (this.hasOwnProperty(field))
this[field] = fields[field];
}
};
UsbDevice_ClearHalt_ResponseParams.validate = function(messageValidator, offset) {
var err;
err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
if (err !== validator.validationError.NONE)
return err;
var kVersionSizes = [
{version: 0, numBytes: 16}
];
err = messageValidator.validateStructVersion(offset, kVersionSizes);
if (err !== validator.validationError.NONE)
return err;
return validator.validationError.NONE;
};
UsbDevice_ClearHalt_ResponseParams.encodedSize = codec.kStructHeaderSize + 8;
UsbDevice_ClearHalt_ResponseParams.decode = function(decoder) {
var packed;
var val = new UsbDevice_ClearHalt_ResponseParams();
var numberOfBytes = decoder.readUint32();
var version = decoder.readUint32();
packed = decoder.readUint8();
val.success = (packed >> 0) & 1 ? true : false;
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
return val;
};
UsbDevice_ClearHalt_ResponseParams.encode = function(encoder, val) {
var packed;
encoder.writeUint32(UsbDevice_ClearHalt_ResponseParams.encodedSize);
encoder.writeUint32(0);
packed = 0;
packed |= (val.success & 1) << 0
encoder.writeUint8(packed);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
};
function UsbDevice_ControlTransferIn_Params(values) {
this.initDefaults_();
this.initFields_(values);
}
UsbDevice_ControlTransferIn_Params.prototype.initDefaults_ = function() {
this.params = null;
this.length = 0;
this.timeout = 0;
};
UsbDevice_ControlTransferIn_Params.prototype.initFields_ = function(fields) {
for(var field in fields) {
if (this.hasOwnProperty(field))
this[field] = fields[field];
}
};
UsbDevice_ControlTransferIn_Params.validate = function(messageValidator, offset) {
var err;
err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
if (err !== validator.validationError.NONE)
return err;
var kVersionSizes = [
{version: 0, numBytes: 24}
];
err = messageValidator.validateStructVersion(offset, kVersionSizes);
if (err !== validator.validationError.NONE)
return err;
// validate UsbDevice_ControlTransferIn_Params.params
err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 0, UsbControlTransferParams, false);
if (err !== validator.validationError.NONE)
return err;
return validator.validationError.NONE;
};
UsbDevice_ControlTransferIn_Params.encodedSize = codec.kStructHeaderSize + 16;
UsbDevice_ControlTransferIn_Params.decode = function(decoder) {
var packed;
var val = new UsbDevice_ControlTransferIn_Params();
var numberOfBytes = decoder.readUint32();
var version = decoder.readUint32();
val.params = decoder.decodeStructPointer(UsbControlTransferParams);
val.length = decoder.decodeStruct(codec.Uint32);
val.timeout = decoder.decodeStruct(codec.Uint32);
return val;
};
UsbDevice_ControlTransferIn_Params.encode = function(encoder, val) {
var packed;
encoder.writeUint32(UsbDevice_ControlTransferIn_Params.encodedSize);
encoder.writeUint32(0);
encoder.encodeStructPointer(UsbControlTransferParams, val.params);
encoder.encodeStruct(codec.Uint32, val.length);
encoder.encodeStruct(codec.Uint32, val.timeout);
};
function UsbDevice_ControlTransferIn_ResponseParams(values) {
this.initDefaults_();
this.initFields_(values);
}
UsbDevice_ControlTransferIn_ResponseParams.prototype.initDefaults_ = function() {
this.status = 0;
this.data = null;
};
UsbDevice_ControlTransferIn_ResponseParams.prototype.initFields_ = function(fields) {
for(var field in fields) {
if (this.hasOwnProperty(field))
this[field] = fields[field];
}
};
UsbDevice_ControlTransferIn_ResponseParams.validate = function(messageValidator, offset) {
var err;
err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
if (err !== validator.validationError.NONE)
return err;
var kVersionSizes = [
{version: 0, numBytes: 24}
];
err = messageValidator.validateStructVersion(offset, kVersionSizes);
if (err !== validator.validationError.NONE)
return err;
// validate UsbDevice_ControlTransferIn_ResponseParams.status
err = messageValidator.validateEnum(offset + codec.kStructHeaderSize + 0, UsbTransferStatus);
if (err !== validator.validationError.NONE)
return err;
// validate UsbDevice_ControlTransferIn_ResponseParams.data
err = messageValidator.validateArrayPointer(offset + codec.kStructHeaderSize + 8, 1, codec.Uint8, false, [0], 0);
if (err !== validator.validationError.NONE)
return err;
return validator.validationError.NONE;
};
UsbDevice_ControlTransferIn_ResponseParams.encodedSize = codec.kStructHeaderSize + 16;
UsbDevice_ControlTransferIn_ResponseParams.decode = function(decoder) {
var packed;
var val = new UsbDevice_ControlTransferIn_ResponseParams();
var numberOfBytes = decoder.readUint32();
var version = decoder.readUint32();
val.status = decoder.decodeStruct(codec.Int32);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
val.data = decoder.decodeArrayPointer(codec.Uint8);
return val;
};
UsbDevice_ControlTransferIn_ResponseParams.encode = function(encoder, val) {
var packed;
encoder.writeUint32(UsbDevice_ControlTransferIn_ResponseParams.encodedSize);
encoder.writeUint32(0);
encoder.encodeStruct(codec.Int32, val.status);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.encodeArrayPointer(codec.Uint8, val.data);
};
function UsbDevice_ControlTransferOut_Params(values) {
this.initDefaults_();
this.initFields_(values);
}
UsbDevice_ControlTransferOut_Params.prototype.initDefaults_ = function() {
this.params = null;
this.data = null;
this.timeout = 0;
};
UsbDevice_ControlTransferOut_Params.prototype.initFields_ = function(fields) {
for(var field in fields) {
if (this.hasOwnProperty(field))
this[field] = fields[field];
}
};
UsbDevice_ControlTransferOut_Params.validate = function(messageValidator, offset) {
var err;
err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
if (err !== validator.validationError.NONE)
return err;
var kVersionSizes = [
{version: 0, numBytes: 32}
];
err = messageValidator.validateStructVersion(offset, kVersionSizes);
if (err !== validator.validationError.NONE)
return err;
// validate UsbDevice_ControlTransferOut_Params.params
err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 0, UsbControlTransferParams, false);
if (err !== validator.validationError.NONE)
return err;
// validate UsbDevice_ControlTransferOut_Params.data
err = messageValidator.validateArrayPointer(offset + codec.kStructHeaderSize + 8, 1, codec.Uint8, false, [0], 0);
if (err !== validator.validationError.NONE)
return err;
return validator.validationError.NONE;
};
UsbDevice_ControlTransferOut_Params.encodedSize = codec.kStructHeaderSize + 24;
UsbDevice_ControlTransferOut_Params.decode = function(decoder) {
var packed;
var val = new UsbDevice_ControlTransferOut_Params();
var numberOfBytes = decoder.readUint32();
var version = decoder.readUint32();
val.params = decoder.decodeStructPointer(UsbControlTransferParams);
val.data = decoder.decodeArrayPointer(codec.Uint8);
val.timeout = decoder.decodeStruct(codec.Uint32);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
return val;
};
UsbDevice_ControlTransferOut_Params.encode = function(encoder, val) {
var packed;
encoder.writeUint32(UsbDevice_ControlTransferOut_Params.encodedSize);
encoder.writeUint32(0);
encoder.encodeStructPointer(UsbControlTransferParams, val.params);
encoder.encodeArrayPointer(codec.Uint8, val.data);
encoder.encodeStruct(codec.Uint32, val.timeout);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
};
function UsbDevice_ControlTransferOut_ResponseParams(values) {
this.initDefaults_();
this.initFields_(values);
}
UsbDevice_ControlTransferOut_ResponseParams.prototype.initDefaults_ = function() {
this.status = 0;
};
UsbDevice_ControlTransferOut_ResponseParams.prototype.initFields_ = function(fields) {
for(var field in fields) {
if (this.hasOwnProperty(field))
this[field] = fields[field];
}
};
UsbDevice_ControlTransferOut_ResponseParams.validate = function(messageValidator, offset) {
var err;
err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
if (err !== validator.validationError.NONE)
return err;
var kVersionSizes = [
{version: 0, numBytes: 16}
];
err = messageValidator.validateStructVersion(offset, kVersionSizes);
if (err !== validator.validationError.NONE)
return err;
// validate UsbDevice_ControlTransferOut_ResponseParams.status
err = messageValidator.validateEnum(offset + codec.kStructHeaderSize + 0, UsbTransferStatus);
if (err !== validator.validationError.NONE)
return err;
return validator.validationError.NONE;
};
UsbDevice_ControlTransferOut_ResponseParams.encodedSize = codec.kStructHeaderSize + 8;
UsbDevice_ControlTransferOut_ResponseParams.decode = function(decoder) {
var packed;
var val = new UsbDevice_ControlTransferOut_ResponseParams();
var numberOfBytes = decoder.readUint32();
var version = decoder.readUint32();
val.status = decoder.decodeStruct(codec.Int32);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
return val;
};
UsbDevice_ControlTransferOut_ResponseParams.encode = function(encoder, val) {
var packed;
encoder.writeUint32(UsbDevice_ControlTransferOut_ResponseParams.encodedSize);
encoder.writeUint32(0);
encoder.encodeStruct(codec.Int32, val.status);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
};
function UsbDevice_GenericTransferIn_Params(values) {
this.initDefaults_();
this.initFields_(values);
}
UsbDevice_GenericTransferIn_Params.prototype.initDefaults_ = function() {
this.endpointNumber = 0;
this.length = 0;
this.timeout = 0;
};
UsbDevice_GenericTransferIn_Params.prototype.initFields_ = function(fields) {
for(var field in fields) {
if (this.hasOwnProperty(field))
this[field] = fields[field];
}
};
UsbDevice_GenericTransferIn_Params.validate = function(messageValidator, offset) {
var err;
err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
if (err !== validator.validationError.NONE)
return err;
var kVersionSizes = [
{version: 0, numBytes: 24}
];
err = messageValidator.validateStructVersion(offset, kVersionSizes);
if (err !== validator.validationError.NONE)
return err;
return validator.validationError.NONE;
};
UsbDevice_GenericTransferIn_Params.encodedSize = codec.kStructHeaderSize + 16;
UsbDevice_GenericTransferIn_Params.decode = function(decoder) {
var packed;
var val = new UsbDevice_GenericTransferIn_Params();
var numberOfBytes = decoder.readUint32();
var version = decoder.readUint32();
val.endpointNumber = decoder.decodeStruct(codec.Uint8);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
val.length = decoder.decodeStruct(codec.Uint32);
val.timeout = decoder.decodeStruct(codec.Uint32);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
return val;
};
UsbDevice_GenericTransferIn_Params.encode = function(encoder, val) {
var packed;
encoder.writeUint32(UsbDevice_GenericTransferIn_Params.encodedSize);
encoder.writeUint32(0);
encoder.encodeStruct(codec.Uint8, val.endpointNumber);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.encodeStruct(codec.Uint32, val.length);
encoder.encodeStruct(codec.Uint32, val.timeout);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
};
function UsbDevice_GenericTransferIn_ResponseParams(values) {
this.initDefaults_();
this.initFields_(values);
}
UsbDevice_GenericTransferIn_ResponseParams.prototype.initDefaults_ = function() {
this.status = 0;
this.data = null;
};
UsbDevice_GenericTransferIn_ResponseParams.prototype.initFields_ = function(fields) {
for(var field in fields) {
if (this.hasOwnProperty(field))
this[field] = fields[field];
}
};
UsbDevice_GenericTransferIn_ResponseParams.validate = function(messageValidator, offset) {
var err;
err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
if (err !== validator.validationError.NONE)
return err;
var kVersionSizes = [
{version: 0, numBytes: 24}
];
err = messageValidator.validateStructVersion(offset, kVersionSizes);
if (err !== validator.validationError.NONE)
return err;
// validate UsbDevice_GenericTransferIn_ResponseParams.status
err = messageValidator.validateEnum(offset + codec.kStructHeaderSize + 0, UsbTransferStatus);
if (err !== validator.validationError.NONE)
return err;
// validate UsbDevice_GenericTransferIn_ResponseParams.data
err = messageValidator.validateArrayPointer(offset + codec.kStructHeaderSize + 8, 1, codec.Uint8, false, [0], 0);
if (err !== validator.validationError.NONE)
return err;
return validator.validationError.NONE;
};
UsbDevice_GenericTransferIn_ResponseParams.encodedSize = codec.kStructHeaderSize + 16;
UsbDevice_GenericTransferIn_ResponseParams.decode = function(decoder) {
var packed;
var val = new UsbDevice_GenericTransferIn_ResponseParams();
var numberOfBytes = decoder.readUint32();
var version = decoder.readUint32();
val.status = decoder.decodeStruct(codec.Int32);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
val.data = decoder.decodeArrayPointer(codec.Uint8);
return val;
};
UsbDevice_GenericTransferIn_ResponseParams.encode = function(encoder, val) {
var packed;
encoder.writeUint32(UsbDevice_GenericTransferIn_ResponseParams.encodedSize);
encoder.writeUint32(0);
encoder.encodeStruct(codec.Int32, val.status);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.encodeArrayPointer(codec.Uint8, val.data);
};
function UsbDevice_GenericTransferOut_Params(values) {
this.initDefaults_();
this.initFields_(values);
}
UsbDevice_GenericTransferOut_Params.prototype.initDefaults_ = function() {
this.endpointNumber = 0;
this.timeout = 0;
this.data = null;
};
UsbDevice_GenericTransferOut_Params.prototype.initFields_ = function(fields) {
for(var field in fields) {
if (this.hasOwnProperty(field))
this[field] = fields[field];
}
};
UsbDevice_GenericTransferOut_Params.validate = function(messageValidator, offset) {
var err;
err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
if (err !== validator.validationError.NONE)
return err;
var kVersionSizes = [
{version: 0, numBytes: 24}
];
err = messageValidator.validateStructVersion(offset, kVersionSizes);
if (err !== validator.validationError.NONE)
return err;
// validate UsbDevice_GenericTransferOut_Params.data
err = messageValidator.validateArrayPointer(offset + codec.kStructHeaderSize + 8, 1, codec.Uint8, false, [0], 0);
if (err !== validator.validationError.NONE)
return err;
return validator.validationError.NONE;
};
UsbDevice_GenericTransferOut_Params.encodedSize = codec.kStructHeaderSize + 16;
UsbDevice_GenericTransferOut_Params.decode = function(decoder) {
var packed;
var val = new UsbDevice_GenericTransferOut_Params();
var numberOfBytes = decoder.readUint32();
var version = decoder.readUint32();
val.endpointNumber = decoder.decodeStruct(codec.Uint8);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
val.timeout = decoder.decodeStruct(codec.Uint32);
val.data = decoder.decodeArrayPointer(codec.Uint8);
return val;
};
UsbDevice_GenericTransferOut_Params.encode = function(encoder, val) {
var packed;
encoder.writeUint32(UsbDevice_GenericTransferOut_Params.encodedSize);
encoder.writeUint32(0);
encoder.encodeStruct(codec.Uint8, val.endpointNumber);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.encodeStruct(codec.Uint32, val.timeout);
encoder.encodeArrayPointer(codec.Uint8, val.data);
};
function UsbDevice_GenericTransferOut_ResponseParams(values) {
this.initDefaults_();
this.initFields_(values);
}
UsbDevice_GenericTransferOut_ResponseParams.prototype.initDefaults_ = function() {
this.status = 0;
};
UsbDevice_GenericTransferOut_ResponseParams.prototype.initFields_ = function(fields) {
for(var field in fields) {
if (this.hasOwnProperty(field))
this[field] = fields[field];
}
};
UsbDevice_GenericTransferOut_ResponseParams.validate = function(messageValidator, offset) {
var err;
err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
if (err !== validator.validationError.NONE)
return err;
var kVersionSizes = [
{version: 0, numBytes: 16}
];
err = messageValidator.validateStructVersion(offset, kVersionSizes);
if (err !== validator.validationError.NONE)
return err;
// validate UsbDevice_GenericTransferOut_ResponseParams.status
err = messageValidator.validateEnum(offset + codec.kStructHeaderSize + 0, UsbTransferStatus);
if (err !== validator.validationError.NONE)
return err;
return validator.validationError.NONE;
};
UsbDevice_GenericTransferOut_ResponseParams.encodedSize = codec.kStructHeaderSize + 8;
UsbDevice_GenericTransferOut_ResponseParams.decode = function(decoder) {
var packed;
var val = new UsbDevice_GenericTransferOut_ResponseParams();
var numberOfBytes = decoder.readUint32();
var version = decoder.readUint32();
val.status = decoder.decodeStruct(codec.Int32);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
return val;
};
UsbDevice_GenericTransferOut_ResponseParams.encode = function(encoder, val) {
var packed;
encoder.writeUint32(UsbDevice_GenericTransferOut_ResponseParams.encodedSize);
encoder.writeUint32(0);
encoder.encodeStruct(codec.Int32, val.status);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
};
function UsbDevice_IsochronousTransferIn_Params(values) {
this.initDefaults_();
this.initFields_(values);
}
UsbDevice_IsochronousTransferIn_Params.prototype.initDefaults_ = function() {
this.endpointNumber = 0;
this.timeout = 0;
this.packetLengths = null;
};
UsbDevice_IsochronousTransferIn_Params.prototype.initFields_ = function(fields) {
for(var field in fields) {
if (this.hasOwnProperty(field))
this[field] = fields[field];
}
};
UsbDevice_IsochronousTransferIn_Params.validate = function(messageValidator, offset) {
var err;
err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
if (err !== validator.validationError.NONE)
return err;
var kVersionSizes = [
{version: 0, numBytes: 24}
];
err = messageValidator.validateStructVersion(offset, kVersionSizes);
if (err !== validator.validationError.NONE)
return err;
// validate UsbDevice_IsochronousTransferIn_Params.packetLengths
err = messageValidator.validateArrayPointer(offset + codec.kStructHeaderSize + 8, 4, codec.Uint32, false, [0], 0);
if (err !== validator.validationError.NONE)
return err;
return validator.validationError.NONE;
};
UsbDevice_IsochronousTransferIn_Params.encodedSize = codec.kStructHeaderSize + 16;
UsbDevice_IsochronousTransferIn_Params.decode = function(decoder) {
var packed;
var val = new UsbDevice_IsochronousTransferIn_Params();
var numberOfBytes = decoder.readUint32();
var version = decoder.readUint32();
val.endpointNumber = decoder.decodeStruct(codec.Uint8);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
val.timeout = decoder.decodeStruct(codec.Uint32);
val.packetLengths = decoder.decodeArrayPointer(codec.Uint32);
return val;
};
UsbDevice_IsochronousTransferIn_Params.encode = function(encoder, val) {
var packed;
encoder.writeUint32(UsbDevice_IsochronousTransferIn_Params.encodedSize);
encoder.writeUint32(0);
encoder.encodeStruct(codec.Uint8, val.endpointNumber);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.encodeStruct(codec.Uint32, val.timeout);
encoder.encodeArrayPointer(codec.Uint32, val.packetLengths);
};
function UsbDevice_IsochronousTransferIn_ResponseParams(values) {
this.initDefaults_();
this.initFields_(values);
}
UsbDevice_IsochronousTransferIn_ResponseParams.prototype.initDefaults_ = function() {
this.data = null;
this.packets = null;
};
UsbDevice_IsochronousTransferIn_ResponseParams.prototype.initFields_ = function(fields) {
for(var field in fields) {
if (this.hasOwnProperty(field))
this[field] = fields[field];
}
};
UsbDevice_IsochronousTransferIn_ResponseParams.validate = function(messageValidator, offset) {
var err;
err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
if (err !== validator.validationError.NONE)
return err;
var kVersionSizes = [
{version: 0, numBytes: 24}
];
err = messageValidator.validateStructVersion(offset, kVersionSizes);
if (err !== validator.validationError.NONE)
return err;
// validate UsbDevice_IsochronousTransferIn_ResponseParams.data
err = messageValidator.validateArrayPointer(offset + codec.kStructHeaderSize + 0, 1, codec.Uint8, false, [0], 0);
if (err !== validator.validationError.NONE)
return err;
// validate UsbDevice_IsochronousTransferIn_ResponseParams.packets
err = messageValidator.validateArrayPointer(offset + codec.kStructHeaderSize + 8, 8, new codec.PointerTo(UsbIsochronousPacket), false, [0], 0);
if (err !== validator.validationError.NONE)
return err;
return validator.validationError.NONE;
};
UsbDevice_IsochronousTransferIn_ResponseParams.encodedSize = codec.kStructHeaderSize + 16;
UsbDevice_IsochronousTransferIn_ResponseParams.decode = function(decoder) {
var packed;
var val = new UsbDevice_IsochronousTransferIn_ResponseParams();
var numberOfBytes = decoder.readUint32();
var version = decoder.readUint32();
val.data = decoder.decodeArrayPointer(codec.Uint8);
val.packets = decoder.decodeArrayPointer(new codec.PointerTo(UsbIsochronousPacket));
return val;
};
UsbDevice_IsochronousTransferIn_ResponseParams.encode = function(encoder, val) {
var packed;
encoder.writeUint32(UsbDevice_IsochronousTransferIn_ResponseParams.encodedSize);
encoder.writeUint32(0);
encoder.encodeArrayPointer(codec.Uint8, val.data);
encoder.encodeArrayPointer(new codec.PointerTo(UsbIsochronousPacket), val.packets);
};
function UsbDevice_IsochronousTransferOut_Params(values) {
this.initDefaults_();
this.initFields_(values);
}
UsbDevice_IsochronousTransferOut_Params.prototype.initDefaults_ = function() {
this.endpointNumber = 0;
this.timeout = 0;
this.data = null;
this.packetLengths = null;
};
UsbDevice_IsochronousTransferOut_Params.prototype.initFields_ = function(fields) {
for(var field in fields) {
if (this.hasOwnProperty(field))
this[field] = fields[field];
}
};
UsbDevice_IsochronousTransferOut_Params.validate = function(messageValidator, offset) {
var err;
err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
if (err !== validator.validationError.NONE)
return err;
var kVersionSizes = [
{version: 0, numBytes: 32}
];
err = messageValidator.validateStructVersion(offset, kVersionSizes);
if (err !== validator.validationError.NONE)
return err;
// validate UsbDevice_IsochronousTransferOut_Params.data
err = messageValidator.validateArrayPointer(offset + codec.kStructHeaderSize + 8, 1, codec.Uint8, false, [0], 0);
if (err !== validator.validationError.NONE)
return err;
// validate UsbDevice_IsochronousTransferOut_Params.packetLengths
err = messageValidator.validateArrayPointer(offset + codec.kStructHeaderSize + 16, 4, codec.Uint32, false, [0], 0);
if (err !== validator.validationError.NONE)
return err;
return validator.validationError.NONE;
};
UsbDevice_IsochronousTransferOut_Params.encodedSize = codec.kStructHeaderSize + 24;
UsbDevice_IsochronousTransferOut_Params.decode = function(decoder) {
var packed;
var val = new UsbDevice_IsochronousTransferOut_Params();
var numberOfBytes = decoder.readUint32();
var version = decoder.readUint32();
val.endpointNumber = decoder.decodeStruct(codec.Uint8);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
val.timeout = decoder.decodeStruct(codec.Uint32);
val.data = decoder.decodeArrayPointer(codec.Uint8);
val.packetLengths = decoder.decodeArrayPointer(codec.Uint32);
return val;
};
UsbDevice_IsochronousTransferOut_Params.encode = function(encoder, val) {
var packed;
encoder.writeUint32(UsbDevice_IsochronousTransferOut_Params.encodedSize);
encoder.writeUint32(0);
encoder.encodeStruct(codec.Uint8, val.endpointNumber);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.encodeStruct(codec.Uint32, val.timeout);
encoder.encodeArrayPointer(codec.Uint8, val.data);
encoder.encodeArrayPointer(codec.Uint32, val.packetLengths);
};
function UsbDevice_IsochronousTransferOut_ResponseParams(values) {
this.initDefaults_();
this.initFields_(values);
}
UsbDevice_IsochronousTransferOut_ResponseParams.prototype.initDefaults_ = function() {
this.packets = null;
};
UsbDevice_IsochronousTransferOut_ResponseParams.prototype.initFields_ = function(fields) {
for(var field in fields) {
if (this.hasOwnProperty(field))
this[field] = fields[field];
}
};
UsbDevice_IsochronousTransferOut_ResponseParams.validate = function(messageValidator, offset) {
var err;
err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
if (err !== validator.validationError.NONE)
return err;
var kVersionSizes = [
{version: 0, numBytes: 16}
];
err = messageValidator.validateStructVersion(offset, kVersionSizes);
if (err !== validator.validationError.NONE)
return err;
// validate UsbDevice_IsochronousTransferOut_ResponseParams.packets
err = messageValidator.validateArrayPointer(offset + codec.kStructHeaderSize + 0, 8, new codec.PointerTo(UsbIsochronousPacket), false, [0], 0);
if (err !== validator.validationError.NONE)
return err;
return validator.validationError.NONE;
};
UsbDevice_IsochronousTransferOut_ResponseParams.encodedSize = codec.kStructHeaderSize + 8;
UsbDevice_IsochronousTransferOut_ResponseParams.decode = function(decoder) {
var packed;
var val = new UsbDevice_IsochronousTransferOut_ResponseParams();
var numberOfBytes = decoder.readUint32();
var version = decoder.readUint32();
val.packets = decoder.decodeArrayPointer(new codec.PointerTo(UsbIsochronousPacket));
return val;
};
UsbDevice_IsochronousTransferOut_ResponseParams.encode = function(encoder, val) {
var packed;
encoder.writeUint32(UsbDevice_IsochronousTransferOut_ResponseParams.encodedSize);
encoder.writeUint32(0);
encoder.encodeArrayPointer(new codec.PointerTo(UsbIsochronousPacket), val.packets);
};
var kUsbDevice_Open_Name = 0;
var kUsbDevice_Close_Name = 1;
var kUsbDevice_SetConfiguration_Name = 2;
var kUsbDevice_ClaimInterface_Name = 3;
var kUsbDevice_ReleaseInterface_Name = 4;
var kUsbDevice_SetInterfaceAlternateSetting_Name = 5;
var kUsbDevice_Reset_Name = 6;
var kUsbDevice_ClearHalt_Name = 7;
var kUsbDevice_ControlTransferIn_Name = 8;
var kUsbDevice_ControlTransferOut_Name = 9;
var kUsbDevice_GenericTransferIn_Name = 10;
var kUsbDevice_GenericTransferOut_Name = 11;
var kUsbDevice_IsochronousTransferIn_Name = 12;
var kUsbDevice_IsochronousTransferOut_Name = 13;
function UsbDevicePtr(handleOrPtrInfo) {
this.ptr = new bindings.InterfacePtrController(UsbDevice,
handleOrPtrInfo);
}
function UsbDeviceAssociatedPtr(associatedInterfacePtrInfo) {
this.ptr = new associatedBindings.AssociatedInterfacePtrController(
UsbDevice, associatedInterfacePtrInfo);
}
UsbDeviceAssociatedPtr.prototype =
Object.create(UsbDevicePtr.prototype);
UsbDeviceAssociatedPtr.prototype.constructor =
UsbDeviceAssociatedPtr;
function UsbDeviceProxy(receiver) {
this.receiver_ = receiver;
}
UsbDevicePtr.prototype.open = function() {
return UsbDeviceProxy.prototype.open
.apply(this.ptr.getProxy(), arguments);
};
UsbDeviceProxy.prototype.open = function() {
var params = new UsbDevice_Open_Params();
return new Promise(function(resolve, reject) {
var builder = new codec.MessageV1Builder(
kUsbDevice_Open_Name,
codec.align(UsbDevice_Open_Params.encodedSize),
codec.kMessageExpectsResponse, 0);
builder.encodeStruct(UsbDevice_Open_Params, params);
var message = builder.finish();
this.receiver_.acceptAndExpectResponse(message).then(function(message) {
var reader = new codec.MessageReader(message);
var responseParams =
reader.decodeStruct(UsbDevice_Open_ResponseParams);
resolve(responseParams);
}).catch(function(result) {
reject(Error("Connection error: " + result));
});
}.bind(this));
};
UsbDevicePtr.prototype.close = function() {
return UsbDeviceProxy.prototype.close
.apply(this.ptr.getProxy(), arguments);
};
UsbDeviceProxy.prototype.close = function() {
var params = new UsbDevice_Close_Params();
return new Promise(function(resolve, reject) {
var builder = new codec.MessageV1Builder(
kUsbDevice_Close_Name,
codec.align(UsbDevice_Close_Params.encodedSize),
codec.kMessageExpectsResponse, 0);
builder.encodeStruct(UsbDevice_Close_Params, params);
var message = builder.finish();
this.receiver_.acceptAndExpectResponse(message).then(function(message) {
var reader = new codec.MessageReader(message);
var responseParams =
reader.decodeStruct(UsbDevice_Close_ResponseParams);
resolve(responseParams);
}).catch(function(result) {
reject(Error("Connection error: " + result));
});
}.bind(this));
};
UsbDevicePtr.prototype.setConfiguration = function() {
return UsbDeviceProxy.prototype.setConfiguration
.apply(this.ptr.getProxy(), arguments);
};
UsbDeviceProxy.prototype.setConfiguration = function(value) {
var params = new UsbDevice_SetConfiguration_Params();
params.value = value;
return new Promise(function(resolve, reject) {
var builder = new codec.MessageV1Builder(
kUsbDevice_SetConfiguration_Name,
codec.align(UsbDevice_SetConfiguration_Params.encodedSize),
codec.kMessageExpectsResponse, 0);
builder.encodeStruct(UsbDevice_SetConfiguration_Params, params);
var message = builder.finish();
this.receiver_.acceptAndExpectResponse(message).then(function(message) {
var reader = new codec.MessageReader(message);
var responseParams =
reader.decodeStruct(UsbDevice_SetConfiguration_ResponseParams);
resolve(responseParams);
}).catch(function(result) {
reject(Error("Connection error: " + result));
});
}.bind(this));
};
UsbDevicePtr.prototype.claimInterface = function() {
return UsbDeviceProxy.prototype.claimInterface
.apply(this.ptr.getProxy(), arguments);
};
UsbDeviceProxy.prototype.claimInterface = function(interfaceNumber) {
var params = new UsbDevice_ClaimInterface_Params();
params.interfaceNumber = interfaceNumber;
return new Promise(function(resolve, reject) {
var builder = new codec.MessageV1Builder(
kUsbDevice_ClaimInterface_Name,
codec.align(UsbDevice_ClaimInterface_Params.encodedSize),
codec.kMessageExpectsResponse, 0);
builder.encodeStruct(UsbDevice_ClaimInterface_Params, params);
var message = builder.finish();
this.receiver_.acceptAndExpectResponse(message).then(function(message) {
var reader = new codec.MessageReader(message);
var responseParams =
reader.decodeStruct(UsbDevice_ClaimInterface_ResponseParams);
resolve(responseParams);
}).catch(function(result) {
reject(Error("Connection error: " + result));
});
}.bind(this));
};
UsbDevicePtr.prototype.releaseInterface = function() {
return UsbDeviceProxy.prototype.releaseInterface
.apply(this.ptr.getProxy(), arguments);
};
UsbDeviceProxy.prototype.releaseInterface = function(interfaceNumber) {
var params = new UsbDevice_ReleaseInterface_Params();
params.interfaceNumber = interfaceNumber;
return new Promise(function(resolve, reject) {
var builder = new codec.MessageV1Builder(
kUsbDevice_ReleaseInterface_Name,
codec.align(UsbDevice_ReleaseInterface_Params.encodedSize),
codec.kMessageExpectsResponse, 0);
builder.encodeStruct(UsbDevice_ReleaseInterface_Params, params);
var message = builder.finish();
this.receiver_.acceptAndExpectResponse(message).then(function(message) {
var reader = new codec.MessageReader(message);
var responseParams =
reader.decodeStruct(UsbDevice_ReleaseInterface_ResponseParams);
resolve(responseParams);
}).catch(function(result) {
reject(Error("Connection error: " + result));
});
}.bind(this));
};
UsbDevicePtr.prototype.setInterfaceAlternateSetting = function() {
return UsbDeviceProxy.prototype.setInterfaceAlternateSetting
.apply(this.ptr.getProxy(), arguments);
};
UsbDeviceProxy.prototype.setInterfaceAlternateSetting = function(interfaceNumber, alternateSetting) {
var params = new UsbDevice_SetInterfaceAlternateSetting_Params();
params.interfaceNumber = interfaceNumber;
params.alternateSetting = alternateSetting;
return new Promise(function(resolve, reject) {
var builder = new codec.MessageV1Builder(
kUsbDevice_SetInterfaceAlternateSetting_Name,
codec.align(UsbDevice_SetInterfaceAlternateSetting_Params.encodedSize),
codec.kMessageExpectsResponse, 0);
builder.encodeStruct(UsbDevice_SetInterfaceAlternateSetting_Params, params);
var message = builder.finish();
this.receiver_.acceptAndExpectResponse(message).then(function(message) {
var reader = new codec.MessageReader(message);
var responseParams =
reader.decodeStruct(UsbDevice_SetInterfaceAlternateSetting_ResponseParams);
resolve(responseParams);
}).catch(function(result) {
reject(Error("Connection error: " + result));
});
}.bind(this));
};
UsbDevicePtr.prototype.reset = function() {
return UsbDeviceProxy.prototype.reset
.apply(this.ptr.getProxy(), arguments);
};
UsbDeviceProxy.prototype.reset = function() {
var params = new UsbDevice_Reset_Params();
return new Promise(function(resolve, reject) {
var builder = new codec.MessageV1Builder(
kUsbDevice_Reset_Name,
codec.align(UsbDevice_Reset_Params.encodedSize),
codec.kMessageExpectsResponse, 0);
builder.encodeStruct(UsbDevice_Reset_Params, params);
var message = builder.finish();
this.receiver_.acceptAndExpectResponse(message).then(function(message) {
var reader = new codec.MessageReader(message);
var responseParams =
reader.decodeStruct(UsbDevice_Reset_ResponseParams);
resolve(responseParams);
}).catch(function(result) {
reject(Error("Connection error: " + result));
});
}.bind(this));
};
UsbDevicePtr.prototype.clearHalt = function() {
return UsbDeviceProxy.prototype.clearHalt
.apply(this.ptr.getProxy(), arguments);
};
UsbDeviceProxy.prototype.clearHalt = function(endpoint) {
var params = new UsbDevice_ClearHalt_Params();
params.endpoint = endpoint;
return new Promise(function(resolve, reject) {
var builder = new codec.MessageV1Builder(
kUsbDevice_ClearHalt_Name,
codec.align(UsbDevice_ClearHalt_Params.encodedSize),
codec.kMessageExpectsResponse, 0);
builder.encodeStruct(UsbDevice_ClearHalt_Params, params);
var message = builder.finish();
this.receiver_.acceptAndExpectResponse(message).then(function(message) {
var reader = new codec.MessageReader(message);
var responseParams =
reader.decodeStruct(UsbDevice_ClearHalt_ResponseParams);
resolve(responseParams);
}).catch(function(result) {
reject(Error("Connection error: " + result));
});
}.bind(this));
};
UsbDevicePtr.prototype.controlTransferIn = function() {
return UsbDeviceProxy.prototype.controlTransferIn
.apply(this.ptr.getProxy(), arguments);
};
UsbDeviceProxy.prototype.controlTransferIn = function(params, length, timeout) {
var params = new UsbDevice_ControlTransferIn_Params();
params.params = params;
params.length = length;
params.timeout = timeout;
return new Promise(function(resolve, reject) {
var builder = new codec.MessageV1Builder(
kUsbDevice_ControlTransferIn_Name,
codec.align(UsbDevice_ControlTransferIn_Params.encodedSize),
codec.kMessageExpectsResponse, 0);
builder.encodeStruct(UsbDevice_ControlTransferIn_Params, params);
var message = builder.finish();
this.receiver_.acceptAndExpectResponse(message).then(function(message) {
var reader = new codec.MessageReader(message);
var responseParams =
reader.decodeStruct(UsbDevice_ControlTransferIn_ResponseParams);
resolve(responseParams);
}).catch(function(result) {
reject(Error("Connection error: " + result));
});
}.bind(this));
};
UsbDevicePtr.prototype.controlTransferOut = function() {
return UsbDeviceProxy.prototype.controlTransferOut
.apply(this.ptr.getProxy(), arguments);
};
UsbDeviceProxy.prototype.controlTransferOut = function(params, data, timeout) {
var params = new UsbDevice_ControlTransferOut_Params();
params.params = params;
params.data = data;
params.timeout = timeout;
return new Promise(function(resolve, reject) {
var builder = new codec.MessageV1Builder(
kUsbDevice_ControlTransferOut_Name,
codec.align(UsbDevice_ControlTransferOut_Params.encodedSize),
codec.kMessageExpectsResponse, 0);
builder.encodeStruct(UsbDevice_ControlTransferOut_Params, params);
var message = builder.finish();
this.receiver_.acceptAndExpectResponse(message).then(function(message) {
var reader = new codec.MessageReader(message);
var responseParams =
reader.decodeStruct(UsbDevice_ControlTransferOut_ResponseParams);
resolve(responseParams);
}).catch(function(result) {
reject(Error("Connection error: " + result));
});
}.bind(this));
};
UsbDevicePtr.prototype.genericTransferIn = function() {
return UsbDeviceProxy.prototype.genericTransferIn
.apply(this.ptr.getProxy(), arguments);
};
UsbDeviceProxy.prototype.genericTransferIn = function(endpointNumber, length, timeout) {
var params = new UsbDevice_GenericTransferIn_Params();
params.endpointNumber = endpointNumber;
params.length = length;
params.timeout = timeout;
return new Promise(function(resolve, reject) {
var builder = new codec.MessageV1Builder(
kUsbDevice_GenericTransferIn_Name,
codec.align(UsbDevice_GenericTransferIn_Params.encodedSize),
codec.kMessageExpectsResponse, 0);
builder.encodeStruct(UsbDevice_GenericTransferIn_Params, params);
var message = builder.finish();
this.receiver_.acceptAndExpectResponse(message).then(function(message) {
var reader = new codec.MessageReader(message);
var responseParams =
reader.decodeStruct(UsbDevice_GenericTransferIn_ResponseParams);
resolve(responseParams);
}).catch(function(result) {
reject(Error("Connection error: " + result));
});
}.bind(this));
};
UsbDevicePtr.prototype.genericTransferOut = function() {
return UsbDeviceProxy.prototype.genericTransferOut
.apply(this.ptr.getProxy(), arguments);
};
UsbDeviceProxy.prototype.genericTransferOut = function(endpointNumber, data, timeout) {
var params = new UsbDevice_GenericTransferOut_Params();
params.endpointNumber = endpointNumber;
params.data = data;
params.timeout = timeout;
return new Promise(function(resolve, reject) {
var builder = new codec.MessageV1Builder(
kUsbDevice_GenericTransferOut_Name,
codec.align(UsbDevice_GenericTransferOut_Params.encodedSize),
codec.kMessageExpectsResponse, 0);
builder.encodeStruct(UsbDevice_GenericTransferOut_Params, params);
var message = builder.finish();
this.receiver_.acceptAndExpectResponse(message).then(function(message) {
var reader = new codec.MessageReader(message);
var responseParams =
reader.decodeStruct(UsbDevice_GenericTransferOut_ResponseParams);
resolve(responseParams);
}).catch(function(result) {
reject(Error("Connection error: " + result));
});
}.bind(this));
};
UsbDevicePtr.prototype.isochronousTransferIn = function() {
return UsbDeviceProxy.prototype.isochronousTransferIn
.apply(this.ptr.getProxy(), arguments);
};
UsbDeviceProxy.prototype.isochronousTransferIn = function(endpointNumber, packetLengths, timeout) {
var params = new UsbDevice_IsochronousTransferIn_Params();
params.endpointNumber = endpointNumber;
params.packetLengths = packetLengths;
params.timeout = timeout;
return new Promise(function(resolve, reject) {
var builder = new codec.MessageV1Builder(
kUsbDevice_IsochronousTransferIn_Name,
codec.align(UsbDevice_IsochronousTransferIn_Params.encodedSize),
codec.kMessageExpectsResponse, 0);
builder.encodeStruct(UsbDevice_IsochronousTransferIn_Params, params);
var message = builder.finish();
this.receiver_.acceptAndExpectResponse(message).then(function(message) {
var reader = new codec.MessageReader(message);
var responseParams =
reader.decodeStruct(UsbDevice_IsochronousTransferIn_ResponseParams);
resolve(responseParams);
}).catch(function(result) {
reject(Error("Connection error: " + result));
});
}.bind(this));
};
UsbDevicePtr.prototype.isochronousTransferOut = function() {
return UsbDeviceProxy.prototype.isochronousTransferOut
.apply(this.ptr.getProxy(), arguments);
};
UsbDeviceProxy.prototype.isochronousTransferOut = function(endpointNumber, data, packetLengths, timeout) {
var params = new UsbDevice_IsochronousTransferOut_Params();
params.endpointNumber = endpointNumber;
params.data = data;
params.packetLengths = packetLengths;
params.timeout = timeout;
return new Promise(function(resolve, reject) {
var builder = new codec.MessageV1Builder(
kUsbDevice_IsochronousTransferOut_Name,
codec.align(UsbDevice_IsochronousTransferOut_Params.encodedSize),
codec.kMessageExpectsResponse, 0);
builder.encodeStruct(UsbDevice_IsochronousTransferOut_Params, params);
var message = builder.finish();
this.receiver_.acceptAndExpectResponse(message).then(function(message) {
var reader = new codec.MessageReader(message);
var responseParams =
reader.decodeStruct(UsbDevice_IsochronousTransferOut_ResponseParams);
resolve(responseParams);
}).catch(function(result) {
reject(Error("Connection error: " + result));
});
}.bind(this));
};
function UsbDeviceStub(delegate) {
this.delegate_ = delegate;
}
UsbDeviceStub.prototype.open = function() {
return this.delegate_ && this.delegate_.open && this.delegate_.open();
}
UsbDeviceStub.prototype.close = function() {
return this.delegate_ && this.delegate_.close && this.delegate_.close();
}
UsbDeviceStub.prototype.setConfiguration = function(value) {
return this.delegate_ && this.delegate_.setConfiguration && this.delegate_.setConfiguration(value);
}
UsbDeviceStub.prototype.claimInterface = function(interfaceNumber) {
return this.delegate_ && this.delegate_.claimInterface && this.delegate_.claimInterface(interfaceNumber);
}
UsbDeviceStub.prototype.releaseInterface = function(interfaceNumber) {
return this.delegate_ && this.delegate_.releaseInterface && this.delegate_.releaseInterface(interfaceNumber);
}
UsbDeviceStub.prototype.setInterfaceAlternateSetting = function(interfaceNumber, alternateSetting) {
return this.delegate_ && this.delegate_.setInterfaceAlternateSetting && this.delegate_.setInterfaceAlternateSetting(interfaceNumber, alternateSetting);
}
UsbDeviceStub.prototype.reset = function() {
return this.delegate_ && this.delegate_.reset && this.delegate_.reset();
}
UsbDeviceStub.prototype.clearHalt = function(endpoint) {
return this.delegate_ && this.delegate_.clearHalt && this.delegate_.clearHalt(endpoint);
}
UsbDeviceStub.prototype.controlTransferIn = function(params, length, timeout) {
return this.delegate_ && this.delegate_.controlTransferIn && this.delegate_.controlTransferIn(params, length, timeout);
}
UsbDeviceStub.prototype.controlTransferOut = function(params, data, timeout) {
return this.delegate_ && this.delegate_.controlTransferOut && this.delegate_.controlTransferOut(params, data, timeout);
}
UsbDeviceStub.prototype.genericTransferIn = function(endpointNumber, length, timeout) {
return this.delegate_ && this.delegate_.genericTransferIn && this.delegate_.genericTransferIn(endpointNumber, length, timeout);
}
UsbDeviceStub.prototype.genericTransferOut = function(endpointNumber, data, timeout) {
return this.delegate_ && this.delegate_.genericTransferOut && this.delegate_.genericTransferOut(endpointNumber, data, timeout);
}
UsbDeviceStub.prototype.isochronousTransferIn = function(endpointNumber, packetLengths, timeout) {
return this.delegate_ && this.delegate_.isochronousTransferIn && this.delegate_.isochronousTransferIn(endpointNumber, packetLengths, timeout);
}
UsbDeviceStub.prototype.isochronousTransferOut = function(endpointNumber, data, packetLengths, timeout) {
return this.delegate_ && this.delegate_.isochronousTransferOut && this.delegate_.isochronousTransferOut(endpointNumber, data, packetLengths, timeout);
}
UsbDeviceStub.prototype.accept = function(message) {
var reader = new codec.MessageReader(message);
switch (reader.messageName) {
default:
return false;
}
};
UsbDeviceStub.prototype.acceptWithResponder =
function(message, responder) {
var reader = new codec.MessageReader(message);
switch (reader.messageName) {
case kUsbDevice_Open_Name:
var params = reader.decodeStruct(UsbDevice_Open_Params);
this.open().then(function(response) {
var responseParams =
new UsbDevice_Open_ResponseParams();
responseParams.error = response.error;
var builder = new codec.MessageV1Builder(
kUsbDevice_Open_Name,
codec.align(UsbDevice_Open_ResponseParams.encodedSize),
codec.kMessageIsResponse, reader.requestID);
builder.encodeStruct(UsbDevice_Open_ResponseParams,
responseParams);
var message = builder.finish();
responder.accept(message);
});
return true;
case kUsbDevice_Close_Name:
var params = reader.decodeStruct(UsbDevice_Close_Params);
this.close().then(function(response) {
var responseParams =
new UsbDevice_Close_ResponseParams();
var builder = new codec.MessageV1Builder(
kUsbDevice_Close_Name,
codec.align(UsbDevice_Close_ResponseParams.encodedSize),
codec.kMessageIsResponse, reader.requestID);
builder.encodeStruct(UsbDevice_Close_ResponseParams,
responseParams);
var message = builder.finish();
responder.accept(message);
});
return true;
case kUsbDevice_SetConfiguration_Name:
var params = reader.decodeStruct(UsbDevice_SetConfiguration_Params);
this.setConfiguration(params.value).then(function(response) {
var responseParams =
new UsbDevice_SetConfiguration_ResponseParams();
responseParams.success = response.success;
var builder = new codec.MessageV1Builder(
kUsbDevice_SetConfiguration_Name,
codec.align(UsbDevice_SetConfiguration_ResponseParams.encodedSize),
codec.kMessageIsResponse, reader.requestID);
builder.encodeStruct(UsbDevice_SetConfiguration_ResponseParams,
responseParams);
var message = builder.finish();
responder.accept(message);
});
return true;
case kUsbDevice_ClaimInterface_Name:
var params = reader.decodeStruct(UsbDevice_ClaimInterface_Params);
this.claimInterface(params.interfaceNumber).then(function(response) {
var responseParams =
new UsbDevice_ClaimInterface_ResponseParams();
responseParams.success = response.success;
var builder = new codec.MessageV1Builder(
kUsbDevice_ClaimInterface_Name,
codec.align(UsbDevice_ClaimInterface_ResponseParams.encodedSize),
codec.kMessageIsResponse, reader.requestID);
builder.encodeStruct(UsbDevice_ClaimInterface_ResponseParams,
responseParams);
var message = builder.finish();
responder.accept(message);
});
return true;
case kUsbDevice_ReleaseInterface_Name:
var params = reader.decodeStruct(UsbDevice_ReleaseInterface_Params);
this.releaseInterface(params.interfaceNumber).then(function(response) {
var responseParams =
new UsbDevice_ReleaseInterface_ResponseParams();
responseParams.success = response.success;
var builder = new codec.MessageV1Builder(
kUsbDevice_ReleaseInterface_Name,
codec.align(UsbDevice_ReleaseInterface_ResponseParams.encodedSize),
codec.kMessageIsResponse, reader.requestID);
builder.encodeStruct(UsbDevice_ReleaseInterface_ResponseParams,
responseParams);
var message = builder.finish();
responder.accept(message);
});
return true;
case kUsbDevice_SetInterfaceAlternateSetting_Name:
var params = reader.decodeStruct(UsbDevice_SetInterfaceAlternateSetting_Params);
this.setInterfaceAlternateSetting(params.interfaceNumber, params.alternateSetting).then(function(response) {
var responseParams =
new UsbDevice_SetInterfaceAlternateSetting_ResponseParams();
responseParams.success = response.success;
var builder = new codec.MessageV1Builder(
kUsbDevice_SetInterfaceAlternateSetting_Name,
codec.align(UsbDevice_SetInterfaceAlternateSetting_ResponseParams.encodedSize),
codec.kMessageIsResponse, reader.requestID);
builder.encodeStruct(UsbDevice_SetInterfaceAlternateSetting_ResponseParams,
responseParams);
var message = builder.finish();
responder.accept(message);
});
return true;
case kUsbDevice_Reset_Name:
var params = reader.decodeStruct(UsbDevice_Reset_Params);
this.reset().then(function(response) {
var responseParams =
new UsbDevice_Reset_ResponseParams();
responseParams.success = response.success;
var builder = new codec.MessageV1Builder(
kUsbDevice_Reset_Name,
codec.align(UsbDevice_Reset_ResponseParams.encodedSize),
codec.kMessageIsResponse, reader.requestID);
builder.encodeStruct(UsbDevice_Reset_ResponseParams,
responseParams);
var message = builder.finish();
responder.accept(message);
});
return true;
case kUsbDevice_ClearHalt_Name:
var params = reader.decodeStruct(UsbDevice_ClearHalt_Params);
this.clearHalt(params.endpoint).then(function(response) {
var responseParams =
new UsbDevice_ClearHalt_ResponseParams();
responseParams.success = response.success;
var builder = new codec.MessageV1Builder(
kUsbDevice_ClearHalt_Name,
codec.align(UsbDevice_ClearHalt_ResponseParams.encodedSize),
codec.kMessageIsResponse, reader.requestID);
builder.encodeStruct(UsbDevice_ClearHalt_ResponseParams,
responseParams);
var message = builder.finish();
responder.accept(message);
});
return true;
case kUsbDevice_ControlTransferIn_Name:
var params = reader.decodeStruct(UsbDevice_ControlTransferIn_Params);
this.controlTransferIn(params.params, params.length, params.timeout).then(function(response) {
var responseParams =
new UsbDevice_ControlTransferIn_ResponseParams();
responseParams.status = response.status;
responseParams.data = response.data;
var builder = new codec.MessageV1Builder(
kUsbDevice_ControlTransferIn_Name,
codec.align(UsbDevice_ControlTransferIn_ResponseParams.encodedSize),
codec.kMessageIsResponse, reader.requestID);
builder.encodeStruct(UsbDevice_ControlTransferIn_ResponseParams,
responseParams);
var message = builder.finish();
responder.accept(message);
});
return true;
case kUsbDevice_ControlTransferOut_Name:
var params = reader.decodeStruct(UsbDevice_ControlTransferOut_Params);
this.controlTransferOut(params.params, params.data, params.timeout).then(function(response) {
var responseParams =
new UsbDevice_ControlTransferOut_ResponseParams();
responseParams.status = response.status;
var builder = new codec.MessageV1Builder(
kUsbDevice_ControlTransferOut_Name,
codec.align(UsbDevice_ControlTransferOut_ResponseParams.encodedSize),
codec.kMessageIsResponse, reader.requestID);
builder.encodeStruct(UsbDevice_ControlTransferOut_ResponseParams,
responseParams);
var message = builder.finish();
responder.accept(message);
});
return true;
case kUsbDevice_GenericTransferIn_Name:
var params = reader.decodeStruct(UsbDevice_GenericTransferIn_Params);
this.genericTransferIn(params.endpointNumber, params.length, params.timeout).then(function(response) {
var responseParams =
new UsbDevice_GenericTransferIn_ResponseParams();
responseParams.status = response.status;
responseParams.data = response.data;
var builder = new codec.MessageV1Builder(
kUsbDevice_GenericTransferIn_Name,
codec.align(UsbDevice_GenericTransferIn_ResponseParams.encodedSize),
codec.kMessageIsResponse, reader.requestID);
builder.encodeStruct(UsbDevice_GenericTransferIn_ResponseParams,
responseParams);
var message = builder.finish();
responder.accept(message);
});
return true;
case kUsbDevice_GenericTransferOut_Name:
var params = reader.decodeStruct(UsbDevice_GenericTransferOut_Params);
this.genericTransferOut(params.endpointNumber, params.data, params.timeout).then(function(response) {
var responseParams =
new UsbDevice_GenericTransferOut_ResponseParams();
responseParams.status = response.status;
var builder = new codec.MessageV1Builder(
kUsbDevice_GenericTransferOut_Name,
codec.align(UsbDevice_GenericTransferOut_ResponseParams.encodedSize),
codec.kMessageIsResponse, reader.requestID);
builder.encodeStruct(UsbDevice_GenericTransferOut_ResponseParams,
responseParams);
var message = builder.finish();
responder.accept(message);
});
return true;
case kUsbDevice_IsochronousTransferIn_Name:
var params = reader.decodeStruct(UsbDevice_IsochronousTransferIn_Params);
this.isochronousTransferIn(params.endpointNumber, params.packetLengths, params.timeout).then(function(response) {
var responseParams =
new UsbDevice_IsochronousTransferIn_ResponseParams();
responseParams.data = response.data;
responseParams.packets = response.packets;
var builder = new codec.MessageV1Builder(
kUsbDevice_IsochronousTransferIn_Name,
codec.align(UsbDevice_IsochronousTransferIn_ResponseParams.encodedSize),
codec.kMessageIsResponse, reader.requestID);
builder.encodeStruct(UsbDevice_IsochronousTransferIn_ResponseParams,
responseParams);
var message = builder.finish();
responder.accept(message);
});
return true;
case kUsbDevice_IsochronousTransferOut_Name:
var params = reader.decodeStruct(UsbDevice_IsochronousTransferOut_Params);
this.isochronousTransferOut(params.endpointNumber, params.data, params.packetLengths, params.timeout).then(function(response) {
var responseParams =
new UsbDevice_IsochronousTransferOut_ResponseParams();
responseParams.packets = response.packets;
var builder = new codec.MessageV1Builder(
kUsbDevice_IsochronousTransferOut_Name,
codec.align(UsbDevice_IsochronousTransferOut_ResponseParams.encodedSize),
codec.kMessageIsResponse, reader.requestID);
builder.encodeStruct(UsbDevice_IsochronousTransferOut_ResponseParams,
responseParams);
var message = builder.finish();
responder.accept(message);
});
return true;
default:
return false;
}
};
function validateUsbDeviceRequest(messageValidator) {
var message = messageValidator.message;
var paramsClass = null;
switch (message.getName()) {
case kUsbDevice_Open_Name:
if (message.expectsResponse())
paramsClass = UsbDevice_Open_Params;
break;
case kUsbDevice_Close_Name:
if (message.expectsResponse())
paramsClass = UsbDevice_Close_Params;
break;
case kUsbDevice_SetConfiguration_Name:
if (message.expectsResponse())
paramsClass = UsbDevice_SetConfiguration_Params;
break;
case kUsbDevice_ClaimInterface_Name:
if (message.expectsResponse())
paramsClass = UsbDevice_ClaimInterface_Params;
break;
case kUsbDevice_ReleaseInterface_Name:
if (message.expectsResponse())
paramsClass = UsbDevice_ReleaseInterface_Params;
break;
case kUsbDevice_SetInterfaceAlternateSetting_Name:
if (message.expectsResponse())
paramsClass = UsbDevice_SetInterfaceAlternateSetting_Params;
break;
case kUsbDevice_Reset_Name:
if (message.expectsResponse())
paramsClass = UsbDevice_Reset_Params;
break;
case kUsbDevice_ClearHalt_Name:
if (message.expectsResponse())
paramsClass = UsbDevice_ClearHalt_Params;
break;
case kUsbDevice_ControlTransferIn_Name:
if (message.expectsResponse())
paramsClass = UsbDevice_ControlTransferIn_Params;
break;
case kUsbDevice_ControlTransferOut_Name:
if (message.expectsResponse())
paramsClass = UsbDevice_ControlTransferOut_Params;
break;
case kUsbDevice_GenericTransferIn_Name:
if (message.expectsResponse())
paramsClass = UsbDevice_GenericTransferIn_Params;
break;
case kUsbDevice_GenericTransferOut_Name:
if (message.expectsResponse())
paramsClass = UsbDevice_GenericTransferOut_Params;
break;
case kUsbDevice_IsochronousTransferIn_Name:
if (message.expectsResponse())
paramsClass = UsbDevice_IsochronousTransferIn_Params;
break;
case kUsbDevice_IsochronousTransferOut_Name:
if (message.expectsResponse())
paramsClass = UsbDevice_IsochronousTransferOut_Params;
break;
}
if (paramsClass === null)
return validator.validationError.NONE;
return paramsClass.validate(messageValidator, messageValidator.message.getHeaderNumBytes());
}
function validateUsbDeviceResponse(messageValidator) {
var message = messageValidator.message;
var paramsClass = null;
switch (message.getName()) {
case kUsbDevice_Open_Name:
if (message.isResponse())
paramsClass = UsbDevice_Open_ResponseParams;
break;
case kUsbDevice_Close_Name:
if (message.isResponse())
paramsClass = UsbDevice_Close_ResponseParams;
break;
case kUsbDevice_SetConfiguration_Name:
if (message.isResponse())
paramsClass = UsbDevice_SetConfiguration_ResponseParams;
break;
case kUsbDevice_ClaimInterface_Name:
if (message.isResponse())
paramsClass = UsbDevice_ClaimInterface_ResponseParams;
break;
case kUsbDevice_ReleaseInterface_Name:
if (message.isResponse())
paramsClass = UsbDevice_ReleaseInterface_ResponseParams;
break;
case kUsbDevice_SetInterfaceAlternateSetting_Name:
if (message.isResponse())
paramsClass = UsbDevice_SetInterfaceAlternateSetting_ResponseParams;
break;
case kUsbDevice_Reset_Name:
if (message.isResponse())
paramsClass = UsbDevice_Reset_ResponseParams;
break;
case kUsbDevice_ClearHalt_Name:
if (message.isResponse())
paramsClass = UsbDevice_ClearHalt_ResponseParams;
break;
case kUsbDevice_ControlTransferIn_Name:
if (message.isResponse())
paramsClass = UsbDevice_ControlTransferIn_ResponseParams;
break;
case kUsbDevice_ControlTransferOut_Name:
if (message.isResponse())
paramsClass = UsbDevice_ControlTransferOut_ResponseParams;
break;
case kUsbDevice_GenericTransferIn_Name:
if (message.isResponse())
paramsClass = UsbDevice_GenericTransferIn_ResponseParams;
break;
case kUsbDevice_GenericTransferOut_Name:
if (message.isResponse())
paramsClass = UsbDevice_GenericTransferOut_ResponseParams;
break;
case kUsbDevice_IsochronousTransferIn_Name:
if (message.isResponse())
paramsClass = UsbDevice_IsochronousTransferIn_ResponseParams;
break;
case kUsbDevice_IsochronousTransferOut_Name:
if (message.isResponse())
paramsClass = UsbDevice_IsochronousTransferOut_ResponseParams;
break;
}
if (paramsClass === null)
return validator.validationError.NONE;
return paramsClass.validate(messageValidator, messageValidator.message.getHeaderNumBytes());
}
var UsbDevice = {
name: 'device.mojom.UsbDevice',
kVersion: 0,
ptrClass: UsbDevicePtr,
proxyClass: UsbDeviceProxy,
stubClass: UsbDeviceStub,
validateRequest: validateUsbDeviceRequest,
validateResponse: validateUsbDeviceResponse,
};
UsbDeviceStub.prototype.validator = validateUsbDeviceRequest;
UsbDeviceProxy.prototype.validator = validateUsbDeviceResponse;
exports.UsbOpenDeviceError = UsbOpenDeviceError;
exports.UsbTransferDirection = UsbTransferDirection;
exports.UsbControlTransferType = UsbControlTransferType;
exports.UsbControlTransferRecipient = UsbControlTransferRecipient;
exports.UsbTransferType = UsbTransferType;
exports.UsbTransferStatus = UsbTransferStatus;
exports.UsbEndpointInfo = UsbEndpointInfo;
exports.UsbAlternateInterfaceInfo = UsbAlternateInterfaceInfo;
exports.UsbInterfaceInfo = UsbInterfaceInfo;
exports.UsbConfigurationInfo = UsbConfigurationInfo;
exports.UsbDeviceInfo = UsbDeviceInfo;
exports.UsbControlTransferParams = UsbControlTransferParams;
exports.UsbIsochronousPacket = UsbIsochronousPacket;
exports.UsbDevice = UsbDevice;
exports.UsbDevicePtr = UsbDevicePtr;
exports.UsbDeviceAssociatedPtr = UsbDeviceAssociatedPtr;
})();
Reference in a new issue View git blame Copy permalink