Fire/FilePack/FPKeyWords.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;

namespace System.Fire.FilePack.FilePackElements {
    public class FPKeyWords {

        // Aufbau Keyword Header:
        // 1 Byte    Byte    Anzahl Zeichen des Keyword Namens (1 Zeichen = 2 Byte)
        // 4 Byte   ULong   Offset(removed)
        // 8 Byte    Long    Length
        // 1 Byte    Byte    Type
        // 1 Byte    Byte    File Extention
        // n Byte    String  Keyword Name


        private string _Keyword;
        private long _Offset;
        private int _Length;
        private FilePackElements.DataType _Type;
        private byte _fileExt;
        private BinaryReader _Stream;


        /// <summary>Erstellt ein neues Keyword Element</summary>
        /// <param name="s">Der Stream Binary-Reader der das Archive geöffnet hat</param>
        public FPKeyWords(BinaryReader s) {
            this._Stream = s;
            byte KeyWordLength = s.ReadByte();
            this._Length = (int)s.ReadInt64();
            this._Type = (FilePackElements.DataType)s.ReadByte();
            this._fileExt = s.ReadByte();
            Encoding enc = System.Text.Encoding.UTF8;
            /*byte[] b = new byte[KeyWordLength - 1];
            for(int i = 0; i < KeyWordLength; i++)
                b[i] = s.ReadByte();*/
            byte[] b = s.ReadBytes(KeyWordLength);
            this._Keyword = enc.GetString(b);
            System.Diagnostics.Debug.WriteLine("Keyword: " + this._Keyword + "; Keyword len: " + KeyWordLength + "; DataLen: " + this._Length + "; Type: " + this._Type.ToString() + "; fileExt: " + this._fileExt);
        }

        public override string ToString() {
            return this._Keyword;
        }

        /// <summary>Gibt das Keyword des Eintrags zurück</summary>
        /// <returns>Gibt das Keyword des Eintrags als String zurück</returns>
        public string Keyword {
            get { return this._Keyword; }
        }

        /// <summary>
        /// Gibt den Offset des Eintrags in dem Archiv zurück oder legt ihn fest
        /// </summary>
        /// <value>Legt den Offset des Eintrags in dem Archiv fest</value>
        /// <returns>Gibt den Offset des Eintrags in dem Archiv als ULong zurück</returns>
        public long Offset {
            get { return this._Offset; }
            set { this._Offset = value; }
        }

        /// <summary>
        /// Gibt die ID der Dateiendung des Eintrags im Archiv als Byte zurück.
        /// </summary>
        /// <returns>Gibt die ID der Dateiendung des Eintrags im Archiv als Byte zurück.</returns>
        /// <remarks>Dies gilt nur, wenn im Archive die Dateiendungen gespeichert wurden</remarks>
        public byte FileExtension {
            get { return this._fileExt; }
        }

        /// <summary>
        /// Gibt den Typ des Eintrags zurück
        /// </summary>
        /// <returns>Gibt den Typ des Eintrags im FilePack.DataType zurück</returns>
        public FilePackElements.DataType Type {
            get { return this._Type; }
        }

        /// <summary>
        /// Gibt die Länge des Eintrags zurück
        /// </summary>
        /// <returns>Gibt die Länge des Eitnrags als Long zurück</returns>
        public long Length {
            get { return this._Length; }
        }

        /// <summary>Gib den Eintrag als Byte-Array zurück</summary>
        /// <returns>Gib den Eintrag als Byte-Array zurück</returns>
        public byte[] getBytes() {
            this._Stream.BaseStream.Seek(this._Offset, IO.SeekOrigin.Begin);
            return this._Stream.ReadBytes(this._Length);
        }

        /// <summary>Gib den Eintrag als Byte-Array zurück</summary>
        /// <returns>Gib den Eintrag als Byte-Array zurück</returns>
        /// <param name="StartIndex">Legt den Startindex fest, ab dem das auslesen begonnen werden soll</param>
        public byte[] getBytes(int StartIndex) {
            this._Stream.BaseStream.Seek(this._Offset + StartIndex, IO.SeekOrigin.Begin);
            return this._Stream.ReadBytes(this._Length - StartIndex);
        }

        /// <summary>Gib den Eintrag als Byte-Array zurück</summary>
        /// <returns>Gib den Eintrag als Byte-Array zurück</returns>
        /// <param name="StartIndex">Legt den Startindex fest, ab dem das auslesen begonnen werden soll</param>
        /// <param name="Length">Legt die Länge der auszulesenden Bytes fest</param>
        public byte[] getBytes(int StartIndex, int Length) {
            this._Stream.BaseStream.Seek(this._Offset + StartIndex, IO.SeekOrigin.Begin);
            int xLength = Length;
            if(this._Length > StartIndex + Length)
                xLength = this._Length - StartIndex;
            return this._Stream.ReadBytes(xLength);
        }

        /// <summary>Gib den Eintrag als String zurück</summary>
        /// <returns>Gib den Eintrag als String zurück</returns>
        public string getString() {
            this._Stream.BaseStream.Seek(this._Offset, IO.SeekOrigin.Begin);
            byte[] Buffer = new byte[this._Length];
            this._Stream.Read(Buffer, 0, this._Length);
            return Convert.ToBase64String(Buffer, Base64FormattingOptions.None);
        }

        /// <summary>Gib den Eintrag als String zurück</summary>
        /// <returns>Gib den Eintrag als String zurück</returns>
        /// <param name="StartIndex">Legt den Startindex fest, ab dem das auslesen begonnen werden soll</param>
        public string getString(int StartIndex) {
            this._Stream.BaseStream.Seek(this._Offset + StartIndex, IO.SeekOrigin.Begin);
            byte[] Buffer = new byte[this._Length - StartIndex];
            this._Stream.Read(Buffer, 0, this._Length - StartIndex);
            return Convert.ToBase64String(Buffer, Base64FormattingOptions.None);
        }

        /// <summary>Gib den Eintrag als String zurück</summary>
        /// <returns>Gib den Eintrag als String zurück</returns>
        /// <param name="StartIndex">Legt den Startindex fest, ab dem das auslesen begonnen werden soll</param>
        /// <param name="Length">Legt die Länge der auszulesenden Bytes fest</param>
        public string getString(int StartIndex, int Length) {
            int xLength = Length;
            if (this._Length > StartIndex + Length)
                xLength = this._Length - StartIndex;
            byte[] Buffer = new byte[xLength];
            this._Stream.BaseStream.Seek(this._Offset + StartIndex, IO.SeekOrigin.Begin);
            this._Stream.Read(Buffer, 0, xLength);
            return Convert.ToBase64String(Buffer, Base64FormattingOptions.None);
        }
    }
}