class Net::IMAP::SequenceSet

IMAP 序列集是一组消息序列号或唯一标识符（“UID”）。它包含数字和数字范围。这些数字都是非零的无符号 32 位整数和一个特殊值（"*"），表示邮箱中的最大值。

某些类型的 IMAP 响应将包含一个 SequenceSet，例如 "MODIFIED" ResponseCode 的数据。某些 IMAP 命令可能会接收一个 SequenceSet 作为参数，例如 IMAP#search、IMAP#fetch 和 IMAP#store。

创建序列集¶ ↑

不带任何参数的 SequenceSet.new 创建一个空的序列集。请注意，空的序列集在 IMAP 语法中是无效的。

set = Net::IMAP::SequenceSet.new
set.empty?        #=> true
set.valid?        #=> false
set.valid_string  #!> raises DataFormatError
set << 1..10
set.empty?        #=> false
set.valid?        #=> true
set.valid_string  #=> "1:10"

SequenceSet.new 可以接收一个可选的参数：一个非零的 32 位无符号整数、一个范围、一个 sequence-set 格式的字符串、另一个序列集、一个 Set（仅包含数字或 *）或一个包含其中任何一个的数组（数组输入可以嵌套）。

set = Net::IMAP::SequenceSet.new(1)
set.valid_string  #=> "1"
set = Net::IMAP::SequenceSet.new(1..100)
set.valid_string  #=> "1:100"
set = Net::IMAP::SequenceSet.new(1...100)
set.valid_string  #=> "1:99"
set = Net::IMAP::SequenceSet.new([1, 2, 5..])
set.valid_string  #=> "1:2,5:*"
set = Net::IMAP::SequenceSet.new("1,2,3:7,5,6:10,2048,1024")
set.valid_string  #=> "1,2,3:7,5,6:10,2048,1024"
set = Net::IMAP::SequenceSet.new(1, 2, 3..7, 5, 6..10, 2048, 1024)
set.valid_string  #=> "1:10,55,1024:2048"

使用带有一个或多个参数的 ::[] 创建一个冻结的 SequenceSet。使用 ::[] 无法创建无效的（空）集合。

set = Net::IMAP::SequenceSet["1,2,3:7,5,6:10,2048,1024"]
set.valid_string  #=> "1,2,3:7,5,6:10,2048,1024"
set = Net::IMAP::SequenceSet[1, 2, [3..7, 5], 6..10, 2048, 1024]
set.valid_string  #=> "1:10,55,1024:2048"

规范化形式¶ ↑

当使用单个 String 值创建序列集时，将保留该 string 表示形式。SequenceSet 的内部表示形式会隐式地对所有条目进行排序、删除重复的数字并合并相邻或重叠的范围。大多数枚举方法和基于偏移量的方法都使用这种规范化表示形式。大多数修改方法会将 string 转换为其规范化形式。

在某些情况下，字符串表示形式的顺序很重要，例如 ESORT、CONTEXT=SORT 和 UIDPLUS 扩展。使用 entries 或 each_entry 按其原始顺序枚举集合。要在修改集合时保留 string 顺序，请使用 append、string= 或 replace。

使用 `*`¶ ↑

IMAP 序列集可以包含一个特殊值 "*"，它表示正在使用的最大数字。来自 RFC9051 §9 中的 seq-number

在消息序列号的情况下，它是非空邮箱中消息的数量。在唯一标识符的情况下，它是邮箱中最后一条消息的唯一标识符；如果邮箱为空，则为邮箱当前的 UIDNEXT 值。

创建 SequenceSet 时，* 可以作为 -1、"*"、:*、无限范围或以 -1 结尾的范围输入。当转换为 elements、ranges 或 numbers 时，它将输出为 :* 或无限范围。例如

Net::IMAP::SequenceSet["1,3,*"].to_a      #=> [1, 3, :*]
Net::IMAP::SequenceSet["1,234:*"].to_a    #=> [1, 234..]
Net::IMAP::SequenceSet[1234..-1].to_a     #=> [1234..]
Net::IMAP::SequenceSet[1234..].to_a       #=> [1234..]

Net::IMAP::SequenceSet[1234..].to_s       #=> "1234:*"
Net::IMAP::SequenceSet[1234..-1].to_s     #=> "1234:*"

使用 limit 将 "*" 转换为最大值。当范围包含 "*" 时，始终会匹配最大值

Net::IMAP::SequenceSet["9999:*"].limit(max: 25)
#=> Net::IMAP::SequenceSet["25"]

令人惊讶的 `*` 行为¶ ↑

当集合包含 * 时，某些方法可能会有令人惊讶的行为。

例如，complement 将 * 视为其自身的数字。这样，集合及其 complement 的 intersection 将始终为空。这与 IMAP 服务器解释集合的方式不同：它会将 * 转换为邮箱中的消息数或 UIDNEXT，具体取决于情况。并且在将 limit 应用于每个集合后，集合及其补集之间将存在重叠

~Net::IMAP::SequenceSet["*"]  == Net::IMAP::SequenceSet[1..(2**32-1)]
~Net::IMAP::SequenceSet[1..5] == Net::IMAP::SequenceSet["6:*"]

set = Net::IMAP::SequenceSet[1..5]
(set & ~set).empty? => true

(set.limit(max: 4) & (~set).limit(max: 4)).to_a => [4]

在计算集合中的数字数量时，除了当集合中也存在 UINT32_MAX 时，会计算 *

UINT32_MAX = 2**32 - 1
Net::IMAP::SequenceSet["*"].count                   => 1
Net::IMAP::SequenceSet[1..UINT32_MAX - 1, :*].count => UINT32_MAX

Net::IMAP::SequenceSet["1:*"].count                 => UINT32_MAX
Net::IMAP::SequenceSet[UINT32_MAX, :*].count        => 1
Net::IMAP::SequenceSet[UINT32_MAX..].count          => 1

这里有什么？¶ ↑

SequenceSet 提供以下方法：

创建 SequenceSet 的方法¶ ↑

::[]：从一个或多个输入创建经过验证的冻结序列集。
::new：创建一个新的可变序列集，该序列集可能为空（无效）。
::try_convert：对对象调用 to_sequence_set 并验证结果是否为 SequenceSet。
::empty：返回冻结的空（无效）SequenceSet。
::full：返回包含每个可能数字的冻结 SequenceSet。

用于比较的方法¶ ↑

与另一个 SequenceSet 进行比较

==：返回给定集合是否包含与 self 相同的数字。
eql?：返回给定集合是否使用与 self 相同的 string。

与可转换为 SequenceSet 的对象进行比较

===：返回给定对象是否完全包含在 self 中；如果该对象无法转换为兼容类型，则返回 nil。
cover?（别名为 ===）：返回给定对象是否完全包含在 self 中。
intersect?（别名为 overlap?）：返回 self 和给定对象是否具有任何公共元素。
disjoint?：返回 self 和给定对象是否没有公共元素。

用于查询的方法¶ ↑

这些方法不会修改 self。

集合成员资格

include?（别名为 member?）：返回给定对象（nz-number、范围或 *）是否包含在该集合中。
include_star?：返回集合是否包含 *。

最小值和最大值元素

min：返回集合中的最小数字。
max：返回集合中的最大数字。
minmax：返回集合中的最小和最大数字。

按偏移量访问值

[]（别名为 slice）：返回给定偏移量或偏移量范围处的数字或连续子集。
at：返回给定偏移量处的数字。
find_index：返回给定数字在集合中的偏移量

集合基数

count（别名为 size）：返回集合中数字的计数。
empty?：返回集合是否没有成员。IMAP 语法不允许空序列集。
valid?：返回集合是否具有任何成员。
full?：返回集合是否包含每个可能的值，包括 *。

用于迭代的方法¶ ↑

each_element：生成集合中排序和合并的每个数字和范围，并返回 self。
elements（别名为 to_a）：返回集合中每个排序和合并的数字和范围的数组。
each_entry：生成集合中未排序且不删除重复数字或合并范围的每个数字和范围，并返回 self。
entries：返回集合中每个未排序且不删除重复数字或合并范围的数字和范围的数组。
each_range：将集合中的每个元素作为 Range 生成并返回 self。
ranges：返回集合中每个元素的数组，将数字转换为单个值的范围。
each_number：生成集合中的每个数字并返回 self。
numbers: 返回一个数组，其中包含集合中的每个数字，并将范围扩展为所有包含的数字。
to_set: 返回一个包含集合中所有numbers的 Set。

集合运算方法¶ ↑

这些方法不会修改 self。

#|（别名为union和+）：返回一个新的集合，其中包含self中的所有成员以及另一个对象中的所有成员。
#&（别名为intersection）：返回一个新的集合，其中包含self和另一个对象共有的所有成员。
-（别名为difference）：返回self的一个副本，其中删除了另一个对象中的所有成员。
#^（别名为xor）：返回一个新的集合，其中包含self和另一个对象的所有成员，但排除两者共有的成员。
#~（别名为complement）：返回一个新集合，其中包含所有不在self中的成员
limit: 返回 self 的一个副本，其中将 * 替换为给定的最大值，并删除所有超出该最大值的成员。

赋值方法¶ ↑

这些方法在 self 中添加或替换元素。

add（别名为<<）：将给定对象添加到集合中；返回self。
add?：如果给定对象不是集合中的元素，则将其添加并返回self；否则，返回nil。
merge：将多个元素合并到集合中；返回self。
append：将给定对象添加到集合中，将其附加到现有字符串中，并返回 self。
string=：赋值新的 string 值并替换 elements 以匹配。
replace：使用给定对象的内容替换集合的内容。
complement!: 使用其自身的 complement 替换集合的内容。

删除方法¶ ↑

这些方法从 self 中删除元素。

clear：删除集合中的所有元素；返回self。
delete：从集合中删除给定对象；返回self。
delete?：如果给定对象是集合中的元素，则将其删除并返回；否则，返回nil。
delete_at：删除给定偏移量处的数字。
slice!：删除给定偏移量或偏移量范围处的数字或连续数字。
subtract：从集合中删除每个给定对象；返回self。
limit!: 将 * 替换为给定的最大值，并删除所有超出该最大值的成员；返回 self。

IMAP 字符串格式化方法¶ ↑

to_s: 返回 sequence-set 字符串，当集合为空时，返回空字符串。
string: 返回 sequence-set 字符串，当集合为空时，返回 nil。
valid_string: 返回 sequence-set 字符串，当集合为空时，引发 DataFormatError。
normalized_string: 返回一个 sequence-set 字符串，其元素已排序和合并，当集合为空时，返回 nil。
normalize: 返回一个新集合，其中包含此集合的规范化 sequence-set 表示形式。
normalize!: 将 string 更新为其规范化的 sequence-set 表示形式，并返回 self。

常量

EMPTY: 有意在类实现之后定义
FULL
STARS: “*”的有效输入
STAR_INT: 在内部表示“*”，以简化排序（等）
UINT32_MAX: 最大的可能的非零无符号 32 位整数

公共类方法

SequenceSet[*values] → 有效的冻结序列集点击切换源

返回一个冻结的 SequenceSet，由 values 构建。

一个空的 SequenceSet 是无效的，将引发一个 DataFormatError。

使用 ::new 创建一个可变或空的 SequenceSet。

# File net-imap-0.5.4/lib/net/imap/sequence_set.rb, line 297
def [](first, *rest)
  if rest.empty?
    if first.is_a?(SequenceSet) && first.frozen? && first.valid?
      first
    else
      new(first).validate.freeze
    end
  else
    new(first).merge(*rest).validate.freeze
  end
end

empty() 点击切换源

返回一个冻结的空集合单例。请注意，有效的 IMAP 序列集不能为空，因此该集合是无效的。

# File net-imap-0.5.4/lib/net/imap/sequence_set.rb, line 328
def empty; EMPTY end

full() 点击切换源

返回一个冻结的完整集合单例: "1:*"

# File net-imap-0.5.4/lib/net/imap/sequence_set.rb, line 331
def full;  FULL end

new(input = nil) 点击切换源

从 input 创建一个新的 SequenceSet 对象，它可以是另一个 SequenceSet、一个 IMAP 格式化的 sequence-set 字符串、一个数字、一个范围、:* 或这些的可枚举对象。

使用 ::[] 创建一个冻结的（非空）SequenceSet。

# File net-imap-0.5.4/lib/net/imap/sequence_set.rb, line 340
def initialize(input = nil) input ? replace(input) : clear end

try_convert(obj) → 序列集或 nil 点击切换源

如果 obj 是一个 SequenceSet，则返回 obj。如果 obj 响应 to_sequence_set，则调用 obj.to_sequence_set 并返回结果。否则返回 nil。

如果 obj.to_sequence_set 没有返回 SequenceSet，则会引发异常。

# File net-imap-0.5.4/lib/net/imap/sequence_set.rb, line 318
def try_convert(obj)
  return obj if obj.is_a?(SequenceSet)
  return nil unless obj.respond_to?(:to_sequence_set)
  obj = obj.to_sequence_set
  return obj if obj.is_a?(SequenceSet)
  raise DataFormatError, "invalid object returned from to_sequence_set"
end

公共实例方法

self & other → 序列集点击切换源

返回一个新的序列集，其中仅包含此集合和 other 共有的数字。

other 可以是任何会被 ::new 接受的对象：非零 32 位无符号整数、范围、sequence-set 格式的字符串、另一个序列集或包含这些的可枚举对象。

Net::IMAP::SequenceSet[1..5] & [2, 4, 6]
#=> Net::IMAP::SequenceSet["2,4"]

(seqset & other) 等效于 (seqset - ~other)。

# File net-imap-0.5.4/lib/net/imap/sequence_set.rb, line 619
def &(other)
  remain_frozen dup.subtract SequenceSet.new(other).complement!
end

也别名为：intersection

self + other → 序列集

别名为: |

self - other → 序列集点击切换源

返回通过复制此集合并删除 other 中出现的每个数字而构建的新序列集。

other 可以是任何会被 ::new 接受的对象：非零 32 位无符号整数、范围、sequence-set 格式的字符串、另一个序列集或包含这些的可枚举对象。

Net::IMAP::SequenceSet[1..5] - 2 - 4 - 6
#=> Net::IMAP::SequenceSet["1,3,5"]

私有实例方法

each_tuple_with_index() { |min, max, idx_min, (idx_max = idx_min + (max - min))| ... } 点击切换源代码

# File net-imap-0.5.4/lib/net/imap/sequence_set.rb, line 1008
def each_tuple_with_index
  idx_min = 0
  @tuples.each do |min, max|
    yield min, max, idx_min, (idx_max = idx_min + (max - min))
    idx_min = idx_max + 1
  end
  idx_min
end

from_tuple_int(num) 点击切换源代码

# File net-imap-0.5.4/lib/net/imap/sequence_set.rb, line 1301
def from_tuple_int(num) num == STAR_INT ? :* : num end

include_tuple?((min, max)) 点击切换源代码

# File net-imap-0.5.4/lib/net/imap/sequence_set.rb, line 1310
def include_tuple?((min, max)) range_gte_to(min)&.cover?(min..max) end

initialize_clone(other) 点击切换源代码

冻结的克隆是浅拷贝的

调用超类方法

# File net-imap-0.5.4/lib/net/imap/sequence_set.rb, line 1244
def initialize_clone(other)
  other.frozen? ? super : initialize_dup(other)
end

initialize_dup(other) 点击切换源代码

调用超类方法

# File net-imap-0.5.4/lib/net/imap/sequence_set.rb, line 1248
def initialize_dup(other)
  @tuples = other.tuples.map(&:dup)
  @string = other.string&.-@
  super
end

input_to_tuple(obj) 点击切换源代码

# File net-imap-0.5.4/lib/net/imap/sequence_set.rb, line 1254
def input_to_tuple(obj)
  obj = input_try_convert obj
  case obj
  when *STARS, Integer then [int = to_tuple_int(obj), int]
  when Range           then range_to_tuple(obj)
  when String          then str_to_tuple(obj)
  else
    raise DataFormatError, "expected number or range, got %p" % [obj]
  end
end

input_to_tuples(obj) 点击切换源代码

# File net-imap-0.5.4/lib/net/imap/sequence_set.rb, line 1265
def input_to_tuples(obj)
  obj = input_try_convert obj
  case obj
  when *STARS, Integer, Range then [input_to_tuple(obj)]
  when String      then str_to_tuples obj
  when SequenceSet then obj.tuples
  when Set         then obj.map      { [to_tuple_int(_1)] * 2 }
  when Array       then obj.flat_map { input_to_tuples _1 }
  when nil         then []
  else
    raise DataFormatError,
          "expected nz-number, range, string, or enumerable; " \
          "got %p" % [obj]
  end
end

input_try_convert(input) 点击切换源代码

与 SequenceSet#try_convert 不同，此方法返回 Integer、Range、String、Set、Array 或…任何类型的对象。

# File net-imap-0.5.4/lib/net/imap/sequence_set.rb, line 1283
def input_try_convert(input)
  SequenceSet.try_convert(input) ||
    Integer.try_convert(input) ||
    String.try_convert(input) ||
    input
end

intersect_tuple?((min, max)) 点击切换源代码

# File net-imap-0.5.4/lib/net/imap/sequence_set.rb, line 1312
def intersect_tuple?((min, max))
  range = range_gte_to(min) and
    range.include?(min) || range.include?(max) || (min..max).cover?(range)
end

modifying!() 点击切换源代码

# File net-imap-0.5.4/lib/net/imap/sequence_set.rb, line 1317
def modifying!
  if frozen?
    raise FrozenError, "can't modify frozen #{self.class}: %p" % [self]
  end
end

nz_number(num) 点击切换源代码

# File net-imap-0.5.4/lib/net/imap/sequence_set.rb, line 1414
def nz_number(num)
  String === num && !/\A[1-9]\d*\z/.match?(num) and
    raise DataFormatError, "%p is not a valid nz-number" % [num]
  NumValidator.ensure_nz_number Integer num
rescue TypeError # To catch errors from Integer()
  raise DataFormatError, $!.message
end

range_gte_to(num) 点击切换源代码

# File net-imap-0.5.4/lib/net/imap/sequence_set.rb, line 1409
def range_gte_to(num)
  first, last = tuples.bsearch { _2 >= num }
  first..last if first
end

range_to_tuple(range) 点击切换源代码

# File net-imap-0.5.4/lib/net/imap/sequence_set.rb, line 1290
def range_to_tuple(range)
  first = to_tuple_int(range.begin || 1)
  last  = to_tuple_int(range.end   || :*)
  last -= 1 if range.exclude_end? && range.end && last != STAR_INT
  unless first <= last
    raise DataFormatError, "invalid range for sequence-set: %p" % [range]
  end
  [first, last]
end

remain_frozen(set) 点击切换源代码

# File net-imap-0.5.4/lib/net/imap/sequence_set.rb, line 1241
def remain_frozen(set) frozen? ? set.freeze : set end

reverse_each_tuple_with_index() { |min, max, (idx_min = idx_max - (max - min)), idx_max| ... } 点击切换源代码

# File net-imap-0.5.4/lib/net/imap/sequence_set.rb, line 1017
def reverse_each_tuple_with_index
  idx_max = -1
  @tuples.reverse_each do |min, max|
    yield min, max, (idx_min = idx_max - (max - min)), idx_max
    idx_max = idx_min - 1
  end
  idx_max
end

slice_length(start, length) 点击切换源代码

# File net-imap-0.5.4/lib/net/imap/sequence_set.rb, line 1096
def slice_length(start, length)
  start  = Integer(start.to_int)
  length = Integer(length.to_int)
  raise ArgumentError, "length must be positive" unless length.positive?
  last = start + length - 1 unless start.negative? && start.abs <= length
  slice_range(start..last)
end

slice_range(range) 点击切换源代码

# File net-imap-0.5.4/lib/net/imap/sequence_set.rb, line 1104
def slice_range(range)
  first = range.begin ||  0
  last  = range.end   || -1
  last -= 1 if range.exclude_end? && range.end && last != STAR_INT
  if (first * last).positive? && last < first
    SequenceSet.empty
  elsif (min = at(first))
    max = at(last)
    if    max == :*  then self & (min..)
    elsif min <= max then self & (min..max)
    else                  SequenceSet.empty
    end
  end
end

str_to_tuple(str) 点击切换源代码

# File net-imap-0.5.4/lib/net/imap/sequence_set.rb, line 1305
def str_to_tuple(str)
  raise DataFormatError, "invalid sequence set string" if str.empty?
  str.split(":", 2).map! { to_tuple_int _1 }.minmax
end

str_to_tuples(str) 点击切换源代码

# File net-imap-0.5.4/lib/net/imap/sequence_set.rb, line 1304
def str_to_tuples(str) str.split(",", -1).map! { str_to_tuple _1 } end

to_tuple_int(obj) 点击切换源代码

# File net-imap-0.5.4/lib/net/imap/sequence_set.rb, line 1300
def to_tuple_int(obj) STARS.include?(obj) ? STAR_INT : nz_number(obj) end

tuple_add(tuple) 点击切换源代码

–|=====| |=====新元组=====| 追加 ?????????-|=====新元组=====|-|===较低===|– 插入

|=====new tuple=====|

———??=======较低=======??————— 无操作

———??===较低==|–|==| 连接剩余 ———??===较低==|–|==|—-|===较高===|– 连接直到较高 ———??===较低==|–|==|–|=====较高===|– 连接到较高

# File net-imap-0.5.4/lib/net/imap/sequence_set.rb, line 1336
def tuple_add(tuple)
  modifying!
  min, max = tuple
  lower, lower_idx = tuple_gte_with_index(min - 1)
  if    lower.nil?              then tuples << tuple
  elsif (max + 1) < lower.first then tuples.insert(lower_idx, tuple)
  else  tuple_coalesce(lower, lower_idx, min, max)
  end
end

tuple_coalesce(较低, lower_idx, min, max) 点击切换源代码

# File net-imap-0.5.4/lib/net/imap/sequence_set.rb, line 1346
def tuple_coalesce(lower, lower_idx, min, max)
  return if lower.first <= min && max <= lower.last
  lower[0] = [min, lower.first].min
  lower[1] = [max, lower.last].max
  lower_idx += 1
  return if lower_idx == tuples.count
  tmax_adj = lower.last + 1
  upper, upper_idx = tuple_gte_with_index(tmax_adj)
  if upper
    tmax_adj < upper.first ? (upper_idx -= 1) : (lower[1] = upper.last)
  end
  tuples.slice!(lower_idx..upper_idx)
end

tuple_gte_with_index(num) 点击切换源代码

# File net-imap-0.5.4/lib/net/imap/sequence_set.rb, line 1405
def tuple_gte_with_index(num)
  idx = tuples.bsearch_index { _2 >= num } and [tuples[idx], idx]
end

tuple_subtract(tuple) 点击切换源代码

|====tuple================|

–|====| 不再有 1. 无操作 –|====|—————————|====较低====|– 2. 无操作 ——-|======较低================|—————- 3. 分割 ——–|=====较低================|—————- 4. 修剪开头

——-|======较低====????????????—————– 修剪较低 ——–|=====较低====????????????—————– 删除较低

——-??=====较低===============|—————– 5. 修剪/删除一个 ——-??=====较低====|–|====| 不再有 6. 删除其余 ——-??=====较低====|–|====|—|====较高====|– 7. 删除直到 ——-??=====较低====|–|====|–|=====较高====|– 8. 删除并修剪

# File net-imap-0.5.4/lib/net/imap/sequence_set.rb, line 1373
def tuple_subtract(tuple)
  modifying!
  min, max = tuple
  lower, idx = tuple_gte_with_index(min)
  if    lower.nil?        then nil # case 1.
  elsif max < lower.first then nil # case 2.
  elsif max < lower.last  then tuple_trim_or_split   lower, idx, min, max
  else                         tuples_trim_or_delete lower, idx, min, max
  end
end

tuple_to_entry((min, max)) 点击切换源代码

# File net-imap-0.5.4/lib/net/imap/sequence_set.rb, line 929
def tuple_to_entry((min, max))
  if    min == STAR_INT then :*
  elsif max == STAR_INT then min..
  elsif min == max      then min
  else                       min..max
  end
end

tuple_to_str(tuple) 点击切换源代码

# File net-imap-0.5.4/lib/net/imap/sequence_set.rb, line 1303
def tuple_to_str(tuple) tuple.uniq.map{ from_tuple_int _1 }.join(":") end

tuple_trim_or_split(较低, idx, tmin, tmax) 点击切换源代码

# File net-imap-0.5.4/lib/net/imap/sequence_set.rb, line 1384
def tuple_trim_or_split(lower, idx, tmin, tmax)
  if lower.first < tmin # split
    tuples.insert(idx, [lower.first, tmin - 1])
  end
  lower[0] = tmax + 1
end

tuples_add(tuples) 点击切换源代码

# File net-imap-0.5.4/lib/net/imap/sequence_set.rb, line 1323
def tuples_add(tuples)      tuples.each do tuple_add _1      end; self end

tuples_subtract(tuples) 点击切换源代码

# File net-imap-0.5.4/lib/net/imap/sequence_set.rb, line 1324
def tuples_subtract(tuples) tuples.each do tuple_subtract _1 end; self end

tuples_trim_or_delete(较低, lower_idx, tmin, tmax) 点击切换源代码

# File net-imap-0.5.4/lib/net/imap/sequence_set.rb, line 1391
def tuples_trim_or_delete(lower, lower_idx, tmin, tmax)
  if lower.first < tmin # trim lower
    lower[1] = tmin - 1
    lower_idx += 1
  end
  if tmax == lower.last                           # case 5
    upper_idx = lower_idx
  elsif (upper, upper_idx = tuple_gte_with_index(tmax + 1))
    upper_idx -= 1                                # cases 7 and 8
    upper[0] = tmax + 1 if upper.first <= tmax    # case 8 (else case 7)
  end
  tuples.slice!(lower_idx..upper_idx)
end