main.d(61): Error: temp_[i_] isn't mutable

[Ben Hanson]

Hi there,

I'm converting the following C++ function to D:

    void negate ()
    {
        const std::size_t max_chars_ = sizeof (CharT) == 1 ?
            num_chars : num_wchar_ts;
        CharT curr_char_ = sizeof (CharT) == 1 ? -128 : 0;
        string temp_;
        const CharT *curr_ = _charset.c_str ();
        const CharT *chars_end_ = curr_ + _charset.size ();

        _negated = !_negated;
        temp_.resize (max_chars_ - _charset.size ());

        CharT *ptr_ = const_cast<CharT *> (temp_.c_str ());
        std::size_t i_ = 0;

        while (curr_ < chars_end_)
        {
            while (*curr_ > curr_char_)
            {
                *ptr_ = curr_char_;
                ++ptr_;
                ++curr_char_;
                ++i_;
            }

            ++curr_char_;
            ++curr_;
            ++i_;
        }

        for (; i_ < max_chars_; ++i_)
        {
            *ptr_ = curr_char_;
            ++ptr_;
            ++curr_char_;
        }

        _charset = temp_;
    }

Here's the complete source:

module main;

import std.algorithm;
import std.string;

template regex(StringT)
{
struct basic_string_token
{
    bool _negated = false;
        StringT _charset;
        typedef typeof(StringT.init[0]) CharT;
        enum size_t MAX_CHARS = CharT.max + 1;

        this(const bool negated_, ref StringT charset_)
        {
                _negated = negated_;
                _charset = charset_;
        }

        void remove_duplicates()
        {
                _charset.sort;
                _charset = squeeze(_charset);
        }

        void normalise()
        {
                if (_charset.length == MAX_CHARS)
                {
            _negated = !_negated;
                        _charset.clear();
                }
                else if (_charset.length > MAX_CHARS / 2)
                {
                        negate();
                }
        }

        void negate()
        {
                CharT curr_char_ = MAX_CHARS == 256 ? 0x80 : 0;
                StringT temp_;
                size_t curr_ = 0;
                size_t end_ = _charset.length;
                size_t i_ = 0;

        _negated = !_negated;
                temp_.length = MAX_CHARS - end_;

                while (curr_ < end_)
                {
                        while (_charset[curr_] > curr_char_)
                        {
                                temp_[i_] = curr_char_;
                                ++curr_char_;
                                ++i_;
                        }

            ++curr_char_;
            ++curr_;
            ++i_;
                }

        for (; i_ < MAX_CHARS; ++i_)
        {
            temp_ ~= curr_char_;
            ++curr_char_;
        }

                _charset = temp_;
        }
};
}

int main(char[][]argv)
{
        regex!(string).basic_string_token token_;

        token_._charset = "cccbba";
        token_.remove_duplicates();
        token_.negate();
        return 0;
}

Can anyone explain the error 'main.d(61): Error: temp_[i_] isn't
mutable'? Can I use pointers instead like the C++ code? What's the
best approach for maximum efficiency in D (pointers would make the
conversion easier to, I guess).

Thanks,

Ben