mojom: Add associative arrays to the mojom language.

mojo/public/cpp/bindings/string.h

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef MOJO_PUBLIC_CPP_BINDINGS_STRING_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_STRING_H_
 
 #include <string>
 
 #include "mojo/public/cpp/bindings/lib/array_internal.h"
 #include "mojo/public/cpp/bindings/type_converter.h"
 #include "mojo/public/cpp/environment/logging.h"
 
 namespace mojo {
 
 class String {
  public:
   typedef internal::String_Data Data_;
 
   String() : is_null_(true) {}
   String(const std::string& str) : value_(str), is_null_(false) {}
   String(const char* chars) : is_null_(!chars) {
     if (chars)
       value_ = chars;
   }
   String(const char* chars, size_t num_chars)
       : value_(chars, num_chars),
         is_null_(false) {
   }
+  String(const mojo::String& str)
+      : value_(str.value_),
+        is_null_(str.is_null_) {
+  }
   template <size_t N>
   String(const char chars[N]) : value_(chars, N-1), is_null_(false) {}
 
   template <typename U>
   static String From(const U& other) {
     return TypeConverter<String, U>::Convert(other);
   }
 
   template <typename U>
   U To() const {
     return TypeConverter<U, String>::Convert(*this);
   }
 
+  String& operator=(const mojo::String& str) {
+    value_ = str.value_;
+    is_null_ = str.is_null_;
+    return *this;
+  }
   String& operator=(const std::string& str) {
     value_ = str;
     is_null_ = false;
     return *this;
   }
   String& operator=(const char* chars) {
     is_null_ = !chars;
     if (chars) {
       value_ = chars;
     } else {
@@ skipping 50 matching lines @@
   return !a.is_null() && a.get() == b;
 }
 inline bool operator!=(const String& a, const String& b) { return !(a == b); }
 inline bool operator!=(const char* a, const String& b) { return !(a == b); }
 inline bool operator!=(const String& a, const char* b) { return !(a == b); }
 
 inline std::ostream& operator<<(std::ostream& out, const String& s) {
   return out << s.get();
 }
 
+inline bool operator<(const String& a, const String& b) {
+  if (a.is_null() && !b.is_null()) {
+    // The null string is less than a non-NULL string.
+    return true;
+  } else if (a.is_null() || b.is_null()) {
+    // in all other cases where A or B is NULL, |a| is not less than |b|.
+    return false;
+  }
+
+  return a.get() < b.get();
+}
+
 // TODO(darin): Add similar variants of operator<,<=,>,>=
 
 template <>
 struct TypeConverter<String, std::string> {
   static String Convert(const std::string& input) { return String(input); }
 };
 
 template <>
 struct TypeConverter<std::string, String> {
   static std::string Convert(const String& input) { return input; }
@@ skipping 18 matching lines @@
 
 template <>
 struct TypeConverter<String, const char*> {
   // |input| may be null, in which case a null String will be returned.
   static String Convert(const char* input) { return String(input); }
 };
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_STRING_H_