public override void Unmarshal(DataInputStream dis)
{
base.Unmarshal(dis);
if (dis != null)
{
try
{
this._originatingID.Unmarshal(dis);
this._receivingID.Unmarshal(dis);
this._realWorldTime.Unmarshal(dis);
this._reason = dis.ReadUnsignedByte();
this._frozenBehavior = dis.ReadUnsignedByte();
this._padding1 = dis.ReadShort();
this._requestID = dis.ReadUnsignedInt();
}
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._parameterIndex = dis.ReadUnsignedShort();
this._parameterValue = dis.ReadShort();
}
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;
}
}
}
}
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 override void Unmarshal(DataInputStream dis)
{
base.Unmarshal(dis);
if (dis != null)
{
try
{
this._issuingEntityID.Unmarshal(dis);
this._collidingEntityID.Unmarshal(dis);
this._collisionEventID.Unmarshal(dis);
this._pad = dis.ReadShort();
this._contactVelocity.Unmarshal(dis);
this._mass = dis.ReadFloat();
this._locationOfImpact.Unmarshal(dis);
this._collisionIntermediateResultXX = dis.ReadFloat();
this._collisionIntermediateResultXY = dis.ReadFloat();
this._collisionIntermediateResultXZ = dis.ReadFloat();
this._collisionIntermediateResultYY = dis.ReadFloat();
this._collisionIntermediateResultYZ = dis.ReadFloat();
this._collisionIntermediateResultZZ = dis.ReadFloat();
this._unitSurfaceNormal.Unmarshal(dis);
this._coefficientOfRestitution = dis.ReadFloat();
}
catch (Exception e)
{
#if DEBUG
Trace.WriteLine(e);
Trace.Flush();
#endif
this.OnException(e);
}
}
}
/// <summary>Read word vectors from an input stream.</summary>
/// <remarks>Read word vectors from an input stream. The stream is not closed on finishing the function.</remarks>
/// <param name="in">The stream to read from. This is not closed.</param>
/// <returns>The word vectors encoded on the stream.</returns>
/// <exception cref="System.IO.IOException">Thrown if we could not read from the stream.</exception>
public static VectorMap Deserialize(InputStream @in)
{
DataInputStream dataIn = new DataInputStream(@in);
// Read the max key length
VectorMap.Itype keyIntType = VectorMap.Itype.GetType(dataIn.ReadInt());
// Read the vector dimensionality
int dim = dataIn.ReadInt();
// Read the size of the dataset
int size = dataIn.ReadInt();
// Read the vectors
VectorMap vectors = new VectorMap();
for (int i = 0; i < size; ++i)
{
// Read the key
int strlen = keyIntType.Read(dataIn);
byte[] buffer = new byte[strlen];
if (dataIn.Read(buffer, 0, strlen) != strlen)
{
throw new IOException("Could not read string buffer fully!");
}
string key = Sharpen.Runtime.GetStringForBytes(buffer);
// Read the vector
float[] vector = new float[dim];
for (int k = 0; k < vector.Length; ++k)
{
vector[k] = ToFloat(dataIn.ReadShort());
}
// Add the key/value
vectors[key] = vector;
}
return(vectors);
}
/// <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._realWorldTime.Unmarshal(dis);
this._reason = dis.ReadUnsignedByte();
this._frozenBehavior = dis.ReadUnsignedByte();
this._padding1 = dis.ReadShort();
this._requestID = dis.ReadUnsignedInt();
}
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._requestingEntityID.Unmarshal(dis);
this._servicingEntityID.Unmarshal(dis);
this._serviceTypeRequested = dis.ReadUnsignedByte();
this._numberOfSupplyTypes = dis.ReadUnsignedByte();
this._serviceRequestPadding = dis.ReadShort();
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 TestGetMetaData()
{
SimulatedFSDataset fsdataset = GetSimulatedFSDataset();
ExtendedBlock b = new ExtendedBlock(bpid, 1, 5, 0);
try
{
NUnit.Framework.Assert.IsTrue(fsdataset.GetMetaDataInputStream(b) == null);
NUnit.Framework.Assert.IsTrue("Expected an IO exception", false);
}
catch (IOException)
{
}
// ok - as expected
AddSomeBlocks(fsdataset);
// Only need to add one but ....
b = new ExtendedBlock(bpid, 1, 0, 0);
InputStream metaInput = fsdataset.GetMetaDataInputStream(b);
DataInputStream metaDataInput = new DataInputStream(metaInput);
short version = metaDataInput.ReadShort();
NUnit.Framework.Assert.AreEqual(BlockMetadataHeader.Version, version);
DataChecksum checksum = DataChecksum.NewDataChecksum(metaDataInput);
NUnit.Framework.Assert.AreEqual(DataChecksum.Type.Null, checksum.GetChecksumType(
));
NUnit.Framework.Assert.AreEqual(0, checksum.GetChecksumSize());
}
public virtual void Unmarshal(DataInputStream dis)
{
if (dis != null)
{
try
{
this._protocolVersion = dis.ReadUnsignedByte();
this._exerciseID = dis.ReadUnsignedByte();
this._pduType = dis.ReadUnsignedByte();
this._protocolFamily = dis.ReadUnsignedByte();
this._timestamp = dis.ReadUnsignedInt();
this._length = dis.ReadUnsignedShort();
this._padding = dis.ReadShort();
}
catch (Exception e)
{
if (PduBase.TraceExceptions)
{
Trace.WriteLine(e);
Trace.Flush();
}
this.RaiseExceptionOccured(e);
if (PduBase.ThrowExceptions)
{
throw e;
}
}
}
}
/// <exception cref="System.IO.IOException"/>
public virtual void ReadFields(DataInputStream @in)
{
this.packetLen = @in.ReadInt();
short protoLen = @in.ReadShort();
byte[] data = new byte[protoLen];
@in.ReadFully(data);
proto = DataTransferProtos.PacketHeaderProto.ParseFrom(data);
}
// Permissions
/// <summary>Extract CachePool permissions stored in the fsimage file.</summary>
/// <param name="in">Datastream to process</param>
/// <param name="v">Visitor to walk over inodes</param>
/// <exception cref="System.IO.IOException"/>
private void ProcessCachePoolPermission(DataInputStream @in, ImageVisitor v)
{
v.VisitEnclosingElement(ImageVisitor.ImageElement.Permissions);
v.Visit(ImageVisitor.ImageElement.CachePoolOwnerName, Text.ReadString(@in));
v.Visit(ImageVisitor.ImageElement.CachePoolGroupName, Text.ReadString(@in));
FsPermission fsp = new FsPermission(@in.ReadShort());
v.Visit(ImageVisitor.ImageElement.CachePoolPermissionString, fsp.ToString());
v.LeaveEnclosingElement();
}
/// <summary>Read an Op.</summary>
/// <remarks>Read an Op. It also checks protocol version.</remarks>
/// <exception cref="System.IO.IOException"/>
protected internal OP ReadOp()
{
short version = @in.ReadShort();
if (version != DataTransferProtocol.DataTransferVersion)
{
throw new IOException("Version Mismatch (Expected: " + DataTransferProtocol.DataTransferVersion
+ ", Received: " + version + " )");
}
return(OP.Read(@in));
}
public virtual void Unmarshal(DataInputStream dis)
{
if (dis != null)
{
try
{
this._currentShaftRPMs = dis.ReadShort();
this._orderedShaftRPMs = dis.ReadShort();
this._shaftRPMRateOfChange = dis.ReadFloat();
}
catch (Exception e)
{
#if DEBUG
Trace.WriteLine(e);
Trace.Flush();
#endif
this.OnException(e);
}
}
}
/// <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;
}
}
}
// INode
/// <exception cref="System.IO.IOException"/>
private void ProcessINodeFileAttributes(DataInputStream @in, ImageVisitor v, string
parentName)
{
string pathName = ReadINodePath(@in, parentName);
v.Visit(ImageVisitor.ImageElement.InodePath, pathName);
ProcessPermission(@in, v);
v.Visit(ImageVisitor.ImageElement.ModificationTime, FormatDate(@in.ReadLong()));
if (NameNodeLayoutVersion.Supports(LayoutVersion.Feature.FileAccessTime, imageVersion
))
{
v.Visit(ImageVisitor.ImageElement.AccessTime, FormatDate(@in.ReadLong()));
}
v.Visit(ImageVisitor.ImageElement.Replication, @in.ReadShort());
v.Visit(ImageVisitor.ImageElement.BlockSize, @in.ReadLong());
}
public virtual void Unmarshal(DataInputStream dis)
{
if (dis != null)
{
try
{
this._parameterIndex = dis.ReadUnsignedShort();
this._parameterValue = dis.ReadShort();
}
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._munitionID.Unmarshal(dis);
this._eventID.Unmarshal(dis);
this._velocity.Unmarshal(dis);
this._locationInWorldCoordinates.Unmarshal(dis);
this._burstDescriptor.Unmarshal(dis);
this._locationInEntityCoordinates.Unmarshal(dis);
this._detonationResult = dis.ReadUnsignedByte();
this._numberOfArticulationParameters = dis.ReadUnsignedByte();
this._pad = dis.ReadShort();
for (int idx = 0; idx < this.NumberOfArticulationParameters; 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;
}
}
}
}
/// <summary>Process CacheManager state from the fsimage.</summary>
/// <exception cref="System.IO.IOException"/>
private void ProcessCacheManagerState(DataInputStream @in, ImageVisitor v)
{
v.Visit(ImageVisitor.ImageElement.CacheNextEntryId, @in.ReadLong());
int numPools = @in.ReadInt();
for (int i = 0; i < numPools; i++)
{
v.Visit(ImageVisitor.ImageElement.CachePoolName, Text.ReadString(@in));
ProcessCachePoolPermission(@in, v);
v.Visit(ImageVisitor.ImageElement.CachePoolWeight, @in.ReadInt());
}
int numEntries = @in.ReadInt();
for (int i_1 = 0; i_1 < numEntries; i_1++)
{
v.Visit(ImageVisitor.ImageElement.CacheEntryPath, Text.ReadString(@in));
v.Visit(ImageVisitor.ImageElement.CacheEntryReplication, @in.ReadShort());
v.Visit(ImageVisitor.ImageElement.CacheEntryPoolName, Text.ReadString(@in));
}
}
public override void Unmarshal(DataInputStream dis)
{
base.Unmarshal(dis);
if (dis != null)
{
try
{
this._issuingEntityID.Unmarshal(dis);
this._collidingEntityID.Unmarshal(dis);
this._collisionEventID.Unmarshal(dis);
this._pad = dis.ReadShort();
this._contactVelocity.Unmarshal(dis);
this._mass = dis.ReadFloat();
this._location.Unmarshal(dis);
this._collisionResultXX = dis.ReadFloat();
this._collisionResultXY = dis.ReadFloat();
this._collisionResultXZ = dis.ReadFloat();
this._collisionResultYY = dis.ReadFloat();
this._collisionResultYZ = dis.ReadFloat();
this._collisionResultZZ = dis.ReadFloat();
this._unitSurfaceNormal.Unmarshal(dis);
this._coefficientOfRestitution = dis.ReadFloat();
}
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._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 (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._receivingEntityID.Unmarshal(dis);
this._repairingEntityID.Unmarshal(dis);
this._repair = dis.ReadUnsignedShort();
this._padding2 = dis.ReadShort();
}
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._protocolVersion = dis.ReadUnsignedByte();
this._exerciseID = dis.ReadUnsignedByte();
this._pduType = dis.ReadUnsignedByte();
this._protocolFamily = dis.ReadUnsignedByte();
this._timestamp = dis.ReadUnsignedInt();
this._length = dis.ReadUnsignedShort();
this._padding = dis.ReadShort();
}
catch (Exception e)
{
#if DEBUG
Trace.WriteLine(e);
Trace.Flush();
#endif
this.OnException(e);
}
}
}
/// <summary>This reads all the fields till the beginning of checksum.</summary>
/// <returns>Metadata Header</returns>
/// <exception cref="System.IO.IOException"/>
public static Org.Apache.Hadoop.Hdfs.Server.Datanode.BlockMetadataHeader ReadHeader
(DataInputStream @in)
{
return(ReadHeader(@in.ReadShort(), @in));
}
// ----------------------------------------------------------------
// Constructor
/// <summary>
/// Constructs a UPropertyAliases object. The binary file DATA_FILE_NAME is
/// read from the jar/classpath and unflattened into member variables of this
/// object.
/// </summary>
///
public UPropertyAliases()
{
// Open the .icu file from the jar/classpath
Stream
mask0 = IBM.ICU.Impl.ICUData.GetRequiredStream(DATA_FILE_NAME);
BufferedStream b = new BufferedStream(mask0, DATA_BUFFER_SIZE);
// Read and discard Unicode version...
/* byte unicodeVersion[] = */
IBM.ICU.Impl.ICUBinary.ReadHeader(b, DATA_FORMAT_ID,
this);
DataInputStream d = new DataInputStream(b);
// Record the origin position of the file. Keep enough around
// to seek back to the start of the header.
d.Mark(256);
short enumToName_offset = d.ReadShort();
short nameToEnum_offset = d.ReadShort();
short enumToValue_offset = d.ReadShort();
short total_size = d.ReadShort();
short valueMap_offset = d.ReadShort();
short valueMap_count = d.ReadShort();
short nameGroupPool_offset = d.ReadShort();
short nameGroupPool_count = d.ReadShort();
short stringPool_offset = d.ReadShort();
short stringPool_count = d.ReadShort();
if (DEBUG)
{
System.Console.Out.WriteLine("enumToName_offset=" + enumToName_offset + "\n"
+ "nameToEnum_offset=" + nameToEnum_offset + "\n"
+ "enumToValue_offset=" + enumToValue_offset + "\n"
+ "total_size=" + total_size + "\n" + "valueMap_offset="
+ valueMap_offset + "\n" + "valueMap_count="
+ valueMap_count + "\n" + "nameGroupPool_offset="
+ nameGroupPool_offset + "\n" + "nameGroupPool_count="
+ nameGroupPool_count + "\n" + "stringPool_offset="
+ stringPool_offset + "\n" + "stringPool_count="
+ stringPool_count);
}
byte[] raw = new byte[total_size];
d.Reset();
d.ReadFully(raw);
d.Close();
UPropertyAliases.Builder builder = new UPropertyAliases.Builder(raw);
stringPool = builder
.ReadStringPool(stringPool_offset, stringPool_count);
nameGroupPool = builder.ReadNameGroupPool(nameGroupPool_offset,
nameGroupPool_count);
builder.SetupValueMap_map(valueMap_offset, valueMap_count);
// Some of the following data structures have to be set up
// here, _not_ in Builder. That's because they are instances
// of non-static inner classes, and they contain implicit
// references to this.
builder.Seek(enumToName_offset);
enumToName = new UPropertyAliases.NonContiguousEnumToShort(builder);
builder.NameGroupOffsetToIndex(enumToName.offsetArray);
builder.Seek(nameToEnum_offset);
nameToEnum = new UPropertyAliases.NameToEnum(this, builder);
builder.Seek(enumToValue_offset);
enumToValue = new UPropertyAliases.NonContiguousEnumToShort(builder);
builder.ValueMapOffsetToIndex(enumToValue.offsetArray);
valueMapArray = new UPropertyAliases.ValueMap [valueMap_count];
for (int i = 0; i < valueMap_count; ++i)
{
// Must seek to the start of each entry.
builder.Seek(builder.valueMap_map[i]);
valueMapArray[i] = new UPropertyAliases.ValueMap(this, builder);
}
builder.Close();
}
public void Handle(byte[] data, RtpMidiServer rtpMidiServer)
{
DataInputStream dataInputStream = new DataInputStream(new MemoryStream(data));
byte header1 = (byte)dataInputStream.ReadByte();
byte version = (byte)((header1 >> 6) & 0x03);
bool paddingFlag = ((header1 >> 5) & 0x01) == 1;
bool extensionFlag = ((header1 >> 4) & 0x01) == 1;
byte contributingSourceIdentifiersCount = (byte)(header1 & 0x0F);
byte header2 = (byte)dataInputStream.ReadByte();
bool markerFlag = ((header2 >> 7) & 0x01) == 1;
byte payloadType = (byte)(header2 & 0x7F);
if (payloadType != RTP_MIDI)
{
return;
}
short sequenceNumber = dataInputStream.ReadShort();
int timestamp = dataInputStream.ReadInt();
int ssrc = dataInputStream.ReadInt();
RtpHeader rtpHeader = new RtpHeader(version, paddingFlag, extensionFlag, contributingSourceIdentifiersCount, markerFlag,
payloadType, sequenceNumber, timestamp, ssrc);
byte midiCommandHeader1 = (byte)dataInputStream.ReadByte();
bool b = ((midiCommandHeader1 >> 7) & 0x01) == 1;
bool j = ((midiCommandHeader1 >> 6) & 0x01) == 1;
bool z = ((midiCommandHeader1 >> 5) & 0x01) == 1;
bool p = ((midiCommandHeader1 >> 4) & 0x01) == 1;
// Header 2 octets
short length;
if (b)
{
byte midiCommandHeader2 = (byte)dataInputStream.ReadByte();
length = (short)((midiCommandHeader1 << 8 | midiCommandHeader2) & 0x0FFF);
}
else
{
length = (short)(midiCommandHeader1 & 0x0F);
}
MidiCommandHeader midiCommandHeader = new MidiCommandHeader(b, j, z, p, length, rtpHeader);
byte[] midiCommandBuffer = new byte[length];
int midiCommandBytesRead = dataInputStream.Read(midiCommandBuffer);
if (((short)midiCommandBytesRead) != length)
{
return;
}
List <MidiTimestampPair> messages = new List <MidiTimestampPair>();
try
{
DataInputStream midiInputStream = new DataInputStream(new MemoryStream(midiCommandBuffer));
messages.AddRange(ReadMidiMessages(midiCommandHeader, midiInputStream));
HandleMessage(new RtpMidiMessage(midiCommandHeader, messages));
}
catch (System.IO.IOException e)
{
Log.Error("RtpMidi", "IOException while processing MIDI message", e);
}
}
/// <summary>Process an INode</summary>
/// <param name="in">image stream</param>
/// <param name="v">visitor</param>
/// <param name="skipBlocks">skip blocks or not</param>
/// <param name="parentName">the name of its parent node</param>
/// <param name="isSnapshotCopy">whether or not the inode is a snapshot copy</param>
/// <exception cref="System.IO.IOException"/>
private void ProcessINode(DataInputStream @in, ImageVisitor v, bool skipBlocks, string
parentName, bool isSnapshotCopy)
{
bool supportSnapshot = NameNodeLayoutVersion.Supports(LayoutVersion.Feature.Snapshot
, imageVersion);
bool supportInodeId = NameNodeLayoutVersion.Supports(LayoutVersion.Feature.AddInodeId
, imageVersion);
v.VisitEnclosingElement(ImageVisitor.ImageElement.Inode);
string pathName = ReadINodePath(@in, parentName);
v.Visit(ImageVisitor.ImageElement.InodePath, pathName);
long inodeId = INodeId.GrandfatherInodeId;
if (supportInodeId)
{
inodeId = @in.ReadLong();
v.Visit(ImageVisitor.ImageElement.InodeId, inodeId);
}
v.Visit(ImageVisitor.ImageElement.Replication, @in.ReadShort());
v.Visit(ImageVisitor.ImageElement.ModificationTime, FormatDate(@in.ReadLong()));
if (NameNodeLayoutVersion.Supports(LayoutVersion.Feature.FileAccessTime, imageVersion
))
{
v.Visit(ImageVisitor.ImageElement.AccessTime, FormatDate(@in.ReadLong()));
}
v.Visit(ImageVisitor.ImageElement.BlockSize, @in.ReadLong());
int numBlocks = @in.ReadInt();
ProcessBlocks(@in, v, numBlocks, skipBlocks);
if (numBlocks >= 0)
{
// File
if (supportSnapshot)
{
// make sure subtreeMap only contains entry for directory
Sharpen.Collections.Remove(subtreeMap, inodeId);
// process file diffs
ProcessFileDiffList(@in, v, parentName);
if (isSnapshotCopy)
{
bool underConstruction = @in.ReadBoolean();
if (underConstruction)
{
v.Visit(ImageVisitor.ImageElement.ClientName, FSImageSerialization.ReadString(@in
));
v.Visit(ImageVisitor.ImageElement.ClientMachine, FSImageSerialization.ReadString(
@in));
}
}
}
ProcessPermission(@in, v);
}
else
{
if (numBlocks == -1)
{
// Directory
if (supportSnapshot && supportInodeId)
{
dirNodeMap[inodeId] = pathName;
}
v.Visit(ImageVisitor.ImageElement.NsQuota, numBlocks == -1 ? @in.ReadLong() : -1);
if (NameNodeLayoutVersion.Supports(LayoutVersion.Feature.DiskspaceQuota, imageVersion
))
{
v.Visit(ImageVisitor.ImageElement.DsQuota, numBlocks == -1 ? @in.ReadLong() : -1);
}
if (supportSnapshot)
{
bool snapshottable = @in.ReadBoolean();
if (!snapshottable)
{
bool withSnapshot = @in.ReadBoolean();
v.Visit(ImageVisitor.ImageElement.IsWithsnapshotDir, bool.ToString(withSnapshot));
}
else
{
v.Visit(ImageVisitor.ImageElement.IsSnapshottableDir, bool.ToString(snapshottable
));
}
}
ProcessPermission(@in, v);
}
else
{
if (numBlocks == -2)
{
v.Visit(ImageVisitor.ImageElement.Symlink, Text.ReadString(@in));
ProcessPermission(@in, v);
}
else
{
if (numBlocks == -3)
{
// reference node
bool isWithName = @in.ReadBoolean();
int snapshotId = @in.ReadInt();
if (isWithName)
{
v.Visit(ImageVisitor.ImageElement.SnapshotLastSnapshotId, snapshotId);
}
else
{
v.Visit(ImageVisitor.ImageElement.SnapshotDstSnapshotId, snapshotId);
}
bool firstReferred = @in.ReadBoolean();
if (firstReferred)
{
// if a subtree is linked by multiple "parents", the corresponding dir
// must be referred by a reference node. we put the reference node into
// the subtreeMap here and let its value be false. when we later visit
// the subtree for the first time, we change the value to true.
subtreeMap[inodeId] = false;
v.VisitEnclosingElement(ImageVisitor.ImageElement.SnapshotRefInode);
ProcessINode(@in, v, skipBlocks, parentName, isSnapshotCopy);
v.LeaveEnclosingElement();
}
else
{
// referred inode
v.Visit(ImageVisitor.ImageElement.SnapshotRefInodeId, @in.ReadLong());
}
}
}
}
}
v.LeaveEnclosingElement();
}
/*
* Get an RBBIDataWrapper from an InputStream onto a pre-compiled set of
* RBBI rules.
*/
static internal RBBIDataWrapper Get(Stream mask0)
{
int i;
DataInputStream dis = new DataInputStream(new BufferedStream(mask0));
RBBIDataWrapper This = new RBBIDataWrapper();
// Seek past the ICU data header.
// TODO: verify that the header looks good.
dis.SkipBytes(0x80);
// Read in the RBBI data header...
This.fHeader = new RBBIDataWrapper.RBBIDataHeader();
This.fHeader.fMagic = dis.ReadInt();
This.fHeader.fVersion = dis.ReadInt();
This.fHeader.fFormatVersion[0] = (byte)(This.fHeader.fVersion >> 24);
This.fHeader.fFormatVersion[1] = (byte)(This.fHeader.fVersion >> 16);
This.fHeader.fFormatVersion[2] = (byte)(This.fHeader.fVersion >> 8);
This.fHeader.fFormatVersion[3] = (byte)(This.fHeader.fVersion);
This.fHeader.fLength = dis.ReadInt();
This.fHeader.fCatCount = dis.ReadInt();
This.fHeader.fFTable = dis.ReadInt();
This.fHeader.fFTableLen = dis.ReadInt();
This.fHeader.fRTable = dis.ReadInt();
This.fHeader.fRTableLen = dis.ReadInt();
This.fHeader.fSFTable = dis.ReadInt();
This.fHeader.fSFTableLen = dis.ReadInt();
This.fHeader.fSRTable = dis.ReadInt();
This.fHeader.fSRTableLen = dis.ReadInt();
This.fHeader.fTrie = dis.ReadInt();
This.fHeader.fTrieLen = dis.ReadInt();
This.fHeader.fRuleSource = dis.ReadInt();
This.fHeader.fRuleSourceLen = dis.ReadInt();
This.fHeader.fStatusTable = dis.ReadInt();
This.fHeader.fStatusTableLen = dis.ReadInt();
dis.SkipBytes(6 * 4); // uint32_t fReserved[6];
if (This.fHeader.fMagic != 0xb1a0 || !(This.fHeader.fVersion == 1 || // ICU
// 3.2
// and
// earlier
This.fHeader.fFormatVersion[0] == 3) // ICU 3.4
)
{
throw new IOException(
"Break Iterator Rule Data Magic Number Incorrect, or unsupported data version.");
}
// Current position in input stream.
int pos = 24 * 4; // offset of end of header, which has 24 fields, all
// int32_t (4 bytes)
//
// Read in the Forward state transition table as an array of shorts.
//
// Quick Sanity Check
if (This.fHeader.fFTable < pos ||
This.fHeader.fFTable > This.fHeader.fLength)
{
throw new IOException("Break iterator Rule data corrupt");
}
// Skip over any padding preceding this table
dis.SkipBytes(This.fHeader.fFTable - pos);
pos = This.fHeader.fFTable;
This.fFTable = new short[This.fHeader.fFTableLen / 2];
for (i = 0; i < This.fFTable.Length; i++)
{
This.fFTable[i] = dis.ReadShort();
pos += 2;
}
//
// Read in the Reverse state table
//
// Skip over any padding in the file
dis.SkipBytes(This.fHeader.fRTable - pos);
pos = This.fHeader.fRTable;
// Create & fill the table itself.
This.fRTable = new short[This.fHeader.fRTableLen / 2];
for (i = 0; i < This.fRTable.Length; i++)
{
This.fRTable[i] = dis.ReadShort();
pos += 2;
}
//
// Read in the Safe Forward state table
//
if (This.fHeader.fSFTableLen > 0)
{
// Skip over any padding in the file
dis.SkipBytes(This.fHeader.fSFTable - pos);
pos = This.fHeader.fSFTable;
// Create & fill the table itself.
This.fSFTable = new short[This.fHeader.fSFTableLen / 2];
for (i = 0; i < This.fSFTable.Length; i++)
{
This.fSFTable[i] = dis.ReadShort();
pos += 2;
}
}
//
// Read in the Safe Reverse state table
//
if (This.fHeader.fSRTableLen > 0)
{
// Skip over any padding in the file
dis.SkipBytes(This.fHeader.fSRTable - pos);
pos = This.fHeader.fSRTable;
// Create & fill the table itself.
This.fSRTable = new short[This.fHeader.fSRTableLen / 2];
for (i = 0; i < This.fSRTable.Length; i++)
{
This.fSRTable[i] = dis.ReadShort();
pos += 2;
}
}
//
// Unserialize the Character categories TRIE
// Because we can't be absolutely certain where the Trie deserialize
// will
// leave the input stream, leave position unchanged.
// The seek to the start of the next item following the TRIE will get us
// back in sync.
//
dis.SkipBytes(This.fHeader.fTrie - pos); // seek input stream from end of
// previous section to
pos = This.fHeader.fTrie; // to the start of the trie
dis.Mark(This.fHeader.fTrieLen + 100); // Mark position of start of TRIE
// in the input
// and tell Java to keep the mark
// valid so long
// as we don't go more than 100
// bytes past the
// past the end of the TRIE.
This.fTrie = new CharTrie(dis, fTrieFoldingFunc); // Deserialize the
// TRIE, leaving input
// stream at an unknown position, preceding the
// padding between TRIE and following section.
dis.Reset(); // Move input stream back to marked position at
// the start of the serialized TRIE. Now our
// "pos" variable and the input stream are in
// agreement.
//
// Read the Rule Status Table
//
if (pos > This.fHeader.fStatusTable)
{
throw new IOException("Break iterator Rule data corrupt");
}
dis.SkipBytes(This.fHeader.fStatusTable - pos);
pos = This.fHeader.fStatusTable;
This.fStatusTable = new int[This.fHeader.fStatusTableLen / 4];
for (i = 0; i < This.fStatusTable.Length; i++)
{
This.fStatusTable[i] = dis.ReadInt();
pos += 4;
}
//
// Put the break rule source into a String
//
if (pos > This.fHeader.fRuleSource)
{
throw new IOException("Break iterator Rule data corrupt");
}
dis.SkipBytes(This.fHeader.fRuleSource - pos);
pos = This.fHeader.fRuleSource;
StringBuilder sb = new StringBuilder(This.fHeader.fRuleSourceLen / 2);
for (i = 0; i < This.fHeader.fRuleSourceLen; i += 2)
{
sb.Append(dis.ReadChar());
pos += 2;
}
This.fRuleSource = sb.ToString();
if (IBM.ICU.Text.RuleBasedBreakIterator.fDebugEnv != null &&
IBM.ICU.Text.RuleBasedBreakIterator.fDebugEnv.IndexOf("data") >= 0)
{
This.Dump();
}
return(This);
}
/// <exclude/>
public void ReadDictionaryFile(DataInputStream ins0)
{
int l;
// read in the version number (right now we just ignore it)
ins0.ReadInt();
// read in the column map (this is serialized in its internal form:
// an index array followed by a data array)
l = ins0.ReadInt();
char[] temp = new char[l];
for (int i = 0; i < temp.Length; i++)
{
temp[i] = (char)ins0.ReadShort();
}
l = ins0.ReadInt();
sbyte[] temp2 = new sbyte[l];
for (int i_0 = 0; i_0 < temp2.Length; i_0++)
{
temp2[i_0] = ins0.ReadByte();
}
columnMap = new CompactByteArray(temp, temp2);
// read in numCols and numColGroups
numCols = ins0.ReadInt();
/* numColGroups = */ ins0.ReadInt();
// read in the row-number index
l = ins0.ReadInt();
rowIndex = new short[l];
for (int i_1 = 0; i_1 < rowIndex.Length; i_1++)
{
rowIndex[i_1] = ins0.ReadShort();
}
// load in the populated-cells bitmap: index first, then bitmap list
l = ins0.ReadInt();
rowIndexFlagsIndex = new short[l];
for (int i_2 = 0; i_2 < rowIndexFlagsIndex.Length; i_2++)
{
rowIndexFlagsIndex[i_2] = ins0.ReadShort();
}
l = ins0.ReadInt();
rowIndexFlags = new int[l];
for (int i_3 = 0; i_3 < rowIndexFlags.Length; i_3++)
{
rowIndexFlags[i_3] = ins0.ReadInt();
}
// load in the row-shift index
l = ins0.ReadInt();
rowIndexShifts = new sbyte[l];
for (int i_4 = 0; i_4 < rowIndexShifts.Length; i_4++)
{
rowIndexShifts[i_4] = ins0.ReadByte();
}
// finally, load in the actual state table
l = ins0.ReadInt();
table = new short[l];
for (int i_5 = 0; i_5 < table.Length; i_5++)
{
table[i_5] = ins0.ReadShort();
}
// this data structure is only necessary for testing and debugging
// purposes
reverseColumnMap = new char[numCols];
for (char c = (char)(0); c < 0xffff; c++)
{
int col = columnMap.ElementAt(c);
if (col != 0)
{
reverseColumnMap[col] = c;
}
}
// close the stream
ins0.Close();
}
