Lines Matching defs:Def
11 ** - upb::Def (upb_def): base class of all the others.
186 * Downcasts are not provided, but upb/def.h defines downcasts for upb::Def. */
287 * upb::Def* def = GetDef();
289 * upb::MessgeDef* md = upb::down_cast<upb::MessageDef>(def);
292 * only downcast from a upb::Def to a specific Def type). */
299 * upb::Def* def = GetDef();
301 * upb::MessgeDef* md = upb::down_cast<upb::MessageDef>(def);
304 * can only downcast from a upb::Def to a specific Def type).. */
312 * upb::Def* def = upb::upcast(md);
320 * upb::upcast_to<upb::Def>(md)->MethodOnDef();
1654 class Def;
1663 UPB_DECLARE_DERIVED_TYPE(upb::Def, upb::RefCounted, upb_def, upb_refcounted)
1675 * of Def::Freeze that allows specifying this as a parameter. */
1679 /* upb::Def: base class for top-level defs ***********************************/
1697 class upb::Def {
1701 Def* Dup(const void *owner) const;
1708 /* "fullname" is the def's fully-qualified name (eg. foo.bar.Message). */
1711 /* The final part of a def's name (eg. Message). */
1714 /* The def must be mutable. Caller retains ownership of fullname. Defs are
1715 * not required to have a name; if a def has no name when it is frozen, it
1716 * will remain an anonymous def. On failure, returns false and details in "s"
1721 /* The file in which this def appears. It is not necessary to add a def to a
1723 * file->Add(def). */
1737 static bool Freeze(Def* const* defs, size_t n, Status* status);
1738 static bool Freeze(const std::vector<Def*>& defs, Status* status);
1741 UPB_DISALLOW_POD_OPS(Def, upb::Def)
1749 upb_def *upb_def_dup(const upb_def *def, const void *owner);
1758 bool upb_def_setfullname(upb_def *def, const char *fullname, upb_status *s);
1767 /* upb::Def casts *************************************************************/
1773 inline cpptype *down_cast<cpptype *, Def>(Def * def) { \
1774 return upb_downcast_##cname##_mutable(def); \
1777 inline cpptype *dyn_cast<cpptype *, Def>(Def * def) { \
1778 return upb_dyncast_##cname##_mutable(def); \
1781 inline const cpptype *down_cast<const cpptype *, const Def>( \
1782 const Def *def) { \
1783 return upb_downcast_##cname(def); \
1786 inline const cpptype *dyn_cast<const cpptype *, const Def>(const Def *def) { \
1787 return upb_dyncast_##cname(def); \
1790 inline const cpptype *down_cast<const cpptype *, Def>(Def * def) { \
1791 return upb_downcast_##cname(def); \
1794 inline const cpptype *dyn_cast<const cpptype *, Def>(Def * def) { \
1795 return upb_dyncast_##cname(def); \
1802 /* Dynamic casts, for determining if a def is of a particular type at runtime.
1803 * Downcasts, for when some wants to assert that a def is of a particular type.
1806 UPB_INLINE const upb_##lower *upb_dyncast_##lower(const upb_def *def) { \
1807 if (upb_def_type(def) != UPB_DEF_##upper) return NULL; \
1808 return (upb_##lower *)def; \
1810 UPB_INLINE const upb_##lower *upb_downcast_##lower(const upb_def *def) { \
1811 assert(upb_def_type(def) == UPB_DEF_##upper); \
1812 return (const upb_##lower *)def; \
1814 UPB_INLINE upb_##lower *upb_dyncast_##lower##_mutable(upb_def *def) { \
1815 return (upb_##lower *)upb_dyncast_##lower(def); \
1817 UPB_INLINE upb_##lower *upb_downcast_##lower##_mutable(upb_def *def) { \
1818 return (upb_##lower *)upb_downcast_##lower(def); \
1823 UPB_DEFINE_CLASS2(cppname, upb::Def, upb::RefCounted, cppmethods, \
1828 UPB_DECLARE_DERIVED_TYPE2(cppname, upb::Def, upb::RefCounted, \
1912 * Its base class is upb::Def (use upb::upcast() to convert). */
1946 /* Functionality from upb::Def. */
1995 * f->containing_type()->field_count(). May only be accessed once the def has
2088 /* Returns the enum or submessage def for this field, if any. The field's
2097 const Def* subdef() const;
2173 * upb::Def*) or symbolically. Symbolic refs must be resolved before the
2175 * guarantees that any def reachable from a live def will also be kept alive.
2181 bool set_subdef(const Def* subdef, Status* s);
2301 * Its base class is upb::Def (use upb::upcast() to convert). */
2310 /* Functionality from upb::Def. */
2318 * Messages with cycles must be frozen as a batch using upb::Def::Freeze(). */
2606 * If the return is true, then the found def will be set, and the non-found
2653 /* Class that represents an enum. Its base class is upb::Def (convert with
2663 /* Functionality from upb::Def. */
2795 * by name once added to a message def. */
2961 const Def* def(int index) const;
2962 Def* def(int index);
2969 /* Adds defs to this file. The def must not already belong to another
2972 * Note: this does *not* ensure that this def's name is unique in this file!
2976 bool AddDef(Def* def, Status* s);
3018 bool upb_filedef_adddef(upb_filedef *f, upb_def *def, const void *ref_donor,
3052 inline Def* Def::Dup(const void* owner) const {
3055 inline Def::Type Def::def_type() const { return upb_def_type(this); }
3056 inline const char* Def::full_name() const { return upb_def_fullname(this); }
3057 inline const char* Def::name() const { return upb_def_name(this); }
3058 inline bool Def::set_full_name(const char* fullname, Status* s) {
3061 inline bool Def::set_full_name(const std::string& fullname, Status* s) {
3064 inline bool Def::Freeze(Def* const* defs, size_t n, Status* status) {
3067 inline bool Def::Freeze(const std::vector<Def*>& defs, Status* status) {
3068 return upb_def_freeze((Def* const*)&defs[0], defs.size(), status);
3257 inline const Def* FieldDef::subdef() const { return upb_fielddef_subdef(this); }
3267 inline bool FieldDef::set_subdef(const Def* subdef, Status* s) {
3642 inline const Def* FileDef::def(int index) const {
3645 inline Def* FileDef::def(int index) {
3646 return const_cast<Def*>(upb_filedef_def(this, index));
3654 inline bool FileDef::AddDef(Def* def, Status* s) {
3655 return upb_filedef_adddef(this, def, NULL, s);
3711 /* Used as a flag during the def's mutable stage. Must be false unless
3735 const upb_msgdef *def; /* If !msg_is_symbolic. */
3739 const upb_def *def; /* If !subdef_is_symbolic. */
6398 ** A symtab (symbol table) stores a name->def map of upb_defs. Clients could
6461 const Def* Resolve(const char* base, const char* sym) const;
6465 const Def* Lookup(const char *sym) const;
6474 * (including enum default values) and finalizing the defs. Only one def per
6499 * TODO(haberman): since the defs must be mutable, refining a frozen def
6504 bool Add(Def*const* defs, size_t n, void* ref_donor, Status* status);
6506 bool Add(const std::vector<Def*>& defs, void *owner, Status* status) {
6507 return Add((Def*const*)&defs[0], defs.size(), owner, status);
6542 * const upb_def *def = upb_symtab_iter_def(&i);
6568 inline const Def *SymbolTable::Resolve(const char *base,
6572 inline const Def* SymbolTable::Lookup(const char *sym) const {
6579 Def*const* defs, size_t n, void* ref_donor, Status* status) {
