public ReadElementContentAsBase64 ( byte buffer, int index, int count ) : int | ||
buffer | byte | |
index | int | |
count | int | |
return | int |
[MonoTODO] // FIXME: Check how expanded entity is handled here. public override int ReadElementContentAsBase64(byte [] buffer, int index, int count) { if (validatingReader != null) { return(validatingReader.ReadElementContentAsBase64(buffer, index, count)); } else { return(sourceReader.ReadElementContentAsBase64(buffer, index, count)); } }
[MonoTODO] // FIXME: Check how expanded entity is handled here. public override int ReadElementContentAsBase64(byte [] buffer, int offset, int length) { if (validatingReader != null) { return(validatingReader.ReadElementContentAsBase64(buffer, offset, length)); } else { return(sourceReader.ReadElementContentAsBase64(buffer, offset, length)); } }
public void StoreImageFromXml(Image image, XmlReader reader) { MemoryStream memoryStream = new MemoryStream(); byte[] readBuffer = new byte[128 * 1024]; int read; while ((read = reader.ReadElementContentAsBase64(readBuffer, 0, readBuffer.Length)) > 0) { memoryStream.Write(readBuffer, 0, read); } this.data[image] = memoryStream.ToArray(); }
public void StoreImageFromXml(Image image, XmlReader reader) { string remoteFilename = GetImageFilename(image); using (Stream fileStream = this.Database.GridFS.Open(remoteFilename, FileMode.Create)) { byte[] readBuffer = new byte[128 * 1024]; int read; while ((read = reader.ReadElementContentAsBase64(readBuffer, 0, readBuffer.Length)) > 0) { fileStream.Write(readBuffer, 0, read); } } }
public override int ReadElementContentAsBase64(byte [] buffer, int index, int count) { // return base.ReadElementContentAsBase64 ( // buffer, index, count); // FIXME: This is problematic wrt end of entity. if (entity != null) { return(entity.ReadElementContentAsBase64( buffer, index, count)); } else { return(source.ReadElementContentAsBase64( buffer, index, count)); } }
public override int ReadElementContentAsBase64( byte [] buffer, int offset, int length) { // return base.ReadElementContentAsBase64 ( // buffer, offset, length); // FIXME: This is problematic wrt end of entity. if (entity != null) { return(entity.ReadElementContentAsBase64( buffer, offset, length)); } else { return(source.ReadElementContentAsBase64( buffer, offset, length)); } }
/// <summary> /// Initializes a new instance of the Message class from data /// read from an XML stream. /// </summary> /// <param name="reader">The XmlReader for the XML data.</param> public Message(XmlReader reader) { MemoryStream growableBuffer = null; try { reader.ReadToFollowing("From"); this.From = reader.ReadElementContentAsString(); reader.ReadToFollowing("To"); this.To = reader.ReadElementContentAsString(); reader.ReadToFollowing("Body"); int got = 0; byte[] buffer = new byte[100]; growableBuffer = new MemoryStream(); while ((got = reader.ReadElementContentAsBase64(buffer, 0, buffer.Length)) > 0) { growableBuffer.Write(buffer, 0, got); } this.Body = growableBuffer.ToArray(); this.Valid = true; } catch { return; } finally { if (growableBuffer != null) { growableBuffer.Dispose(); } } }
protected void ParseTerrainElement(XmlReader r) { // save the name of the element string name = r.Name; String mapFormat = null; string val; if (name == "seedMap") { // parse seedMap attributes for (int i = 0; i < r.AttributeCount; i++) { r.MoveToAttribute(i); // set the field in this object based on the element we just read switch (r.Name) { case "width": SeedMapWidth = int.Parse(r.Value); break; case "height": SeedMapHeight = int.Parse(r.Value); break; case "mapFormat": mapFormat = r.Value; break; case "bitsPerSample": bitsPerSample = int.Parse(r.Value); // deal with old terrain xml, which set bitsPerSample to 256 for 8-bit samples if (bitsPerSample == 256) { bitsPerSample = 8; } break; } } r.MoveToElement(); //Moves the reader back to the element node. SeedMap = new float[SeedMapWidth * SeedMapHeight]; switch (mapFormat) { case "digitString": // read the value r.Read(); if (r.NodeType != XmlNodeType.Text) { return; } val = r.Value; Debug.Assert(val.Length == (SeedMapWidth * SeedMapHeight), "ParseSeedMap: value is wrong length"); for (int i = 0; i < (SeedMapWidth * SeedMapHeight); i++) { SeedMap[i] = (val[i] - '0') / 9f; } // error out if we dont see an end element here r.Read(); if (r.NodeType != XmlNodeType.EndElement) { return; } break; case "base64": int bytesPerSample = bitsPerSample >> 3; int byteCount = bytesPerSample * SeedMapWidth * SeedMapHeight; float divisor = 1.0f / ((float)Math.Pow(256d, bytesPerSample) - 1f); byte [] byteMap = new byte[byteCount]; int bytesRead = r.ReadElementContentAsBase64(byteMap, 0, byteCount); Debug.Assert(bytesRead == (byteCount)); for (int i = 0; i < (SeedMapWidth * SeedMapHeight); i++) { int value = 0; int byteOffset = i * bytesPerSample; for (int j=0; j<bytesPerSample; j++) value |= (byteMap[byteOffset + j] << (j * 8)); SeedMap[i] = value * divisor; } // dont read the end element, because the ReadBase64 appears to consume it break; } } else { // read the value r.Read(); if (r.NodeType != XmlNodeType.Text) { return; } val = r.Value; // error out if we dont see an end element here r.Read(); if (r.NodeType != XmlNodeType.EndElement) { return; } // set the field in this object based on the element we just read switch (name) { case "algorithm": for (int i = 0; i < AlgorithmNames.Length; i++) { if (AlgorithmNames[i] == val) { Algorithm = (GeneratorAlgorithm)i; break; } } break; case "xOffset": XOff = float.Parse(val); break; case "yOffset": YOff = float.Parse(val); break; case "zOffset": ZOff = float.Parse(val); break; case "h": H = float.Parse(val); break; case "lacunarity": Lacunarity = float.Parse(val); break; case "octaves": Octaves = float.Parse(val); break; case "metersPerPerlinUnit": MetersPerPerlinUnit = float.Parse(val); break; case "heightScale": HeightScale = float.Parse(val); break; case "heightOffset": HeightOffset = float.Parse(val); break; case "fractalOffset": FractalOffset = float.Parse(val); break; case "heightFloor": HeightFloor = float.Parse(val); break; case "seedMapOriginX": SeedMapOriginX = float.Parse(val); break; case "seedMapOriginY": SeedMapOriginY = float.Parse(val); break; case "seedMapOriginZ": SeedMapOriginZ = float.Parse(val); break; case "seedMapMetersPerSample": SeedMapMetersPerSample = float.Parse(val); break; case "outsideSeedMapHeight": OutsideMapSeedHeight = float.Parse(val); break; } } }
public override int ReadElementContentAsBase64(byte[] buffer, int index, int count) { CheckAsync(); return(_coreReader.ReadElementContentAsBase64(buffer, index, count)); }
protected virtual object ReadValueFromXmlReader(XmlReader xmlReader) { xmlReader.MoveToContent(); using (var memoryStream = new MemoryStream()) { const int BUFFER_SIZE = 4096; byte[] buffer = new byte[BUFFER_SIZE]; int readByteCount = 0; while ((readByteCount = xmlReader.ReadElementContentAsBase64(buffer, 0, BUFFER_SIZE)) > 0) { memoryStream.Write(buffer, 0, readByteCount); } memoryStream.Seek(0, SeekOrigin.Begin); var deserializedObject = _binarySer.Deserialize(memoryStream); return deserializedObject; } }
private void ReadAdditionalFiles(XmlReader reader, Release release) { reader.AssertElementStart(Keys.AdditionalFiles); if (reader.IsEmptyElement) { return; } bool skipRead = false; while (skipRead || reader.Read()) { skipRead = false; if (reader.IsElementEnd(Keys.AdditionalFiles)) { break; } reader.AssertElementStart(Keys.AdditionalFile); ReleaseAdditionalFile file = new ReleaseAdditionalFile() { Type = Utility.ParseEnum<ReleaseAdditionalFileType>(reader.GetAttributeOrNull(Keys.Type)), Description = reader.GetAttributeOrNull(Keys.Description), OriginalFilename = reader.GetAttributeOrNull(Keys.OriginalFilename) }; byte[] resultBuffer = new byte[0]; int read; while ((read = reader.ReadElementContentAsBase64(this.readBuffer, 0, this.readBuffer.Length)) > 0) { byte[] newResultBuffer = new byte[resultBuffer.Length + read]; Array.Copy(resultBuffer, newResultBuffer, resultBuffer.Length); Array.Copy(this.readBuffer, 0, newResultBuffer, resultBuffer.Length, read); resultBuffer = newResultBuffer; } file.File = resultBuffer; release.AdditionalFiles.Add(file); skipRead = true; } }
/// <summary> /// Constructor. Parses the LAYER part of the TMX map file. There can be many layers. /// </summary> /// <param name="xml">Assumes the LAYER part of the tmx map file</param> /// <param name="engine"></param> /// <param name="tileSet"></param> public Layer(XmlReader xml, Engine engine, TileSet tileSet) { // Move xml ahead xml.Read(); // Read in layer name _name = xml.GetAttribute("name"); // Read in layer width and height _width = int.Parse(xml.GetAttribute("width")); _height = int.Parse(xml.GetAttribute("height")); // Parse the layer block while (xml.Read()) { switch (xml.Name) { // We currently only support the data block for tile layers, properties are thus ignored case "data": // We create a byte buffer to read in the base64 encoded data, which may or may not be compressed int dataSize = (_width * _height * 4) + 1024; var buffer = new byte[dataSize]; if (xml.CanReadBinaryContent) { // Read base64 content info buffer xml.ReadElementContentAsBase64(buffer, 0, dataSize); // We create a memory stream of the buffer Stream stream = new MemoryStream(buffer, false); // At this point it would be natural to check for gzip, zlib or uncompressed xml data since these are all options in Tiled // However, due to time constraints I've only implemented the default setting, zlib compressed base64 encoded data. // The first two bytes are Zlib specific identifiers, we skip those before decompressing stream.ReadByte(); stream.ReadByte(); stream = new DeflateStream(stream, CompressionMode.Decompress); // At this point we have a decompressed base64 stream which we need to "parse". // For that we use a binary reader to read out the tile ids within the layer. // In pure XML, layer data is just a long list of tile ids which represent the tile within the tileset used. // So we need to loop through the layer width by height, as each tile is listed in this order. using (stream) using (var br = new BinaryReader(stream)) { // Loop layer height for (int y = 0; y < _height; y++) { // Loop layer width for (int x = 0; x < _width; x++) { // tileId represent the tile in the tileset int tileId = br.ReadInt32(); // Tile id 0 means nothing was "painted" in this tile so we skip that. if (tileId > 0) { // Get the TileSetTile using the id we extracted TileSetTile t = tileSet.getTileById(tileId); if (t is TileSetTile) { // At this point we check if this tile has a collidable property, if so, we create a new collidable and add to the engine collidable list. if (t.getProperty("Collidable") is string && t.getProperty("Collidable").Equals("True")) { engine.AddCollidable( new Collidable( new Rectangle( x * tileSet.tileWidth, y * tileSet.tileHeight, tileSet.tileWidth, tileSet.tileHeight ) ) ); } // Add the new layertile to the layer list of tiles _layerTiles.Add(new LayerTile(t, x, y)); } } } } } } break; } } }