Zenoh keys#

use pamoja_zenoh::keyexpr::{canonize, is_canon, is_valid, join, matches};

// A key expression names a set of keys. Chunks sit between slashes, `*` stands for
// exactly one chunk, whatever it holds, and `**` for any number of them, including none.
let selects = |pattern: &str, key: &str| {
    let verdict = if matches(pattern, key) {
        "covers"
    } else {
        "misses"
    };
    format!("{verdict:<10}{pattern} {verdict} {key}")
};
println!("{}", selects("farm/*/power", "farm/t7/power"));
println!("{}", selects("farm/*/power", "farm/substation/power"));
println!(
    "{}, since * is exactly one chunk",
    selects("farm/*/power", "farm/row2/t14/power")
);
println!("{}", selects("farm/**/power", "farm/row2/t14/power"));
println!(
    "{}, where ** is no chunk at all",
    selects("farm/**/alarm", "farm/alarm")
);

// `$*` stands for any run of characters inside one chunk, so it selects on part of a name.
println!("{}", selects("farm/t$*/power", "farm/t7/power"));
println!("{}", selects("farm/t$*/power", "farm/substation/power"));

// One set of keys has one canonical spelling, and a Zenoh session accepts no other.
for written in ["farm/*/**/power", "farm/**/*/power", "farm/**/**/power"] {
    let canonical = canonize(written).expect("a valid expression");
    if is_canon(written) {
        println!("canonical {written}, as written");
    } else {
        println!("rewritten {written} is spelled {canonical}");
    }
}

// Joining places one expression beneath another, and canonizes the seam between them.
for (prefix, suffix) in [("farm/t7", "power"), ("farm/**", "*/power")] {
    let joined = join(prefix, suffix).expect("two valid halves");
    println!("joined    {prefix} and {suffix} make {joined}");
}

// A malformed expression is refused rather than repaired into something plausible.
for (written, why) in [
    ("farm//power", "a chunk is empty"),
    ("farm/t7*/power", "* stands alone in its chunk, or after $"),
    ("farm/t7/power?", "? and # are reserved"),
] {
    if !is_valid(written) && canonize(written).is_none() {
        println!("malformed {written}, since {why}");
    }
}

use pamoja_zenoh::keyexpr::{includes, intersects};

// Two expressions intersect when some key belongs to both. That is the question a router
// asks before it forwards a publication on one to a subscriber on the other.
let overlap = |a: &str, b: &str| {
    if intersects(a, b) {
        format!("overlap   {a} and {b} share a key")
    } else {
        format!("disjoint  {a} and {b} share no key")
    }
};
println!("{}", overlap("farm/*/power", "farm/t7/**"));
println!("{}", overlap("farm/*/power", "farm/*/alarm"));

// One includes the other when every key of the second belongs to the first, so a bridge
// that already holds the wider subscription declares nothing new for the narrower one.
let covers = |a: &str, b: &str| {
    if includes(a, b) {
        format!("included  {a} covers every key of {b}")
    } else {
        format!("wider     {b} holds keys {a} does not")
    }
};
println!("{}", covers("farm/**", "farm/*/power"));
println!("{}", covers("farm/*/power", "farm/**"));

// Two spellings of one set include each other, which compares expressions nobody
// canonized.
let (one, other) = ("farm/**/*/power", "farm/*/**/power");
if one != other && includes(one, other) && includes(other, one) {
    println!("same      {one} and {other} select the same keys");
}

// A chunk that starts with @ is verbatim: no wildcard selects it, and only the same chunk
// matches it. A second payload version under @v2 stays out of every subscription that
// does not name it, the way Zenoh keeps its own administration space out of **.
let current = "farm/@v2/t7/power";
println!(
    "{}, since no wildcard selects a chunk that starts with @",
    selects("farm/**", current)
);
println!("{}", selects("farm/@v2/**", current));
println!(
    "{}, so a reader of one version never sees the other",
    overlap("farm/@v1/**", "farm/@v2/**")
);

import { keyexpr } from '@pamoja/zenoh'

// A key expression names a set of keys. Chunks sit between slashes, `*` stands for exactly one
// chunk, whatever it holds, and `**` for any number of them, including none.
const selects = (pattern: string, key: string): string => {
  const verdict = keyexpr.matches(pattern, key) ? 'covers' : 'misses'
  return `${verdict.padEnd(10)}${pattern} ${verdict} ${key}`
}
console.log(selects('farm/*/power', 'farm/t7/power'))
console.log(selects('farm/*/power', 'farm/substation/power'))
console.log(`${selects('farm/*/power', 'farm/row2/t14/power')}, since * is exactly one chunk`)
console.log(selects('farm/**/power', 'farm/row2/t14/power'))
console.log(`${selects('farm/**/alarm', 'farm/alarm')}, where ** is no chunk at all`)

// `$*` stands for any run of characters inside one chunk, so it selects on part of a name.
console.log(selects('farm/t$*/power', 'farm/t7/power'))
console.log(selects('farm/t$*/power', 'farm/substation/power'))

// One set of keys has one canonical spelling, and a Zenoh session accepts no other.
for (const written of ['farm/*/**/power', 'farm/**/*/power', 'farm/**/**/power']) {
  const canonical = keyexpr.canonize(written)
  if (keyexpr.isCanon(written)) {
    console.log(`canonical ${written}, as written`)
  } else {
    console.log(`rewritten ${written} is spelled ${canonical}`)
  }
}

// Joining places one expression beneath another, and canonizes the seam between them.
for (const [prefix, suffix] of [
  ['farm/t7', 'power'],
  ['farm/**', '*/power'],
]) {
  console.log(`joined    ${prefix} and ${suffix} make ${keyexpr.join(prefix, suffix)}`)
}

// A malformed expression is refused rather than repaired into something plausible.
for (const [written, why] of [
  ['farm//power', 'a chunk is empty'],
  ['farm/t7*/power', '* stands alone in its chunk, or after $'],
  ['farm/t7/power?', '? and # are reserved'],
]) {
  if (!keyexpr.isValid(written) && keyexpr.canonize(written) === null) {
    console.log(`malformed ${written}, since ${why}`)
  }
}

// Two expressions intersect when some key belongs to both. That is the question a router asks
// before it forwards a publication on one to a subscriber on the other.
const overlap = (a: string, b: string): string =>
  keyexpr.intersects(a, b)
    ? `overlap   ${a} and ${b} share a key`
    : `disjoint  ${a} and ${b} share no key`
console.log(overlap('farm/*/power', 'farm/t7/**'))
console.log(overlap('farm/*/power', 'farm/*/alarm'))

// One includes the other when every key of the second belongs to the first, so a bridge that
// already holds the wider subscription declares nothing new for the narrower one.
const covers = (a: string, b: string): string =>
  keyexpr.includes(a, b)
    ? `included  ${a} covers every key of ${b}`
    : `wider     ${b} holds keys ${a} does not`
console.log(covers('farm/**', 'farm/*/power'))
console.log(covers('farm/*/power', 'farm/**'))

// Two spellings of one set include each other, which compares expressions nobody canonized.
const [one, other] = ['farm/**/*/power', 'farm/*/**/power']
if (one !== other && keyexpr.includes(one, other) && keyexpr.includes(other, one)) {
  console.log(`same      ${one} and ${other} select the same keys`)
}

// A chunk that starts with @ is verbatim: no wildcard selects it, and only the same chunk
// matches it. A second payload version under @v2 stays out of every subscription that does not
// name it, the way Zenoh keeps its own administration space out of **.
const current = 'farm/@v2/t7/power'
console.log(
  `${selects('farm/**', current)}, since no wildcard selects a chunk that starts with @`,
)
console.log(selects('farm/@v2/**', current))
console.log(
  `${overlap('farm/@v1/**', 'farm/@v2/**')}, so a reader of one version never sees the other`,
)

from pamoja.zenoh import canonize, is_canon, is_valid, join, matches


# A key expression names a set of keys. Chunks sit between slashes, `*` stands for exactly one
# chunk, whatever it holds, and `**` for any number of them, including none.
def selects(pattern: str, key: str) -> str:
    verdict = "covers" if matches(pattern, key) else "misses"
    return f"{verdict:<10}{pattern} {verdict} {key}"


print(selects("farm/*/power", "farm/t7/power"))
print(selects("farm/*/power", "farm/substation/power"))
print(f"{selects('farm/*/power', 'farm/row2/t14/power')}, since * is exactly one chunk")
print(selects("farm/**/power", "farm/row2/t14/power"))
print(f"{selects('farm/**/alarm', 'farm/alarm')}, where ** is no chunk at all")

# `$*` stands for any run of characters inside one chunk, so it selects on part of a name.
print(selects("farm/t$*/power", "farm/t7/power"))
print(selects("farm/t$*/power", "farm/substation/power"))

# One set of keys has one canonical spelling, and a Zenoh session accepts no other.
for written in ("farm/*/**/power", "farm/**/*/power", "farm/**/**/power"):
    canonical = canonize(written)
    if is_canon(written):
        print(f"canonical {written}, as written")
    else:
        print(f"rewritten {written} is spelled {canonical}")

# Joining places one expression beneath another, and canonizes the seam between them.
for prefix, suffix in (("farm/t7", "power"), ("farm/**", "*/power")):
    print(f"joined    {prefix} and {suffix} make {join(prefix, suffix)}")

# A malformed expression is refused rather than repaired into something plausible.
for written, why in (
    ("farm//power", "a chunk is empty"),
    ("farm/t7*/power", "* stands alone in its chunk, or after $"),
    ("farm/t7/power?", "? and # are reserved"),
):
    if not is_valid(written) and canonize(written) is None:
        print(f"malformed {written}, since {why}")

from pamoja.zenoh import includes, intersects


# Two expressions intersect when some key belongs to both. That is the question a router asks
# before it forwards a publication on one to a subscriber on the other.
def overlap(a: str, b: str) -> str:
    if intersects(a, b):
        return f"overlap   {a} and {b} share a key"
    return f"disjoint  {a} and {b} share no key"


print(overlap("farm/*/power", "farm/t7/**"))
print(overlap("farm/*/power", "farm/*/alarm"))


# One includes the other when every key of the second belongs to the first, so a bridge that
# already holds the wider subscription declares nothing new for the narrower one.
def covers(a: str, b: str) -> str:
    if includes(a, b):
        return f"included  {a} covers every key of {b}"
    return f"wider     {b} holds keys {a} does not"


print(covers("farm/**", "farm/*/power"))
print(covers("farm/*/power", "farm/**"))

# Two spellings of one set include each other, which compares expressions nobody canonized.
one, other = "farm/**/*/power", "farm/*/**/power"
if one != other and includes(one, other) and includes(other, one):
    print(f"same      {one} and {other} select the same keys")

# A chunk that starts with @ is verbatim: no wildcard selects it, and only the same chunk
# matches it. A second payload version under @v2 stays out of every subscription that does not
# name it, the way Zenoh keeps its own administration space out of **.
current = "farm/@v2/t7/power"
print(f"{selects('farm/**', current)}, since no wildcard selects a chunk that starts with @")
print(selects("farm/@v2/**", current))
print(f"{overlap('farm/@v1/**', 'farm/@v2/**')}, so a reader of one version never sees the other")

// A key expression names a set of keys. Chunks sit between slashes, `*` stands for
// exactly one chunk, whatever it holds, and `**` for any number of them, including none.
static string Selects(string pattern, string key)
{
    string verdict = KeyExpression.Matches(pattern, key) ? "covers" : "misses";
    return $"{verdict,-10}{pattern} {verdict} {key}";
}
Console.WriteLine(Selects("farm/*/power", "farm/t7/power"));
Console.WriteLine(Selects("farm/*/power", "farm/substation/power"));
Console.WriteLine(
    $"{Selects("farm/*/power", "farm/row2/t14/power")}, since * is exactly one chunk");
Console.WriteLine(Selects("farm/**/power", "farm/row2/t14/power"));
Console.WriteLine(
    $"{Selects("farm/**/alarm", "farm/alarm")}, where ** is no chunk at all");

// `$*` stands for any run of characters inside one chunk, so it selects on part of a
// name.
Console.WriteLine(Selects("farm/t$*/power", "farm/t7/power"));
Console.WriteLine(Selects("farm/t$*/power", "farm/substation/power"));

// One set of keys has one canonical spelling, and a Zenoh session accepts no other.
foreach (string written in new[] { "farm/*/**/power", "farm/**/*/power", "farm/**/**/power" })
{
    string? canonical = KeyExpression.Canonize(written);
    if (KeyExpression.IsCanon(written))
    {
        Console.WriteLine($"canonical {written}, as written");
    }
    else
    {
        Console.WriteLine($"rewritten {written} is spelled {canonical}");
    }
}

// Joining places one expression beneath another, and canonizes the seam between them.
foreach ((string prefix, string suffix) in new[] { ("farm/t7", "power"), ("farm/**", "*/power") })
{
    Console.WriteLine(
        $"joined    {prefix} and {suffix} make {KeyExpression.Join(prefix, suffix)}");
}

// A malformed expression is refused rather than repaired into something plausible.
foreach ((string written, string why) in new[]
{
    ("farm//power", "a chunk is empty"),
    ("farm/t7*/power", "* stands alone in its chunk, or after $"),
    ("farm/t7/power?", "? and # are reserved"),
})
{
    if (!KeyExpression.IsValid(written) && KeyExpression.Canonize(written) is null)
    {
        Console.WriteLine($"malformed {written}, since {why}");
    }
}

// Two expressions intersect when some key belongs to both. That is the question a
// router asks before it forwards a publication on one to a subscriber on the other.
static string Overlap(string a, string b) =>
    KeyExpression.Intersects(a, b)
        ? $"overlap   {a} and {b} share a key"
        : $"disjoint  {a} and {b} share no key";
Console.WriteLine(Overlap("farm/*/power", "farm/t7/**"));
Console.WriteLine(Overlap("farm/*/power", "farm/*/alarm"));

// One includes the other when every key of the second belongs to the first, so a
// bridge that already holds the wider subscription declares nothing new for the
// narrower one.
static string Covers(string a, string b) =>
    KeyExpression.Includes(a, b)
        ? $"included  {a} covers every key of {b}"
        : $"wider     {b} holds keys {a} does not";
Console.WriteLine(Covers("farm/**", "farm/*/power"));
Console.WriteLine(Covers("farm/*/power", "farm/**"));

// Two spellings of one set include each other, which compares expressions nobody
// canonized.
(string one, string other) = ("farm/**/*/power", "farm/*/**/power");
if (one != other && KeyExpression.Includes(one, other) && KeyExpression.Includes(other, one))
{
    Console.WriteLine($"same      {one} and {other} select the same keys");
}

// A chunk that starts with @ is verbatim: no wildcard selects it, and only the same
// chunk matches it. A second payload version under @v2 stays out of every
// subscription that does not name it, the way Zenoh keeps its own administration
// space out of **.
const string Current = "farm/@v2/t7/power";
Console.WriteLine(
    $"{Selects("farm/**", Current)}, since no wildcard selects a chunk that starts with @");
Console.WriteLine(Selects("farm/@v2/**", Current));
Console.WriteLine(
    $"{Overlap("farm/@v1/**", "farm/@v2/**")}, so a reader of one version never sees the other");