mapf 0.3.0

Base traits and utilities for multi-agent planning
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

/*
 * Copyright (C) 2023 Open Source Robotics Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
*/

use std::{borrow::Borrow, cmp::Eq, fmt::Debug, hash::Hash};

/// The `Key` trait describes objects that can be used as Keys by Keyed domains.
///
/// The `Debug` trait is required so that key information can be put into error
/// messages.
pub trait Key: Hash + Eq + Send + Sync + Debug + 'static {}
impl<T: Hash + Eq + Send + Sync + Debug + 'static> Key for T {}

/// `Keyed` is used to indicate an associated [`Key`] type for a struct.
pub trait Keyed {
    type Key: Key;
}

impl<T: Key + Clone> Keyed for T {
    type Key = T;
}

pub trait PartialKeyed {
    type PartialKey: Key;
}

/// The `Keyring` trait is implemented by structs that can produce a key for a
/// given state.
pub trait Keyring<State>: Keyed {
    type KeyRef<'a>: Borrow<Self::Key> + 'a
    where
        Self: 'a,
        State: 'a;

    fn key_for<'a>(&'a self, state: &'a State) -> Self::KeyRef<'a>
    where
        Self: 'a,
        State: 'a;
}

/// If a State contains its own key, it can implement SelfKey so that its key
/// can be obtained without a [`Keyring`].
pub trait SelfKey: Keyed {
    type KeyRef<'a>: Borrow<Self::Key> + 'a
    where
        Self: 'a;
    fn key<'a>(&'a self) -> Self::KeyRef<'a>
    where
        Self: 'a;
}

impl<T: Key + Clone> SelfKey for T {
    type KeyRef<'a>
        = &'a Self::Key
    where
        Self: 'a;
    fn key<'a>(&'a self) -> &'a Self::Key
    where
        Self: 'a,
    {
        self
    }
}

/// Implements a [`Keyring`] for states that implement [`SelfKey`].
pub struct SelfKeyring<K>(std::marker::PhantomData<K>);

impl<K> SelfKeyring<K> {
    pub fn new() -> Self {
        Self(Default::default())
    }
}

impl<K> Default for SelfKeyring<K> {
    fn default() -> Self {
        Self::new()
    }
}

impl<K: Key> Keyed for SelfKeyring<K> {
    type Key = K;
}

impl<State: SelfKey> Keyring<State> for SelfKeyring<State::Key> {
    type KeyRef<'a>
        = State::KeyRef<'a>
    where
        State: 'a;
    fn key_for<'a>(&'a self, state: &'a State) -> State::KeyRef<'a>
    where
        State: 'a,
    {
        state.key()
    }
}

pub struct SelfPartialKeyring<K>(std::marker::PhantomData<K>);

impl<K> SelfPartialKeyring<K> {
    pub fn new() -> Self {
        Self(Default::default())
    }
}

impl<K> Default for SelfPartialKeyring<K> {
    fn default() -> Self {
        Self::new()
    }
}

impl<K: Key> PartialKeyed for SelfPartialKeyring<K> {
    type PartialKey = K;
}

impl<K: Key> Keyed for SelfPartialKeyring<K> {
    type Key = Option<K>;
}

impl<K: Key, State: SelfKey<Key = Option<K>>> Keyring<State> for SelfPartialKeyring<K> {
    type KeyRef<'a>
        = State::KeyRef<'a>
    where
        Self: 'a,
        State: 'a,
        K: 'a;

    fn key_for<'a>(&'a self, state: &'a State) -> State::KeyRef<'a>
    where
        Self: 'a,
        State: 'a,
        K: 'a,
    {
        state.key()
    }
}