minimum
float minimum;
status_t SetLimitsFor(int32 channel, int32 minimum,
status_t SetLimits(int32 minimum, int32 maximum);
virtual void SetLimits(int32 minimum, int32 maximum);
void GetLimits(int32* minimum, int32* maximum) const;
uint16 minimum;
uint32 minimum;
uint64 minimum;
if (addressLength == 0 && addressMaximum <= acpiRange.minimum) {
addressMaximum = acpiRange.minimum + addressLength - 1;
} else if (addressLength != addressMaximum - acpiRange.minimum + 1) {
addressLength = addressMaximum - acpiRange.minimum + 1;
range.host_address = acpiRange.minimum + acpiRange.translation_offset;
range.pci_address = acpiRange.minimum;
(unsigned long)acpiRange.minimum, resource.minAddress_fixed,
HIDReport::_SignExtend(uint32 &minimum, uint32 &maximum)
if (minimum & mask) {
minimum |= mask;
void _SignExtend(uint32 &minimum, uint32 &maximum);
HIDReportItem::ScaledRangeData(uint32 minimum, uint32 maximum)
return zeroBasedData * (maximum - minimum + 1) / (fMaximum - fMinimum + 1)
+ minimum;
uint32 minimum, uint32 maximum, uint32 usage)
fMinimum(minimum),
uint32 minimum, uint32 maximum,
uint32 ScaledRangeData(uint32 minimum, uint32 maximum);
if (bestLength < minimum)
else if (minimum > 1) {
bestLength = round_down(bestLength, minimum);
off_t numBlocks, block_run& run, uint16 minimum)
return AllocateBlocks(transaction, group, start, numBlocks, minimum, run);
uint16 start, uint16 maximum, uint16 minimum, block_run& run)
groupIndex, start, maximum, minimum));
uint16 minimum = 1);
uint16 minimum, block_run& run);
uint16 minimum = 1;
minimum = data->double_indirect.Length();
minimum = data->double_indirect.Length();
minimum = data->double_indirect.Length();
if (minimum > 1) {
blocksRequested = round_up(blocksRequested, minimum);
run, minimum);
minimum = _DoubleIndirectBlockLength();
blocksRequested = round_up(blocksNeeded, minimum);
uint16 minimum = 1);
block_run& run, uint16 minimum)
minimum);
BlockAllocator::AllocateBlocks(Transaction& transaction, uint32 minimum,
minimum, maximum, blockGroup, start, fNumGroups);
if (bestLength < minimum) {
minimum);
off_t numBlocks, uint32 minimum, fsblock_t& start, uint32& allocated)
return AllocateBlocks(transaction, minimum, minimum + 8, group, start,
uint32 minimum, uint32 maximum, uint32& blockGroup,
off_t numBlocks, uint32 minimum, fsblock_t& start,
Volume::AllocateBlocks(Transaction& transaction, uint32 minimum, uint32 maximum,
status_t status = fBlockAllocator->AllocateBlocks(transaction, minimum,
uint32 minimum, uint32 maximum,
BChannelControl::SetLimitsFor(int32 channel, int32 minimum, int32 maximum)
return SetLimitsFor(channel, 1, &minimum, &maximum);
BChannelControl::GetLimitsFor(int32 channel, int32* minimum,
return GetLimitsFor(channel, 1, minimum, maximum);
const int32* minimum, const int32* maximum)
if (minimum[i] > maximum[i])
fChannelMin[fromChannel + i] = minimum[i];
if (fChannelValues[fromChannel + i] < minimum[i])
fChannelValues[fromChannel + i] = minimum[i];
int32* minimum, int32* maximum) const
if (minimum == NULL || maximum == NULL)
minimum[i] = fChannelMin[fromChannel + i];
BChannelControl::SetLimits(int32 minimum, int32 maximum)
if (minimum > maximum)
fChannelMin[c] = minimum;
if (fChannelValues[c] < minimum)
fChannelValues[c] = minimum;
BSlider::SetLimits(int32 minimum, int32 maximum)
if (minimum <= maximum) {
fMinValue = minimum;
value = std::max(minimum, value);
GetLimits__7BSliderPlT1(BSlider* slider, int32* minimum, int32* maximum)
slider->GetLimits(minimum, maximum);
_ReservedSlider4__7BSlider(BSlider* slider, int32 minimum, int32 maximum)
slider->BSlider::SetLimits(minimum, maximum);
BSlider::GetLimits(int32* minimum, int32* maximum) const
if (minimum != NULL)
*minimum = fMinValue;
const char* unit, float minimum, float maximum, float stepping)
fMinimum(minimum),
float minimum, float maximum, float stepping)
kind, unit, minimum, maximum, stepping);
m = minimum(datlen, KEYSZ + IVSZ);
m = minimum(n, rs->rs_have);
RingBuffer::Write(const void* data, size_t length, size_t minimum, bool isUser, bool* wasEmpty)
if (writeAvailable == 0 || writeAvailable < minimum)
size_t minimum, bool isUser, bool* wasEmpty);