public string Decode(byte[] encodeBytes)
        {
            string decodeString = "";

            try
            {
                //** Массив байт в поток бит
                BitArray encodeBits = new BitArray(encodeBytes);

                var         streamSize        = encodeBits.Length - 1;
                List <bool> revertSteamOfBits = new List <bool>();

                const byte  byteLength = 7;
                byte        bitIndex   = 0;
                List <bool> byteInBits = new List <bool>();

                //переворачиваем поток битов в обратную сторону. Как в исходном
                foreach (var bit in encodeBits)
                {
                    byteInBits.Add((bool)bit);

                    if (bitIndex == byteLength)
                    {
                        var reversBits = byteInBits.Reverse <bool>();
                        revertSteamOfBits.AddRange(reversBits);
                        byteInBits.Clear();
                        bitIndex = 0;
                    }
                    else
                    {
                        bitIndex++;
                    }
                }


                //** Из потока бит узнать какой длинны был один ИД слова в двоично системе
                var bitsCount = _archiveDictionary.GetAmountOfBitsForEncode();

                List <bool> sourceStreamOfBits = new List <bool>();
                bitIndex = 0;
                byteInBits.Clear();

                List <byte> stremOfByte = new List <byte>();

                //** Парсить каждый бит до этого числа
                foreach (var bit in revertSteamOfBits)
                {
                    byteInBits.Add((bool)bit);

                    if (bitIndex == bitsCount - 1)
                    {
                        var byteOfData = EncodeDecodeHelper.ConvertBitsToByte(byteInBits, (int)bitsCount);
                        stremOfByte.AddRange(byteOfData);
                        bitIndex = 0;
                        byteInBits.Clear();
                    }
                    else
                    {
                        bitIndex++;
                    }
                }
                //** Конвертировать в десятичный формат
                var decodeList = EncodeDecodeHelper.ConvertBytesToNumbers(stremOfByte.ToArray(), (int)bitsCount).Reverse();

                //** Искать слово по этому ИД
                //** Добавлять в рашифрованную строку

                foreach (var id in decodeList)
                {
                    var word = _archiveDictionary.GetWordById((ushort)id);

                    decodeString += word;
                }
            }
            catch (Exception ex)
            {
                _logger.Error(ex);
            }


            return(decodeString);
        }
Exemplo n.º 2
0
        // ***** Алгоритм преобразования исходного текста в поток байтов *****
        private IList <bool> EncodeSourceTextToStreamOfBits(string sourceString)
        {
            string       currentParseWord = string.Empty;
            Stack <byte> encodeResult     = new Stack <byte>();

            Stack <bool> streamOfBits = new Stack <bool>();
            IList <byte> encodeId     = new byte[] { };

            var bitsCount = _archiveDictionary.GetAmountOfBitsForEncode();

            string wordId;

            for (int index = 0; index <= sourceString.Length; index++)
            {
                try
                {
                    char gliphy = sourceString[index];

                    //Если глиф пробел или знак то ишем его в словаре и переходим к след глифу
                    if (char.IsWhiteSpace(gliphy) || char.IsPunctuation(gliphy))
                    {
                        wordId = _archiveDictionary.GetWordId(gliphy);

                        var bits = NubmerToBitList(wordId, bitsCount);
                        PushToStack(bits, ref streamOfBits);
                        continue;
                    }

                    //пока не достигли конца текста - ищем слова
                    if (index + 1 < sourceString.Length)
                    {
                        //Если след буква значит слово не закончилось - добавляем к недослову и преходи к след глифу
                        if (char.IsLetter(sourceString[index + 1]) || char.IsNumber(sourceString[index + 1]))
                        {
                            currentParseWord += gliphy;
                            continue;
                        }
                        //иначе все же будет конец слова то добавляем последний глиф и ищем недослово
                        else
                        {
                            currentParseWord += gliphy;
                            wordId            = _archiveDictionary.GetWordId(currentParseWord);

                            var bits = NubmerToBitList(wordId, bitsCount);
                            PushToStack(bits, ref streamOfBits);

                            currentParseWord = string.Empty;
                            continue;

                            //Если служебный знак то идем к след глифу
                            if (sourceString[index + 1] == '\'')
                            {
                                continue;
                            }
                        }
                    }
                    // если конец текста то добаляем последний глиф к недослову. Ищем недослово и конец парсинга
                    else
                    {
                        currentParseWord += gliphy;
                        wordId            = _archiveDictionary.GetWordId(currentParseWord);

                        var bits = NubmerToBitList(wordId, bitsCount);
                        PushToStack(bits, ref streamOfBits);

                        currentParseWord = string.Empty;
                        continue;
                    }
                }
                catch (Exception ex)
                {
                    currentParseWord = string.Empty;
                    _logger.Error(ex);
                    continue;
                }
            }


            return(streamOfBits.Reverse().ToList());
        }