Pixels class prototype and test (not to be committed).

runtime/vm/object.h

 // Copyright (c) 2012, 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 "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 1192 matching lines @@
   // Returns an instance of Double or Double::null().
   // 'index' points to either:
   // - constants_list_ position of found element, or
   // - constants_list_ position where new canonical can be inserted.
   RawDouble* LookupCanonicalDouble(Zone* zone,
                                    double value, intptr_t* index) const;
   RawMint* LookupCanonicalMint(Zone* zone,
                                int64_t value, intptr_t* index) const;
   RawBigint* LookupCanonicalBigint(Zone* zone,
                                    const Bigint& value, intptr_t* index) const;
+  RawPixels* LookupCanonicalPixels(Zone* zone,
+                                   intptr_t value, intptr_t* index) const;
   // The methods above are more efficient than this generic one.
   RawInstance* LookupCanonicalInstance(Zone* zone,
                                        const Instance& value) const;
 
   RawInstance* InsertCanonicalConstant(Zone* zone,
                                        const Instance& constant) const;
   void InsertCanonicalNumber(Zone* zone,
                              intptr_t index,
                              const Number& constant) const;
 
@@ skipping 5114 matching lines @@
   static RawTypedData* NewDigitsFromDecCString(const char* str, intptr_t* used,
                                                Heap::Space space = Heap::kNew);
 
   static RawBigint* Allocate(intptr_t length, Heap::Space space = Heap::kNew);
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Bigint, Integer);
   friend class Class;
 };
 
 
-// Class Double represents class Double in corelib_impl, which implements
+class Pixels : public Number {
+ public:
+  static const intptr_t kFractionalBits = 6;
+  static const intptr_t kScaling = 1 << kFractionalBits;
+  static const intptr_t kPlusInfinity = kSmiMax32;
+  static const intptr_t kMinusInfinity = kSmiMin32;
+
+  // Returns the internal representation, i.e. the scaled value.
+  intptr_t Value() const {
+    return Smi::Value(raw_ptr()->value_);
+  }
+  virtual bool CanonicalizeEquals(const Instance& other) const;
+
+  static RawPixels* New(Heap::Space space = Heap::kNew) {  // For snapshots.
+    return New(0, space);
+  }
+
+  static RawPixels* New(intptr_t value, Heap::Space space = Heap::kNew);
+
+  // Returns a canonical Pixels object allocated in the old gen space.
+  static RawPixels* NewCanonical(intptr_t value);
+
+  // Returns a canonical Pixels object (allocated in the old gen space) or
+  // Pixels::null() if str points to a string that does not convert to a
+  // Pixels value.
+  static RawPixels* NewCanonical(const String& str);
+
+  static intptr_t InstanceSize() {
+    return RoundedAllocationSize(sizeof(RawPixels));
+  }
+
+  static intptr_t value_offset() {
+    return OFFSET_OF(RawPixels, value_);
+  }
+
+ private:
+  void set_value(intptr_t value) const;
+
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(Pixels, Number);
+  friend class Class;
+  friend class Number;
+};
+
+
+// Class Double represents Dart class _Double in runtime/lib, which implements
 // abstract class double in corelib.
 class Double : public Number {
  public:
   double value() const {
     return raw_ptr()->value_;
   }
 
   bool BitwiseEqualsToDouble(double value) const;
   virtual bool OperatorEquals(const Instance& other) const;
   virtual bool CanonicalizeEquals(const Instance& other) const;
@@ skipping 2297 matching lines @@
 
 inline void TypeArguments::SetHash(intptr_t value) const {
   // This is only safe because we create a new Smi, which does not cause
   // heap allocation.
   StoreSmi(&raw_ptr()->hash_, Smi::New(value));
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_