ppapi/cpp/extensions/dict_field.h

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef PPAPI_CPP_EXTENSIONS_DICT_FIELD_H_
   6 #define PPAPI_CPP_EXTENSIONS_DICT_FIELD_H_
   7
   8 #include <string>
   9
  10 #include "ppapi/c/pp_bool.h"
  11 #include "ppapi/cpp/extensions/from_var_converter.h"
  12 #include "ppapi/cpp/extensions/optional.h"
  13 #include "ppapi/cpp/extensions/to_var_converter.h"
  14 #include "ppapi/cpp/var.h"
  15 #include "ppapi/cpp/var_dictionary.h"
  16
  17 namespace pp {
  18 namespace ext {
  19
  20 template <class T>
  21 class DictField {
  22  public:
  23   explicit DictField(const std::string& key) : key_(key), value_() {
  24   }
  25
  26   ~DictField() {
  27   }
  28
  29   const std::string& key() const { return key_; }
  30
  31   // Returns the value.
  32   T& operator()() { return value_; }
  33   const T& operator()() const { return value_; }
  34
  35   // Adds this field to the dictionary var.
  36   bool AddTo(VarDictionary* dict) const {
  37     if (!dict)
  38       return false;
  39
  40     internal::ToVarConverter<T> converter(value_);
  41     return dict->Set(Var(key_), converter.var());
  42   }
  43
  44   bool Populate(const VarDictionary& dict) {
  45     Var value_var = dict.Get(Var(key_));
  46     if (value_var.is_undefined())
  47       return false;
  48
  49     internal::FromVarConverter<T> converter(value_var.pp_var());
  50     value_ = converter.value();
  51     return true;
  52   }
  53
  54  private:
  55   std::string key_;
  56   T value_;
  57 };
  58
  59 template <class T>
  60 class OptionalDictField {
  61  public:
  62   explicit OptionalDictField(const std::string& key) : key_(key) {
  63   }
  64
  65   ~OptionalDictField() {
  66   }
  67
  68   const std::string& key() const { return key_; }
  69
  70   // Returns the value.
  71   Optional<T>& operator()() { return value_; }
  72   const Optional<T>& operator()() const { return value_; }
  73
  74   // Adds this field to the dictionary var, if |value| has been set.
  75   bool MayAddTo(VarDictionary* dict) const {
  76     if (!dict)
  77       return false;
  78     if (!value_.IsSet())
  79       return true;
  80
  81     internal::ToVarConverter<T> converter(*value_);
  82     return dict->Set(Var(key_), converter.var());
  83   }
  84
  85   bool Populate(const VarDictionary& dict) {
  86     Var value_var = dict.Get(Var(key_));
  87     internal::FromVarConverter<Optional<T> > converter(value_var.pp_var());
  88     value_.Swap(&converter.value());
  89     return true;
  90   }
  91
  92  private:
  93   std::string key_;
  94   Optional<T> value_;
  95 };
  96
  97 }  // namespace ext
  98 }  // namespace pp
  99
 100 #endif  // PPAPI_CPP_EXTENSIONS_DICT_FIELD_H_