### class
PacketBuilder.LazyPacket
Unlike the [PacketBuilder.Packet](#Packet) class, this class ALP action methods do not trigger a binary packet
build right away. Instead they add the ALP packet corresponding to the call to an internal representation that can be built later.
Therefore, the ALP action methods return the original packet itself instead of a new packet (as opposed to the
[PacketBuilder.Packet](#Packet) methods behavior).
See [examples](#ExamplePacketLazy) for more details on the different behaviors between the packet classes.
#### Standard methods
##### `build()`: [PacketBuilder.Packet](#Packet)
Builds an ALP packet.
##### `build_buffer()`: `Buffer`
Builds the current ALP packet into a buffer.
##### `xplain()`: `any[]`
Gives an [`xplain`](#xplain) representation of this packet.
##### `list()`: `any[]`
Return an Object representation of the contained ALP actions that can be passed the `alp-lib.build` to build the
corresponding binary packet.
#### Specification dependent methods
Implements all the [specification dependent PacketBuilder.Packet methods](#SpecBuildMethods) but in a "lazy" way.
Examples
======================================================================================================
###
Parsing action
```
const AT = require("../alp_tools");
const read_command_packet = Buffer.from("B45641420007")
console.log("parse", AT.parse(binary));
console.log("parse.xplain", AT.parse.xplain(binary));
let complex_payload = new Buffer("B400F3640004000841010142004142000941420001", "hex");
console.log("Complex payload explained:", AT.parse.xplain(complex_payload));
```
###
Common ALP actions building
```
const AT = require("./alp_tools");
// Print helper
function bin_pkt_print(first_line, binary, no_xplain) {
console.log(first_line);
console.log(binary.buffer());
// Comparing the standard parse and xplain parse versions
console.log("PARSE", AT.parse(binary));
console.log("PARSE.XPLAIN", AT.parse.xplain(binary));
console.log();
}
// Creating a packet builder
let alp_builder = new AT.PacketBuilder();
// Building a status
let status = alp_builder.status({
ext: 0,
action_id: 1,
status: 2,
});
bin_pkt_print("STATUS:", status, true);
// Building a local read file
let local_read_file = alp_builder
.tag({
eop: true,
tag_id: 4,
}).read_file({
resp: true,
group: false,
file_id: 0, // UID file
file_offset: 0,
length: 8,
});
bin_pkt_print("LOCAL_READ_FILE:", local_read_file, true);
// Setting some common default parameters for the ALP builder for ergonomy
alp_builder.set_default_params({
tag: {eop: true, tag_id: 0},
read_file: {resp: true, group: false, file_offset: 0},
write_file: {resp: true, group: false, file_offset: 0},
fwd: {
resp: true,
group: false,
itf_id: 0xD7,
stop_on_err: false,
record: false,
retry_mode: 0,
resp_mode: 1,
dorm_to: 0,
te: 0,
addr: {
addr_type: 2,
nls_method: 6,
estimated_reached: 1,
},
},
});
// Building the local read more easily
let easy_local_read_file = alp_builder
.tag()
.read_file({
file_id: 0, // UID file
length: 8,
});
bin_pkt_print("EASY_LOCAL_READ_FILE:", easy_local_read_file, true);
// Building a distant write file
let distant_write_file = alp_builder
.tag()
.fwd({
addr: {
id: Buffer.from("001BC50C70000D11", "hex"),
access_class: 0x01,
},
})
.write_file({
file_id: 0x42, // scratch file on devices modem
data: Buffer.from("FEDCBA", "hex"),
});
// Unfortunately, as can be seen in the next print, AT.parse.xplain still have trouble explaining some action
// fields.
bin_pkt_print("DISTANT_WRITE_FILE:", distant_write_file, true);
```
###
Difference between [Packet](#Packet) and [LazyPacket](#LazyPacket)
```
const AT = require("../alp_tools");
// Creating a packet builder
let alp_builder = new AT.PacketBuilder();
// Setting some common default parameters for the ALP builder for ergonomy
alp_builder.set_default_params({
tag: {eop: true, tag_id: 0},
read_file: {resp: true, group: false, file_offset: 0},
write_file: {resp: true, group: false, file_offset: 0},
fwd: {
resp: true,
group: false,
itf_id: 0xD7,
stop_on_err: false,
record: false,
retry_mode: 0,
resp_mode: 1,
dorm_to: 0,
te: 0,
addr: {
addr_type: 2,
nls_method: 6,
estimated_reached: 1,
},
},
});
// Test function
function test_packet(packet) {
let tag = packet.tag();
let tagged_read = tag.read_file({file_id: 0, length: 5});
console.log("Packet tag: ", tag.toString());
console.log("Packet tagged_read", tagged_read.toString());
}
// Test Packet
console.log("Testing Packet");
test_packet(alp_builder.new());
console.log();
// Test LazyPacket
console.log("Testing LazyPacket");
test_packet(alp_builder.lazy());
console.log("Oh no! Packet tag contains a read!");
console.log();
// Correct LazyPacket usage
let packet = alp_builder.lazy();
packet.tag();
for(let i = 0; i < 10; ++i) {
packet.read_file({file_id: i, length: i});
}
console.log("LazyPacket many reads:", packet.toString());
```