Returns the volume group extent count.
489869
def extent_count(self):
        
        self.open()
        count = lvm_vg_get_extent_count(self.handle)
        self.close()
        return count
507002
def volume( self ):
        
        return np.dot( self.matrix[0], np.cross( self.matrix[1], self.matrix[2] ) )
1296345
def group_num(self):
        
        xkb_state = XkbStateRec()
        XkbGetState(self._display, XkbUseCoreKbd, byref(xkb_state))
        return xkb_state.group
577297
def numberOfYTilesAtZoom(self, zoom):
        ""
        [minRow, minCol, maxRow, maxCol] = self.getExtentAddress(zoom)
        return maxRow - minRow + 1
754551
public function getUsedVolumeAttribute()
    {

        $content = $this->content;

        if (! is_null($content))
            return $content->sum(function ($item) {

                return $item->type->volume;
            });

        return 0.0;
    }
1023558
def detect(self, volume_system, vstype='detect'):
        """'"""
        volume = volume_system._make_single_subvolume(offset=0)
        is_directory = os.path.isdir(volume_system.parent.get_raw_path())

        if is_directory:
            filesize = _util.check_output_(['du', '-scDb', volume_system.parent.get_raw_path()]).strip()
            if filesize:
                volume.size = int(filesize.splitlines()[-1].split()[0])

        else:
            description = _util.check_output_(['file', '-sL', volume_system.parent.get_raw_path()]).strip()
            if description:
                # description is the part after the :, until the first comma
                volume.info['fsdescription'] = description.split(': ', 1)[1].split(',', 1)[0].strip()
                if 'size' in description:
                    volume.size = int(re.findall(r'size:? (\d+)', description)[0])
                else:
                    volume.size = os.path.getsize(volume_system.parent.get_raw_path())

        volume.flag = 'alloc'
        volume_system.volume_source = 'single'
        volume_system._assign_disktype_data(volume)
        yield volume
585434
def get_volume(self):
        """"""
        self.request(EP_GET_VOLUME)
        return 0 if self.last_response is None else self.last_response.get('payload').get('volume')
164497
public static int getCurrentVolume(Context context) {
		AudioManager mAudioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
		return mAudioManager.getStreamVolume(AudioManager.STREAM_MUSIC);
	}
1012876
async def volume(gc: GroupControl, volume):
    """"""
    click.echo("Setting volume to %s" % volume)
    click.echo(await gc.set_group_volume(volume))
1155640
public int getTotalClusterCount() {
    int clusterCount = 0;

    for(int i = 0; i < numclusters.length; i++) {
      clusterCount += numclusters[i];
    }

    return clusterCount;
  }
912996
def get(self, volume_ids=None, filters=None):
        """"""
        params = {}
        if filters:
            params["filters"] = make_filters(filters)
        if isinstance(volume_ids, str):
            volume_ids = [volume_ids]
        return self.call("DescribeVolumes",
                         VolumeIds=volume_ids,
                         response_data_key="Volumes",
                         **params)
482167
def number_of_volumes(self):
    """"""
    if not self._is_parsed:
      self._Parse()
      self._is_parsed = True

    return len(self._volumes)
105241
def _elect_source_replication_group(
            self,
            over_replicated_rgs,
            partition,
    ):
        
        return max(
            over_replicated_rgs,
            key=lambda rg: rg.count_replica(partition),
        )
1121506
public function groupCount()
    {
        $ret = 0;

        foreach ($this->_data as $val) {
            if ($val instanceof Horde_Mail_Rfc822_Group) {
                ++$ret;
            }
        }

        return $ret;
    }
773843
def grouped_count_sizes(fileslist, fgrouped):  # pragma: no cover
    ''''''
    fsizes = {}
    total_files = 0
    allitems = None
    if isinstance(fgrouped, dict):
        allitems = fgrouped.iteritems()
    elif isinstance(fgrouped, list):
        allitems = enumerate(fgrouped)
    for fkey, cluster in allitems:
        fsizes[fkey] = []
        for subcluster in cluster:
            tot = 0
            if subcluster is not None:
                for fname in subcluster:
                    tot += fileslist[fname]
                    total_files += 1
            fsizes[fkey].append(tot)
    return fsizes, total_files
313081
def groups_count(self):
        
        if self._keyboard_description.contents.ctrls is not None:
            return self._keyboard_description.contents.ctrls.contents.num_groups
        else:
            groups_source = self._groups_source

            groups_count = 0
            while (groups_count < XkbNumKbdGroups and
                   groups_source[groups_count] != None_):
                groups_count += 1

            return groups_count
633471
def size
      volume = 0.0
      last_index = @slices.length - 1
      # Iterate each slice:
      @slices.each_index do |i|
        # Get the contoured area in this slice, convert it to volume and add to our total.
        # If the slice is the first or last, only multiply by half of the slice thickness:
        if i == 0 or i == last_index
          volume += @slices[i].area * image_series.slice_spacing * 0.5
        else
          volume += @slices[i].area * image_series.slice_spacing
        end
      end
      # Convert from mm^3 to cm^3:
      return volume / 1000.0
    end