Add a member name to the class dict *clsdict* containing the value of
        this member object. Where the name of this object is None, do
        nothing; this allows out-of-band values to be defined without adding
        a name to the class dict.
542515
def register_name(self, clsdict):
        
        if self.name is None:
            return
        clsdict[self.name] = self.value
385969
def contribute_to_class(self, cls, name):
        

        self.update_rel_to(cls)

        # Called to get a name
        self.set_attributes_from_name(name)
        self.model = cls

        # Set the through field
        if not self.remote_field.through and not cls._meta.abstract:
            self.remote_field.through = create_many_to_many_intermediary_model(
                self, cls)

        # Do the rest
        super(M2MFromVersion, self).contribute_to_class(cls, name)
99156
def populate_class_members(self, element_cls, prop_name):
        
        self._element_cls = element_cls
        self._prop_name = prop_name

        self._add_attr_property()
1072425
def contribute_to_class(self, cls, name):
        
        super(StateField, self).contribute_to_class(cls, name)

        parent_property = getattr(cls, self.name, None)
        setattr(cls, self.name, StateFieldProperty(self, parent_property))
1289620
def handle_typical_memberdefs(self, signature, memberdef_nodes):
        
        if len(memberdef_nodes) == 1 or not self.with_overloaded_functions:
            self.handle_typical_memberdefs_no_overload(signature, memberdef_nodes)
            return

        self.add_text(['\n', '%feature("docstring") ', signature, ' "', '\n'])
        if self.with_function_signature:
            for n in memberdef_nodes:
                self.add_line_with_subsequent_indent(self.get_function_signature(n))
        self.add_text('\n')
        self.add_text(['Overloaded function', '\n',
                       '-------------------'])
        for n in memberdef_nodes:
            self.add_text('\n')
            self.add_line_with_subsequent_indent('* ' + self.get_function_signature(n))
            self.subnode_parse(n, pieces=[], indent=4, ignore=['definition', 'name'])
        self.add_text(['";', '\n'])
1290526
def addObject(self, object, name=None):
    
    if name is None:
      name = len(self.objects)

    self.objects[name] = object
1204972
function (member, memberValue, visibility) {
        if (_GPF_VISIBILITY_STATIC === visibility) {
            _gpfAssert(undefined === this._Constructor[member], "Static members can't be overridden");
            this._Constructor[member] = memberValue;
        } else if ("constructor" === member) {
            this._addConstructor(memberValue, visibility);
        } else {
            this._addNonStaticMember(member, memberValue, visibility);
        }
    }
553514
def save_dynamic_class(self, obj):
        
        clsdict = dict(obj.__dict__)  # copy dict proxy to a dict
        clsdict.pop('__weakref__', None)

        # For ABCMeta in python3.7+, remove _abc_impl as it is not picklable.
        # This is a fix which breaks the cache but this only makes the first
        # calls to issubclass slower.
        if "_abc_impl" in clsdict:
            import abc
            (registry, _, _, _) = abc._get_dump(obj)
            clsdict["_abc_impl"] = [subclass_weakref()
                                    for subclass_weakref in registry]

        # On PyPy, __doc__ is a readonly attribute, so we need to include it in
        # the initial skeleton class.  This is safe because we know that the
        # doc can't participate in a cycle with the original class.
        type_kwargs = {'__doc__': clsdict.pop('__doc__', None)}

        if hasattr(obj, "__slots__"):
            type_kwargs['__slots__'] = obj.__slots__
            # pickle string length optimization: member descriptors of obj are
            # created automatically from obj's __slots__ attribute, no need to
            # save them in obj's state
            if isinstance(obj.__slots__, string_types):
                clsdict.pop(obj.__slots__)
            else:
                for k in obj.__slots__:
                    clsdict.pop(k, None)

        # If type overrides __dict__ as a property, include it in the type kwargs.
        # In Python 2, we can't set this attribute after construction.
        __dict__ = clsdict.pop('__dict__', None)
        if isinstance(__dict__, property):
            type_kwargs['__dict__'] = __dict__

        save = self.save
        write = self.write

        # We write pickle instructions explicitly here to handle the
        # possibility that the type object participates in a cycle with its own
        # __dict__. We first write an empty "skeleton" version of the class and
        # memoize it before writing the class' __dict__ itself. We then write
        # instructions to "rehydrate" the skeleton class by restoring the
        # attributes from the __dict__.
        #
        # A type can appear in a cycle with its __dict__ if an instance of the
        # type appears in the type's __dict__ (which happens for the stdlib
        # Enum class), or if the type defines methods that close over the name
        # of the type, (which is common for Python 2-style super() calls).

        # Push the rehydration function.
        save(_rehydrate_skeleton_class)

        # Mark the start of the args tuple for the rehydration function.
        write(pickle.MARK)

        # Create and memoize an skeleton class with obj's name and bases.
        tp = type(obj)
        self.save_reduce(tp, (obj.__name__, obj.__bases__, type_kwargs), obj=obj)

        # Now save the rest of obj's __dict__. Any references to obj
        # encountered while saving will point to the skeleton class.
        save(clsdict)

        # Write a tuple of (skeleton_class, clsdict).
        write(pickle.TUPLE)

        # Call _rehydrate_skeleton_class(skeleton_class, clsdict)
        write(pickle.REDUCE)
465626
def apply(self, cls, originalMemberNameList, memberName, classNamingConvention, getter, setter):
        
        accessorDict = self._accessorDict(memberName, classNamingConvention, getter, setter)
        for accessorName, accessor in accessorDict.items():
            if accessorName not in originalMemberNameList and accessor is not None:
                setattr(cls, accessorName, accessor)
1232912
def _add_enum_member(enum, name, value, bitmask=DEFMASK):
    """"""
    error = idaapi.add_enum_member(enum, name, value, bitmask)

    if error:
        raise _enum_member_error(error, enum, name, value, bitmask)
300065
function (member, memberValue, visibility) {
        if (undefined === visibility) {
            visibility = _GPF_VISIBILITY_PUBLIC;
        } else {
            visibility = _gpfVisibilityKeywords.indexOf(visibility);
            if (-1 === visibility) {
                gpf.Error.classInvalidVisibility();
            }
        }
        this._addMember(member, memberValue, visibility);
    }
590137
def add(self, name, value):
        ''''''
        normalized_name = normalize_name(name, self._normalize_overrides)
        self._map[normalized_name].append(value)
857019
private void appendListOfValues(ClassDescriptor cld, StringBuffer stmt)
    {
        FieldDescriptor[] fields = cld.getAllRwFields();

        if(fields.length == 0)
        {
            return;
        }

        stmt.append(" VALUES (");
        for(int i = 0; i < fields.length; i++)
        {
            stmt.append("?");
            if(i < fields.length - 1)
            {
                stmt.append(",");
            }
        }
        stmt.append(") ");
    }
864884
def makeref2namesdct(name2refdct):
    """"""
    ref2namesdct = {}
    for key, values in name2refdct.items():
        for value in values:
            ref2namesdct.setdefault(value, set()).add(key)
    return ref2namesdct
470778
def add_to_class(self, cls, name):
        '''
        
        '''
        self._name = name
        self._container_model_class = cls
        setattr(cls, name, FieldDescriptor(self))
        self._bound = True
583270
def addCodedValue(self, name, code):
        
        i = {"name" : name, "code" : code}
        if i not in self._codedValues:
            self._codedValues.append(i)
1226450
def add_member(self, member, dn=False):
        

        if dn:
            if self.check_member(member, dn=True):
                return
            mod = (ldap.MOD_ADD, 'member', member.encode('ascii'))
        else:
            if self.check_member(member):
                return
            mod = (ldap.MOD_ADD, 'member', member.get_dn().encode('ascii'))

        if self.__lib__.__batch_mods__:
            self.__lib__.enqueue_mod(self.__dn__, mod)
        elif not self.__lib__.__ro__:
            mod_attrs = [mod]
            self.__con__.modify_s(self.__dn__, mod_attrs)
        else:
            print("ADD VALUE member = {} FOR {}".format(mod[2], self.__dn__))