public override void Unmarshal(DataInputStream dis)
{
base.Unmarshal(dis);
if (dis != null)
{
try
{
this._designatingEntityID.Unmarshal(dis);
this._codeName = dis.ReadUnsignedShort();
this._designatedEntityID.Unmarshal(dis);
this._designatorCode = dis.ReadUnsignedShort();
this._designatorPower = dis.ReadFloat();
this._designatorWavelength = dis.ReadFloat();
this._designatorSpotWrtDesignated.Unmarshal(dis);
this._designatorSpotLocation.Unmarshal(dis);
this._deadReckoningAlgorithm = dis.ReadByte();
this._padding1 = dis.ReadUnsignedShort();
this._padding2 = dis.ReadByte();
this._entityLinearAcceleration.Unmarshal(dis);
}
catch (Exception e)
{
#if DEBUG
Trace.WriteLine(e);
Trace.Flush();
#endif
this.OnException(e);
}
}
}
public override void Unmarshal(DataInputStream dis)
{
base.Unmarshal(dis);
if (dis != null)
{
try
{
this._emittingEntityID.Unmarshal(dis);
this._eventID.Unmarshal(dis);
this._stateChangeIndicator = dis.ReadByte();
this._pad = dis.ReadByte();
this._passiveParameterIndex = dis.ReadUnsignedShort();
this._propulsionPlantConfiguration = dis.ReadUnsignedByte();
this._numberOfShafts = dis.ReadUnsignedByte();
this._numberOfAPAs = dis.ReadUnsignedByte();
this._numberOfUAEmitterSystems = dis.ReadUnsignedByte();
for (int idx = 0; idx < this.NumberOfShafts; idx++)
{
ShaftRPMs anX = new ShaftRPMs();
anX.Unmarshal(dis);
this._shaftRPMs.Add(anX);
}
for (int idx = 0; idx < this.NumberOfAPAs; idx++)
{
ApaData anX = new ApaData();
anX.Unmarshal(dis);
this._apaData.Add(anX);
}
for (int idx = 0; idx < this.NumberOfUAEmitterSystems; idx++)
{
AcousticEmitterSystemData anX = new AcousticEmitterSystemData();
anX.Unmarshal(dis);
this._emitterSystems.Add(anX);
}
}
catch (Exception e)
{
if (PduBase.TraceExceptions)
{
Trace.WriteLine(e);
Trace.Flush();
}
this.RaiseExceptionOccured(e);
if (PduBase.ThrowExceptions)
{
throw e;
}
}
}
}
public void handle(byte[] data, model.RtpMidiServer appleMidiServer)
{
DataInputStream dataInputStream = new DataInputStream(new MemoryStream(data));
try {
byte header1 = (byte)dataInputStream.ReadByte();
if (header1 != RtpMidiCommand.MIDI_COMMAND_HEADER1)
{
Log.Info("RtpMidi", "Header did not contain first MIDI command header");
return;
}
byte header2 = (byte)dataInputStream.ReadByte();
if (header2 != RtpMidiCommand.MIDI_COMMAND_HEADER2)
{
Log.Info("RtpMidi", "Header did not contain second MIDI command header");
return;
}
byte[] commandBuffer = new byte[COMMAND_BUFFER_LENGTH];
int commandBytesRead = dataInputStream.Read(commandBuffer);
if (commandBytesRead != COMMAND_BUFFER_LENGTH)
{
Log.Info("RtpMidi", "The number of command bytes: {} did not match: {}", commandBytesRead, COMMAND_BUFFER_LENGTH);
return;
}
string command = Encoding.UTF8.GetString(commandBuffer);
CommandWord commandWord;
try
{
commandWord = (CommandWord)System.Enum.Parse(typeof(CommandWord), command);
}
catch (IllegalArgumentException e) {
Log.Info("RtpMidi", "Could not parse command word from: {}", command);
return;
}
switch (commandWord)
{
case CommandWord.IN:
HandleInvitation(dataInputStream, appleMidiServer);
break;
case CommandWord.CK:
HandleSynchronization(dataInputStream, appleMidiServer);
break;
case CommandWord.BY:
HandleEndSession(dataInputStream, appleMidiServer);
break;
}
}
catch (System.IO.IOException e)
{
Log.Error("RtpMidi", "IOException while parsing message", e);
}
}
/// <summary>
/// Reads four bytes from the input and returns a VersionInfo object. Use it
/// to read different collator versions.
/// </summary>
///
/// <param name="input">already instantiated DataInputStream, positioned at the startof four version bytes</param>
/// <returns>a ready VersionInfo object</returns>
/// <exception cref="IOException">thrown when error occurs while reading version bytes</exception>
protected static internal VersionInfo ReadVersion(DataInputStream input)
{
sbyte[] version = new sbyte[4];
version[0] = input.ReadByte();
version[1] = input.ReadByte();
version[2] = input.ReadByte();
version[3] = input.ReadByte();
VersionInfo result = IBM.ICU.Util.VersionInfo.GetInstance((int)version[0],
(int)version[1], (int)version[2], (int)version[3]);
return(result);
}
public override void Unmarshal(DataInputStream dis)
{
base.Unmarshal(dis);
if (dis != null)
{
try
{
this._emittingEntityID.Unmarshal(dis);
this._eventID.Unmarshal(dis);
this._stateChangeIndicator = dis.ReadByte();
this._pad = dis.ReadByte();
this._passiveParameterIndex = dis.ReadUnsignedShort();
this._propulsionPlantConfiguration = dis.ReadUnsignedByte();
this._numberOfShafts = dis.ReadUnsignedByte();
this._numberOfAPAs = dis.ReadUnsignedByte();
this._numberOfUAEmitterSystems = dis.ReadUnsignedByte();
for (int idx = 0; idx < this.NumberOfShafts; idx++)
{
Vector3Float anX = new Vector3Float();
anX.Unmarshal(dis);
this._shaftRPMs.Add(anX);
}
;
for (int idx = 0; idx < this.NumberOfAPAs; idx++)
{
Vector3Float anX = new Vector3Float();
anX.Unmarshal(dis);
this._apaData.Add(anX);
}
;
for (int idx = 0; idx < this.NumberOfUAEmitterSystems; idx++)
{
Vector3Float anX = new Vector3Float();
anX.Unmarshal(dis);
this._emitterSystems.Add(anX);
}
;
}
catch (Exception e)
{
#if DEBUG
Trace.WriteLine(e);
Trace.Flush();
#endif
this.OnException(e);
}
}
}
private int ReadDeltaTime(DataInputStream midiInputStream)
{
byte deltaTimeOctet = (byte)midiInputStream.ReadByte();
int deltaTime = deltaTimeOctet & 0x7F;
int numberOfOctets = 1;
while (((deltaTimeOctet >> 7) & 0x01) == 1 || numberOfOctets < 4)
{
numberOfOctets++;
deltaTimeOctet = (byte)midiInputStream.ReadByte();
deltaTime = ((deltaTimeOctet << 8) & 0x7F) | deltaTimeOctet;
}
return(deltaTime);
}
public override void Unmarshal(DataInputStream dis)
{
base.Unmarshal(dis);
if (dis != null)
{
try
{
this._entityID.Unmarshal(dis);
this._forceId = dis.ReadUnsignedByte();
this._articulationParameterCount = dis.ReadByte();
this._entityType.Unmarshal(dis);
this._alternativeEntityType.Unmarshal(dis);
this._entityLinearVelocity.Unmarshal(dis);
this._entityLocation.Unmarshal(dis);
this._entityOrientation.Unmarshal(dis);
this._entityAppearance = dis.ReadInt();
this._deadReckoningParameters.Unmarshal(dis);
for (int idx = 0; idx < this._marking.Length; idx++)
{
this._marking[idx] = dis.ReadByte();
}
this._capabilities = dis.ReadInt();
for (int idx = 0; idx < this.ArticulationParameterCount; idx++)
{
ArticulationParameter anX = new ArticulationParameter();
anX.Unmarshal(dis);
this._articulationParameters.Add(anX);
}
}
catch (Exception e)
{
if (PduBase.TraceExceptions)
{
Trace.WriteLine(e);
Trace.Flush();
}
this.RaiseExceptionOccured(e);
if (PduBase.ThrowExceptions)
{
throw e;
}
}
}
}
// private methods ---------------------------------------------------
/// <summary>
/// Reads an individual record of AlgorithmNames
/// </summary>
///
/// <returns>an instance of AlgorithNames if read is successful otherwise null</returns>
/// <exception cref="IOException">thrown when file read error occurs or data is corrupted</exception>
private UCharacterName.AlgorithmName ReadAlg()
{
UCharacterName.AlgorithmName result = new UCharacterName.AlgorithmName();
int rangestart = m_dataInputStream_.ReadInt();
int rangeend = m_dataInputStream_.ReadInt();
sbyte type = m_dataInputStream_.ReadByte();
sbyte variant = m_dataInputStream_.ReadByte();
if (!result.SetInfo(rangestart, rangeend, type, variant))
{
return(null);
}
int size = m_dataInputStream_.ReadChar();
if (type == IBM.ICU.Impl.UCharacterName.AlgorithmName.TYPE_1_)
{
char[] factor = new char[variant];
for (int j = 0; j < variant; j++)
{
factor[j] = m_dataInputStream_.ReadChar();
}
result.SetFactor(factor);
size -= (variant << 1);
}
StringBuilder prefix = new StringBuilder();
char c = (char)(m_dataInputStream_.ReadByte() & 0x00FF);
while (c != 0)
{
prefix.Append(c);
c = (char)(m_dataInputStream_.ReadByte() & 0x00FF);
}
result.SetPrefix(prefix.ToString());
size -= (ALG_INFO_SIZE_ + prefix.Length + 1);
if (size > 0)
{
byte[] str0 = new byte[size];
m_dataInputStream_.ReadFully(str0);
result.SetFactorString(str0);
}
return(result);
}
public override void Unmarshal(DataInputStream dis)
{
base.Unmarshal(dis);
if (dis != null)
{
try
{
this._receivingEntityID.Unmarshal(dis);
this._supplyingEntityID.Unmarshal(dis);
this._numberOfSupplyTypes = dis.ReadUnsignedByte();
this._padding1 = dis.ReadShort();
this._padding2 = dis.ReadByte();
for (int idx = 0; idx < this.NumberOfSupplyTypes; idx++)
{
SupplyQuantity anX = new SupplyQuantity();
anX.Unmarshal(dis);
this._supplies.Add(anX);
}
;
}
catch (Exception e)
{
#if DEBUG
Trace.WriteLine(e);
Trace.Flush();
#endif
this.OnException(e);
}
}
}
public virtual void Unmarshal(DataInputStream dis)
{
if (dis != null)
{
try
{
this._deadReckoningAlgorithm = dis.ReadUnsignedByte();
for (int idx = 0; idx < this._otherParameters.Length; idx++)
{
this._otherParameters[idx] = dis.ReadByte();
}
this._entityLinearAcceleration.Unmarshal(dis);
this._entityAngularVelocity.Unmarshal(dis);
}
catch (Exception e)
{
if (PduBase.TraceExceptions)
{
Trace.WriteLine(e);
Trace.Flush();
}
this.RaiseExceptionOccured(e);
if (PduBase.ThrowExceptions)
{
throw e;
}
}
}
}
public virtual void Unmarshal(DataInputStream dis)
{
if (dis != null)
{
try
{
this._beamDirection.Unmarshal(dis);
this._azimuthBeamwidth = dis.ReadFloat();
this._referenceSystem = dis.ReadFloat();
this._padding1 = dis.ReadShort();
this._padding2 = dis.ReadByte();
this._ez = dis.ReadFloat();
this._ex = dis.ReadFloat();
this._phase = dis.ReadFloat();
}
catch (Exception e)
{
if (PduBase.TraceExceptions)
{
Trace.WriteLine(e);
Trace.Flush();
}
this.RaiseExceptionOccured(e);
if (PduBase.ThrowExceptions)
{
throw e;
}
}
}
}
/*
* Reads the information from the index and data files.
*
* @param index holds the sprite indices
* @param data holds the sprite data per index
* @throws IOException
*/
public void readValues(DataInputStream index, DataInputStream data)
{
do
{
int opCode = data.ReadByte();
if (opCode == 0)
{
break;
}
if (opCode == 1)
{
id = data.ReadShort();
}
else if (opCode == 2)
{
name = data.ReadUTF();
}
else if (opCode == 3)
{
drawOffsetX = data.ReadShort();
}
else if (opCode == 4)
{
drawOffsetY = data.ReadShort();
}
else if (opCode == 5)
{
int indexLength = index.ReadInt();
byte[] dataread = new byte[indexLength];
data.Read(dataread, 0, indexLength);
spriteData = dataread;
}
} while (true);
}
public override void Unmarshal(DataInputStream dis)
{
base.Unmarshal(dis);
if (dis != null)
{
try
{
this._issuingEntityID.Unmarshal(dis);
this._collidingEntityID.Unmarshal(dis);
this._eventID.Unmarshal(dis);
this._collisionType = dis.ReadUnsignedByte();
this._pad = dis.ReadByte();
this._velocity.Unmarshal(dis);
this._mass = dis.ReadFloat();
this._location.Unmarshal(dis);
}
catch (Exception e)
{
#if DEBUG
Trace.WriteLine(e);
Trace.Flush();
#endif
this.OnException(e);
}
}
}
public override void Unmarshal(DataInputStream dis)
{
base.Unmarshal(dis);
if (dis != null)
{
try
{
this._receivingEntityID.Unmarshal(dis);
this._repairingEntityID.Unmarshal(dis);
this._repairResult = dis.ReadUnsignedByte();
this._padding1 = dis.ReadShort();
this._padding2 = dis.ReadByte();
}
catch (Exception e)
{
if (PduBase.TraceExceptions)
{
Trace.WriteLine(e);
Trace.Flush();
}
this.RaiseExceptionOccured(e);
if (PduBase.ThrowExceptions)
{
throw e;
}
}
}
}
public virtual void TestLocalFileCorruption()
{
Configuration conf = new HdfsConfiguration();
Path file = new Path(PathUtils.GetTestDirName(GetType()), "corruptFile");
FileSystem fs = FileSystem.GetLocal(conf);
DataOutputStream dos = fs.Create(file);
dos.WriteBytes("original bytes");
dos.Close();
// Now deliberately corrupt the file
dos = new DataOutputStream(new FileOutputStream(file.ToString()));
dos.WriteBytes("corruption");
dos.Close();
// Now attempt to read the file
DataInputStream dis = fs.Open(file, 512);
try
{
System.Console.Out.WriteLine("A ChecksumException is expected to be logged.");
dis.ReadByte();
}
catch (ChecksumException)
{
}
//expect this exception but let any NPE get thrown
fs.Delete(file, true);
}
/// <summary>Read an integer of this type from the given input stream</summary>
/// <exception cref="System.IO.IOException"/>
public int Read(DataInputStream @in)
{
switch (this)
{
case VectorMap.Itype.Int8:
{
return(@in.ReadByte());
}
case VectorMap.Itype.Int16:
{
return(@in.ReadShort());
}
case VectorMap.Itype.Int32:
{
return(@in.ReadInt());
}
default:
{
throw new Exception("Unknown itype: " + this);
}
}
}
public override void Unmarshal(DataInputStream dis)
{
base.Unmarshal(dis);
if (dis != null)
{
try
{
this._entityID.Unmarshal(dis);
this._padding1 = dis.ReadByte();
this._numberOfVariableParameters = dis.ReadUnsignedByte();
this._entityLinearVelocity.Unmarshal(dis);
this._entityLocation.Unmarshal(dis);
this._entityOrientation.Unmarshal(dis);
this._entityAppearance = dis.ReadUnsignedInt();
for (int idx = 0; idx < this.NumberOfVariableParameters; idx++)
{
VariableParameter anX = new VariableParameter();
anX.Unmarshal(dis);
this._variableParameters.Add(anX);
}
;
}
catch (Exception e)
{
#if DEBUG
Trace.WriteLine(e);
Trace.Flush();
#endif
this.OnException(e);
}
}
}
/// <summary>
/// Reads an automaton from a byte stream.
/// </summary>
/// <param name="stream">The stream to read.</param>
internal CFSA2(Stream stream)
{
using (DataInputStream input = new DataInputStream(stream, true))
{
// Read flags.
ushort flagBits = (ushort)input.ReadInt16();
flags = 0;
flags = (FSAFlags)flagBits;
if (flagBits != (ushort)flags)
{
throw new IOException($"Unrecognized flags: 0x{((int)flagBits).ToHexString()}");
}
this.hasNumbers = (flags & FSAFlags.Numbers) != 0;
/*
* Read mapping dictionary.
*/
int labelMappingSize = input.ReadByte() & 0xff;
LabelMapping = new byte[labelMappingSize];
input.ReadFully(LabelMapping);
/*
* Read arcs' data.
*/
Arcs = ReadRemaining(input);
}
}
public virtual void Unmarshal(DataInputStream dis)
{
if (dis != null)
{
try
{
this._beamDirection.Unmarshal(dis);
this._azimuthBeamwidth = dis.ReadFloat();
this._referenceSystem = dis.ReadFloat();
this._padding1 = dis.ReadShort();
this._padding2 = dis.ReadByte();
this._ez = dis.ReadFloat();
this._ex = dis.ReadFloat();
this._phase = dis.ReadFloat();
}
catch (Exception e)
{
#if DEBUG
Trace.WriteLine(e);
Trace.Flush();
#endif
this.OnException(e);
}
}
}
public virtual void Unmarshal(DataInputStream dis)
{
if (dis != null)
{
try
{
this._order = dis.ReadByte();
}
catch (Exception e)
{
if (PduBase.TraceExceptions)
{
Trace.WriteLine(e);
Trace.Flush();
}
this.RaiseExceptionOccured(e);
if (PduBase.ThrowExceptions)
{
throw e;
}
}
}
}
public override void Unmarshal(DataInputStream dis)
{
base.Unmarshal(dis);
if (dis != null)
{
try
{
this._originatingSimulationAddress.Unmarshal(dis);
this._padding1 = dis.ReadInt();
this._padding2 = dis.ReadShort();
this._attributeRecordPduType = dis.ReadUnsignedByte();
this._attributeRecordProtocolVersion = dis.ReadUnsignedByte();
this._masterAttributeRecordType = dis.ReadUnsignedInt();
this._actionCode = dis.ReadUnsignedByte();
this._padding3 = dis.ReadByte();
this._numberAttributeRecordSet = dis.ReadUnsignedShort();
}
catch (Exception e)
{
#if DEBUG
Trace.WriteLine(e);
Trace.Flush();
#endif
this.OnException(e);
}
}
}
public override void Unmarshal(DataInputStream dis)
{
base.Unmarshal(dis);
if (dis != null)
{
try
{
this._issuingEntityID.Unmarshal(dis);
this._collidingEntityID.Unmarshal(dis);
this._eventID.Unmarshal(dis);
this._collisionType = dis.ReadUnsignedByte();
this._pad = dis.ReadByte();
this._velocity.Unmarshal(dis);
this._mass = dis.ReadFloat();
this._location.Unmarshal(dis);
}
catch (Exception e)
{
if (PduBase.TraceExceptions)
{
Trace.WriteLine(e);
Trace.Flush();
}
this.RaiseExceptionOccured(e);
if (PduBase.ThrowExceptions)
{
throw e;
}
}
}
}
public virtual void Unmarshal(DataInputStream dis)
{
if (dis != null)
{
try
{
for (int idx = 0; idx < this._otherParameters.Length; idx++)
{
this._otherParameters[idx] = dis.ReadByte();
}
}
catch (Exception e)
{
if (PduBase.TraceExceptions)
{
Trace.WriteLine(e);
Trace.Flush();
}
this.RaiseExceptionOccured(e);
if (PduBase.ThrowExceptions)
{
throw e;
}
}
}
}
/// <summary>
/// 读取Byte[]
/// </summary>
///
/// <param name="dis"></param>
/// <param name="readLength"></param>
/// <returns></returns>
/// <exception cref="System.Exception"></exception>
public static byte[] ReadByteArray(DataInputStream dis, int readLength)
{
byte[] readBytes = new byte[readLength];
for (int i = 0; i < readLength; i++)
{
readBytes[i] = (byte)dis.ReadByte();
}
return(readBytes);
}
// public methods --------------------------------------------------------
/// <summary>
/// <p>
/// ICU data header reader method. Takes a ICU generated big-endian input
/// stream, parse the ICU standard file header and authenticates them.
/// </p>
/// <p>
/// Header format:
/// <ul>
/// <li>Header size (char)
/// <li>Magic number 1 (byte)
/// <li>Magic number 2 (byte)
/// <li>Rest of the header size (char)
/// <li>Reserved word (char)
/// <li>Big endian indicator (byte)
/// <li>Character set family indicator (byte)
/// <li>Size of a char (byte) for c++ and c use
/// <li>Reserved byte (byte)
/// <li>Data format identifier (4 bytes), each ICU data has its own
/// identifier to distinguish them. [0] major [1] minor [2] milli [3] micro
/// <li>Data version (4 bytes), the change version of the ICU data [0] major
/// [1] minor [2] milli [3] micro
/// <li>Unicode version (4 bytes) this ICU is based on.
/// </ul>
/// </p>
/// <p>
/// Example of use:<br>
/// <pre>
/// try {
/// FileInputStream input = new FileInputStream(filename);
/// If (Utility.readICUDataHeader(input, dataformat, dataversion,
/// unicode) {
/// System.out.println("Verified file header, this is a ICU data file");
/// }
/// } catch (IOException e) {
/// System.out.println("This is not a ICU data file");
/// }
/// </pre>
/// </p>
/// </summary>
///
/// <param name="inputStream">input stream that contains the ICU data header</param>
/// <param name="dataFormatIDExpected">Data format expected. An array of 4 bytes information aboutthe data format. E.g. data format ID 1.2.3.4. will became anarray of {1, 2, 3, 4}</param>
/// <param name="authenticate">user defined extra data authentication. This value can benull, if no extra authentication is needed.</param>
/// <exception cref="IOException">thrown if there is a read error or when headerauthentication fails.</exception>
/// @draft 2.1
public static byte[] ReadHeader(Stream inputStream,
byte[] dataFormatIDExpected, ICUBinary.Authenticate authenticate)
{
DataInputStream input = new DataInputStream(inputStream);
char headersize = input.ReadChar();
int readcount = 2;
// reading the header format
byte magic1 = (byte)input.ReadByte();
readcount++;
byte magic2 = (byte)input.ReadByte();
readcount++;
if (magic1 != MAGIC1 || magic2 != MAGIC2)
{
throw new IOException(MAGIC_NUMBER_AUTHENTICATION_FAILED_);
}
input.ReadChar(); // reading size
readcount += 2;
input.ReadChar(); // reading reserved word
readcount += 2;
sbyte bigendian = input.ReadByte();
readcount++;
sbyte charset = input.ReadByte();
readcount++;
sbyte charsize = input.ReadByte();
readcount++;
input.ReadByte(); // reading reserved byte
readcount++;
byte[] dataFormatID = new byte[4];
input.ReadFully(dataFormatID);
readcount += 4;
byte[] dataVersion = new byte[4];
input.ReadFully(dataVersion);
readcount += 4;
byte[] unicodeVersion = new byte[4];
input.ReadFully(unicodeVersion);
readcount += 4;
if (headersize < readcount)
{
throw new IOException("Internal Error: Header size error");
}
input.SkipBytes(headersize - readcount);
if (bigendian != BIG_ENDIAN_ ||
charset != CHAR_SET_ ||
charsize != CHAR_SIZE_ ||
!ILOG.J2CsMapping.Collections.Arrays.Equals(dataFormatIDExpected, dataFormatID) ||
(authenticate != null && !authenticate
.IsDataVersionAcceptable(dataVersion)))
{
throw new IOException(HEADER_AUTHENTICATION_FAILED_);
}
return(unicodeVersion);
}
/// <summary>
/// Loads the rules from a DateInputStream, often in a jar file.
/// </summary>
/// <param name="dis"> the DateInputStream to load, not null </param>
/// <exception cref="Exception"> if an error occurs </exception>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: private void load(java.io.DataInputStream dis) throws Exception
private void Load(DataInputStream dis)
{
if (dis.ReadByte() != 1)
{
throw new StreamCorruptedException("File format not recognised");
}
// group
String groupId = dis.ReadUTF();
if ("TZDB".Equals(groupId) == false)
{
throw new StreamCorruptedException("File format not recognised");
}
// versions
int versionCount = dis.ReadShort();
for (int i = 0; i < versionCount; i++)
{
VersionId = dis.ReadUTF();
}
// regions
int regionCount = dis.ReadShort();
String[] regionArray = new String[regionCount];
for (int i = 0; i < regionCount; i++)
{
regionArray[i] = dis.ReadUTF();
}
RegionIds = Arrays.AsList(regionArray);
// rules
int ruleCount = dis.ReadShort();
Object[] ruleArray = new Object[ruleCount];
for (int i = 0; i < ruleCount; i++)
{
sbyte[] bytes = new sbyte[dis.ReadShort()];
dis.ReadFully(bytes);
ruleArray[i] = bytes;
}
// link version-region-rules
for (int i = 0; i < versionCount; i++)
{
int versionRegionCount = dis.ReadShort();
RegionToRules.Clear();
for (int j = 0; j < versionRegionCount; j++)
{
String region = regionArray[dis.ReadShort()];
Object rule = ruleArray[dis.ReadShort() & 0xffff];
RegionToRules[region] = rule;
}
}
}
/// <summary>
/// This constructs a DataChecksum by reading HEADER_LEN bytes from input
/// stream <i>in</i>
/// </summary>
/// <exception cref="System.IO.IOException"/>
public static DataChecksum NewDataChecksum(DataInputStream @in)
{
int type = @in.ReadByte();
int bpc = @in.ReadInt();
DataChecksum summer = NewDataChecksum(DataChecksum.Type.ValueOf(type), bpc);
if (summer == null)
{
throw new IOException("Could not create DataChecksum of type " + type + " with bytesPerChecksum "
+ bpc);
}
return(summer);
}
/// <summary>
/// Creates a new automaton, reading it from a file in FSA format, version 5.
/// </summary>
internal CFSA(Stream stream)
{
using (DataInputStream input = new DataInputStream(stream, true))
{
// Skip legacy header fields.
input.ReadByte(); // filler
input.ReadByte(); // annotation
byte hgtl = (byte)input.ReadByte();
/*
* Determine if the automaton was compiled with NUMBERS. If so, modify
* ctl and goto fields accordingly.
*/
flags = FSAFlags.Flexible | FSAFlags.StopBit | FSAFlags.NextBit;
if ((hgtl & 0xf0) != 0)
{
this.NodeDataLength = (hgtl.TripleShift(4)) & 0x0f;
this.GoToLength = hgtl & 0x0f;
flags |= FSAFlags.Numbers;
}
else
{
this.NodeDataLength = 0;
this.GoToLength = hgtl & 0x0f;
}
/*
* Read mapping dictionary.
*/
LabelMapping = new byte[1 << 5];
input.ReadFully(LabelMapping);
/*
* Read arcs' data.
*/
Arcs = ReadRemaining(input);
}
}
/// <summary>
/// Read and wrap a binary automaton in FSA version 5.
/// </summary>
internal FSA5(Stream stream)
{
DataInputStream input = new DataInputStream(stream);
this.Filler = (byte)input.ReadByte();
this.Annotation = (byte)input.ReadByte();
byte hgtl = (byte)input.ReadByte();
/*
* Determine if the automaton was compiled with NUMBERS. If so, modify
* ctl and goto fields accordingly.
*/
flags = FSAFlags.Flexible | FSAFlags.StopBit | FSAFlags.NextBit;
if ((hgtl & 0xf0) != 0)
{
flags |= FSAFlags.Numbers;
}
this.NodeDataLength = (hgtl.TripleShift(4)) & 0x0f;
this.GoToLength = hgtl & 0x0f;
Arcs = ReadRemaining(input);
}
/// <summary>
/// Checks for updates at the remote host.
/// </summary>
public virtual SessionToken CheckForUpdate(string currentVersion)
{
string[] parameters = null;
if (currentVersion != null)
parameters = new[] { ReplicationService.REPLICATE_VERSION_PARAM, currentVersion };
HttpResponseMessage response = base.ExecuteGet(ReplicationService.ReplicationAction.UPDATE.ToString(), parameters);
return DoAction(response, () =>
{
using (DataInputStream inputStream = new DataInputStream(ResponseInputStream(response)))
{
return inputStream.ReadByte() == 0 ? null : new SessionToken(inputStream);
}
});
}