sketch SkValue API

src/core/SkValue.h

Index: src/core/SkValue.h
diff --git a/src/core/SkValue.h b/src/core/SkValue.h
new file mode 100644
index 0000000000000000000000000000000000000000..1a6e626c9ed0d23392e2d7b0c25b6b375cdcd403
--- /dev/null
+++ b/src/core/SkValue.h
@@ -0,0 +1,80 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkValue_DEFINED
+#define SkValue_DEFINED
+
+#include "SkTypes.h"
+#include <functional>
+
+class SkValue {
+public:
+    enum Type : uint32_t {
+        // 0-255 are reserved for built-in SkValue types.
+        Null,
+        Byte , S16 , U16 , S32 , U32 , S64 , U64 , F32 , F64 ,

[hal.canary, 2016/01/14 16:11:45]

I thought you preferred U8 to byte.

[mtklein, 2016/01/14 16:45:15]

I thought so too.  But then I realized I don't think I've ever seen a use of
int8_t in Skia that's not better a uint8_t or an int.  When we work with bytes,
we don't really care or think about their sign.

For comparison, Reader32/Writer32/ReadBuffer/WriteBuffer all don't support S8. 
Streams have readS8() method that's completely unused except to implement
readU8().

If you prefer S8, U8, that seems fine to me.  But Bytes still seems like it
wants to be Bytes, not split into S8s/U8s.

[mtklein, 2016/01/14 16:45:15]

I was thinking of adding Bit too, as a signal to Objects that they may be stored
hyper-efficiently.  E.g.

class Object {
...
Map fMap;
uint64_t fBits;
...
void set(Key k, Value v) {
   if (v.type() == Bit && k < 64) {
      // set kth bit in fBits to v.bit()
   } else {
      // store as generic value in fMap
   }
}

Wouldn't want to implement that until it's useful, but it might be nice to start
off with a Bit type to see if it gets used.

+        Bytes, S16s, U16s, S32s, U32s, S64s, U64s, F32s, F64s, Values,
+
+        // 256-2147483647 may be used by Skia for public Object types.
+
+
+        // 2147483648+ won't be used by Skia.  They're open for client-specific use, testing, etc.
+    };
+
+    enum Key : uint32_t {
+        // Each Object type may define its own namespace of Key values,
+        // so there are no pre-defined Keys here.
+        //
+        // This is just a reminder that they must fit in a uint32_t,
+        // and that their namespace is distinct from other uint32_ts (e.g. Type).
+    };
+
+    SkValue();
+    SkValue(const SkValue&);

[hal.canary, 2016/01/14 16:11:45]

what does it mean to copy a SkValue that has complex type?  a deep copy? 
reference count?

[mtklein, 2016/01/14 16:45:15]

From an API perspective, it doesn't matter how we copy, as long as it's copied
(that is, we produce an observably-equivalent SkValue whose lifetime is
decoupled from the original's).

I'm open to either implementation, though I probably wouldn't want SkValues to
be publicly ref-countable.  I don't mind if we ref-count things like Bytes and
Object.  E.g. Bytes can be implemented with SkData.

+    SkValue(SkValue&&);
+
+    SkValue& operator=(const SkValue&);
+    SkValue& operator=(SkValue&&);
+
+    ~SkValue();
+
+    static SkValue FromS32(int32_t);
+    static SkValue FromU32(uint32_t);
+    static SkValue FromF32(float);
+    static SkValue FromBytes(const void*, size_t);

[hal.canary, 2016/01/14 19:16:37]

does this copy?

+    static SkValue Object(Type);

[hal.canary, 2016/01/14 19:16:37]

 static SkValue List(int reserve = 0);

+
+    Type type() const;
+
+    // These remaining methods may assert they're called on a value of the appropriate type.
+
+    int32_t  s32() const;
+    uint32_t u32() const;
+    float    f32() const;
+
+    const void* bytes() const;
+    size_t      count() const;
+
+    void set(Key, SkValue);

[hal.canary, 2016/01/14 19:16:37]

set(Key, SkValue&&);
set(Key, const SkValue&);

+    const SkValue* get(Key) const;
+    void foreach(std::function<void(Key, const SkValue&)>) const;
+

[hal.canary, 2016/01/14 19:16:38]

void append(const Value&);
void append(Value&&);

[hal.canary, 2016/01/14 19:26:21]

const SkValue* getFromList(int);

+private:
+    class Bytes;
+    class Object;
+
+    Type fType;
+    union {
+        int32_t       fS32;
+        uint32_t      fU32;
+        float         fF32;
+        class Bytes*  fBytes;
+        class Object* fObject;
+    };
+};
+
+#endif//SkValue_DEFINED