Returns a list of sections
491013
def _parseSections(self, data, elfHeader):
        """"""
        offset = elfHeader.header.e_shoff
        shdrs = []
        for i in range(elfHeader.header.e_shnum):
            shdr = self.__classes.SHDR.from_buffer(data, offset)
            section_bytes = None
            ba_section_bytes = None
            if shdr.sh_type != SHT.NOBITS:
                section_bytes = (c_ubyte * shdr.sh_size).from_buffer(data, shdr.sh_offset)
                ba_section_bytes = bytearray(section_bytes)
            shdrs.append(ShdrData(name=None,header=shdr, raw=section_bytes, bytes=ba_section_bytes))
            offset += elfHeader.header.e_shentsize

        if elfHeader.header.e_shstrndx != SHN.UNDEF:
            strtab = shdrs[elfHeader.header.e_shstrndx]
            strtab_offset = strtab.header.sh_offset

            for section in shdrs:
                section.name = get_str(strtab.raw, section.header.sh_name)

        return shdrs
178132
def get_sections_2d_nts(self, sortby=None):
        """"""
        sections_2d_nts = []
        for section_name, hdrgos_actual in self.get_sections_2d():
            hdrgo_nts = self.gosubdag.get_nts(hdrgos_actual, sortby=sortby)
            sections_2d_nts.append((section_name, hdrgo_nts))
        return sections_2d_nts
1301007
def _get_sections(request):
    
    sections = []
    for section_url in SECTIONS:
        crumb = find_crumb(request, section_url)
        if crumb:
            if section_url == '/':
                if request.path == section_url:
                    crumb.is_current = True
            else:
                if request.path.startswith(section_url):
                    crumb.is_current = True
            sections.append(crumb)

    return sections
53921
def to_dict(self):
        
        return {sect: self.__getitem__(sect).to_dict()
                for sect in self.sections()}
414961
private function getSections() {
		$sections = array();
		foreach (Craft::$app->getSections()->getEditableSections() as $section) {
			$sections[$section->id] = Craft::t('site', $section->name);
		}
		return $sections;
	}
583103
def keys(self, section, prefix=None):
        
        return [key for key, _ in self.items(section) if (not prefix or key.startswith(prefix))]
726666
function getSections($) {
    // Create a sections object to return.
    var sections = {};

    // Iterate through each Fieldset ("Section").
    $('fieldset').each(function() {
      var $fieldset           = $(this),
          sectionName         = getSectionNameFromFieldset($, $fieldset),
          sectionSubsections  = getSectionSubsectionsFromFieldset($, $fieldset);

      sections[sectionName] = sectionSubsections;
    });

    return sections;
  }
750945
def connections(self):
        
        conn = lambda x: str(x).replace('connection:', '')
        return [conn(name) for name in self.sections()]
164336
def get_section_marks(self):
        """"""
        return [abc if s in self.sec2chr else "." for s, abc in self.datobj.sec2chr.items()]
942360
def root_sections(h):
    
    roots = []
    for section in h.allsec():
        sref = h.SectionRef(sec=section)
        # has_parent returns a float... cast to bool
        if sref.has_parent() < 0.9:
            roots.append(section)
    return roots
736825
def get_sections_for_term(id, opts = {})
      data, _status_code, _headers = get_sections_for_term_with_http_info(id, opts)
      return data
    end
38223
def list_sections(self):
        """"""
        if not os.path.exists(self._full_base):
            return []
        return [
            name for name in os.listdir(self._full_base)
            if os.path.isdir(os.path.join(self._full_base, name))
        ]
322982
def list_section(service_name = nil, section_name = nil, graph_name = nil)
      graphs = list_graph(service_name, section_name, graph_name)
      services = {}
      graphs.each do |graph|
        service_name, section_name = graph['service_name'], graph['section_name']
        services[service_name] ||= {}
        services[service_name][section_name] ||= true
      end
      Hash[services.map {|service_name, sections| [service_name, sections.keys] }]
    end
358616
def items(self):
        """"""
        return list(zip((self.scalars + self.sections), list(self.values())))
637941
def section(self, resources):
        

        section = [p for p in self.parents(resources) if p.rtype == 'section']
        if section:
            return section[0]
        return None
1267991
def get_values(self, keys):
        
        if is_string(keys):
            return [s.__dict__[keys] for s in self.sections]
        else:
            values = []
            for k in keys:
                values.append([s.__dict__[k] for s in self.sections])
            return values
624094
@XmlElementWrapper(name = "sections")
    @XmlElement(name = "s", type = S.class)
    public List<S> getSections() {
        return sections;
    }