private void InitializeFrom(StringScanner/*!*/ other) {
     _currentPosition = other._currentPosition;
     _foundPosition = other._foundPosition;
     _lastMatch = other._lastMatch;
     _lastMatchingGroups = other._lastMatchingGroups;
     _previousPosition = other._previousPosition;
     _scanString = other.ScanString;
 }

 public static StringScanner Concat(StringScanner/*!*/ self, MutableString str)
 {
     self.ScanString.Append(str);
     return self;
 }

 public static StringScanner Unscan(StringScanner/*!*/ self)
 {
     if (self.LastMatch == null) {
         // throw Exception StringScanner::Error
         throw RubyExceptions.CreateRangeError("unscan failed: previous match had failed");
     }
     int position = self.PreviousPosition;
     self.Reset();
     self.CurrentPosition = position;
     return self;
 }

 public static int? SkipUntil(StringScanner/*!*/ self, [NotNull]RubyRegex/*!*/ pattern)
 {
     bool match = self.Match(pattern, false, true);
     if (!match) {
         return null;
     }
     return (self.CurrentPosition - self.PreviousPosition);
 }

 public static int SetCurrentPosition(StringScanner/*!*/ self, int newPosition)
 {
     int newPos = newPosition;
     if (newPos < 0) {
         newPos = self.Length - self.CurrentPosition;
     }
     if (newPos > self.Length) {
         throw RubyExceptions.CreateRangeError("index out of range");
     }
     self.CurrentPosition = newPos;
     return newPosition;
 }

 public static object ScanUntil(StringScanner/*!*/ self, [NotNull]RubyRegex/*!*/ pattern)
 {
     return SearchFull(self, pattern, true, true);
 }

 public static int RestSize(StringScanner/*!*/ self)
 {
     return (self.CurrentPosition < self.Length) ? (self.Length - self.CurrentPosition) : 0;
 }

 public static StringScanner Reset(StringScanner/*!*/ self)
 {
     self.Reset();
     return self;
 }

 public static MutableString GetString(StringScanner/*!*/ self)
 {
     return self.ScanString;
 }

 public static MutableString GetMatchSubgroup(StringScanner/*!*/ self, int subgroup)
 {
     if (subgroup == 0 && self.LastMatch != null) {
         return MutableString.Create(self.LastMatch);
     }
     if (self.LastMatchingGroups == null) {
         return null;
     }
     if (subgroup < 0) {
         subgroup = self.LastMatchingGroups.GroupCount - subgroup;
     }
     if (subgroup >= self.LastMatchingGroups.GroupCount) {
         return null;
     }
     return self.LastMatchingGroups.GetGroupValue(subgroup);
 }

 public static int GetCurrentPosition(StringScanner/*!*/ self)
 {
     return self.CurrentPosition;
 }

 public static MutableString GetChar(StringScanner/*!*/ self)
 {
     if (self.CurrentPosition >= self.Length) {
         return null;
     }
     self.PreviousPosition = self.CurrentPosition;
     self.FoundPosition = self.CurrentPosition;
     self.LastMatch = self.ScanString.GetSlice(self.CurrentPosition++, 1);
     return MutableString.Create(self.LastMatch);
 }

 public static int? Exist(StringScanner/*!*/ self, [NotNull]RubyRegex/*!*/ pattern)
 {
     if (!self.Match(pattern, false, false)) {
         return null;
     }
     return self.FoundPosition + self.LastMatch.Length;
 }

 public static bool EndOfLine(StringScanner/*!*/ self)
 {
     return self.CurrentPosition >= self.Length;
 }

 public static StringScanner Create(RubyClass/*!*/ self, [DefaultProtocol, NotNull]MutableString/*!*/ scan, [Optional]object ignored)
 {
     var result = new StringScanner(self);
     result.ScanString = scan;
     result.Reset();
     return result;
 }

 public static MutableString PreMatch(StringScanner/*!*/ self)
 {
     if (self.LastMatch == null) {
         return null;
     }
     return self.ScanString.GetSlice(0, self.FoundPosition);
 }

 public static void Reinitialize(StringScanner/*!*/ self, [DefaultProtocol, NotNull]MutableString/*!*/ scan, [Optional]object ignored)
 {
     self.ScanString = scan;
     self.Reset();
 }

 public static void InitializeFrom(StringScanner/*!*/ self, [DefaultProtocol, NotNull]StringScanner/*!*/ other)
 {
     self.InitializeFrom(other);
 }

 public static MutableString Rest(StringScanner/*!*/ self)
 {
     int len = self.Length - self.CurrentPosition;
     if (len <= 0) {
         return MutableString.CreateEmpty();
     }
     return self.ScanString.GetSlice(self.CurrentPosition, len);
 }

 public static bool IsRestLeft(StringScanner/*!*/ self)
 {
     return self.CurrentPosition < self.Length;
 }