Оптимизация алгоритма

    /*!
     * \class   BitsSlice
     * \brief   Битовый нарезчик данных.
     * \details ---
     */
    template <typename SourceDataType>
    class BitsSlice
    {
    private:
        /*!
         * \enum    SourceType
         * \brief   Перечисление с внутренними флагами входящих ресурсов для чтения.
         * \details ---
         */
        enum SourceType
        {
            VECTOR   = 1, ///< STL вектор.
            PTRARRAY = 2  ///< Указатель на данные.
        };
 
        SourceDataType     SequenceComponent; ///< Элемент STL вектора/массива указателей.
        unsigned long long int  CurrentIndex; ///< Индекс текущего элемента.
        std::vector<SourceDataType>  *Vector; ///< Указатель на ресурс STL вектора.
        SourceDataType             *PtrArray; ///< Указатель на данные.
        unsigned long long int          Size; ///< Размер ресурса.
        SourceType                      Flag; ///< Флаг вида ресурса.
        unsigned long long int      SizeBits; ///< Размер типа данных в битах.
        unsigned long long int BitIndexInSeq; ///< Битовый индекс текущего элемента.
        bool                           Order; ///< Порядок бит(FALSE - слева направо, TRUE - справа налево).
 
    public:
        /*!
         * \fn      BitsSlice
         * \brief   Конструктор по умолчанию.
         * \details Удален.
         */
        BitsSlice() = delete;
        /*!
         * \fn      BitsSlice
         * \brief   Конструктор копирования.
         * \details Удален.
         * \param   Object - объект класса.
         */
        BitsSlice(const BitsSlice<SourceDataType> &Object) = delete;
        /*!
         * \fn      BitsSlice
         * \brief   Конструктор заполнения объекта.
         * \details Выполняет заполнение объекта с помощью ресурса представленного вектором STL.
         * \param   VectorData - STL вектор.
         * \param   BitOrder   - порядок бит.
         */
        BitsSlice(std::vector<SourceDataType> *VectorData, bool BitOrder = false);
        /*!
         * \fn      BitsSlice
         * \brief   Конструктор заполнения объекта.
         * \details Выполняет заполнение объекта с помощью ресурса представленного указателем на данные.
         * \param   PtrArrayData - указатель на данные.
         * \param   SizeArray    - количество данные в указателе.
         * \param   BitOrder     - порядок бит.
         */
        BitsSlice(SourceDataType *PtrArrayData, const unsigned long long int SizeArray, bool BitOrder = false);
        /*!
         * \fn      ~BitsSlice
         * \brief   Деструктор.
         * \details ---
         */
       ~BitsSlice();
        /*!
         * \fn      JumpOverBeats
         * \brief   Перепрыгнуть на N бит вперед.
         * \details ---
         * \param   NumberOfBits - количество бит.
         * \return  bool         - TRUE - успешное выполнение функции.
         */
        bool JumpOverBeats(unsigned long long int NumberOfBits);
        /*!
         * \fn      CutBits
         * \brief   Отрезать N бит в буффер. Данные ресурса не уничтожаются.
         * \details ---
         * \param   Buffer       - ссылка на буфер.
         * \param   NumberOfBits - количество бит.
         * \return  bool         - TRUE - успешное выполнение функции.
         */
        template<typename BufferDataType>
        bool CutBits(BufferDataType &Buffer, unsigned long long int NumberOfBits);
    };
 
    template <typename SourceDataType>
    BitsSlice<SourceDataType>::BitsSlice(std::vector<SourceDataType> *VectorData, bool BitOrder)
    : SequenceComponent(0),
      CurrentIndex(1),
      Vector(VectorData),
      PtrArray(nullptr),
      Size(0),
      Flag(VECTOR),
      SizeBits(sizeof(SourceDataType) * 8u),
      BitIndexInSeq(sizeof(SourceDataType) * 8u),
      Order(BitOrder),
      BitBuffer("")
    {
        this->Size = this->Vector->size();
        this->SequenceComponent = this->Vector->at(0);
    }
 
    template <typename SourceDataType>
    BitsSlice<SourceDataType>::BitsSlice(SourceDataType *PtrArrayData, const unsigned long long int SizeArray, bool BitOrder)
    : SequenceComponent(0),
      CurrentIndex(1),
      Vector(nullptr),
      PtrArray(PtrArrayData),
      Size(SizeArray),
      Flag(PTRARRAY),
      SizeBits(sizeof(SourceDataType) * 8u),
      BitIndexInSeq(sizeof(SourceDataType) * 8u),
      Order(BitOrder),
      BitBuffer("")
    {
        this->SequenceComponent = this->PtrArrayData[0];
    }
 
    template <typename SourceDataType>
    BitsSlice<SourceDataType>::~BitsSlice()
    {
        this->SequenceComponent = 0;
        this->CurrentIndex      = 0;
        this->Vector            = nullptr;
        this->PtrArray          = nullptr;
        this->Size              = 0;
        this->SizeBits          = 0;
        this->BitIndexInSeq     = 0;
        this->BitBuffer         = "";
    }
 
    template <typename SourceDataType>
    bool BitsSlice<SourceDataType>::JumpOverBeats(unsigned long long int NumberOfBits)
    {
        if (NumberOfBits == 0)
            return true;
 
        else
        if ( !(NumberOfBits ^ BitIndexInSeq) )
        {
            this->BitIndexInSeq = 0;
            return true;
        }
        if (NumberOfBits < this->BitIndexInSeq)
        {
            this->BitIndexInSeq -= NumberOfBits;
            return true;
        }
        else
        {
            while(NumberOfBits > this->BitIndexInSeq)
            {
                if (Size >= CurrentIndex + 1)
                {
                    NumberOfBits -= this->BitIndexInSeq;
                    ++this->CurrentIndex;
                    this->BitIndexInSeq = this->SizeBits;
                }
                else
                    return false;
            }
 
            this->BitIndexInSeq -= NumberOfBits;
 
            switch(this->Flag)
            {
                case VECTOR:
                {
                    SequenceComponent = this->Vector->at(this->CurrentIndex);
                    break;
                }
                case PTRARRAY:
                {
                    SequenceComponent = this->PtrArray[this->CurrentIndex];
                    break;
                }
            }
            return true;
        }
    }
 
    template<typename SourceDataType>
    template<typename BufferDataType>
    bool BitsSlice<SourceDataType>::CutBits(BufferDataType &Buffer, unsigned long long int NumberOfBits)
    {
        if ((sizeof(BufferDataType) * 8u) < NumberOfBits || NumberOfBits == 0)
            return false;
 
        Buffer = 0;
        SourceDataType Mask = 0;
 
        while (NumberOfBits--)
        {
            Buffer <<= 1;
            if (this->BitIndexInSeq == 0)
            {
                if (!(this->CurrentIndex ^ this->Size) || (this->CurrentIndex > this->Size))
                    return false;
 
                switch(Flag)
                {
                    case VECTOR:
                    {
                        SequenceComponent = this->Vector->at(this->CurrentIndex);
                        break;
                    }
                    case PTRARRAY:
                    {
                        SequenceComponent = this->PtrArray[this->CurrentIndex];
                        break;
                    }
                }
                this->CurrentIndex++;
                this->BitIndexInSeq = this->SizeBits;
            }
            if (Order)
                Mask = 1 << (SizeBits - BitIndexInSeq);
            else
                Mask = 1 << (BitIndexInSeq - 1);
            Buffer |= (SequenceComponent & Mask) ? 1 : 0;
            --BitIndexInSeq;
        }
        return true;
    }

    template <typename SourceDataType>
    class BitsSlice
    {
    private:
        /*!
         * \enum    SourceType
         * \brief   Перечисление с внутренними флагами входящих ресурсов.
         * \details ---
         */
        enum SourceType
        {
            Vector   = 1, ///< STL вектор.
            PtrArray = 2  ///< Указатель на данные.
        };
 
        SourceDataType              _sequenceComponent; ///< Элемент STL вектора/массива указателей.
        unsigned long long int           _currentIndex; ///< Индекс текущего элемента.
        std::vector<SourceDataType>           *_vector; ///< Указатель на ресурс STL вектора.
        SourceDataType                      *_ptrArray; ///< Указатель на данные.
        unsigned long long int                   _size; ///< Размер ресурса.
        SourceType                       _flagResource; ///< Флаг вида ресурса.
        unsigned int                       _sizeOfBits; ///< Размер типа данных в битах.
        unsigned int           _bitInSequenceComponent; ///< Остаток бит на текущий раунд.
        bool                                 _bitOrder; ///< Порядок бит(FALSE - слева направо, TRUE - справа налево).
 
    public:
        /*!
         * \fn      BitsSlice
         * \brief   Конструктор по умолчанию.
         * \details Удален.
         */
        BitsSlice() = delete;
        /*!
         * \fn      BitsSlice
         * \brief   Конструктор копирования.
         * \details Удален.
         * \param   object - объект класса.
         */
        BitsSlice(const BitsSlice<SourceDataType> &object) = delete;
        /*!
         * \fn      BitsSlice
         * \brief   Конструктор заполнения объекта.
         * \details Выполняет заполнение объекта с помощью ресурса представленного вектором STL.
         * \param   vectorArray - STL вектор.
         * \param   bitOrder    - порядок бит.
         */
        BitsSlice(std::vector<SourceDataType> *vectorArray, bool bitOrder = false);
        /*!
         * \fn      BitsSlice
         * \brief   Конструктор заполнения объекта.
         * \details Выполняет заполнение объекта с помощью ресурса представленного указателем на данные.
         * \param   ptrArray     - указатель на данные.
         * \param   arraySize    - количество данные в указателе.
         * \param   bitOrder     - порядок бит.
         */
        BitsSlice(SourceDataType *ptrArray, const unsigned long long int arraySize, bool bitOrder = false);
        /*!
         * \fn      ~BitsSlice
         * \brief   Деструктор.
         * \details ---
         */
       ~BitsSlice();
        /*!
         * \fn      jumpOverBeats
         * \brief   Перепрыгнуть на N бит вперед.
         * \details ---
         * \param   numberOfBits - количество бит.
         * \return  bool         - TRUE - успешное выполнение функции.
         */
        bool jumpOverBeats(unsigned int numberOfBits);
        /*!
         * \fn      cutBits
         * \brief   Отрезать N бит в буффер. Данные ресурса не уничтожаются.
         * \details ---
         * \param   buffer       - ссылка на буфер.
         * \param   numberOfBits - количество бит.
         * \return  bool         - TRUE - успешное выполнение функции.
         */
        template<typename BufferDataType>
        bool cutBits(BufferDataType &buffer, unsigned int numberOfBits);
 
    private:
        /*!
         * \fn      getCurrentSequenceComponent
         * \brief   Получить элемент STL вектора/массива указателей по текущему индексу.
         * \details ---
         * \return  bool - TRUE - успешное выполнение функции.
         */
        bool getCurrentSequenceComponent();
    };
 
    template <typename SourceDataType>
    BitsSlice<SourceDataType>::BitsSlice(std::vector<SourceDataType> *vectorArray, bool bitOrder)
    : _sequenceComponent(0),
      _currentIndex(0),
      _vector(vectorArray),
      _ptrArray(nullptr),
      _size(0),
      _flagResource(Vector),
      _sizeOfBits(sizeof(SourceDataType) * 8u),
      _bitInSequenceComponent(sizeof(SourceDataType) * 8u),
      _bitOrder(bitOrder),
      _bitBuffer("")
    {
        this->_size              = this->_vector->size();
        this->_sequenceComponent = this->_vector->at(0);
    }
 
    template <typename SourceDataType>
    BitsSlice<SourceDataType>::BitsSlice(SourceDataType *ptrArray, const unsigned long long int arraySize, bool bitOrder)
    : _sequenceComponent(0),
      _currentIndex(0),
      _vector(nullptr),
      _ptrArray(ptrArray),
      _size(arraySize),
      _flagResource(PtrArray),
      _sizeOfBits(sizeof(SourceDataType) * 8u),
      _bitInSequenceComponent(sizeof(SourceDataType) * 8u),
      _bitOrder(bitOrder),
      _bitBuffer("")
    {
        this->_sequenceComponent = this->_ptrArray[0];
    }
 
    template <typename SourceDataType>
    BitsSlice<SourceDataType>::~BitsSlice()
    {
        this->_sequenceComponent      = 0;
        this->_currentIndex           = 0;
        this->_vector                 = nullptr;
        this->_ptrArray               = nullptr;
        this->_size                   = 0;
        this->_sizeOfBits             = 0;
        this->_bitInSequenceComponent = 0;
        this->_bitBuffer              = "";
    }
 
    template <typename SourceDataType>
    bool BitsSlice<SourceDataType>::jumpOverBeats(unsigned int numberOfBits)
    {
        if (numberOfBits <= this->_bitInSequenceComponent)
        {
            this->_bitInSequenceComponent -= numberOfBits;
            return true;
        }
        else
        {
            numberOfBits -= this->_bitInSequenceComponent;
 
            unsigned int сoefficient = numberOfBits / this->_sizeOfBits;
 
            numberOfBits -= сoefficient * this->_sizeOfBits;
            this->_currentIndex += сoefficient + 1;
            this->_bitInSequenceComponent = this->_sizeOfBits - numberOfBits;
 
            return this->getCurrentSequenceComponent();
        }
    }
 
    template<typename SourceDataType>
    template<typename BufferDataType>
    bool BitsSlice<SourceDataType>::cutBits(BufferDataType &buffer, unsigned int numberOfBits)
    {
        if ((sizeof(BufferDataType) * 8u) < numberOfBits || !numberOfBits)
            return false;
 
        unsigned int bitShiftLeft     = 0;
        unsigned int bitShiftRight    = 0;
 
        while(numberOfBits)
        {
            if (!this->_bitInSequenceComponent)
            {
                this->_bitInSequenceComponent = this->_sizeOfBits;
                ++this->_currentIndex;
            }
 
            if (!this->getCurrentSequenceComponent())
                return false;
 
            unsigned int bitCountsInRound =
                                 this->_bitInSequenceComponent <= numberOfBits
                               ? this->_bitInSequenceComponent
                               : numberOfBits;
 
            if (this->_bitOrder)
            {
                /* обратный порядок */
                bitShiftLeft  = this->_bitInSequenceComponent - bitCountsInRound;
                bitShiftRight = this->_sizeOfBits - bitCountsInRound;
            }
            else
            {
                /* прямой порядок */
                bitShiftLeft  = this->_sizeOfBits - this->_bitInSequenceComponent;
                bitShiftRight = this->_sizeOfBits - bitCountsInRound;
            }
 
            this->_sequenceComponent <<= bitShiftLeft;
            this->_sequenceComponent >>= bitShiftRight;
 
            buffer                       <<= bitCountsInRound;
            buffer                        |= this->_sequenceComponent;
            this->_bitInSequenceComponent -= bitCountsInRound;
            numberOfBits                  -= bitCountsInRound;
 
            if (this->_bitOrder && bitCountsInRound > 1)
            {
                bool flag      = bitCountsInRound % 2;
                bool flagBegin = false;
                bool flagEnd   = false;
                for (unsigned int index = 0; --bitCountsInRound; ++index)
                {
                    flagBegin = (buffer & (1 << index) ? true : false);
                    flagEnd   = (buffer & (1 << bitCountsInRound) ? true : false);
 
                    if ((flagBegin && !flagEnd) || (!flagBegin && flagEnd))
                    {
                        buffer ^= (1 << bitCountsInRound);
                        buffer ^= (1 << index);
                    }
 
                    if (!( (flag ? bitCountsInRound + 1 : bitCountsInRound) ^ (index + 1)))
                        break;
                }
            }
        }
        return true;
    }
 
    template <typename SourceDataType>
    bool BitsSlice<SourceDataType>::getCurrentSequenceComponent()
    {
        if (this->_currentIndex >= this->_size)
            return false;
 
        switch(this->_flagResource)
        {
            case Vector:
                this->_sequenceComponent = this->_vector->at(this->_currentIndex);
                break;
 
            case PtrArray:
                this->_sequenceComponent = this->_ptrArray[this->_currentIndex];
                break;
        }
        return true;
    }

class Timer
{
private:
    using clock_t = std::chrono::high_resolution_clock;
    using second_t = std::chrono::duration<double, std::ratio<1> >;
 
    std::chrono::time_point<clock_t> m_beg;
 
public:
    Timer() : m_beg(clock_t::now())
    {
    }
 
    void reset()
    {
        m_beg = clock_t::now();
    }
 
    double elapsed() const
    {
        return std::chrono::duration_cast<second_t>(clock_t::now() - m_beg).count();
    }
};

        /*!
         * \fn      cutBits
         * \brief   Отрезать N бит в буффер. Данные ресурса не уничтожаются.
         * \details ---
         * \param   buffer       - ссылка на буфер.
         * \param   numberOfBits - количество бит.
         * \return  bool         - TRUE - успешное выполнение функции.
         */
        template<typename BufferDataType>
        bool cutBits(BufferDataType &buffer, unsigned int numberOfBits)
        {
            if ((sizeof(BufferDataType) * 8u) < numberOfBits || !numberOfBits)
                return false;
 
            unsigned int bitShiftLeft  = 0;
            unsigned int bitShiftRight = 0;
 
            while(numberOfBits)
            {
                if (!this->_bitInSequenceComponent)
                {
                    this->_bitInSequenceComponent = this->_sizeOfBits;
                    ++this->_currentIndex;
                    if (!this->getCurrentSequenceComponent())
                        return false;
                }
 
                unsigned int bitCountsInRound =
                                     this->_bitInSequenceComponent <= numberOfBits
                                   ? this->_bitInSequenceComponent
                                   : numberOfBits;
 
                if (this->_bitOrder)
                {
                    /* обратный порядок */
                    bitShiftLeft  = this->_bitInSequenceComponent - bitCountsInRound;
                    bitShiftRight = this->_sizeOfBits - bitCountsInRound;
 
                    (buffer <<= bitCountsInRound) |= (this->_sequenceComponent << bitShiftLeft) >> bitShiftRight;
                    this->_bitInSequenceComponent -= bitCountsInRound;
                    numberOfBits                  -= bitCountsInRound;
 
                    if (bitCountsInRound > 1)
                    {
                        bool flag      = bitCountsInRound % 2;
                        bool flagBegin(false);
                        bool flagEnd(false);
                        for (unsigned int index = 0; --bitCountsInRound; ++index)
                        {
                            flagBegin = buffer & (1 << index);
                            flagEnd   = buffer & (1 << bitCountsInRound);
 
                            if ((flagBegin && !flagEnd) || (!flagBegin && flagEnd))
                            {
                                buffer ^= 1 << bitCountsInRound;
                                buffer ^= 1 << index;
                            }
 
                            if (!( (flag ? bitCountsInRound + 1 : bitCountsInRound) ^ (index + 1)))
                                break;
                        }
                        /*
                        bool flag      = bitCountsInRound % 2;
                        bool flagBegin = false;
                        bool flagEnd   = false;
                        for (unsigned int index = 0; --bitCountsInRound; ++index)
                        {
                            flagBegin = buffer & (1 << index);
                            flagEnd   = buffer & (1 << bitCountsInRound);
 
                            if ((flagBegin && !flagEnd) || (!flagBegin && flagEnd))
                            {
                                buffer ^= (1 << bitCountsInRound);
                                buffer ^= (1 << index);
                            }
 
                            if (!( (flag ? bitCountsInRound + 1 : bitCountsInRound) ^ (index + 1)))
                                break;
                        }
                        */
                    }
 
                    continue;
                }
 
                /* прямой порядок */
                bitShiftLeft  = this->_sizeOfBits - this->_bitInSequenceComponent;
                bitShiftRight = this->_sizeOfBits - bitCountsInRound;
 
                (buffer <<= bitCountsInRound) |= (this->_sequenceComponent << bitShiftLeft) >> bitShiftRight;
                this->_bitInSequenceComponent -= bitCountsInRound;
                numberOfBits                  -= bitCountsInRound;
 
                continue;
            }
            return true;
        }

bool UnpackPackBits(signed char *PackString, unsigned long long int Size, std::vector<char> &UnpackString)
{
    signed int Length = 0;
    for (unsigned long long int IndexPackString = 0; IndexPackString < Size; ++IndexPackString)
    {
        if (PackString[IndexPackString] == -128)
                continue;
 
        if (PackString[IndexPackString] >= -127 && PackString[IndexPackString] < 0)
        {
            Length = (-PackString[IndexPackString++]) + 1;
            //++IndexPackString;
            UnpackString.insert(UnpackString.end(), static_cast<unsigned long long int>(Length), PackString[IndexPackString]);
        }
        else if (PackString[IndexPackString] >= 0)
        {
            Length = PackString[IndexPackString++] + 1;
            //++IndexPackString;
            UnpackString.insert(UnpackString.end(), PackString + IndexPackString,
                                                    PackString + (IndexPackString + Length));
            IndexPackString += Length - 1;
        }
        else
            return false;
    }
    return true;