676 lines
20 KiB
JavaScript
Executable File
676 lines
20 KiB
JavaScript
Executable File
PDU = function() {
|
|
this.fields = [];
|
|
this.lengthBytes = 4;
|
|
};
|
|
|
|
PDU.prototype.length = function(fields) {
|
|
var len = 0;
|
|
fields.forEach(function(f) {
|
|
len += !f.getFields ? f.length() : f.length(f.getFields());
|
|
});
|
|
return len;
|
|
};
|
|
|
|
PDU.prototype.is = function(type) {
|
|
return this.type == type;
|
|
};
|
|
|
|
PDU.prototype.getFields = function(fields) {
|
|
var len = this.lengthField(fields);
|
|
fields.unshift(len);
|
|
if (this.type !== null) {
|
|
fields.unshift(new ReservedField());
|
|
fields.unshift(new HexField(this.type));
|
|
}
|
|
|
|
return fields;
|
|
};
|
|
|
|
PDU.prototype.lengthField = function(fields) {
|
|
if (this.lengthBytes == 4) {
|
|
return new UInt32Field(this.length(fields));
|
|
} else if (this.lengthBytes == 2) {
|
|
return new UInt16Field(this.length(fields));
|
|
} else {
|
|
throw 'Invalid length bytes';
|
|
}
|
|
};
|
|
|
|
PDU.prototype.read = function(stream) {
|
|
stream.read(C.TYPE_HEX, 1);
|
|
var length = stream.read(C.TYPE_UINT32);
|
|
this.readBytes(stream, length);
|
|
};
|
|
|
|
PDU.prototype.load = function(stream) {
|
|
return pduByStream(stream);
|
|
};
|
|
|
|
PDU.prototype.loadPDV = function(stream, length) {
|
|
if (stream.end()) return false;
|
|
var bytesRead = 0, pdvs = [];
|
|
while (bytesRead < length) {
|
|
var plength = stream.read(C.TYPE_UINT32),
|
|
pdv = new PresentationDataValueItem();
|
|
pdv.readBytes(stream, plength);
|
|
bytesRead += plength + 4;
|
|
|
|
pdvs.push(pdv);
|
|
}
|
|
|
|
return pdvs;
|
|
};
|
|
|
|
PDU.prototype.loadDicomMessage = function(stream, isCommand, isLast) {
|
|
var message = readMessage(stream, isCommand, isLast);
|
|
return message;
|
|
};
|
|
|
|
PDU.prototype.stream = function() {
|
|
var stream = new WriteStream(),
|
|
fields = this.getFields();
|
|
|
|
// writing to buffer
|
|
fields.forEach(function(field) {
|
|
field.write(stream);
|
|
});
|
|
|
|
return stream;
|
|
};
|
|
|
|
PDU.prototype.buffer = function() {
|
|
return this.stream().buffer();
|
|
};
|
|
|
|
var interpretCommand = function(stream, isLast) {
|
|
parseDicomMessage(stream);
|
|
};
|
|
|
|
mergePDVs = function(pdvs) {
|
|
var merges = [], count = pdvs.length, i = 0;
|
|
while (i < count) {console.log(pdvs[i].isLast, pdvs[i].type);
|
|
if (!pdvs[i].isLast) {
|
|
var j = i;
|
|
while (!pdvs[j++].isLast && j < count) {
|
|
pdvs[i].messageStream.concat(pdvs[j].messageStream);
|
|
}
|
|
|
|
merges.push(pdvs[i]);
|
|
i = j;
|
|
} else {
|
|
merges.push(pdvs[i++]);
|
|
}
|
|
}
|
|
|
|
return merges;
|
|
};
|
|
|
|
pduByStream = function(stream) {
|
|
if (stream.end()) return null;
|
|
|
|
var pduType = stream.read(C.TYPE_HEX, 1), typeNum = parseInt(pduType, 16), pdu = null;
|
|
//console.log("RECEIVED PDU-TYPE ", pduType);
|
|
switch (typeNum) {
|
|
case 0x01 : pdu = new AssociateRQ(); break;
|
|
case 0x02 : pdu = new AssociateAC(); break;
|
|
case 0x04 : pdu = new PDataTF(); break;
|
|
case 0x06 : pdu = new ReleaseRP(); break;
|
|
case 0x07 : pdu = new AssociateAbort(); break;
|
|
case 0x10 : pdu = new ApplicationContextItem(); break;
|
|
case 0x20 : pdu = new PresentationContextItem(); break;
|
|
case 0x21 : pdu = new PresentationContextItemAC(); break;
|
|
case 0x30 : pdu = new AbstractSyntaxItem(); break;
|
|
case 0x40 : pdu = new TransferSyntaxItem(); break;
|
|
case 0x50 : pdu = new UserInformationItem(); break;
|
|
case 0x51 : pdu = new MaximumLengthItem(); break;
|
|
case 0x52 : pdu = new ImplementationClassUIDItem(); break;
|
|
case 0x55 : pdu = new ImplementationVersionNameItem(); break;
|
|
default : throw 'Unrecoginized pdu type ' + pduType; break;
|
|
}
|
|
if (pdu)
|
|
pdu.read(stream);
|
|
|
|
return pdu;
|
|
};
|
|
|
|
var nextItemIs = function(stream, pduType) {
|
|
if (stream.end()) return false;
|
|
|
|
var nextType = stream.read(C.TYPE_HEX, 1);
|
|
stream.increment(-1);
|
|
return pduType == nextType;
|
|
};
|
|
|
|
AssociateRQ = function() {
|
|
PDU.call(this);
|
|
this.type = C.ITEM_TYPE_PDU_ASSOCIATE_RQ;
|
|
this.protocolVersion = 1;
|
|
};
|
|
|
|
util.inherits(AssociateRQ, PDU);
|
|
|
|
AssociateRQ.prototype.setProtocolVersion = function(version) {
|
|
this.protocolVersion = version;
|
|
};
|
|
|
|
AssociateRQ.prototype.setCalledAETitle = function(title) {
|
|
this.calledAETitle = title;
|
|
};
|
|
|
|
AssociateRQ.prototype.setCallingAETitle = function(title) {
|
|
this.callingAETitle = title;
|
|
};
|
|
|
|
AssociateRQ.prototype.setApplicationContextItem = function(item) {
|
|
this.applicationContextItem = item;
|
|
};
|
|
|
|
AssociateRQ.prototype.setPresentationContextItems = function(items) {
|
|
this.presentationContextItems = items;
|
|
};
|
|
|
|
AssociateRQ.prototype.setUserInformationItem = function(item) {
|
|
this.userInformationItem = item;
|
|
};
|
|
|
|
AssociateRQ.prototype.allAccepted = function() {
|
|
for (var i in this.presentationContextItems) {
|
|
var item = this.presentationContextItems[i];
|
|
if (!item.accepted()) return false;
|
|
}
|
|
|
|
return true;
|
|
};
|
|
|
|
AssociateRQ.prototype.getFields = function() {
|
|
var f = [
|
|
new UInt16Field(this.protocolVersion), new ReservedField(2),
|
|
new FilledField(this.calledAETitle, 16), new FilledField(this.callingAETitle, 16),
|
|
new ReservedField(32), this.applicationContextItem
|
|
];
|
|
this.presentationContextItems.forEach(function(context) {
|
|
f.push(context);
|
|
});
|
|
f.push(this.userInformationItem);
|
|
return AssociateRQ.super_.prototype.getFields.call(this, f);
|
|
};
|
|
|
|
AssociateRQ.prototype.readBytes = function(stream, length) {
|
|
this.type = C.ITEM_TYPE_PDU_ASSOCIATE_RQ;
|
|
var version = stream.read(C.TYPE_UINT16);
|
|
this.setProtocolVersion(version);
|
|
stream.increment(2);
|
|
var calledAE = stream.read(C.TYPE_ASCII, 16);
|
|
this.setCalledAETitle(calledAE);
|
|
var callingAE = stream.read(C.TYPE_ASCII, 16);
|
|
this.setCallingAETitle(callingAE);
|
|
stream.increment(32);
|
|
|
|
var appContext = this.load(stream);
|
|
this.setApplicationContextItem(appContext);
|
|
|
|
var presContexts = [];
|
|
do {
|
|
presContexts.push(this.load(stream));
|
|
} while (nextItemIs(stream, C.ITEM_TYPE_PRESENTATION_CONTEXT_AC));
|
|
this.setPresentationContextItems(presContexts);
|
|
|
|
var userItem = this.load(stream);
|
|
this.setUserInformationItem(userItem);
|
|
};
|
|
|
|
AssociateRQ.prototype.buffer = function() {
|
|
return AssociateRQ.super_.prototype.buffer.call(this);
|
|
};
|
|
|
|
AssociateAC = function() {
|
|
AssociateRQ.call(this);
|
|
};
|
|
|
|
util.inherits(AssociateAC, AssociateRQ);
|
|
|
|
AssociateAC.prototype.readBytes = function(stream, length) {
|
|
this.type = C.ITEM_TYPE_PDU_ASSOCIATE_AC;
|
|
var version = stream.read(C.TYPE_UINT16);
|
|
this.setProtocolVersion(version);
|
|
stream.increment(66);
|
|
|
|
var appContext = this.load(stream);
|
|
this.setApplicationContextItem(appContext);
|
|
|
|
var presContexts = [];
|
|
do {
|
|
presContexts.push(this.load(stream));
|
|
} while (nextItemIs(stream, C.ITEM_TYPE_PRESENTATION_CONTEXT_AC));
|
|
this.setPresentationContextItems(presContexts);
|
|
|
|
var userItem = this.load(stream);
|
|
this.setUserInformationItem(userItem);
|
|
};
|
|
|
|
AssociateAbort = function() {
|
|
this.type = C.ITEM_TYPE_PDU_AABORT;
|
|
this.source = 1;
|
|
this.reason = 0;
|
|
PDU.call(this);
|
|
};
|
|
|
|
util.inherits(AssociateAbort, PDU);
|
|
|
|
AssociateAbort.prototype.setSource = function(src) {
|
|
this.source = src;
|
|
};
|
|
|
|
AssociateAbort.prototype.setReason = function(reason) {
|
|
this.reason = reason;
|
|
};
|
|
|
|
AssociateAbort.prototype.readBytes = function(stream, length) {
|
|
stream.increment(2);
|
|
|
|
var source = stream.read(C.TYPE_UINT8);
|
|
this.setSource(source);
|
|
|
|
var reason = stream.read(C.TYPE_UINT8);
|
|
this.setReason(reason);
|
|
};
|
|
|
|
AssociateAbort.prototype.getFields = function() {
|
|
return AssociateAbort.super_.prototype.getFields.call(this, [
|
|
new ReservedField(), new ReservedField(),
|
|
new UInt8Field(this.source), new UInt8Field(this.reason)
|
|
]);
|
|
};
|
|
|
|
ReleaseRQ = function() {
|
|
this.type = C.ITEM_TYPE_PDU_RELEASE_RQ;
|
|
PDU.call(this);
|
|
};
|
|
|
|
util.inherits(ReleaseRQ, PDU);
|
|
|
|
ReleaseRQ.prototype.getFields = function() {
|
|
return ReleaseRQ.super_.prototype.getFields.call(this, [ new ReservedField(4) ]);
|
|
};
|
|
|
|
ReleaseRP = function() {
|
|
this.type = C.ITEM_TYPE_PDU_RELEASE_RP;
|
|
PDU.call(this);
|
|
};
|
|
|
|
util.inherits(ReleaseRP, PDU);
|
|
|
|
ReleaseRP.prototype.readBytes = function(stream, length) {
|
|
stream.increment(4);
|
|
};
|
|
|
|
ReleaseRP.prototype.getFields = function() {
|
|
return ReleaseRP.super_.prototype.getFields.call(this, [ new ReservedField(4) ]);
|
|
};
|
|
|
|
PDataTF = function() {
|
|
this.type = C.ITEM_TYPE_PDU_PDATA;
|
|
this.presentationDataValueItems = [];
|
|
PDU.call(this);
|
|
};
|
|
|
|
util.inherits(PDataTF, PDU);
|
|
|
|
PDataTF.prototype.setPresentationDataValueItems = function(items) {
|
|
this.presentationDataValueItems = items ? items : [];
|
|
};
|
|
|
|
PDataTF.prototype.getFields = function() {
|
|
var fields = this.presentationDataValueItems;
|
|
|
|
return PDataTF.super_.prototype.getFields.call(this, fields);
|
|
};
|
|
|
|
PDataTF.prototype.readBytes = function(stream, length) {
|
|
var pdvs = this.loadPDV(stream, length);
|
|
//let merges = mergePDVs(pdvs);
|
|
|
|
this.setPresentationDataValueItems(pdvs);
|
|
};
|
|
|
|
Item = function() {
|
|
PDU.call(this);
|
|
this.lengthBytes = 2;
|
|
};
|
|
|
|
util.inherits(Item, PDU);
|
|
|
|
Item.prototype.read = function(stream) {
|
|
stream.read(C.TYPE_HEX, 1);
|
|
var length = stream.read(C.TYPE_UINT16);
|
|
this.readBytes(stream, length);
|
|
};
|
|
|
|
Item.prototype.write = function(stream) {
|
|
stream.concat(this.stream());
|
|
};
|
|
|
|
Item.prototype.getFields = function(fields) {
|
|
return Item.super_.prototype.getFields.call(this, fields);
|
|
};
|
|
|
|
PresentationDataValueItem = function(context) {
|
|
this.type = null;
|
|
this.isLast = true;
|
|
this.dataFragment = null;
|
|
this.contextId = context;
|
|
this.messageStream = null;
|
|
Item.call(this);
|
|
|
|
this.lengthBytes = 4;
|
|
};
|
|
|
|
util.inherits(PresentationDataValueItem, Item);
|
|
|
|
PresentationDataValueItem.prototype.setContextId = function(id) {
|
|
this.contextId = id;
|
|
};
|
|
|
|
PresentationDataValueItem.prototype.setFlag = function(flag) {
|
|
this.flag = flag;
|
|
};
|
|
|
|
PresentationDataValueItem.prototype.setPresentationDataValue = function(pdv) {
|
|
this.pdv = pdv;
|
|
};
|
|
|
|
PresentationDataValueItem.prototype.setMessage = function(msg) {
|
|
this.dataFragment = msg;
|
|
};
|
|
|
|
PresentationDataValueItem.prototype.getMessage = function() {
|
|
return this.dataFragment;
|
|
};
|
|
|
|
PresentationDataValueItem.prototype.readBytes = function(stream, length) {
|
|
this.contextId = stream.read(C.TYPE_UINT8);
|
|
var messageHeader = stream.read(C.TYPE_UINT8);
|
|
this.isLast = messageHeader >> 1;
|
|
this.type = messageHeader & 1 ? C.DATA_TYPE_COMMAND : C.DATA_TYPE_DATA;
|
|
|
|
//load dicom messages
|
|
this.messageStream = stream.more(length - 2);
|
|
};
|
|
|
|
PresentationDataValueItem.prototype.getFields = function() {
|
|
var fields = [ new UInt8Field(this.contextId) ];
|
|
//define header
|
|
var messageHeader = (1 & this.dataFragment.type) | ((this.isLast ? 1 : 0) << 1);
|
|
fields.push(new UInt8Field(messageHeader));
|
|
|
|
fields.push(this.dataFragment);
|
|
/*var stream = new WriteStream();this.dataFragment.write(stream);
|
|
//var f = this.dataFragment.getFields();
|
|
//var wr = new WriteStream();f[0].setSyntax(this.dataFragment.syntax);f[0].write(wr);
|
|
var rst = stream.toReadBuffer();
|
|
rst.setEndian(C.LITTLE_ENDIAN);
|
|
var group = rst.read(C.TYPE_UINT16),
|
|
element = rst.read(C.TYPE_UINT16),
|
|
tag = tagFromNumbers(group, element);
|
|
|
|
console.log(tag.toString(), rst.read(C.TYPE_UINT32));*/
|
|
return PresentationDataValueItem.super_.prototype.getFields.call(this, fields);
|
|
};
|
|
|
|
ApplicationContextItem = function() {
|
|
this.type = C.ITEM_TYPE_APPLICATION_CONTEXT;
|
|
this.applicationContextName = C.APPLICATION_CONTEXT_NAME;
|
|
Item.call(this);
|
|
};
|
|
|
|
util.inherits(ApplicationContextItem, Item);
|
|
|
|
ApplicationContextItem.prototype.setApplicationContextName = function(name) {
|
|
this.applicationContextName = name;
|
|
};
|
|
|
|
ApplicationContextItem.prototype.getFields = function() {
|
|
return ApplicationContextItem.super_.prototype.getFields.call(this, [ new StringField(this.applicationContextName) ]);
|
|
};
|
|
|
|
ApplicationContextItem.prototype.readBytes = function(stream, length) {
|
|
var appContext = stream.read(C.TYPE_ASCII, length);
|
|
this.setApplicationContextName(appContext);
|
|
};
|
|
|
|
ApplicationContextItem.prototype.buffer = function() {
|
|
return ApplicationContextItem.super_.prototype.buffer.call(this);
|
|
};
|
|
|
|
PresentationContextItem = function() {
|
|
this.type = C.ITEM_TYPE_PRESENTATION_CONTEXT;
|
|
Item.call(this);
|
|
};
|
|
|
|
util.inherits(PresentationContextItem, Item);
|
|
|
|
PresentationContextItem.prototype.setPresentationContextID = function(id) {
|
|
this.presentationContextID = id;
|
|
};
|
|
|
|
PresentationContextItem.prototype.setAbstractSyntaxItem = function(item) {
|
|
this.abstractSyntaxItem = item;
|
|
};
|
|
|
|
PresentationContextItem.prototype.setTransferSyntaxesItems = function(items) {
|
|
this.transferSyntaxesItems = items;
|
|
};
|
|
|
|
PresentationContextItem.prototype.setResultReason = function(reason) {
|
|
this.resultReason = reason;
|
|
};
|
|
|
|
PresentationContextItem.prototype.accepted = function() {
|
|
return this.resultReason == 0;
|
|
};
|
|
|
|
PresentationContextItem.prototype.readBytes = function(stream, length) {
|
|
var contextId = stream.read(C.TYPE_UINT8);
|
|
this.setPresentationContextID(contextId);
|
|
stream.increment(1);
|
|
stream.increment(1);
|
|
stream.increment(1);
|
|
|
|
var abstractItem = this.load(stream);
|
|
this.setAbstractSyntaxItem(abstractItem);
|
|
|
|
var transContexts = [];
|
|
do {
|
|
transContexts.push(this.load(stream));
|
|
} while (nextItemIs(stream, C.ITEM_TYPE_TRANSFER_CONTEXT));
|
|
this.setTransferSyntaxesItems(transContexts);
|
|
};
|
|
|
|
PresentationContextItem.prototype.getFields = function() {
|
|
var f = [
|
|
new UInt8Field(this.presentationContextID),
|
|
new ReservedField(), new ReservedField(), new ReservedField(), this.abstractSyntaxItem
|
|
];
|
|
this.transferSyntaxesItems.forEach(function(syntaxItem) {
|
|
f.push(syntaxItem);
|
|
});
|
|
return PresentationContextItem.super_.prototype.getFields.call(this, f);
|
|
};
|
|
|
|
PresentationContextItem.prototype.buffer = function() {
|
|
return PresentationContextItem.super_.prototype.buffer.call(this);
|
|
};
|
|
|
|
PresentationContextItemAC = function() {
|
|
this.type = C.ITEM_TYPE_PRESENTATION_CONTEXT_AC;
|
|
Item.call(this);
|
|
};
|
|
|
|
util.inherits(PresentationContextItemAC, PresentationContextItem);
|
|
|
|
PresentationContextItemAC.prototype.readBytes = function(stream, length) {
|
|
var contextId = stream.read(C.TYPE_UINT8);
|
|
this.setPresentationContextID(contextId);
|
|
stream.increment(1);
|
|
var resultReason = stream.read(C.TYPE_UINT8);
|
|
this.setResultReason(resultReason);
|
|
stream.increment(1);
|
|
|
|
var transItem = this.load(stream);
|
|
this.setTransferSyntaxesItems([ transItem ]);
|
|
};
|
|
|
|
AbstractSyntaxItem = function() {
|
|
this.type = C.ITEM_TYPE_ABSTRACT_CONTEXT;
|
|
Item.call(this);
|
|
};
|
|
|
|
util.inherits(AbstractSyntaxItem, Item);
|
|
|
|
AbstractSyntaxItem.prototype.setAbstractSyntaxName = function(name) {
|
|
this.abstractSyntaxName = name;
|
|
};
|
|
|
|
AbstractSyntaxItem.prototype.getFields = function() {
|
|
return AbstractSyntaxItem.super_.prototype.getFields.call(this, [ new StringField(this.abstractSyntaxName) ]);
|
|
};
|
|
|
|
AbstractSyntaxItem.prototype.buffer = function() {
|
|
return AbstractSyntaxItem.super_.prototype.buffer.call(this);
|
|
};
|
|
|
|
AbstractSyntaxItem.prototype.readBytes = function(stream, length) {
|
|
var name = stream.read(C.TYPE_ASCII, length);
|
|
this.setAbstractSyntaxName(name);
|
|
};
|
|
|
|
TransferSyntaxItem = function() {
|
|
this.type = C.ITEM_TYPE_TRANSFER_CONTEXT;
|
|
Item.call(this);
|
|
};
|
|
|
|
util.inherits(TransferSyntaxItem, Item);
|
|
|
|
TransferSyntaxItem.prototype.setTransferSyntaxName = function(name) {
|
|
this.transferSyntaxName = name;
|
|
};
|
|
|
|
TransferSyntaxItem.prototype.readBytes = function(stream, length) {
|
|
var transfer = stream.read(C.TYPE_ASCII, length);
|
|
this.setTransferSyntaxName(transfer);
|
|
};
|
|
|
|
TransferSyntaxItem.prototype.getFields = function() {
|
|
return TransferSyntaxItem.super_.prototype.getFields.call(this, [ new StringField(this.transferSyntaxName) ]);
|
|
};
|
|
|
|
TransferSyntaxItem.prototype.buffer = function() {
|
|
return TransferSyntaxItem.super_.prototype.buffer.call(this);
|
|
};
|
|
|
|
UserInformationItem = function() {
|
|
this.type = C.ITEM_TYPE_USER_INFORMATION;
|
|
Item.call(this);
|
|
};
|
|
|
|
util.inherits(UserInformationItem, Item);
|
|
|
|
UserInformationItem.prototype.setUserDataItems = function(items) {
|
|
this.userDataItems = items;
|
|
};
|
|
|
|
UserInformationItem.prototype.readBytes = function(stream, length) {
|
|
var items = [], pdu = this.load(stream);
|
|
|
|
do {
|
|
items.push(pdu);
|
|
} while (pdu = this.load(stream));
|
|
this.setUserDataItems(items);
|
|
};
|
|
|
|
UserInformationItem.prototype.getFields = function() {
|
|
var f = [];
|
|
this.userDataItems.forEach(function(userData) {
|
|
f.push(userData);
|
|
});
|
|
return UserInformationItem.super_.prototype.getFields.call(this, f);
|
|
};
|
|
|
|
UserInformationItem.prototype.buffer = function() {
|
|
return UserInformationItem.super_.prototype.buffer.call(this);
|
|
};
|
|
|
|
ImplementationClassUIDItem = function() {
|
|
this.type = C.ITEM_TYPE_IMPLEMENTATION_UID;
|
|
Item.call(this);
|
|
};
|
|
|
|
util.inherits(ImplementationClassUIDItem, Item);
|
|
|
|
ImplementationClassUIDItem.prototype.setImplementationClassUID = function(id) {
|
|
this.implementationClassUID = id;
|
|
};
|
|
|
|
ImplementationClassUIDItem.prototype.readBytes = function(stream, length) {
|
|
var uid = stream.read(C.TYPE_ASCII, length);
|
|
this.setImplementationClassUID(uid);
|
|
};
|
|
|
|
ImplementationClassUIDItem.prototype.getFields = function() {
|
|
return ImplementationClassUIDItem.super_.prototype.getFields.call(this, [ new StringField(this.implementationClassUID) ]);
|
|
};
|
|
|
|
ImplementationClassUIDItem.prototype.buffer = function() {
|
|
return ImplementationClassUIDItem.super_.prototype.buffer.call(this);
|
|
};
|
|
|
|
ImplementationVersionNameItem = function() {
|
|
this.type = C.ITEM_TYPE_IMPLEMENTATION_VERSION;
|
|
Item.call(this);
|
|
};
|
|
|
|
util.inherits(ImplementationVersionNameItem, Item);
|
|
|
|
ImplementationVersionNameItem.prototype.setImplementationVersionName = function(name) {
|
|
this.implementationVersionName = name;
|
|
};
|
|
|
|
ImplementationVersionNameItem.prototype.readBytes = function(stream, length) {
|
|
var name = stream.read(C.TYPE_ASCII, length);
|
|
this.setImplementationVersionName(name);
|
|
};
|
|
|
|
ImplementationVersionNameItem.prototype.getFields = function() {
|
|
return ImplementationVersionNameItem.super_.prototype.getFields.call(this, [ new StringField(this.implementationVersionName) ]);
|
|
};
|
|
|
|
ImplementationVersionNameItem.prototype.buffer = function() {
|
|
return ImplementationVersionNameItem.super_.prototype.buffer.call(this);
|
|
};
|
|
|
|
MaximumLengthItem = function() {
|
|
this.type = C.ITEM_TYPE_MAXIMUM_LENGTH;
|
|
this.maximumLengthReceived = 32768;
|
|
Item.call(this);
|
|
};
|
|
|
|
util.inherits(MaximumLengthItem, Item);
|
|
|
|
MaximumLengthItem.prototype.setMaximumLengthReceived = function(length) {
|
|
this.maximumLengthReceived = length;
|
|
};
|
|
|
|
MaximumLengthItem.prototype.readBytes = function(stream, length) {
|
|
var l = stream.read(C.TYPE_UINT32);
|
|
this.setMaximumLengthReceived(l);
|
|
};
|
|
|
|
MaximumLengthItem.prototype.getFields = function() {
|
|
return MaximumLengthItem.super_.prototype.getFields.call(this, [ new UInt32Field(this.maximumLengthReceived) ]);
|
|
};
|
|
|
|
MaximumLengthItem.prototype.buffer = function() {
|
|
return MaximumLengthItem.super_.prototype.buffer.call(this);
|
|
};
|
|
|