extends System.Text.Encoding to create Petscii Encoding : Encoding « Internationalization I18N « C# / C Sharp

1. C# / C Sharp
2. Internationalization I18N
3. Encoding

extends System.Text.Encoding to create Petscii Encoding

  
//-----------------------------------------------------------------------
// <copyright file="Program.cs" company="Payton Byrd">
//     Copyright (c) 2007 Payton Byrd.  All rights reserved.
// </copyright>
//-----------------------------------------------------------------------

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

namespace CBM_Commander.Common.Encoding
{
    public class Petscii : System.Text.Encoding
    {
        public static PetsciiEncoder GetPetsciiEncoder()
        {
            return new PetsciiEncoder();
        }

        public static PetsciiDecoder GetPetsciiDecoder()
        {
            return new PetsciiDecoder();
        }

        public override int GetByteCount(
            char[] chars,
            int index,
            int count)
        {
            return GetPetsciiEncoder().GetByteCount(
                chars, index, count, false);
        }

        public override int GetBytes(
            char[] chars,
            int charIndex,
            int charCount,
            byte[] bytes,
            int byteIndex)
        {
            return GetPetsciiEncoder().GetBytes(
                chars, charIndex, charCount,
                bytes, byteIndex, false);
        }

        public override int GetCharCount(
            byte[] bytes,
            int index,
            int count)
        {
            return GetPetsciiDecoder().GetCharCount(
                bytes, index, count);
        }

        public override int GetChars(
            byte[] bytes,
            int byteIndex,
            int byteCount,
            char[] chars,
            int charIndex)
        {
            return GetPetsciiDecoder().GetChars(
                bytes, byteIndex, byteCount,
                chars, charIndex);
        }

        public override int GetMaxByteCount(int charCount)
        {
            return charCount;
        }

        public override int GetMaxCharCount(int byteCount)
        {
            return byteCount;
        }
    }
}

//-----------------------------------------------------------------------
// <copyright file="Program.cs" company="Payton Byrd">
//     Copyright (c) 2007 Payton Byrd.  All rights reserved.
// </copyright>
//-----------------------------------------------------------------------

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

namespace CBM_Commander.Common.Encoding
{
    public sealed class PetsciiDecoder : Decoder
    {
        private byte[] _newLine = null;
        private byte[] _space = null;

        internal PetsciiDecoder()
        {
            _newLine = ASCIIEncoding.ASCII.GetBytes("\n");
            _space = ASCIIEncoding.ASCII.GetBytes(" ");
        }

        public override int GetCharCount(
            byte[] bytes,
            int index,
            int count)
        {
            DecodeBytes(
                bytes, index,
                count, index);

            return count;

        }

        public override int GetChars(
            byte[] bytes,
            int byteIndex,
            int byteCount,
            char[] chars,
            int charIndex)
        {
            char[] decodedChars =
                DecodeBytes(
                    bytes, byteIndex,
                    byteCount, charIndex);

            for (int i = byteIndex;
                i < (byteIndex + byteCount);
                i++)
            {
                chars[charIndex + (i - byteIndex)] =
                    decodedChars[i];
            }

            return byteCount;
        }

        private char[] DecodeBytes(
            byte[] bytes,
            int byteIndex,
            int byteCount,
            int charIndex)
        {
            char[] results = null;
            List<byte> output = new List<byte>();
            byte[] translated = null;

            foreach (byte b in bytes)
            {
                output.AddRange(TranslateByte(b));
            }

            translated = output.ToArray();

            results =
                ASCIIEncoding.ASCII.GetChars(translated);

            return results;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="Character"></param>
        /// <returns></returns>
        private byte[] TranslateByte(byte SourceByte)
        {
            switch (SourceByte & 0xff)
            {
                case 0x0a:
                case 0x0d:
                    return _newLine;
                case 0x40:
                case 0x60:
                    return new byte[] { SourceByte };
                case 0xa0:
                case 0xe0:
                    return _space;
                default:
                    switch (SourceByte & 0xe0)
                    {
                        case 0x40:
                        case 0x60:
                            return new byte[] { (byte)(SourceByte ^ (byte)0x20) };

                        case 0xc0:
                            return new byte[] { (byte)(SourceByte ^ (byte)0x80) };

                    }

                    return new byte[] { SourceByte };
            }
        }
    }
}

Petscii Encoder
//-----------------------------------------------------------------------
// <copyright file="Program.cs" company="Payton Byrd">
//     Copyright (c) 2007 Payton Byrd.  All rights reserved.
// </copyright>
//-----------------------------------------------------------------------

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

namespace CBM_Commander.Common.Encoding
{
    public sealed class PetsciiEncoder : Encoder
    {
        private byte[] _newLine = null;
        private byte[] _space = null;
        private Dictionary<char, byte>
            _ascii = new Dictionary<char, byte>();

        internal PetsciiEncoder()
        {
            _newLine = ASCIIEncoding.ASCII.GetBytes("\n");
            _space = ASCIIEncoding.ASCII.GetBytes(" ");

            for (byte i = 0x00; i < 0xFF; i++)
            {
                char c = (char)i;
                _ascii.Add(c,
                    ASCIIEncoding.ASCII.GetBytes(
                        new char[] { c })[0]);
            }
        }

        public override int GetByteCount(
            char[] chars,
            int index,
            int count,
            bool flush)
        {
            List<byte> targetBytes = new List<byte>();

            byte[] sourceBytes =
                ASCIIEncoding.ASCII.GetBytes(chars);

            for (int i = index; i < (index + count); i++)
            {
                targetBytes.Add(
                    TranslateCharacter(sourceBytes[i]));
            }

            return targetBytes.Count;
        }

        public override int GetBytes(
            char[] chars,
            int charIndex,
            int charCount,
            byte[] bytes,
            int byteIndex,
            bool flush)
        {
            List<byte> targetBytes = new List<byte>();

            byte[] sourceBytes =
                ASCIIEncoding.ASCII.GetBytes(chars);

            foreach (byte b in sourceBytes)
            {
                targetBytes.Add(TranslateCharacter(b));
            }

            for (
                int i = charIndex;
                i < (charIndex + charCount);
                i++)
            {
                bytes[byteIndex + (i - charIndex)] =
                    targetBytes[i];
            }

            return charCount;
        }

        private byte TranslateCharacter(byte Character)
        {
            if (
                Character >= 0x5B &&
                Character <= 0x7E)
            {
                return (byte)(Character ^ 0x20);
            }
            else if (
                Character >= _ascii['A'] &&
                Character <= _ascii['Z'])
            {
                return (byte)(Character | 0x80);
            }
            else if (Character == _newLine[0])
            {
                return 0x0D;
            }

            return Character;
        }
    }
}

   
    
  

Related examples in the same category