hphp/runtime/vm/record-emitter.h

   1 /*
   2    +----------------------------------------------------------------------+
   3    | HipHop for PHP                                                       |
   4    +----------------------------------------------------------------------+
   5    | Copyright (c) 2010-present 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
  17 #ifndef incl_HPHP_VM_RECORD_EMIT_H_
  18 #define incl_HPHP_VM_RECORD_EMIT_H_
  19
  20 #include "hphp/runtime/base/repo-auth-type.h"
  21 #include "hphp/runtime/base/array-data.h"
  22
  23 #include "hphp/runtime/vm/func.h"
  24 #include "hphp/runtime/vm/func-emitter.h"
  25 #include "hphp/runtime/vm/record.h"
  26 #include "hphp/runtime/vm/repo-helpers.h"
  27
  28 #include <vector>
  29
  30 namespace HPHP {
  31 ///////////////////////////////////////////////////////////////////////////////
  32 struct UnitEmitter;
  33
  34 struct RecordEmitter {
  35
  36   struct Field {
  37     Field() = default;
  38
  39     Field(const RecordEmitter* re,
  40           const StringData* n,
  41           Attr attrs,
  42           const StringData* userType,
  43           const TypeConstraint& typeConstraint,
  44           const StringData* docComment,
  45           const TypedValue* val,
  46           RepoAuthType repoAuthType,
  47           UserAttributeMap userAttributes);
  48
  49     const StringData* name() const { return m_name; }
  50     const StringData* mangledName() const { return m_mangledName; }
  51     Attr attrs() const { return m_attrs; }
  52     const StringData* userType() const { return m_userType; }
  53     const TypeConstraint& typeConstraint() const { return m_typeConstraint; }
  54     const StringData* docComment() const { return m_docComment; }
  55     const TypedValue& val() const { return m_val; }
  56     RepoAuthType repoAuthType() const { return m_repoAuthType; }
  57     UserAttributeMap userAttributes() const { return m_userAttributes; }
  58
  59     template<class SerDe> void serde(SerDe& sd) {
  60       sd(m_name)
  61         (m_mangledName)
  62         (m_attrs)
  63         (m_userType)
  64         (m_docComment)
  65         (m_val)
  66         (m_repoAuthType)
  67         (m_typeConstraint)
  68         (m_userAttributes)
  69         ;
  70     }
  71
  72   private:
  73     friend RecordEmitter;
  74     void resolveArray(const RecordEmitter* re) {
  75       m_repoAuthType.resolveArray(re->ue());
  76     }
  77
  78   private:
  79     LowStringPtr m_name{nullptr};
  80     LowStringPtr m_mangledName{nullptr};
  81     Attr m_attrs{AttrNone};
  82     LowStringPtr m_userType{nullptr};
  83     LowStringPtr m_docComment{nullptr};
  84     TypedValue m_val{};
  85     RepoAuthType m_repoAuthType{};
  86     TypeConstraint m_typeConstraint{};
  87     UserAttributeMap m_userAttributes{};
  88   };
  89
  90   using FieldMap = IndexedStringMap<Field, true, Slot>;
  91
  92   RecordEmitter(UnitEmitter& ue, Id id, const std::string& name);
  93
  94   void init(int line1, int line2, Attr attrs,
  95             const StringData* parentName,
  96             const StringData* docComment);
  97
  98   UnitEmitter& ue() const { return m_ue; }
  99   const StringData* name() const { return m_name; }
 100   const StringData* parentName() const { return m_parent; }
 101   Attr attrs() const { return m_attrs; }
 102   UserAttributeMap userAttributes() const { return m_userAttributes; }
 103   void setUserAttributes(UserAttributeMap map) {
 104     m_userAttributes = std::move(map);
 105   }
 106
 107   Id id() const { return m_id; }
 108
 109   void commit(RepoTxn& txn) const; // throws(RepoExc)
 110
 111   PreRecordDesc* create(Unit& unit) const;
 112
 113   template<class SerDe> void serdeMetaData(SerDe&);
 114
 115   std::pair<int,int> getLocation() const {
 116     return std::make_pair(m_line1, m_line2);
 117   }
 118   const StringData* docComment() const { return m_docComment; }
 119
 120   const FieldMap::Builder& fieldMap() const { return m_fieldMap; }
 121   using UpperBoundVec = CompactVector<TypeConstraint>;
 122   void addUpperBound(const StringData*, const UpperBoundVec&) {}
 123   bool hasUpperBound(const StringData*) { return false; }
 124   bool addField(const StringData* n,
 125                 Attr attrs,
 126                 const StringData* userType,
 127                 const TypeConstraint& typeConstraint,
 128                 const UpperBoundVec&, // unused
 129                 const StringData* docComment,
 130                 const TypedValue* val,
 131                 RepoAuthType,
 132                 UserAttributeMap);
 133
 134   private:
 135     UnitEmitter& m_ue;
 136     int m_line1;
 137     int m_line2;
 138     LowStringPtr m_name;
 139     Attr m_attrs;
 140     LowStringPtr m_parent;
 141     LowStringPtr m_docComment;
 142     Id m_id;
 143     UserAttributeMap m_userAttributes;
 144     FieldMap::Builder m_fieldMap;
 145 };
 146
 147 struct RecordRepoProxy : RepoProxy {
 148   friend struct PreRecordDesc;
 149   friend struct RecordEmitter;
 150
 151   explicit RecordRepoProxy(Repo& repo);
 152   ~RecordRepoProxy();
 153   void createSchema(int repoId, RepoTxn& txn); // throws(RepoExc)
 154
 155   struct InsertRecordStmt : public RepoProxy::Stmt {
 156     InsertRecordStmt(Repo& repo, int repoId) : Stmt(repo, repoId) {}
 157     void insert(const RecordEmitter& re, RepoTxn& txn, int64_t unitSn,
 158                 Id recordId, const StringData* name); // throws(RepoExc)
 159   };
 160
 161   struct GetRecordsStmt : public RepoProxy::Stmt {
 162     GetRecordsStmt(Repo& repo, int repoId) : Stmt(repo, repoId) {}
 163     void get(UnitEmitter& ue); // throws(RepoExc)
 164   };
 165
 166   InsertRecordStmt insertRecord[RepoIdCount];
 167   GetRecordsStmt getRecords[RepoIdCount];
 168 };
 169
 170 ///////////////////////////////////////////////////////////////////////////////
 171 }
 172
 173 #endif