dymokomi/luced-message
Source of release 0.5.0
## What the window reads from the store: a folder list and a folder's message index,
## each read whole from a prism snapshot (mail_db) into an object Luce holds, with one
## accessor per column. Reading them in Base keeps a 50,000-message folder quick to open.
from luce_std import files
import interop
import memory
from luce_prism import prism
from luce_mime import mime
from luce_std.collections import Buffer, List
from mail_store import Row, Folder
from mail_threads import Threads, thread
import mail_db
## A folder's messages, as the store has them.
pub struct MessageIndex:
var rows: mail_db.Rows
## Positions in UID order, for `position`.
var by_uid: List[u32]
## Positions newest first: by date, then by UID.
var order: List[u32]
## The messages grouped into conversations.
var threads: Threads
## How many messages there are.
pub func count() -> i64:
return (i64)self.rows.rows.length()
func row(at: i64) -> Row:
if at < 0 or at >= (i64)self.rows.rows.length():
trap("no message at that position in the index")
return self.rows.rows.at((usize)at)
pub func uid(at: i64) -> i64:
return (i64)self.row(at).uid
## imap.Flags bits: 1 seen, 2 answered, 4 flagged, 8 deleted, 16 draft, 64 forwarded, 128 junk.
pub func flags(at: i64) -> i64:
return (i64)self.row(at).flags
## Seconds since 1970 UTC.
pub func date(at: i64) -> i64:
return self.row(at).date
pub func size(at: i64) -> i64:
return (i64)self.row(at).size
pub func attachment(at: i64) -> bool:
return self.row(at).attachment
pub func sender(at: i64) -> str:
return self.row(at).sender
pub func subject(at: i64) -> str:
return self.row(at).subject
pub func message_id(at: i64) -> str:
return self.row(at).message_id
pub func in_reply_to(at: i64) -> str:
return self.row(at).in_reply_to
pub func preview(at: i64) -> str:
return self.row(at).preview
## The position of the message with UID `uid`, or -1.
pub func position(uid: i64) -> i64:
var low: usize = 0
var high = self.by_uid.length()
while low < high:
let middle = (low + high) // 2
let at = self.by_uid.at(middle)
let found = (i64)self.rows.rows.at((usize)at).uid
if found == uid:
return (i64)at
if found < uid:
low = middle + 1
else:
high = middle
return -1
## The position of the `nth` newest message.
pub func newest(nth: i64) -> i64:
if nth < 0 or nth >= (i64)self.order.length():
trap("no message at that place in the order")
return (i64)self.order.at((usize)nth)
## Fill the UID and newest-first orders.
func sort() -> !:
let count = self.rows.rows.length()
for at in 0..<count:
try self.by_uid.append((u32)at)
try self.order.append((u32)at)
try self.merge_sort(&self.by_uid, true)
try self.merge_sort(&self.order, false)
## Sort `positions` by UID (`by_uid`), else newest first; a stable merge sort, fast
## on the mostly sorted orders mailboxes have.
func merge_sort(positions: List[u32]*, by_uid: bool) -> !:
let count = positions.length()
if count < 2:
return
let scratch = try new u32[count] --- in memory.heap
defer free(scratch) in memory.heap
var width: usize = 1
while width < count:
var start: usize = 0
while start < count:
let middle = start + width if start + width < count else count
let end = start + 2 * width if start + 2 * width < count else count
var left = start
var right = middle
var out = start
while out < end:
var take_left = right >= end
if not take_left and left < middle:
let a = positions.at(left)
let b = positions.at(right)
take_left = not (self.uid_before(b, a) if by_uid else self.newer(b, a))
if take_left:
scratch[out] = positions.at(left)
left += 1
else:
scratch[out] = positions.at(right)
right += 1
out += 1
start = end
for at in 0..<count:
positions.set(at, scratch[at])
width *= 2
func uid_before(a: u32, b: u32) -> bool:
return self.rows.rows.at((usize)a).uid < self.rows.rows.at((usize)b).uid
## Whether the row at `a` is newer than the row at `b`.
func newer(a: u32, b: u32) -> bool:
let first = self.rows.rows.at((usize)a)
let second = self.rows.rows.at((usize)b)
if first.date != second.date:
return first.date > second.date
return first.uid > second.uid
# mark: conversations ======================================================================
## How many conversations there are.
pub func thread_count() -> i64:
return (i64)self.threads.count()
func checked_thread(nth: i64) -> usize:
if nth < 0 or nth >= (i64)self.threads.count():
trap("no conversation at that place")
return (usize)nth
## How many messages conversation `nth` (newest first) holds.
pub func thread_size(nth: i64) -> i64:
return (i64)self.threads.size(self.checked_thread(nth))
## The position of the `member`-th newest message of conversation `nth`.
pub func thread_member(nth: i64, member: i64) -> i64:
let group = self.checked_thread(nth)
if member < 0 or member >= (i64)self.threads.size(group):
trap("no message at that place in the conversation")
return (i64)self.threads.member(group, (usize)member)
## Whether any message of conversation `nth` has all of flag bits `bit`
## (`seen` asks for the inverse: whether any is unread).
pub func thread_any(nth: i64, bit: i64, wanted: bool) -> bool:
let group = self.checked_thread(nth)
for member in 0..<self.threads.size(group):
let flags = (i64)self.rows.rows.at((usize)self.threads.member(group, member)).flags
if ((flags & bit) == bit) == wanted:
return true
return false
## Whether any message of conversation `nth` has attachments.
pub func thread_attachment(nth: i64) -> bool:
let group = self.checked_thread(nth)
for member in 0..<self.threads.size(group):
if self.rows.rows.at((usize)self.threads.member(group, member)).attachment:
return true
return false
pub func close():
self.rows.close()
self.by_uid.destroy()
self.order.destroy()
self.threads.close()
pub let message_index_type: interop.Type[MessageIndex] = interop.Type[MessageIndex]("Message index", MessageIndex.close, closeable = true)
## The messages of folder identity `identity` in `store`; empty when it has none yet.
pub func read_index(store: interop.Reference[prism.Store], identity: str) -> interop.Reference[MessageIndex]!:
let native = try new MessageIndex(rows = try mail_db.read_rows(try store.get(), identity)) in memory.heap
errdefer free(native) in memory.heap
try native.sort()
native.threads = try thread(&native.rows.rows)
return try interop.Reference[MessageIndex].adopt(native, message_index_type)
## Message `uid` of folder identity `identity`, parsed; none when its body is not in
## the store yet.
pub func open_message(store: interop.Reference[prism.Store], identity: str, uid: i64) -> interop.Reference[mime.Message]?!:
if uid < 0 or uid > 0xFFFFFFFF:
return none
var raw: Buffer
defer raw.destroy()
if not try mail_db.read_raw(try store.get(), identity, (u32)uid, &raw):
return none
return try mime.parse(raw.view())
## The folders of one account, as the engine listed them.
pub struct FolderList:
var listed: mail_db.Folders
pub func count() -> i64:
return (i64)self.listed.folders.length()
func folder(at: i64) -> Folder:
if at < 0 or at >= (i64)self.listed.folders.length():
trap("no folder at that position")
return self.listed.folders.at((usize)at)
## The server's name for folder `at`, used in commands.
pub func path(at: i64) -> str:
return self.folder(at).path
## The name to show.
pub func name(at: i64) -> str:
return self.folder(at).name
## The hierarchy delimiter as a character code, zero for none.
pub func delimiter(at: i64) -> i64:
return (i64)self.folder(at).delimiter
## imap.MailboxFlags bits: 256 all, 512 archive, 1024 drafts, 2048 flagged, 4096 junk,
## 8192 sent, 16384 trash.
pub func flags(at: i64) -> i64:
return (i64)self.folder(at).flags
## How many levels down folder `at` is: the delimiters in its path.
pub func depth(at: i64) -> i64:
let folder = self.folder(at)
if folder.delimiter == 0:
return 0
var count: i64 = 0
for byte in folder.path.bytes:
if byte == folder.delimiter:
count += 1
return count
## The last part of folder `at`'s name: `2026` for `Archive/2026`.
pub func leaf(at: i64) -> str:
let folder = self.folder(at)
if folder.delimiter == 0:
return folder.name
let data = folder.name.bytes
var start: usize = 0
for index in 0..<data.length:
if data[index] == folder.delimiter:
start = index + 1
return (str)data[start..]
## The folder's directory name in the store.
pub func key(at: i64) -> str:
return self.folder(at).key
pub func total(at: i64) -> i64:
return (i64)self.folder(at).total
pub func unseen(at: i64) -> i64:
return (i64)self.folder(at).unseen
pub func close():
self.listed.close()
pub let folder_list_type: interop.Type[FolderList] = interop.Type[FolderList]("Folder list", FolderList.close, closeable = true)
## The folders of account `account` in `store`; empty when it has none yet.
pub func read_folders(store: interop.Reference[prism.Store], account: str) -> interop.Reference[FolderList]!:
let native = try new FolderList(listed = try mail_db.read_folders(try store.get(), account)) in memory.heap
return try interop.Reference[FolderList].adopt(native, folder_list_type)
## Whether a file or directory exists at `path`.
pub func exists(path: str) -> bool:
var name: Buffer
defer name.destroy()
name.put_text(path) catch failure:
return false
let file = name.terminated() catch failure:
return false
return files.exists(file)
## Whether flag word `flags` has every bit of `bit` set: Luce has no bit operations.
pub func has(flags: i64, bit: i64) -> bool:
return (flags & bit) == bit