hphp/runtime/vm/name_value_table_wrapper.h

   1 /*
   2    +----------------------------------------------------------------------+
   3    | HipHop for PHP                                                       |
   4    +----------------------------------------------------------------------+
   5    | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
   6    +----------------------------------------------------------------------+
   7    | This source file is subject to version 3.01 of the PHP license,      |
   8    | that is bundled with this package in the file LICENSE, and is        |
   9    | available through the world-wide-web at the following url:           |
  10    | http://www.php.net/license/3_01.txt                                  |
  11    | If you did not receive a copy of the PHP license and are unable to   |
  12    | obtain it through the world-wide-web, please send a note to          |
  13    | license@php.net so we can mail you a copy immediately.               |
  14    +----------------------------------------------------------------------+
  15 */
  16 #ifndef incl_HPHP_RUNTIME_VM_NAME_VALUE_TABLE_WRAPPER_H
  17 #define incl_HPHP_RUNTIME_VM_NAME_VALUE_TABLE_WRAPPER_H
  18
  19 #include "hphp/runtime/vm/name_value_table.h"
  20 #include "hphp/runtime/base/array/array_data.h"
  21
  22 namespace HPHP {
  23
  24 //////////////////////////////////////////////////////////////////////
  25
  26 /*
  27  * Wrapper to provide a KindOfArray interface to a NameValueTable.
  28  * This is used to expose a NameValueTable to php code, particularly
  29  * for $GLOBALS, but also for some internal generated-bytecode
  30  * initialization routines (86pinit, 86sinit).
  31  *
  32  * Some differences compared to normal php arrays:
  33  *
  34  *   - Does not behave as if it has value semantics.  (I.e., no COW.)
  35  *
  36  *   - Iteration order is not specified.
  37  *
  38  *   - Non-string keys are not really supported.  (Integers are
  39  *     converted to strings.)
  40  *
  41  *   - size() is an O(N) operation.  (This is because of KindOfIndirect
  42  *     support in the underlying NameValueTable.)
  43  *
  44  *   - Append/prepend operations are not supported.
  45  *
  46  *   - Strong iterators "past the end" are not updated when new
  47  *     elements are added.  (Since iteration order is unspecified,
  48  *     this semantic would seem weird anyway.)
  49  *
  50  * This holds a pointer to a NameValueTable whose lifetime must be
  51  * guaranteed to outlast the lifetime of the NameValueTableWrapper.
  52  * (The wrapper is refcounted, as required by ArrayData, but the table
  53  * pointed to is not.)
  54  */
  55 struct NameValueTableWrapper : public ArrayData {
  56   explicit NameValueTableWrapper(NameValueTable* tab)
  57     : ArrayData(kNameValueTableWrapper)
  58     , m_tab(tab)
  59   { }
  60
  61 public: // ArrayData implementation
  62
  63   // these using directives ensure the full set of overloaded functions
  64   // are visible in this class, to avoid triggering implicit conversions
  65   // from a CVarRef key to int64.
  66   using ArrayData::exists;
  67   using ArrayData::get;
  68   using ArrayData::getIndex;
  69   using ArrayData::lval;
  70   using ArrayData::lvalNew;
  71   using ArrayData::lvalPtr;
  72   using ArrayData::set;
  73   using ArrayData::setRef;
  74   using ArrayData::add;
  75   using ArrayData::addLval;
  76   using ArrayData::remove;
  77
  78   virtual ssize_t vsize() const;
  79   virtual Variant getKey(ssize_t pos) const;
  80   virtual Variant getValue(ssize_t pos) const;
  81   virtual CVarRef getValueRef(ssize_t pos) const;
  82   virtual bool noCopyOnWrite() const;
  83
  84   virtual bool exists(int64_t k) const;
  85   virtual bool exists(const StringData* k) const;
  86   virtual bool idxExists(ssize_t idx) const;
  87
  88   virtual CVarRef get(int64_t k, bool error = false) const;
  89   virtual CVarRef get(const StringData* k, bool error = false) const;
  90
  91   virtual TypedValue* nvGet(int64_t k) const;
  92   virtual TypedValue* nvGet(const StringData* k) const;
  93
  94   virtual ssize_t getIndex(int64_t k) const;
  95   virtual ssize_t getIndex(const StringData* k) const;
  96
  97   virtual ArrayData* lval(int64_t k, Variant*& ret, bool copy,
  98                           bool checkExist = false);
  99   virtual ArrayData* lval(StringData* k, Variant*& ret,
 100                           bool copy, bool checkExist = false);
 101   virtual ArrayData* lvalNew(Variant*& ret, bool copy);
 102
 103   virtual ArrayData* set(int64_t k, CVarRef v, bool copy);
 104   virtual ArrayData* set(StringData* k, CVarRef v, bool copy);
 105   virtual ArrayData* setRef(int64_t k, CVarRef v, bool copy);
 106   virtual ArrayData* setRef(StringData* k, CVarRef v, bool copy);
 107   virtual ArrayData* remove(int64_t k, bool copy);
 108   virtual ArrayData* remove(const StringData* k, bool copy);
 109
 110   virtual ArrayData* copy() const { return 0; }
 111
 112   virtual ArrayData* append(CVarRef v, bool copy);
 113   virtual ArrayData* appendRef(CVarRef v, bool copy);
 114   virtual ArrayData* appendWithRef(CVarRef v, bool copy);
 115
 116   virtual ArrayData* append(const ArrayData* elems, ArrayOp op, bool copy);
 117
 118   virtual ArrayData* prepend(CVarRef v, bool copy);
 119
 120   virtual ssize_t iter_begin() const;
 121   virtual ssize_t iter_end() const;
 122   virtual ssize_t iter_advance(ssize_t prev) const;
 123   virtual ssize_t iter_rewind(ssize_t prev) const;
 124
 125   virtual Variant reset();
 126   virtual Variant prev();
 127   virtual Variant current() const;
 128   virtual CVarRef currentRef();
 129   virtual Variant next();
 130   virtual Variant end();
 131   virtual CVarRef endRef();
 132   virtual Variant key() const;
 133   virtual Variant value(int32_t &pos) const;
 134   virtual Variant each();
 135   virtual bool validFullPos(const FullPos & fp) const;
 136   virtual bool advanceFullPos(FullPos&);
 137
 138   virtual ArrayData* escalateForSort();
 139   virtual void ksort(int sort_flags, bool ascending);
 140   virtual void sort(int sort_flags, bool ascending);
 141   virtual void asort(int sort_flags, bool ascending);
 142   virtual void uksort(CVarRef cmp_function);
 143   virtual void usort(CVarRef cmp_function);
 144   virtual void uasort(CVarRef cmp_function);
 145
 146 private:
 147   NameValueTable* const m_tab;
 148 };
 149
 150 class GlobalNameValueTableWrapper : public NameValueTableWrapper {
 151  public:
 152   explicit GlobalNameValueTableWrapper(NameValueTable* tab);
 153   Variant gvm_argc;
 154   Variant gvm_argv;
 155   Variant gvm__SERVER;
 156   Variant gvm__GET;
 157   Variant gvm__POST;
 158   Variant gvm__COOKIE;
 159   Variant gvm__FILES;
 160   Variant gvm__ENV;
 161   Variant gvm__REQUEST;
 162   Variant gvm__SESSION;
 163   Variant gvm_HTTP_RAW_POST_DATA;
 164   Variant gvm_http_response_header;
 165
 166   Variant __realPropProxy;
 167   Variant __lvalProxy;
 168
 169   Variant stgv_Variant[1];
 170   #define k_SID stgv_Variant[0]
 171 };
 172
 173 //////////////////////////////////////////////////////////////////////
 174
 175 }
 176
 177 #endif