Associates member type DocElements with their corresponding members
        in the specified code element. The element must have a dictionary of
        members already.
184987
def process_memberdocs(self, docs, codeEl, add=True):
        """"""        
        #Now we need to associate the members with their docstrings
        #Some of the members may be buried inside a group tag and
        #need to be handled separately.
        remainingdocs = []
        expandeddocs = []

        #Process any groups that are in the doc list.
        for doc in docs:
            if isinstance(doc, DocGroup):
                kids = self._process_docgroup(doc, codeEl, add)
                expandeddocs.extend(kids)
            else:
                expandeddocs.append(doc)

        for doc in expandeddocs:
            #Process the docstring, if it doesn't belong to a member
            #we will add it to the list of unassigned docstrings,
            #these most likely point to type declarations.           
            if not self._process_docstrings(doc, codeEl.members, add):
                remainingdocs.append(doc)
        return remainingdocs
968998
public void addMemberTags(ExecutableElement member, Content methodsContentTree) {
        Content tagContent = new ContentBuilder();
        TagletManager tagletManager =
            configuration.tagletManager;
        TagletWriter.genTagOutput(tagletManager, member,
            tagletManager.getSerializedFormTaglets(),
            writer.getTagletWriterInstance(false), tagContent);
        Content dlTags = new HtmlTree(HtmlTag.DL);
        dlTags.addContent(tagContent);
        methodsContentTree.addContent(dlTags);
        if (name(member).compareTo("writeExternal") == 0
                && utils.getSerialDataTrees(member).isEmpty()) {
            serialWarning(member, "doclet.MissingSerialDataTag",
                utils.getFullyQualifiedName(member.getEnclosingElement()), name(member));
        }
    }
1319758
protected void addMemberDesc(MemberDoc member, Content contentTree) {
        ClassDoc containing = member.containingClass();
        String classdesc = utils.getTypeName(
                configuration, containing, true) + " ";
        if (member.isField()) {
            if (member.isStatic()) {
                contentTree.addContent(
                        getResource("doclet.Static_variable_in", classdesc));
            } else {
                contentTree.addContent(
                        getResource("doclet.Variable_in", classdesc));
            }
        } else if (member.isConstructor()) {
            contentTree.addContent(
                    getResource("doclet.Constructor_for", classdesc));
        } else if (member.isMethod()) {
            if (member.isStatic()) {
                contentTree.addContent(
                        getResource("doclet.Static_method_in", classdesc));
            } else {
                contentTree.addContent(
                        getResource("doclet.Method_in", classdesc));
            }
        }
        addPreQualifiedClassLink(LinkInfoImpl.Kind.INDEX, containing,
                false, contentTree);
    }
1170120
protected String ensureFieldDeclarationKeyword(CodeElementExtractor.ElementDescription memberDescription) {
		final List<String> modifiers = getCodeBuilderConfig().getModifiers().get(memberDescription.getName());
		if (modifiers != null && !modifiers.isEmpty()) {
			return modifiers.get(0);
		}
		return getExpressionConfig().getFieldDeclarationKeyword();
	}
1350763
public static void addMember(TypeDeclaration type, BodyDeclaration decl) {
        List<BodyDeclaration> members = type.getMembers();
        if (members == null) {
            members = new ArrayList<BodyDeclaration>();
            type.setMembers(members);
        }
        members.add(decl);
    }
1372287
def element(self):
        """"""
        #We assume here that the entire operation is associated with a single
        #code element. Since the sequence matcher groups operations by contiguous
        #lines of code to change, this is a safe assumption.
        if self._element is None:
            line = self.icached[0]
            #If we are inserting a new line, the location at the start of the line
            #that used to be there interferes with the element finder.
            if self.mode == "insert":
                line -= 1
            self._element = self.context.module.get_element(line, 0)

        return self._element
914333
def AddMembers(self, *Members):
        
        self._Alter('ADDMEMBERS', ', '.join([x.Handle for x in Members]))
492014
def add_element_list(self, elt_list, **kwargs):
        """"""
        for e in elt_list:
            self.add_element(Element(e, **kwargs))
187337
protected AbstractRule getMemberRule(CodeElementExtractor.ElementDescription description) {
		for (final Assignment assignment : GrammarUtil.containedAssignments(description.getGrammarComponent())) {
			if (Objects.equals(getCodeBuilderConfig().getMemberCollectionExtensionGrammarName(), assignment.getFeature())) {
				if (assignment.getTerminal() instanceof RuleCall) {
					return ((RuleCall) assignment.getTerminal()).getRule();
				}
			}
		}
		return null;
	}
1110517
private void composeDeprecatedList(List<Doc> list, MemberDoc[] members) {
        for (MemberDoc member : members) {
            if (utils.isDeprecated(member)) {
                list.add(member);
            }
        }
    }
681296
private void composeDeprecatedList(List<Doc> list, MemberDoc[] members) {
        for (int i = 0; i < members.length; i++) {
            if (Util.isDeprecated(members[i])) {
                list.add(members[i]);
            }
        }
    }
190487
private void addFileElements(Collection<ArchiveEntry> files, Element filesElement) throws Exception
    {
        for (ArchiveEntry entry : files) {
            // Don't add files in META-INF to the package.xml file
            if (entry.getName().indexOf("META-INF") == -1) {
                XWikiDocument xdoc = getDocFromXML(entry.getFile());
                String reference = xdoc.getReference();
                Element element = new DOMElement(FILE_TAG);
                element.setText(reference);
                element.addAttribute("language", xdoc.getLocale());
                element.addAttribute("defaultAction", "0");

                // Add configured properties
                XAREntry cfgEntry = getEntryMap().get(reference);
                if (cfgEntry != null && cfgEntry.getType() != null) {
                    element.addAttribute("type", cfgEntry.getType());
                }

                filesElement.add(element);
            }
        }
    }
138702
public void buildAnnotationTypeMember(XMLNode node, Content memberDetailsTree) {
        if (writer == null) {
            return;
        }
        int size = members.size();
        if (size > 0) {
            writer.addAnnotationDetailsMarker(memberDetailsTree);
            for (currentMemberIndex = 0; currentMemberIndex < size;
                    currentMemberIndex++) {
                Content detailsTree = writer.getMemberTreeHeader();
                writer.addAnnotationDetailsTreeHeader(classDoc, detailsTree);
                Content annotationDocTree = writer.getAnnotationDocTreeHeader(
                        (MemberDoc) members.get(currentMemberIndex), detailsTree);
                buildChildren(node, annotationDocTree);
                detailsTree.addContent(writer.getAnnotationDoc(
                        annotationDocTree, (currentMemberIndex == size - 1)));
                memberDetailsTree.addContent(writer.getAnnotationDetails(detailsTree));
            }
        }
    }
11110
def _get_members_of_type(obj, member_type):
    

    if not issubclass(type(obj), ModelBase):
        obj = obj.__class__

    key_hash = []
    for key in dir(obj):
        try:
            attr = getattr(obj, key)
        except AttributeError as e:
            try:
                attr = obj.__dict__[key]
            except KeyError:
                raise AttributeError(INTROSPECTION_ERROR % (e, obj, member_type))

        if type(attr) is member_type:
            key_hash.append((key, attr))

    return key_hash
1137231
private static void applyElement(Annotated member, Schema property) {
        final XmlElementWrapper wrapper = member.getAnnotation(XmlElementWrapper.class);
        if (wrapper != null) {
            final XML xml = getXml(property);
            xml.setWrapped(true);
            // No need to set the xml name if the name provided by xmlelementwrapper annotation is ##default or equal to the property name | https://github.com/swagger-api/swagger-core/pull/2050
            if (!"##default".equals(wrapper.name()) && !wrapper.name().isEmpty() && !wrapper.name().equals(((SchemaImpl) property).getName())) {
                xml.setName(wrapper.name());
            }
        } else {
            final XmlElement element = member.getAnnotation(XmlElement.class);
            if (element != null) {
                setName(element.namespace(), element.name(), property);
            }
        }
    }
136200
private void addModifier(ProgramElementDoc member, Content code) {
        if (member.isProtected()) {
            code.addContent("protected ");
        } else if (member.isPrivate()) {
            code.addContent("private ");
        } else if (!member.isPublic()) { // Package private
            code.addContent(configuration.getText("doclet.Package_private"));
            code.addContent(" ");
        }
        if (member.isMethod()) {
            if (!(member.containingClass().isInterface()) &&
                    ((MethodDoc)member).isAbstract()) {
                code.addContent("abstract ");
            }
            // This check for isDefault() and the default modifier needs to be
            // added for it to appear on the "Modifier and Type" column in the
            // method summary section. Once the default modifier is added
            // to the Modifier list on DocEnv and once it is updated to use the
            // javax.lang.model.element.Modifier, we will need to remove this.
            if (((MethodDoc)member).isDefault()) {
                code.addContent("default ");
            }
        }
        if (member.isStatic()) {
            code.addContent("static ");
        }
    }
527597
def expand_code(docset)
      results = []

      if docset[:code]
        (docset[:code][:members] || []).each do |m|
          results << code_to_docset(m) unless @constructor_found && JsDuck::Class.constructor?(m)
        end
      end

      results
    end