Implement case mapping using the Unicode default case mapping algorithm.

runtime/vm/object.h

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "vm/assert.h"
 #include "vm/dart.h"
 #include "vm/globals.h"
@@ skipping 2285 matching lines @@
   static intptr_t length_offset() { return OFFSET_OF(RawString, length_); }
 
   virtual intptr_t Hash() const;
   static intptr_t hash_offset() { return OFFSET_OF(RawString, hash_); }
   static intptr_t Hash(const String& str, intptr_t begin_index, intptr_t len);
   static intptr_t Hash(const uint8_t* characters, intptr_t len);
   static intptr_t Hash(const uint16_t* characters, intptr_t len);
   static intptr_t Hash(const uint32_t* characters, intptr_t len);
 
   virtual int32_t CharAt(intptr_t index) const;
+  virtual void SetCharAt(intptr_t index, int32_t value) const;

[Ivan Posva, 2011/10/18 22:01:13]

This should only be accessible to very few limited implementation methods within
the String class. Can you somehow enforce that?

[cshapiro, 2011/10/20 02:35:05]

I have added a Transform method that is safe to use externally.  Within the
String class and its subtypes we can continue to use CharAddr.  Elsewhere, the
Transform method provides an interface for creating a string where its elements
are determined by a user-supplied mapping function.  This seems cleaner.  What
do you think?

[Ivan Posva, 2011/10/21 14:03:37]

Looks a lot cleaner.

 
   bool Equals(const String& str, intptr_t begin_index, intptr_t len) const;
   bool Equals(const char* str) const;
   bool Equals(const uint8_t* characters, intptr_t len) const;
   bool Equals(const uint16_t* characters, intptr_t len) const;
   bool Equals(const uint32_t* characters, intptr_t len) const;
 
   virtual bool Equals(const Instance& other) const;
 
   intptr_t CompareTo(const String& other) const;
@@ skipping 41 matching lines @@
                               Heap::Space space = Heap::kNew);
 
   static RawString* SubString(const String& str,
                               intptr_t begin_index,
                               Heap::Space space = Heap::kNew);
   static RawString* SubString(const String& str,
                               intptr_t begin_index,
                               intptr_t length,
                               Heap::Space space = Heap::kNew);
 
+  static RawString* ToUpperCase(const String& str,
+                                Heap::Space space = Heap::kNew);
+  static RawString* ToLowerCase(const String& str,
+                                Heap::Space space = Heap::kNew);
+
   static RawString* NewSymbol(const char* str);
   template<typename T>
   static RawString* NewSymbol(const T* characters, intptr_t len);
   static RawString* NewSymbol(const String& str);
   static RawString* NewSymbol(const String& str,
                               intptr_t begin_index,
                               intptr_t length);
 
  protected:
   bool HasHash() const {
@@ skipping 15 matching lines @@
 
   HEAP_OBJECT_IMPLEMENTATION(String, Instance);
 };
 
 
 class OneByteString : public String {
  public:
   virtual int32_t CharAt(intptr_t index) const {
     return *CharAddr(index);
   }
+  virtual void SetCharAt(intptr_t index, int32_t value) const {
+    ASSERT(value <= 0xFF);
+    *CharAddr(index) = value;
+  }
 
   static intptr_t InstanceSize() {
     ASSERT(sizeof(RawOneByteString) == OFFSET_OF(RawOneByteString, data_));
     return 0;
   }
 
   static intptr_t InstanceSize(intptr_t len) {
     return RoundedAllocationSize(sizeof(RawOneByteString) + len);
   }
 
@@ skipping 34 matching lines @@
   friend class Class;
   friend class String;
 };
 
 
 class TwoByteString : public String {
  public:
   virtual int32_t CharAt(intptr_t index) const {
     return *CharAddr(index);
   }
+  virtual void SetCharAt(intptr_t index, int32_t value) const {
+    ASSERT(value <= 0xFFFF);
+    *CharAddr(index) = value;
+  }
 
   static intptr_t InstanceSize() {
     ASSERT(sizeof(RawTwoByteString) == OFFSET_OF(RawTwoByteString, data_));
     return 0;
   }
 
   static intptr_t InstanceSize(intptr_t len) {
     return RoundedAllocationSize(sizeof(RawTwoByteString) + (2 * len));
   }
 
@@ skipping 30 matching lines @@
   friend class Class;
   friend class String;
 };
 
 
 class FourByteString : public String {
  public:
   virtual int32_t CharAt(intptr_t index) const {
     return *CharAddr(index);
   }
+  virtual void SetCharAt(intptr_t index, int32_t value) const {
+    ASSERT(value <= 0x10FFFF);
+    *CharAddr(index) = value;
+  }
 
   static intptr_t InstanceSize() {
     ASSERT(sizeof(RawFourByteString) == OFFSET_OF(RawFourByteString, data_));
     return 0;
   }
 
   static intptr_t InstanceSize(intptr_t len) {
     return RoundedAllocationSize(sizeof(RawFourByteString) + (4 * len));
   }
 
@@ skipping 360 matching lines @@
 }
 
 
 void Context::SetAt(intptr_t index, const Instance& value) const {
   StorePointer(InstanceAddr(index), value.raw());
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_