FormatOptions are used to transport additional information to the entries. This includes forinstance the information how a service instance is reachable (IP-Address, TransportProtocol, Port Number).
This page hosts a formal specification of AUTOSAR SOME/IP Service Discovery Options using Kaitai Struct. This specification can be automatically translated into a variety of programming languages to get a parsing library.
// This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
import io.kaitai.struct.ByteBufferKaitaiStream;
import io.kaitai.struct.KaitaiStruct;
import io.kaitai.struct.KaitaiStream;
import java.io.IOException;
import java.util.ArrayList;
import io.kaitai.struct.ConsistencyError;
import java.util.Objects;
import java.util.Map;
import java.util.HashMap;
import java.nio.charset.StandardCharsets;
import java.nio.charset.Charset;
import java.util.List;
/**
* FormatOptions are used to transport additional information to the entries.
* This includes forinstance the information how a service instance is
* reachable (IP-Address, TransportProtocol, Port Number).
* @see <a href="https://www.autosar.org/fileadmin/standards/foundation/19-11/AUTOSAR_PRS_SOMEIPServiceDiscoveryProtocol.pdf
* -">section 4.1.2.4 Options Format</a>
*/
public class SomeIpSdOptions extends KaitaiStruct.ReadWrite {
public static SomeIpSdOptions fromFile(String fileName) throws IOException {
return new SomeIpSdOptions(new ByteBufferKaitaiStream(fileName));
}
public SomeIpSdOptions() {
this(null, null, null);
}
public SomeIpSdOptions(KaitaiStream _io) {
this(_io, null, null);
}
public SomeIpSdOptions(KaitaiStream _io, KaitaiStruct.ReadWrite _parent) {
this(_io, _parent, null);
}
public SomeIpSdOptions(KaitaiStream _io, KaitaiStruct.ReadWrite _parent, SomeIpSdOptions _root) {
super(_io);
this._parent = _parent;
this._root = _root == null ? this : _root;
}
public void _read() {
this.entries = new ArrayList<SdOption>();
{
int i = 0;
while (!this._io.isEof()) {
SdOption _t_entries = new SdOption(this._io, this, _root);
try {
_t_entries._read();
} finally {
this.entries.add(_t_entries);
}
i++;
}
}
_dirty = false;
}
public void _fetchInstances() {
for (int i = 0; i < this.entries.size(); i++) {
this.entries.get(((Number) (i)).intValue())._fetchInstances();
}
}
public void _write_Seq() {
_assertNotDirty();
for (int i = 0; i < this.entries.size(); i++) {
if (this._io.isEof())
throw new ConsistencyError("entries", 0, this._io.size() - this._io.pos());
this.entries.get(((Number) (i)).intValue())._write_Seq(this._io);
}
if (!(this._io.isEof()))
throw new ConsistencyError("entries", 0, this._io.size() - this._io.pos());
}
public void _check() {
for (int i = 0; i < this.entries.size(); i++) {
if (!Objects.equals(this.entries.get(((Number) (i)).intValue())._root(), _root()))
throw new ConsistencyError("entries", _root(), this.entries.get(((Number) (i)).intValue())._root());
if (!Objects.equals(this.entries.get(((Number) (i)).intValue())._parent(), this))
throw new ConsistencyError("entries", this, this.entries.get(((Number) (i)).intValue())._parent());
}
_dirty = false;
}
public static class SdOption extends KaitaiStruct.ReadWrite {
public static SdOption fromFile(String fileName) throws IOException {
return new SdOption(new ByteBufferKaitaiStream(fileName));
}
public enum OptionTypes {
CONFIGURATION_OPTION(1),
LOAD_BALANCING_OPTION(2),
IPV4_ENDPOINT_OPTION(4),
IPV6_ENDPOINT_OPTION(6),
IPV4_MULTICAST_OPTION(20),
IPV6_MULTICAST_OPTION(22),
IPV4_SD_ENDPOINT_OPTION(36),
IPV6_SD_ENDPOINT_OPTION(38);
private final long id;
OptionTypes(long id) { this.id = id; }
public long id() { return id; }
private static final Map<Long, OptionTypes> byId = new HashMap<Long, OptionTypes>(8);
static {
for (OptionTypes e : OptionTypes.values())
byId.put(e.id(), e);
}
public static OptionTypes byId(long id) { return byId.get(id); }
}
public SdOption() {
this(null, null, null);
}
public SdOption(KaitaiStream _io) {
this(_io, null, null);
}
public SdOption(KaitaiStream _io, SomeIpSdOptions _parent) {
this(_io, _parent, null);
}
public SdOption(KaitaiStream _io, SomeIpSdOptions _parent, SomeIpSdOptions _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.header = new SdOptionHeader(this._io, this, _root);
this.header._read();
{
OptionTypes on = header().type();
if (on != null) {
switch (header().type()) {
case CONFIGURATION_OPTION: {
this.content = new SdConfigurationOption(this._io, this, _root);
((SdConfigurationOption) (this.content))._read();
break;
}
case IPV4_ENDPOINT_OPTION: {
this.content = new SdIpv4EndpointOption(this._io, this, _root);
((SdIpv4EndpointOption) (this.content))._read();
break;
}
case IPV4_MULTICAST_OPTION: {
this.content = new SdIpv4MulticastOption(this._io, this, _root);
((SdIpv4MulticastOption) (this.content))._read();
break;
}
case IPV4_SD_ENDPOINT_OPTION: {
this.content = new SdIpv4SdEndpointOption(this._io, this, _root);
((SdIpv4SdEndpointOption) (this.content))._read();
break;
}
case IPV6_ENDPOINT_OPTION: {
this.content = new SdIpv6EndpointOption(this._io, this, _root);
((SdIpv6EndpointOption) (this.content))._read();
break;
}
case IPV6_MULTICAST_OPTION: {
this.content = new SdIpv6MulticastOption(this._io, this, _root);
((SdIpv6MulticastOption) (this.content))._read();
break;
}
case IPV6_SD_ENDPOINT_OPTION: {
this.content = new SdIpv6SdEndpointOption(this._io, this, _root);
((SdIpv6SdEndpointOption) (this.content))._read();
break;
}
case LOAD_BALANCING_OPTION: {
this.content = new SdLoadBalancingOption(this._io, this, _root);
((SdLoadBalancingOption) (this.content))._read();
break;
}
}
}
}
_dirty = false;
}
public void _fetchInstances() {
this.header._fetchInstances();
{
OptionTypes on = header().type();
if (on != null) {
switch (header().type()) {
case CONFIGURATION_OPTION: {
((SdConfigurationOption) (this.content))._fetchInstances();
break;
}
case IPV4_ENDPOINT_OPTION: {
((SdIpv4EndpointOption) (this.content))._fetchInstances();
break;
}
case IPV4_MULTICAST_OPTION: {
((SdIpv4MulticastOption) (this.content))._fetchInstances();
break;
}
case IPV4_SD_ENDPOINT_OPTION: {
((SdIpv4SdEndpointOption) (this.content))._fetchInstances();
break;
}
case IPV6_ENDPOINT_OPTION: {
((SdIpv6EndpointOption) (this.content))._fetchInstances();
break;
}
case IPV6_MULTICAST_OPTION: {
((SdIpv6MulticastOption) (this.content))._fetchInstances();
break;
}
case IPV6_SD_ENDPOINT_OPTION: {
((SdIpv6SdEndpointOption) (this.content))._fetchInstances();
break;
}
case LOAD_BALANCING_OPTION: {
((SdLoadBalancingOption) (this.content))._fetchInstances();
break;
}
}
}
}
}
public void _write_Seq() {
_assertNotDirty();
this.header._write_Seq(this._io);
{
OptionTypes on = header().type();
if (on != null) {
switch (header().type()) {
case CONFIGURATION_OPTION: {
((SdConfigurationOption) (this.content))._write_Seq(this._io);
break;
}
case IPV4_ENDPOINT_OPTION: {
((SdIpv4EndpointOption) (this.content))._write_Seq(this._io);
break;
}
case IPV4_MULTICAST_OPTION: {
((SdIpv4MulticastOption) (this.content))._write_Seq(this._io);
break;
}
case IPV4_SD_ENDPOINT_OPTION: {
((SdIpv4SdEndpointOption) (this.content))._write_Seq(this._io);
break;
}
case IPV6_ENDPOINT_OPTION: {
((SdIpv6EndpointOption) (this.content))._write_Seq(this._io);
break;
}
case IPV6_MULTICAST_OPTION: {
((SdIpv6MulticastOption) (this.content))._write_Seq(this._io);
break;
}
case IPV6_SD_ENDPOINT_OPTION: {
((SdIpv6SdEndpointOption) (this.content))._write_Seq(this._io);
break;
}
case LOAD_BALANCING_OPTION: {
((SdLoadBalancingOption) (this.content))._write_Seq(this._io);
break;
}
}
}
}
}
public void _check() {
if (!Objects.equals(this.header._root(), _root()))
throw new ConsistencyError("header", _root(), this.header._root());
if (!Objects.equals(this.header._parent(), this))
throw new ConsistencyError("header", this, this.header._parent());
{
OptionTypes on = header().type();
if (on != null) {
switch (header().type()) {
case CONFIGURATION_OPTION: {
if (!Objects.equals(((SomeIpSdOptions.SdOption.SdConfigurationOption) (this.content))._root(), _root()))
throw new ConsistencyError("content", _root(), ((SomeIpSdOptions.SdOption.SdConfigurationOption) (this.content))._root());
if (!Objects.equals(((SomeIpSdOptions.SdOption.SdConfigurationOption) (this.content))._parent(), this))
throw new ConsistencyError("content", this, ((SomeIpSdOptions.SdOption.SdConfigurationOption) (this.content))._parent());
break;
}
case IPV4_ENDPOINT_OPTION: {
if (!Objects.equals(((SomeIpSdOptions.SdOption.SdIpv4EndpointOption) (this.content))._root(), _root()))
throw new ConsistencyError("content", _root(), ((SomeIpSdOptions.SdOption.SdIpv4EndpointOption) (this.content))._root());
if (!Objects.equals(((SomeIpSdOptions.SdOption.SdIpv4EndpointOption) (this.content))._parent(), this))
throw new ConsistencyError("content", this, ((SomeIpSdOptions.SdOption.SdIpv4EndpointOption) (this.content))._parent());
break;
}
case IPV4_MULTICAST_OPTION: {
if (!Objects.equals(((SomeIpSdOptions.SdOption.SdIpv4MulticastOption) (this.content))._root(), _root()))
throw new ConsistencyError("content", _root(), ((SomeIpSdOptions.SdOption.SdIpv4MulticastOption) (this.content))._root());
if (!Objects.equals(((SomeIpSdOptions.SdOption.SdIpv4MulticastOption) (this.content))._parent(), this))
throw new ConsistencyError("content", this, ((SomeIpSdOptions.SdOption.SdIpv4MulticastOption) (this.content))._parent());
break;
}
case IPV4_SD_ENDPOINT_OPTION: {
if (!Objects.equals(((SomeIpSdOptions.SdOption.SdIpv4SdEndpointOption) (this.content))._root(), _root()))
throw new ConsistencyError("content", _root(), ((SomeIpSdOptions.SdOption.SdIpv4SdEndpointOption) (this.content))._root());
if (!Objects.equals(((SomeIpSdOptions.SdOption.SdIpv4SdEndpointOption) (this.content))._parent(), this))
throw new ConsistencyError("content", this, ((SomeIpSdOptions.SdOption.SdIpv4SdEndpointOption) (this.content))._parent());
break;
}
case IPV6_ENDPOINT_OPTION: {
if (!Objects.equals(((SomeIpSdOptions.SdOption.SdIpv6EndpointOption) (this.content))._root(), _root()))
throw new ConsistencyError("content", _root(), ((SomeIpSdOptions.SdOption.SdIpv6EndpointOption) (this.content))._root());
if (!Objects.equals(((SomeIpSdOptions.SdOption.SdIpv6EndpointOption) (this.content))._parent(), this))
throw new ConsistencyError("content", this, ((SomeIpSdOptions.SdOption.SdIpv6EndpointOption) (this.content))._parent());
break;
}
case IPV6_MULTICAST_OPTION: {
if (!Objects.equals(((SomeIpSdOptions.SdOption.SdIpv6MulticastOption) (this.content))._root(), _root()))
throw new ConsistencyError("content", _root(), ((SomeIpSdOptions.SdOption.SdIpv6MulticastOption) (this.content))._root());
if (!Objects.equals(((SomeIpSdOptions.SdOption.SdIpv6MulticastOption) (this.content))._parent(), this))
throw new ConsistencyError("content", this, ((SomeIpSdOptions.SdOption.SdIpv6MulticastOption) (this.content))._parent());
break;
}
case IPV6_SD_ENDPOINT_OPTION: {
if (!Objects.equals(((SomeIpSdOptions.SdOption.SdIpv6SdEndpointOption) (this.content))._root(), _root()))
throw new ConsistencyError("content", _root(), ((SomeIpSdOptions.SdOption.SdIpv6SdEndpointOption) (this.content))._root());
if (!Objects.equals(((SomeIpSdOptions.SdOption.SdIpv6SdEndpointOption) (this.content))._parent(), this))
throw new ConsistencyError("content", this, ((SomeIpSdOptions.SdOption.SdIpv6SdEndpointOption) (this.content))._parent());
break;
}
case LOAD_BALANCING_OPTION: {
if (!Objects.equals(((SomeIpSdOptions.SdOption.SdLoadBalancingOption) (this.content))._root(), _root()))
throw new ConsistencyError("content", _root(), ((SomeIpSdOptions.SdOption.SdLoadBalancingOption) (this.content))._root());
if (!Objects.equals(((SomeIpSdOptions.SdOption.SdLoadBalancingOption) (this.content))._parent(), this))
throw new ConsistencyError("content", this, ((SomeIpSdOptions.SdOption.SdLoadBalancingOption) (this.content))._parent());
break;
}
}
}
}
_dirty = false;
}
public static class SdConfigKvPair extends KaitaiStruct.ReadWrite {
public static SdConfigKvPair fromFile(String fileName) throws IOException {
return new SdConfigKvPair(new ByteBufferKaitaiStream(fileName));
}
public SdConfigKvPair() {
this(null, null, null);
}
public SdConfigKvPair(KaitaiStream _io) {
this(_io, null, null);
}
public SdConfigKvPair(KaitaiStream _io, SomeIpSdOptions.SdOption.SdConfigString _parent) {
this(_io, _parent, null);
}
public SdConfigKvPair(KaitaiStream _io, SomeIpSdOptions.SdOption.SdConfigString _parent, SomeIpSdOptions _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.key = new String(this._io.readBytesTerm((byte) 61, false, true, true), StandardCharsets.US_ASCII);
this.value = new String(this._io.readBytesFull(), StandardCharsets.US_ASCII);
_dirty = false;
}
public void _fetchInstances() {
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeBytes((this.key).getBytes(Charset.forName("ASCII")));
this._io.writeU1(61);
this._io.writeBytes((this.value).getBytes(Charset.forName("ASCII")));
if (!(this._io.isEof()))
throw new ConsistencyError("value", 0, this._io.size() - this._io.pos());
}
public void _check() {
if (KaitaiStream.byteArrayIndexOf((this.key).getBytes(Charset.forName("ASCII")), ((byte) 61)) != -1)
throw new ConsistencyError("key", -1, KaitaiStream.byteArrayIndexOf((this.key).getBytes(Charset.forName("ASCII")), ((byte) 61)));
_dirty = false;
}
private String key;
private String value;
private SomeIpSdOptions _root;
private SomeIpSdOptions.SdOption.SdConfigString _parent;
public String key() { return key; }
public void setKey(String _v) { _dirty = true; key = _v; }
public String value() { return value; }
public void setValue(String _v) { _dirty = true; value = _v; }
public SomeIpSdOptions _root() { return _root; }
public void set_root(SomeIpSdOptions _v) { _dirty = true; _root = _v; }
public SomeIpSdOptions.SdOption.SdConfigString _parent() { return _parent; }
public void set_parent(SomeIpSdOptions.SdOption.SdConfigString _v) { _dirty = true; _parent = _v; }
}
public static class SdConfigString extends KaitaiStruct.ReadWrite {
public static SdConfigString fromFile(String fileName) throws IOException {
return new SdConfigString(new ByteBufferKaitaiStream(fileName));
}
public SdConfigString() {
this(null, null, null);
}
public SdConfigString(KaitaiStream _io) {
this(_io, null, null);
}
public SdConfigString(KaitaiStream _io, SomeIpSdOptions.SdOption.SdConfigStringsContainer _parent) {
this(_io, _parent, null);
}
public SdConfigString(KaitaiStream _io, SomeIpSdOptions.SdOption.SdConfigStringsContainer _parent, SomeIpSdOptions _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.length = this._io.readU1();
if (length() != 0) {
this._raw_config = this._io.readBytes(length());
KaitaiStream _io__raw_config = new ByteBufferKaitaiStream(this._raw_config);
this.config = new SdConfigKvPair(_io__raw_config, this, _root);
this.config._read();
}
_dirty = false;
}
public void _fetchInstances() {
if (length() != 0) {
this.config._fetchInstances();
}
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeU1(this.length);
if (length() != 0) {
final KaitaiStream _io__raw_config = new ByteBufferKaitaiStream(length());
this._io.addChildStream(_io__raw_config);
{
long _pos2 = this._io.pos();
this._io.seek(this._io.pos() + (length()));
final SdConfigString _this = this;
_io__raw_config.setWriteBackHandler(new KaitaiStream.WriteBackHandler(_pos2) {
@Override
protected void write(KaitaiStream parent) {
_this._raw_config = _io__raw_config.toByteArray();
if (_this._raw_config.length != length())
throw new ConsistencyError("raw(config)", length(), _this._raw_config.length);
parent.writeBytes(_this._raw_config);
}
});
}
this.config._write_Seq(_io__raw_config);
}
}
public void _check() {
if (length() != 0) {
if (!Objects.equals(this.config._root(), _root()))
throw new ConsistencyError("config", _root(), this.config._root());
if (!Objects.equals(this.config._parent(), this))
throw new ConsistencyError("config", this, this.config._parent());
}
_dirty = false;
}
private int length;
private SdConfigKvPair config;
private SomeIpSdOptions _root;
private SomeIpSdOptions.SdOption.SdConfigStringsContainer _parent;
private byte[] _raw_config;
public int length() { return length; }
public void setLength(int _v) { _dirty = true; length = _v; }
public SdConfigKvPair config() { return config; }
public void setConfig(SdConfigKvPair _v) { _dirty = true; config = _v; }
public SomeIpSdOptions _root() { return _root; }
public void set_root(SomeIpSdOptions _v) { _dirty = true; _root = _v; }
public SomeIpSdOptions.SdOption.SdConfigStringsContainer _parent() { return _parent; }
public void set_parent(SomeIpSdOptions.SdOption.SdConfigStringsContainer _v) { _dirty = true; _parent = _v; }
public byte[] _raw_config() { return _raw_config; }
public void set_raw_Config(byte[] _v) { _dirty = true; _raw_config = _v; }
}
public static class SdConfigStringsContainer extends KaitaiStruct.ReadWrite {
public static SdConfigStringsContainer fromFile(String fileName) throws IOException {
return new SdConfigStringsContainer(new ByteBufferKaitaiStream(fileName));
}
public SdConfigStringsContainer() {
this(null, null, null);
}
public SdConfigStringsContainer(KaitaiStream _io) {
this(_io, null, null);
}
public SdConfigStringsContainer(KaitaiStream _io, SomeIpSdOptions.SdOption.SdConfigurationOption _parent) {
this(_io, _parent, null);
}
public SdConfigStringsContainer(KaitaiStream _io, SomeIpSdOptions.SdOption.SdConfigurationOption _parent, SomeIpSdOptions _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.configStrings = new ArrayList<SdConfigString>();
{
int i = 0;
while (!this._io.isEof()) {
SdConfigString _t_configStrings = new SdConfigString(this._io, this, _root);
try {
_t_configStrings._read();
} finally {
this.configStrings.add(_t_configStrings);
}
i++;
}
}
_dirty = false;
}
public void _fetchInstances() {
for (int i = 0; i < this.configStrings.size(); i++) {
this.configStrings.get(((Number) (i)).intValue())._fetchInstances();
}
}
public void _write_Seq() {
_assertNotDirty();
for (int i = 0; i < this.configStrings.size(); i++) {
if (this._io.isEof())
throw new ConsistencyError("config_strings", 0, this._io.size() - this._io.pos());
this.configStrings.get(((Number) (i)).intValue())._write_Seq(this._io);
}
if (!(this._io.isEof()))
throw new ConsistencyError("config_strings", 0, this._io.size() - this._io.pos());
}
public void _check() {
for (int i = 0; i < this.configStrings.size(); i++) {
if (!Objects.equals(this.configStrings.get(((Number) (i)).intValue())._root(), _root()))
throw new ConsistencyError("config_strings", _root(), this.configStrings.get(((Number) (i)).intValue())._root());
if (!Objects.equals(this.configStrings.get(((Number) (i)).intValue())._parent(), this))
throw new ConsistencyError("config_strings", this, this.configStrings.get(((Number) (i)).intValue())._parent());
}
_dirty = false;
}
private List<SdConfigString> configStrings;
private SomeIpSdOptions _root;
private SomeIpSdOptions.SdOption.SdConfigurationOption _parent;
public List<SdConfigString> configStrings() { return configStrings; }
public void setConfigStrings(List<SdConfigString> _v) { _dirty = true; configStrings = _v; }
public SomeIpSdOptions _root() { return _root; }
public void set_root(SomeIpSdOptions _v) { _dirty = true; _root = _v; }
public SomeIpSdOptions.SdOption.SdConfigurationOption _parent() { return _parent; }
public void set_parent(SomeIpSdOptions.SdOption.SdConfigurationOption _v) { _dirty = true; _parent = _v; }
}
public static class SdConfigurationOption extends KaitaiStruct.ReadWrite {
public static SdConfigurationOption fromFile(String fileName) throws IOException {
return new SdConfigurationOption(new ByteBufferKaitaiStream(fileName));
}
public SdConfigurationOption() {
this(null, null, null);
}
public SdConfigurationOption(KaitaiStream _io) {
this(_io, null, null);
}
public SdConfigurationOption(KaitaiStream _io, SomeIpSdOptions.SdOption _parent) {
this(_io, _parent, null);
}
public SdConfigurationOption(KaitaiStream _io, SomeIpSdOptions.SdOption _parent, SomeIpSdOptions _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.reserved = this._io.readU1();
this._raw_configurations = this._io.readBytes(_parent().header().length() - 1);
KaitaiStream _io__raw_configurations = new ByteBufferKaitaiStream(this._raw_configurations);
this.configurations = new SdConfigStringsContainer(_io__raw_configurations, this, _root);
this.configurations._read();
_dirty = false;
}
public void _fetchInstances() {
this.configurations._fetchInstances();
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeU1(this.reserved);
final KaitaiStream _io__raw_configurations = new ByteBufferKaitaiStream(_parent().header().length() - 1);
this._io.addChildStream(_io__raw_configurations);
{
long _pos2 = this._io.pos();
this._io.seek(this._io.pos() + (_parent().header().length() - 1));
final SdConfigurationOption _this = this;
_io__raw_configurations.setWriteBackHandler(new KaitaiStream.WriteBackHandler(_pos2) {
@Override
protected void write(KaitaiStream parent) {
_this._raw_configurations = _io__raw_configurations.toByteArray();
if (_this._raw_configurations.length != _parent().header().length() - 1)
throw new ConsistencyError("raw(configurations)", _parent().header().length() - 1, _this._raw_configurations.length);
parent.writeBytes(_this._raw_configurations);
}
});
}
this.configurations._write_Seq(_io__raw_configurations);
}
public void _check() {
if (!Objects.equals(this.configurations._root(), _root()))
throw new ConsistencyError("configurations", _root(), this.configurations._root());
if (!Objects.equals(this.configurations._parent(), this))
throw new ConsistencyError("configurations", this, this.configurations._parent());
_dirty = false;
}
private int reserved;
private SdConfigStringsContainer configurations;
private SomeIpSdOptions _root;
private SomeIpSdOptions.SdOption _parent;
private byte[] _raw_configurations;
public int reserved() { return reserved; }
public void setReserved(int _v) { _dirty = true; reserved = _v; }
public SdConfigStringsContainer configurations() { return configurations; }
public void setConfigurations(SdConfigStringsContainer _v) { _dirty = true; configurations = _v; }
public SomeIpSdOptions _root() { return _root; }
public void set_root(SomeIpSdOptions _v) { _dirty = true; _root = _v; }
public SomeIpSdOptions.SdOption _parent() { return _parent; }
public void set_parent(SomeIpSdOptions.SdOption _v) { _dirty = true; _parent = _v; }
public byte[] _raw_configurations() { return _raw_configurations; }
public void set_raw_Configurations(byte[] _v) { _dirty = true; _raw_configurations = _v; }
}
public static class SdIpv4EndpointOption extends KaitaiStruct.ReadWrite {
public static SdIpv4EndpointOption fromFile(String fileName) throws IOException {
return new SdIpv4EndpointOption(new ByteBufferKaitaiStream(fileName));
}
public SdIpv4EndpointOption() {
this(null, null, null);
}
public SdIpv4EndpointOption(KaitaiStream _io) {
this(_io, null, null);
}
public SdIpv4EndpointOption(KaitaiStream _io, SomeIpSdOptions.SdOption _parent) {
this(_io, _parent, null);
}
public SdIpv4EndpointOption(KaitaiStream _io, SomeIpSdOptions.SdOption _parent, SomeIpSdOptions _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.reserved = this._io.readU1();
this.address = this._io.readBytes(4);
this.reserved2 = this._io.readU1();
this.l4Protocol = this._io.readU1();
this.port = this._io.readU2be();
_dirty = false;
}
public void _fetchInstances() {
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeU1(this.reserved);
this._io.writeBytes(this.address);
this._io.writeU1(this.reserved2);
this._io.writeU1(this.l4Protocol);
this._io.writeU2be(this.port);
}
public void _check() {
if (this.address.length != 4)
throw new ConsistencyError("address", 4, this.address.length);
_dirty = false;
}
private int reserved;
private byte[] address;
private int reserved2;
private int l4Protocol;
private int port;
private SomeIpSdOptions _root;
private SomeIpSdOptions.SdOption _parent;
public int reserved() { return reserved; }
public void setReserved(int _v) { _dirty = true; reserved = _v; }
public byte[] address() { return address; }
public void setAddress(byte[] _v) { _dirty = true; address = _v; }
public int reserved2() { return reserved2; }
public void setReserved2(int _v) { _dirty = true; reserved2 = _v; }
public int l4Protocol() { return l4Protocol; }
public void setL4Protocol(int _v) { _dirty = true; l4Protocol = _v; }
public int port() { return port; }
public void setPort(int _v) { _dirty = true; port = _v; }
public SomeIpSdOptions _root() { return _root; }
public void set_root(SomeIpSdOptions _v) { _dirty = true; _root = _v; }
public SomeIpSdOptions.SdOption _parent() { return _parent; }
public void set_parent(SomeIpSdOptions.SdOption _v) { _dirty = true; _parent = _v; }
}
public static class SdIpv4MulticastOption extends KaitaiStruct.ReadWrite {
public static SdIpv4MulticastOption fromFile(String fileName) throws IOException {
return new SdIpv4MulticastOption(new ByteBufferKaitaiStream(fileName));
}
public SdIpv4MulticastOption() {
this(null, null, null);
}
public SdIpv4MulticastOption(KaitaiStream _io) {
this(_io, null, null);
}
public SdIpv4MulticastOption(KaitaiStream _io, SomeIpSdOptions.SdOption _parent) {
this(_io, _parent, null);
}
public SdIpv4MulticastOption(KaitaiStream _io, SomeIpSdOptions.SdOption _parent, SomeIpSdOptions _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.reserved = this._io.readU1();
this.address = this._io.readBytes(4);
this.reserved2 = this._io.readU1();
this.l4Protocol = this._io.readU1();
this.port = this._io.readU2be();
_dirty = false;
}
public void _fetchInstances() {
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeU1(this.reserved);
this._io.writeBytes(this.address);
this._io.writeU1(this.reserved2);
this._io.writeU1(this.l4Protocol);
this._io.writeU2be(this.port);
}
public void _check() {
if (this.address.length != 4)
throw new ConsistencyError("address", 4, this.address.length);
_dirty = false;
}
private int reserved;
private byte[] address;
private int reserved2;
private int l4Protocol;
private int port;
private SomeIpSdOptions _root;
private SomeIpSdOptions.SdOption _parent;
public int reserved() { return reserved; }
public void setReserved(int _v) { _dirty = true; reserved = _v; }
public byte[] address() { return address; }
public void setAddress(byte[] _v) { _dirty = true; address = _v; }
public int reserved2() { return reserved2; }
public void setReserved2(int _v) { _dirty = true; reserved2 = _v; }
public int l4Protocol() { return l4Protocol; }
public void setL4Protocol(int _v) { _dirty = true; l4Protocol = _v; }
public int port() { return port; }
public void setPort(int _v) { _dirty = true; port = _v; }
public SomeIpSdOptions _root() { return _root; }
public void set_root(SomeIpSdOptions _v) { _dirty = true; _root = _v; }
public SomeIpSdOptions.SdOption _parent() { return _parent; }
public void set_parent(SomeIpSdOptions.SdOption _v) { _dirty = true; _parent = _v; }
}
public static class SdIpv4SdEndpointOption extends KaitaiStruct.ReadWrite {
public static SdIpv4SdEndpointOption fromFile(String fileName) throws IOException {
return new SdIpv4SdEndpointOption(new ByteBufferKaitaiStream(fileName));
}
public SdIpv4SdEndpointOption() {
this(null, null, null);
}
public SdIpv4SdEndpointOption(KaitaiStream _io) {
this(_io, null, null);
}
public SdIpv4SdEndpointOption(KaitaiStream _io, SomeIpSdOptions.SdOption _parent) {
this(_io, _parent, null);
}
public SdIpv4SdEndpointOption(KaitaiStream _io, SomeIpSdOptions.SdOption _parent, SomeIpSdOptions _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.reserved = this._io.readU1();
this.address = this._io.readBytes(4);
this.reserved2 = this._io.readU1();
this.l4Protocol = this._io.readU1();
this.port = this._io.readU2be();
_dirty = false;
}
public void _fetchInstances() {
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeU1(this.reserved);
this._io.writeBytes(this.address);
this._io.writeU1(this.reserved2);
this._io.writeU1(this.l4Protocol);
this._io.writeU2be(this.port);
}
public void _check() {
if (this.address.length != 4)
throw new ConsistencyError("address", 4, this.address.length);
_dirty = false;
}
private int reserved;
private byte[] address;
private int reserved2;
private int l4Protocol;
private int port;
private SomeIpSdOptions _root;
private SomeIpSdOptions.SdOption _parent;
public int reserved() { return reserved; }
public void setReserved(int _v) { _dirty = true; reserved = _v; }
public byte[] address() { return address; }
public void setAddress(byte[] _v) { _dirty = true; address = _v; }
public int reserved2() { return reserved2; }
public void setReserved2(int _v) { _dirty = true; reserved2 = _v; }
public int l4Protocol() { return l4Protocol; }
public void setL4Protocol(int _v) { _dirty = true; l4Protocol = _v; }
public int port() { return port; }
public void setPort(int _v) { _dirty = true; port = _v; }
public SomeIpSdOptions _root() { return _root; }
public void set_root(SomeIpSdOptions _v) { _dirty = true; _root = _v; }
public SomeIpSdOptions.SdOption _parent() { return _parent; }
public void set_parent(SomeIpSdOptions.SdOption _v) { _dirty = true; _parent = _v; }
}
public static class SdIpv6EndpointOption extends KaitaiStruct.ReadWrite {
public static SdIpv6EndpointOption fromFile(String fileName) throws IOException {
return new SdIpv6EndpointOption(new ByteBufferKaitaiStream(fileName));
}
public SdIpv6EndpointOption() {
this(null, null, null);
}
public SdIpv6EndpointOption(KaitaiStream _io) {
this(_io, null, null);
}
public SdIpv6EndpointOption(KaitaiStream _io, SomeIpSdOptions.SdOption _parent) {
this(_io, _parent, null);
}
public SdIpv6EndpointOption(KaitaiStream _io, SomeIpSdOptions.SdOption _parent, SomeIpSdOptions _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.reserved = this._io.readU1();
this.address = this._io.readBytes(16);
this.reserved2 = this._io.readU1();
this.l4Protocol = this._io.readU1();
this.port = this._io.readU2be();
_dirty = false;
}
public void _fetchInstances() {
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeU1(this.reserved);
this._io.writeBytes(this.address);
this._io.writeU1(this.reserved2);
this._io.writeU1(this.l4Protocol);
this._io.writeU2be(this.port);
}
public void _check() {
if (this.address.length != 16)
throw new ConsistencyError("address", 16, this.address.length);
_dirty = false;
}
private int reserved;
private byte[] address;
private int reserved2;
private int l4Protocol;
private int port;
private SomeIpSdOptions _root;
private SomeIpSdOptions.SdOption _parent;
public int reserved() { return reserved; }
public void setReserved(int _v) { _dirty = true; reserved = _v; }
public byte[] address() { return address; }
public void setAddress(byte[] _v) { _dirty = true; address = _v; }
public int reserved2() { return reserved2; }
public void setReserved2(int _v) { _dirty = true; reserved2 = _v; }
public int l4Protocol() { return l4Protocol; }
public void setL4Protocol(int _v) { _dirty = true; l4Protocol = _v; }
public int port() { return port; }
public void setPort(int _v) { _dirty = true; port = _v; }
public SomeIpSdOptions _root() { return _root; }
public void set_root(SomeIpSdOptions _v) { _dirty = true; _root = _v; }
public SomeIpSdOptions.SdOption _parent() { return _parent; }
public void set_parent(SomeIpSdOptions.SdOption _v) { _dirty = true; _parent = _v; }
}
public static class SdIpv6MulticastOption extends KaitaiStruct.ReadWrite {
public static SdIpv6MulticastOption fromFile(String fileName) throws IOException {
return new SdIpv6MulticastOption(new ByteBufferKaitaiStream(fileName));
}
public SdIpv6MulticastOption() {
this(null, null, null);
}
public SdIpv6MulticastOption(KaitaiStream _io) {
this(_io, null, null);
}
public SdIpv6MulticastOption(KaitaiStream _io, SomeIpSdOptions.SdOption _parent) {
this(_io, _parent, null);
}
public SdIpv6MulticastOption(KaitaiStream _io, SomeIpSdOptions.SdOption _parent, SomeIpSdOptions _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.reserved = this._io.readU1();
this.address = this._io.readBytes(16);
this.reserved2 = this._io.readU1();
this.l4Protocol = this._io.readU1();
this.port = this._io.readU2be();
_dirty = false;
}
public void _fetchInstances() {
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeU1(this.reserved);
this._io.writeBytes(this.address);
this._io.writeU1(this.reserved2);
this._io.writeU1(this.l4Protocol);
this._io.writeU2be(this.port);
}
public void _check() {
if (this.address.length != 16)
throw new ConsistencyError("address", 16, this.address.length);
_dirty = false;
}
private int reserved;
private byte[] address;
private int reserved2;
private int l4Protocol;
private int port;
private SomeIpSdOptions _root;
private SomeIpSdOptions.SdOption _parent;
public int reserved() { return reserved; }
public void setReserved(int _v) { _dirty = true; reserved = _v; }
public byte[] address() { return address; }
public void setAddress(byte[] _v) { _dirty = true; address = _v; }
public int reserved2() { return reserved2; }
public void setReserved2(int _v) { _dirty = true; reserved2 = _v; }
public int l4Protocol() { return l4Protocol; }
public void setL4Protocol(int _v) { _dirty = true; l4Protocol = _v; }
public int port() { return port; }
public void setPort(int _v) { _dirty = true; port = _v; }
public SomeIpSdOptions _root() { return _root; }
public void set_root(SomeIpSdOptions _v) { _dirty = true; _root = _v; }
public SomeIpSdOptions.SdOption _parent() { return _parent; }
public void set_parent(SomeIpSdOptions.SdOption _v) { _dirty = true; _parent = _v; }
}
public static class SdIpv6SdEndpointOption extends KaitaiStruct.ReadWrite {
public static SdIpv6SdEndpointOption fromFile(String fileName) throws IOException {
return new SdIpv6SdEndpointOption(new ByteBufferKaitaiStream(fileName));
}
public SdIpv6SdEndpointOption() {
this(null, null, null);
}
public SdIpv6SdEndpointOption(KaitaiStream _io) {
this(_io, null, null);
}
public SdIpv6SdEndpointOption(KaitaiStream _io, SomeIpSdOptions.SdOption _parent) {
this(_io, _parent, null);
}
public SdIpv6SdEndpointOption(KaitaiStream _io, SomeIpSdOptions.SdOption _parent, SomeIpSdOptions _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.reserved = this._io.readU1();
this.address = this._io.readBytes(16);
this.reserved2 = this._io.readU1();
this.l4Protocol = this._io.readU1();
this.port = this._io.readU2be();
_dirty = false;
}
public void _fetchInstances() {
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeU1(this.reserved);
this._io.writeBytes(this.address);
this._io.writeU1(this.reserved2);
this._io.writeU1(this.l4Protocol);
this._io.writeU2be(this.port);
}
public void _check() {
if (this.address.length != 16)
throw new ConsistencyError("address", 16, this.address.length);
_dirty = false;
}
private int reserved;
private byte[] address;
private int reserved2;
private int l4Protocol;
private int port;
private SomeIpSdOptions _root;
private SomeIpSdOptions.SdOption _parent;
public int reserved() { return reserved; }
public void setReserved(int _v) { _dirty = true; reserved = _v; }
public byte[] address() { return address; }
public void setAddress(byte[] _v) { _dirty = true; address = _v; }
public int reserved2() { return reserved2; }
public void setReserved2(int _v) { _dirty = true; reserved2 = _v; }
public int l4Protocol() { return l4Protocol; }
public void setL4Protocol(int _v) { _dirty = true; l4Protocol = _v; }
public int port() { return port; }
public void setPort(int _v) { _dirty = true; port = _v; }
public SomeIpSdOptions _root() { return _root; }
public void set_root(SomeIpSdOptions _v) { _dirty = true; _root = _v; }
public SomeIpSdOptions.SdOption _parent() { return _parent; }
public void set_parent(SomeIpSdOptions.SdOption _v) { _dirty = true; _parent = _v; }
}
public static class SdLoadBalancingOption extends KaitaiStruct.ReadWrite {
public static SdLoadBalancingOption fromFile(String fileName) throws IOException {
return new SdLoadBalancingOption(new ByteBufferKaitaiStream(fileName));
}
public SdLoadBalancingOption() {
this(null, null, null);
}
public SdLoadBalancingOption(KaitaiStream _io) {
this(_io, null, null);
}
public SdLoadBalancingOption(KaitaiStream _io, SomeIpSdOptions.SdOption _parent) {
this(_io, _parent, null);
}
public SdLoadBalancingOption(KaitaiStream _io, SomeIpSdOptions.SdOption _parent, SomeIpSdOptions _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.reserved = this._io.readU1();
this.priority = this._io.readU2be();
this.weight = this._io.readU2be();
_dirty = false;
}
public void _fetchInstances() {
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeU1(this.reserved);
this._io.writeU2be(this.priority);
this._io.writeU2be(this.weight);
}
public void _check() {
_dirty = false;
}
private int reserved;
private int priority;
private int weight;
private SomeIpSdOptions _root;
private SomeIpSdOptions.SdOption _parent;
public int reserved() { return reserved; }
public void setReserved(int _v) { _dirty = true; reserved = _v; }
public int priority() { return priority; }
public void setPriority(int _v) { _dirty = true; priority = _v; }
public int weight() { return weight; }
public void setWeight(int _v) { _dirty = true; weight = _v; }
public SomeIpSdOptions _root() { return _root; }
public void set_root(SomeIpSdOptions _v) { _dirty = true; _root = _v; }
public SomeIpSdOptions.SdOption _parent() { return _parent; }
public void set_parent(SomeIpSdOptions.SdOption _v) { _dirty = true; _parent = _v; }
}
public static class SdOptionHeader extends KaitaiStruct.ReadWrite {
public static SdOptionHeader fromFile(String fileName) throws IOException {
return new SdOptionHeader(new ByteBufferKaitaiStream(fileName));
}
public SdOptionHeader() {
this(null, null, null);
}
public SdOptionHeader(KaitaiStream _io) {
this(_io, null, null);
}
public SdOptionHeader(KaitaiStream _io, SomeIpSdOptions.SdOption _parent) {
this(_io, _parent, null);
}
public SdOptionHeader(KaitaiStream _io, SomeIpSdOptions.SdOption _parent, SomeIpSdOptions _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.length = this._io.readU2be();
this.type = SomeIpSdOptions.SdOption.OptionTypes.byId(this._io.readU1());
_dirty = false;
}
public void _fetchInstances() {
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeU2be(this.length);
this._io.writeU1(((Number) (this.type.id())).intValue());
}
public void _check() {
_dirty = false;
}
private int length;
private OptionTypes type;
private SomeIpSdOptions _root;
private SomeIpSdOptions.SdOption _parent;
public int length() { return length; }
public void setLength(int _v) { _dirty = true; length = _v; }
public OptionTypes type() { return type; }
public void setType(OptionTypes _v) { _dirty = true; type = _v; }
public SomeIpSdOptions _root() { return _root; }
public void set_root(SomeIpSdOptions _v) { _dirty = true; _root = _v; }
public SomeIpSdOptions.SdOption _parent() { return _parent; }
public void set_parent(SomeIpSdOptions.SdOption _v) { _dirty = true; _parent = _v; }
}
private SdOptionHeader header;
private KaitaiStruct.ReadWrite content;
private SomeIpSdOptions _root;
private SomeIpSdOptions _parent;
public SdOptionHeader header() { return header; }
public void setHeader(SdOptionHeader _v) { _dirty = true; header = _v; }
public KaitaiStruct.ReadWrite content() { return content; }
public void setContent(KaitaiStruct.ReadWrite _v) { _dirty = true; content = _v; }
public SomeIpSdOptions _root() { return _root; }
public void set_root(SomeIpSdOptions _v) { _dirty = true; _root = _v; }
public SomeIpSdOptions _parent() { return _parent; }
public void set_parent(SomeIpSdOptions _v) { _dirty = true; _parent = _v; }
}
private List<SdOption> entries;
private SomeIpSdOptions _root;
private KaitaiStruct.ReadWrite _parent;
public List<SdOption> entries() { return entries; }
public void setEntries(List<SdOption> _v) { _dirty = true; entries = _v; }
public SomeIpSdOptions _root() { return _root; }
public void set_root(SomeIpSdOptions _v) { _dirty = true; _root = _v; }
public KaitaiStruct.ReadWrite _parent() { return _parent; }
public void set_parent(KaitaiStruct.ReadWrite _v) { _dirty = true; _parent = _v; }
}