Index

Modules: find, find/size.

API symbols

`!=`:

• size: proc `!=`(fs: FSize): FSize

`<=`:

• size: proc `<=`(fs: FSize): FSize

`<`:

• size: proc `<`(fs: FSize): FSize

`==`:

• size: proc `==`(fs: FSize): FSize

`>=`:

• size: proc `>=`(fs: FSize): FSize

`>`:

• size: proc `>`(fs: FSize): FSize

Bytes:

• find: FileSizeUnit.Bytes
• size: FileSizeUnit.Bytes

bytes:

• size: proc bytes(i: float): FSize
• size: proc bytes(i: int): FSize

collect:

• find: proc collect(f: Finder; res: var seq[string])

contains:

• find: proc contains(f: Finder; pattern: string): Finder

EQ:

• size: SizeOp.EQ

ext:

• find: proc ext(f: Finder; extension: string): Finder

FileSizeUnit:

• find: enum FileSizeUnit
• size: enum FileSizeUnit

find:

• find: iterator find(f: Finder): string

Finder:

• find: type Finder

finder:

• find: proc finder(kind: FinderSearchKind = fkFile): Finder

FinderSearchKind:

• find: enum FinderSearchKind

fkAny:

• find: FinderSearchKind.fkAny

fkDir:

• find: FinderSearchKind.fkDir

fkFile:

• find: FinderSearchKind.fkFile

fkLinkToDir:

• find: FinderSearchKind.fkLinkToDir

fkLinkToFile:

• find: FinderSearchKind.fkLinkToFile

FSize:

• size: type FSize

gb:

• size: proc gb(i: float): FSize

GB:

• size: proc GB(i: float): FSize

gb:

• size: proc gb(i: int): FSize

Gigabytes:

• find: FileSizeUnit.Gigabytes
• size: FileSizeUnit.Gigabytes

gigabytes:

• size: proc gigabytes(i: float): FSize

GT:

• size: SizeOp.GT

GTE:

• size: SizeOp.GTE

isVcsPath:

• find: proc isVcsPath(path: string): bool

kb:

• size: proc kb(i: float): FSize

KB:

• size: proc KB(i: float): FSize

kb:

• size: proc kb(i: int): FSize

Kilobytes:

• find: FileSizeUnit.Kilobytes
• size: FileSizeUnit.Kilobytes

kilobytes:

• size: proc kilobytes(i: float): FSize

largerThan:

• find: proc largerThan(f: Finder; size: FSize): Finder

LT:

• size: SizeOp.LT

LTE:

• size: SizeOp.LTE

mb:

• size: proc mb(i: float): FSize

MB:

• size: proc MB(i: float): FSize

mb:

• size: proc mb(i: int): FSize

Megabytes:

• find: FileSizeUnit.Megabytes
• size: FileSizeUnit.Megabytes

megabytes:

• size: proc megabytes(i: float): FSize

modifiedAfter:

• find: proc modifiedAfter(f: Finder; t: Time): Finder

modifiedBefore:

• find: proc modifiedBefore(f: Finder; t: Time): Finder

name:

• find: proc name(f: Finder; pattern: string): Finder

namePattern:

• find: proc namePattern(f: Finder; pattern: string): Finder

NE:

• size: SizeOp.NE

newFinder:

• find: proc newFinder(kind: FinderSearchKind = fkFile): Finder

notContains:

• find: proc notContains(f: Finder; pattern: string): Finder

parseSize:

• find: proc parseSize(raw: string): int64

path:

• find: proc path(f: Finder; root: string): Finder

pathRegex:

• find: proc pathRegex(f: Finder; pattern: string): Finder

recursive:

• find: proc recursive(f: Finder; enabled = true): Finder

size:

• find: proc size(f: Finder; rule: FSize): Finder

SizeOp:

• size: enum SizeOp

smallerThan:

• find: proc smallerThan(f: Finder; size: FSize): Finder

soNone:

• size: SizeOp.soNone

tb:

• size: proc tb(i: float): FSize

TB:

• size: proc TB(i: float): FSize

tb:

• size: proc tb(i: int): FSize

Terabytes:

• find: FileSizeUnit.Terabytes
• size: FileSizeUnit.Terabytes

terabytes:

• size: proc terabytes(i: float): FSize

toBytes:

• size: proc toBytes(size: float64; unit: FileSizeUnit = Bytes): int64