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

[Ellery Newcomer]

On 06/19/2010 12:30 PM, Ben Hanson wrote:
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

because strings aren't mutable. char[]'s on the other hand are, so you 
could just change temp_'s type to

import std.traits;

Unqual!(typeof(StringT.init[0]))[] temp_;

or something like that.