template <typename typeData, typename typeFieldForSeparation, typename typeResultData = typeData>
    class SeparationByField
    {
        const array<typeData>& InitialArray;
        const typeFieldForSeparation typeData::* const Field;

        uint32 NextIndex;
        typeFieldForSeparation NextValue;
        array<typeResultData> NextArray;

    public:

        SeparationByField(const array<typeData>& InitialArray_, typeFieldForSeparation typeData::*Field_):
            InitialArray(InitialArray_),
            Field(Field_)
        {
            NextIndex = 0;

            NextArray.CreateAllocator(1000, strategyAllocationMemory::MaxAllocation);
        }

        bool ExistNextData()
        {
            cuint32 Quantity = InitialArray.Size();
            if(NextIndex == Quantity) return false;

            NextArray.Clear();

            NextValue = InitialArray[NextIndex].*Field;

            for(;NextIndex < InitialArray.Size(); ++NextIndex)
            {
                typeData NextData = InitialArray[NextIndex];

                if(!Equal(NextValue, NextData.*Field)) break;

                NextArray.Add(NextData);
            }

            return true;
        }
        
        typeFieldForSeparation GetNextValue() const
        {
            return NextValue;
        }

        array<typeResultData>& GetNextArray() const
        {
            return NextArray;
        }
    };

SeparationByField<allData, char*, writeData> SeparatorByClient(ArrayOfData, &allData::Client);

SeparationByField<allData, char[], writeData> SeparatorByClient(ArrayOfData, &allData::Client);