Compare commits

...

2 commits

12 changed files with 337 additions and 163 deletions
examples
tty-04-posint/src
tty-05-dictionary/src
lib-nested-core/src
lib-nested-tty/src/editors

View file

@ -49,20 +49,18 @@ async fn main() {
*/
let int_builder = ReprTreeBuilder::new( ctx.clone() )
.require(Context::parse(&ctx,
" ~ <PosInt 16 BigEndian> ~ <Seq~List <Digit 16>~Char> ~ EditTree"))
" ~ <PosInt 16 BigEndian> ~ EditTree"))
.require(Context::parse(&ctx,
" ~ <PosInt 10 BigEndian> ~ <Seq~List <Digit 10>~Char> ~ EditTree"))
/*
" ~ <PosInt 10 BigEndian> ~ EditTree"))
.require(Context::parse(&ctx,
" ~ <PosInt 8 BigEndian> ~ EditTree"))
.require(Context::parse(&ctx,
" ~ <PosInt 2 BigEndian> ~ EditTree"))
*/
;
let mut rt_int = nested::repr_tree::ReprTree::from_str("f");
let mut rt_int = nested::repr_tree::ReprTree::from_str("3");
rt_int.write().unwrap().set_halo(
/* HALO TYPE */
/* HALO TYPE (append to top of type ladder) */
Context::parse(&ctx, "
~ <PosInt 16 BigEndian>
@ -78,7 +76,11 @@ async fn main() {
/* list of editors
*/
let mut list_editor = nested::editors::list::ListEditor::new(ctx.clone(), Context::parse(&ctx, "<Seq Char>"));
let mut list_editor = nested::editors::list::ListEditor::new(
ctx.clone(),
Context::parse(&ctx, "EditTree"),
ReprTreeBuilder::new(ctx.clone())
);
// add all desired editors to the list
for edit_leaf in int_builder.required_leaves.iter() {
@ -97,7 +99,7 @@ async fn main() {
leaf_rt.edittree(&ctx).get_mut().goto(TreeCursor::none());
}
let first_idx : usize = 1;
let first_idx : usize = 0;
int_builder.update( &rt_int, int_builder.required_leaves[first_idx].clone() );
edittree.goto(TreeCursor{
@ -124,9 +126,7 @@ async fn main() {
let ci = cur.tree_addr[0];
if *li != ci as usize {
eprintln!("--------\nCHANGE MASTER EDITOR\n--------------------");
int_builder.update( &rt_int, int_builder.required_leaves[ci as usize].clone() );
eprintln!("-----\nDone\n----");
*li = ci as usize;
}
}

View file

@ -166,18 +166,23 @@ async fn main() {
"));
let symbol_builder = ReprTreeBuilder::new( ctx.clone() )
//.require(Context::parse(&ctx, "Instruction ~ Opcode ~ ~ <PosInt 10 BigEndian> ~ EditTree"))
.require(Context::parse(&ctx, "Instruction ~ Mnemonic ~ <Seq~List Char> ~ EditTree"))
.require(Context::parse(&ctx, "Instruction ~ Opcode ~ ~ <PosInt 10 BigEndian> ~ EditTree"))
.require(Context::parse(&ctx, "Instruction ~ Opcode ~ ~ <PosInt 16 BigEndian> ~ EditTree"))
;
symbol_rt = symbol_builder.build_from(symbol_rt).expect("failed to build symbol repr-tree");
let mut list_editor = nested::editors::list::ListEditor::new(ctx.clone(), Context::parse(&ctx, "<Seq Char>"));
let mut list_editor = nested::editors::list::ListEditor::new(
ctx.clone(),
Context::parse(&ctx, "<Seq Char>"),
ReprTreeBuilder::new(ctx.clone()),
);
// add all desired editors to the list
for edit_leaf in symbol_builder.required_leaves {
for edit_leaf in symbol_builder.required_leaves.iter() {
let leaf_rt = symbol_rt.descend(edit_leaf.clone()).unwrap();
list_editor.data.push(leaf_rt);
list_editor.insert(leaf_rt);
}
let mut edittree = list_editor.into_node(SingletonBuffer::new(0).get_port());
@ -195,17 +200,17 @@ async fn main() {
/* event handler
*/
let ctx = ctx.clone();
let symbol_rt = symbol_rt.clone();
let last_idx = RwLock::new(0);
let symbol_rt = symbol_rt.clone(); //let symbol_builder = symbol_builder.clone();
let last_idx = RwLock::new(99999);
move |ev| {
let cur = edittree.read().unwrap().get_cursor();
if cur.tree_addr.len() > 0 {
let mut li = last_idx.write().unwrap();
let ci = cur.tree_addr[0];
if *li != ci {
// symbol_builder.update()
*li = ci;
if *li != ci as usize {
symbol_builder.update( &symbol_rt, symbol_builder.required_leaves[ci as usize].clone() );
*li = ci as usize;
}
}
@ -232,7 +237,7 @@ async fn main() {
) {
let rt_edittree = rt.descend(Context::parse(&ctx, "EditTree")).expect("descend");
let halo_type = rt_edittree.read().unwrap().get_halo_type().clone();
let edittree = rt_edittree.read().unwrap().get_view::<dyn r3vi::view::singleton::SingletonView<Item = Arc<RwLock<EditTree>>>>().unwrap().get().read().unwrap().clone();
let edittree = rt_edittree.edittree(&ctx).get();
comp.push( nested_tty::make_label( &ctx.read().unwrap().type_term_to_str(&halo_type) )
.map_item(|_pt, atom| atom.add_style_front(TerminalStyle::fg_color((90,90,90))))
@ -246,8 +251,8 @@ async fn main() {
}
show_edit_tree( &ctx, &mut comp, &symbol_rt.descend(Context::parse(&ctx, "Instruction ~ Mnemonic ~ <Seq~List Char>")).unwrap(), 1 );
//show_edit_tree( &ctx, &mut comp, &symbol_rt.descend(Context::parse(&ctx, "Instruction ~ Opcode ~ ~ <PosInt 10 BigEndian>")).unwrap(), 3 );
//show_edit_tree( &ctx, &mut comp, &symbol_rt.descend(Context::parse(&ctx, "Instruction ~ Opcode ~ ~ <PosInt 16 BigEndian>")).unwrap(), 5 );
show_edit_tree( &ctx, &mut comp, &symbol_rt.descend(Context::parse(&ctx, "Instruction ~ Opcode ~ ~ <PosInt 10 BigEndian>")).unwrap(), 3 );
show_edit_tree( &ctx, &mut comp, &symbol_rt.descend(Context::parse(&ctx, "Instruction ~ Opcode ~ ~ <PosInt 16 BigEndian>")).unwrap(), 5 );
}
/* write the changes in the view of `term_port` to the terminal

View file

@ -33,7 +33,6 @@ pub fn init_ctx( ctx: Arc<RwLock<Context>> ) {
if let Some(buf) = b {
// buffer already exists
} else {
eprintln!("create char buffer");
// create char buffer
rt.write().unwrap().insert_leaf(
vec![].into_iter(),
@ -73,7 +72,6 @@ pub fn init_ctx( ctx: Arc<RwLock<Context>> ) {
.singleton_buffer::<EditTree>();
if rt.write().unwrap().singleton_buffer::<char>().is_none() {
eprintln!("insert singleton buffer");
rt.insert_leaf(
Context::parse(&ctx, "Char"),
ReprLeaf::from_singleton_buffer(

View file

@ -31,31 +31,68 @@ pub fn init_ctx( ctx: Arc<RwLock<Context>> ) {
_ => 0
};
let char_buf = SingletonBuffer::<char>::new('?');
let char_rt = src_rt.descend_create(Context::parse(&ctx, "Char")).unwrap();
let char_buf = {
let mut b = char_rt.write().unwrap().singleton_buffer::<char>();
if let Some(buf) = b {
// buffer already exists
eprintln!("take existing char buffer");
buf
} else {
// create char buffer
eprintln!("create char buffer");
let char_buf = SingletonBuffer::<char>::new('?');
src_rt.insert_leaf(
Context::parse(&ctx, "Char"),
ReprLeaf::from_singleton_buffer(char_buf.clone())
);
char_buf
}
};
/* Create EditTree object
*/
let mut edittree = DigitEditor::new(
ctx.clone(),
radix,
char_buf
).into_node(
r3vi::buffer::singleton::SingletonBuffer::<usize>::new(0).get_port()
);
src_rt.write().unwrap()
.insert_branch(
ReprTree::from_singleton_buffer(
Context::parse(&ctx, "EditTree"),
SingletonBuffer::new(edittree)
)
//if src_rt.descend(Context::parse(&ctx, "EditTree")).is_none() {
eprintln!("create Digit-Editor");
let mut edittree = DigitEditor::new(
ctx.clone(),
radix,
char_buf
).into_node(
r3vi::buffer::singleton::SingletonBuffer::<usize>::new(0).get_port()
);
ctx.read().unwrap().setup_edittree( src_rt );
src_rt.write().unwrap()
.insert_branch(
ReprTree::from_singleton_buffer(
Context::parse(&ctx, "EditTree"),
SingletonBuffer::new(edittree)
)
);
ctx.read().unwrap().setup_edittree( src_rt );
//}
}
}
);
/*
let digit_morph_char_to_digit = GenericReprTreeMorphism::new(
Context::parse(&ctx, "Char"),
Context::parse(&ctx, "<Digit Radix>~Char"),
{
let ctx = ctx.clone();
move |src_rt, σ| {
src_rt.write().unwrap().set_halo(
Context::parse(&ctx, "<Digit Radix>")
.apply_substitution(&|k|σ.get(k).cloned())
.clone()
);
}
}
);
*/
let digit_morph_char_to_edittree = GenericReprTreeMorphism::new(
Context::parse(&ctx, "<Digit Radix>~Char"),
Context::parse(&ctx, "<Digit Radix>~EditTree"),
@ -85,6 +122,7 @@ pub fn init_ctx( ctx: Arc<RwLock<Context>> ) {
.insert_branch(
ReprTree::from_singleton_buffer(
Context::parse(&ctx, "EditTree"),
SingletonBuffer::new(edittree)
)
);
@ -101,18 +139,20 @@ pub fn init_ctx( ctx: Arc<RwLock<Context>> ) {
{
let ctx = ctx.clone();
move |src_rt, σ| {
let edittree = src_rt.edittree( &ctx );
let port =
edittree
.get()
.get_edit::<DigitEditor>().unwrap()
.read().unwrap()
.get_char_port();
src_rt.insert_leaf(
src_rt.attach_leaf_to(
Context::parse(&ctx, "Char"),
ReprLeaf::from_view( port )
)
src_rt.edittree(&ctx)
.get_port()
.map(
|edit| {
edit.get_edit::<DigitEditor>().unwrap()
.read().unwrap()
.get_char_port()
.get_view().get()
}
)
);
}
}
);

View file

@ -218,33 +218,37 @@ pub fn init_ctx(ctx: Arc<RwLock<Context>>) {
{
let ctx = ctx.clone();
move |src_rt, σ| {
let mut list_edittree = src_rt.descend(
Context::parse(&ctx, " ~ <PosInt Radix BigEndian> ~ <Seq~List <Digit Radix>>")
if src_rt.descend(
Context::parse(&ctx, " ~ <PosInt Radix BigEndian> ~ EditTree")
.apply_substitution(&|x| σ.get(x).cloned()).clone()
)
.unwrap()
.edittree( &ctx )
.get();
// clear display
list_edittree.disp.view = ReprTree::new_arc(Context::parse(&ctx, "Display"));
/*
src_rt.insert_leaf(
Context::parse(&ctx, "<PosInt Radix BigEndian> ~ EditTree")
.apply_substitution(&|x| σ.get(x).cloned()).clone(),
ReprLeaf::from_singleton_buffer(
SingletonBuffer::new(
list_edittree
)
)
);
*/
ctx.read().unwrap().setup_edittree(
&src_rt.descend(
Context::parse(&ctx, "<PosInt Radix BigEndian>")
).is_none() {
let mut list_edittree = src_rt.descend(
Context::parse(&ctx, " ~ <PosInt Radix BigEndian> ~ <Seq~List <Digit Radix>>")
.apply_substitution(&|x| σ.get(x).cloned()).clone()
).unwrap()
);
)
.unwrap()
.edittree( &ctx )
.get().clone();
// clear display
list_edittree.disp.view = ReprTree::new_arc(Context::parse(&ctx, "Display"));
src_rt.insert_leaf(
Context::parse(&ctx, "<PosInt Radix BigEndian> ~ EditTree")
.apply_substitution(&|x| σ.get(x).cloned()).clone(),
ReprLeaf::from_singleton_buffer(
SingletonBuffer::new(
list_edittree
)
)
);
ctx.read().unwrap().setup_edittree(
&src_rt.descend(
Context::parse(&ctx, "<PosInt Radix BigEndian>")
.apply_substitution(&|x| σ.get(x).cloned()).clone()
).unwrap()
);
}
}
}
);
@ -255,31 +259,35 @@ pub fn init_ctx(ctx: Arc<RwLock<Context>>) {
{
let ctx = ctx.clone();
move |src_rt, σ| {
let mut list_edittree = src_rt.descend(
Context::parse(&ctx, " ~ <PosInt Radix BigEndian>")
.apply_substitution(&|x| σ.get(x).cloned()).clone())
.unwrap()
.edittree( &ctx )
.get_mut();
if src_rt.descend(
Context::parse(&ctx, " ~ <PosInt Radix BigEndian> ~<Seq~List <Digit Radix>> ~ EditTree")
.apply_substitution(&|x| σ.get(x).cloned()).clone()
).is_none() {
let mut list_edittree = src_rt.descend(
Context::parse(&ctx, " ~ <PosInt Radix BigEndian> ~ EditTree")
.apply_substitution(&|x| σ.get(x).cloned()).clone())
.unwrap()
.edittree( &ctx )
.get().clone();
// clear display
list_edittree.disp.view = ReprTree::new_arc(Context::parse(&ctx, "Display"));
/*
src_rt.insert_leaf(
Context::parse(&ctx, "<PosInt Radix BigEndian> ~ <Seq~List <Digit Radix>>~EditTree")
.apply_substitution(&|x| σ.get(x).cloned()).clone(),
ReprLeaf::from_singleton_buffer(
SingletonBuffer::new(list_edittree)
)
);
*/
// clear display
list_edittree.disp.view = ReprTree::new_arc(Context::parse(&ctx, "Display"));
ctx.read().unwrap().setup_edittree(
&src_rt.descend(
Context::parse(&ctx, "<PosInt Radix BigEndian> ~ <Seq~List <Digit Radix>>")
.apply_substitution(&|x| σ.get(x).cloned()).clone()
).unwrap()
);
src_rt.insert_leaf(
Context::parse(&ctx, "<PosInt Radix BigEndian> ~ <Seq~List <Digit Radix>>~EditTree")
.apply_substitution(&|x| σ.get(x).cloned()).clone(),
ReprLeaf::from_singleton_buffer(
SingletonBuffer::new(list_edittree)
)
);
ctx.read().unwrap().setup_edittree(
&src_rt.descend(
Context::parse(&ctx, "<PosInt Radix BigEndian> ~ <Seq~List <Digit Radix>>")
.apply_substitution(&|x| σ.get(x).cloned()).clone()
).unwrap()
);
}
}
}
);

View file

@ -5,7 +5,7 @@ pub mod ctx;
pub use {
add::Add,
editor::PosIntEditor,
//editor::PosIntEditor,
radix::RadixProjection,
ctx::init_ctx
};
@ -41,7 +41,7 @@ pub trait PositionalUInt : SequenceView<Item = u64> {
}
}
val
val
}
}
@ -146,5 +146,3 @@ impl Observer<dyn PositionalUInt> for PosUIntToDigits {
self.cast.notify(idx);
}
}

View file

@ -3,7 +3,7 @@ use {
edit_tree::EditTree, editors::{
char::CharEditor,
list::ListEditor
}, repr_tree::{context::TYPEID_char, Context, GenericReprTreeMorphism, ReprLeaf, ReprTree, ReprTreeArc, ReprTreeExt}
}, repr_tree::{context::TYPEID_char, Context, GenericReprTreeMorphism, ReprLeaf, ReprTree, ReprTreeArc, ReprTreeBuilder, ReprTreeExt}
}, laddertypes::TypeTerm, r3vi::{
buffer::{singleton::*, vec::*}, view::{
list::*, port::UpdateTask, singleton::*, Observer, OuterViewPort, ViewPort
@ -166,7 +166,34 @@ pub fn init_ctx__unpack_reprtree( ctx: &Arc<RwLock<Context>> ) {
}
);
/*
* note: this requires ReprTree to contain Char repr.
* todo: how to formally require and enforce this?
*/
let list_morph_rt_to_digit_char = GenericReprTreeMorphism::new(
Context::parse(&ctx, "<List <Digit Radix>> ~ <List ReprTree>"),
Context::parse(&ctx, "<List <Digit Radix>> ~ <List Char>"),
{
let ctx = ctx.clone();
move |src_rt, σ| {
src_rt.attach_leaf_to(
Context::parse(&ctx, "<List Char>"),
src_rt.descend(Context::parse(&ctx, "<List ReprTree>")).expect("cant descend")
.view_list::<ReprTreeArc>()
.map({ let ctx = ctx.clone();
move |rt| {
rt.descend(Context::parse(&ctx, "Char")).expect("cant descend to char")
.view_singleton::<char>()
.get_view()
.get()
}})
);
}
}
);
ctx.write().unwrap().morphisms.add_morphism( list_morph_rt_to_char );
ctx.write().unwrap().morphisms.add_morphism( list_morph_rt_to_digit_char );
}
pub fn init_ctx__pack_reprtree( ctx: &Arc<RwLock<Context>> ) {
@ -177,7 +204,7 @@ pub fn init_ctx__pack_reprtree( ctx: &Arc<RwLock<Context>> ) {
let ctx = ctx.clone();
move |src_rt, σ| {
src_rt.attach_leaf_to(
Context::parse(&ctx, "<List Char>~<List ReprTree>"),
Context::parse(&ctx, "<List Char> ~ <List ReprTree>"),
src_rt.view_list::<char>()
.map(|c| {
ReprTree::from_singleton_buffer(
@ -189,7 +216,45 @@ pub fn init_ctx__pack_reprtree( ctx: &Arc<RwLock<Context>> ) {
}
}
);
let list_morph_digit_rt_from_char_rt = GenericReprTreeMorphism::new(
Context::parse(&ctx, "<List <Digit Radix>> ~ <List Char> ~ <List ReprTree>"),
Context::parse(&ctx, "<List <Digit Radix>> ~ <List ReprTree>"),
{
let ctx = ctx.clone();
move |src_rt, σ| {
let ty_digit = Context::parse(&ctx, "<Digit Radix>")
.apply_substitution(&|k|σ.get(k).cloned())
.clone();
let ty_digit_as_char = Context::parse(&ctx, "<Digit Radix> ~ Char")
.apply_substitution(&|k|σ.get(k).cloned())
.clone();
// list item builder
let item_builder = ReprTreeBuilder::new(ctx.clone())
.require(ty_digit_as_char.clone())
;
src_rt.attach_leaf_to(
Context::parse(&ctx, "<List ReprTree>"),
src_rt.descend(Context::parse(&ctx, "<List Char~ReprTree>")).expect("cant descend to <List Char~ReprTree>")
.view_list::<ReprTreeArc>()
.map({ let ctx = ctx.clone();
let σ = σ.clone();
move |rt| {
rt.write().unwrap().set_halo(ty_digit.clone());
let new_rt = item_builder.build_from(rt.clone()).expect("cant build item repr tree");
eprintln!("morph <List <Digit 16>~Char> to <List ReprTree> :: new_rt = \n{}\n", new_rt.read().unwrap().fmt(&ctx, 0));
new_rt
}
})
);
}
}
);
ctx.write().unwrap().morphisms.add_morphism( list_morph_rt_from_char );
ctx.write().unwrap().morphisms.add_morphism( list_morph_digit_rt_from_char_rt );
}
pub fn init_ctx(ctx: Arc<RwLock<Context>>) {
@ -221,8 +286,26 @@ pub fn init_ctx(ctx: Arc<RwLock<Context>>) {
list_editor.data = item_vec_buffer;
list_editor.update_item_reprtrees(&item_type);
} else {
let mut list_editor = ListEditor::with_data(ctx.clone(), item_type.clone(), item_vec_buffer);
list_editor.update_item_reprtrees(&item_type);
let mut item_builder = ReprTreeBuilder::new(ctx.clone());
let mut item_type = item_type.clone();
/*
if item_type == &Context::parse(&ctx, "Char") {
item_builder = item_builder.require(
Context::parse(&ctx, "Char")
);
}
if item_type == &Context::parse(&ctx, "<Digit 16>") {
item_builder = item_builder.require(
Context::parse(&ctx, "<Digit 16>~Char")
);
}
if item_type == &Context::parse(&ctx, "<Digit 10>") {
item_builder = item_builder.require(
Context::parse(&ctx, "<Digit 10>~Char")
);
}
*/
let mut list_editor = ListEditor::with_data(ctx.clone(), item_type, item_builder, item_vec_buffer);
let mut edittree_list = list_editor.into_node(
SingletonBuffer::<usize>::new(0).get_port()
);

View file

@ -34,11 +34,13 @@ pub struct ListEditor {
impl ListEditor {
pub fn new(
ctx: Arc<RwLock<Context>>,
typ: TypeTerm
typ: TypeTerm,
item_builder: ReprTreeBuilder
) -> Self {
Self::with_data(
ctx,
typ,
item_builder,
VecBuffer::new()
)
}
@ -46,9 +48,11 @@ impl ListEditor {
pub fn with_data(
ctx: Arc<RwLock<Context>>,
typ: TypeTerm,
item_builder: ReprTreeBuilder,
data: VecBuffer< ReprTreeArc >
) -> Self {
let cursor = SingletonBuffer::new(ListCursor::default());
eprintln!("make list editor of type {}\n", ctx.read().unwrap().type_term_to_str(&typ) );
let mut le = ListEditor {
mode_port: cursor
@ -109,8 +113,8 @@ impl ListEditor {
cursor,
data,
spillbuf: Arc::new(RwLock::new(Vec::new())),
item_builder: ReprTreeBuilder::new(ctx.clone())
.require( typ.clone() )
item_builder: item_builder
//.require( typ.clone() )
.require( TypeTerm::Ladder(vec![
typ.clone(),
TypeTerm::TypeID(TYPEID_edittree)
@ -135,7 +139,8 @@ impl ListEditor {
.set_editor(editor.clone())
.set_nav(editor.clone())
.set_cmd(editor.clone())
.set_diag(e.get_edittree_seq()
.set_diag(e.get_edittree_list()
.to_sequence()
.enumerate()
.map(|(idx, item_editor)| {
let idx = *idx;
@ -197,10 +202,6 @@ impl ListEditor {
})
}
pub fn get_edittree_seq(&self) -> OuterViewPort<dyn SequenceView<Item = EditTree>> {
self.get_edittree_list().to_sequence()
}
/*
pub fn get_data(&self) -> Arc<RwLock<ReprTree>> {
let data_view = self.get_data_port();
@ -292,6 +293,7 @@ impl ListEditor {
/// insert a new element
pub fn insert(&mut self, item: ReprTreeArc) {
eprintln!("List: insert {}", item.read().unwrap().fmt(&self.ctx, 0));
self.item_builder.update( &item, self.master_repr.read().unwrap().clone() );
let mut item_edit = item.edittree(&self.ctx).get_mut();

View file

@ -9,8 +9,7 @@ pub mod ctx;
pub use {
cursor::{ListCursor, ListCursorMode},
editor::ListEditor,
segment::{ListSegment, ListSegmentSequence},
segment::{ListSegment, ListSegments},
cmd::ListCmd,
ctx::init_ctx
};

View file

@ -4,7 +4,9 @@ use {
Observer, ObserverBroadcast, ObserverExt, OuterViewPort, View, ViewPort,
singleton::*,
sequence::*,
list::*
},
buffer::vec::*,
projection::projection_helper::*
},
crate::{
@ -15,6 +17,7 @@ use {
std::sync::RwLock,
};
#[derive(Clone)]
pub enum ListSegment {
InsertCursor,
Item {
@ -25,24 +28,22 @@ pub enum ListSegment {
/* todo: switch to ListView instead of SequenceView
*/
pub struct ListSegmentSequence {
data: Arc<dyn SequenceView<Item = EditTree>>,
pub struct ListSegments {
data: Arc<dyn ListView<EditTree>>,
cursor: Arc<dyn SingletonView<Item = ListCursor>>,
cur_cursor: ListCursor,
port: ViewPort<dyn SequenceView<Item = ListSegment>>,
cast: Arc<RwLock<ObserverBroadcast<dyn SequenceView<Item = ListSegment>>>>,
port: ViewPort<dyn ListView<ListSegment>>,
cast: Arc<RwLock<ObserverBroadcast<dyn ListView<ListSegment>>>>,
proj_helper: ProjectionHelper<usize, Self>,
}
impl View for ListSegmentSequence {
type Msg = usize;
impl View for ListSegments {
type Msg = ListDiff<ListSegment>;
}
impl SequenceView for ListSegmentSequence {
type Item = ListSegment;
impl ListView<ListSegment> for ListSegments {
fn len(&self) -> Option<usize> {
let l = self.data.len()?;
match self.cur_cursor.mode {
@ -53,7 +54,7 @@ impl SequenceView for ListSegmentSequence {
}
}
fn get(&self, idx: &usize) -> Option<Self::Item> {
fn get(&self, idx: &usize) -> Option<ListSegment> {
let c = self.cursor.get();
Some(if let Some(cur) = c.idx {
match c.mode {
@ -88,41 +89,82 @@ impl SequenceView for ListSegmentSequence {
}
}
impl ListSegmentSequence {
impl ListSegments {
pub fn new(
cursor_port: OuterViewPort<dyn SingletonView<Item = ListCursor>>,
data_port: OuterViewPort<dyn SequenceView<Item = EditTree>>,
data_port: OuterViewPort<dyn ListView<EditTree>>,
) -> Arc<RwLock<Self>> {
let out_port = ViewPort::new();
let mut proj_helper = ProjectionHelper::new(out_port.update_hooks.clone());
let proj = Arc::new(RwLock::new(ListSegmentSequence {
let proj = Arc::new(RwLock::new(ListSegments {
cur_cursor: cursor_port.get_view().get(),
port: out_port.clone(),
cursor: proj_helper.new_singleton_arg(0, cursor_port, |s: &mut Self, _msg| {
let _old_cursor = s.cur_cursor;
s.cur_cursor = s.cursor.get();
let old_cursor = s.cur_cursor;
let new_cursor = s.cursor.get();
s.cur_cursor = new_cursor;
// todo: optimize
s.cast.notify_each(0..=s.data.len().unwrap_or(0) + 1);
if old_cursor.mode == ListCursorMode::Insert {
if let Some(idx) = old_cursor.idx {
s.cast.notify(&ListDiff::Remove(idx as usize));
}
}
if new_cursor.mode == ListCursorMode::Insert {
if let Some(idx) = new_cursor.idx {
s.cast.notify(&ListDiff::Insert { idx: idx as usize, val: ListSegment::InsertCursor });
}
}
}),
data: proj_helper.new_sequence_arg(1, data_port, |s: &mut Self, idx| {
data: proj_helper.new_list_arg(1, data_port, |s: &mut Self, diff| {
let mut target_idx = match diff {
ListDiff::Clear => 0,
ListDiff::Remove(idx) => *idx,
ListDiff::Insert { idx, val } => *idx,
ListDiff::Update { idx, val } => *idx
};
let mut cur_dist = 0;
if let Some(cur_idx) = s.cur_cursor.idx {
match s.cur_cursor.mode {
ListCursorMode::Insert => {
if *idx < cur_idx as usize {
s.cast.notify(idx);
} else {
s.cast.notify(&(*idx + 1));
}
}
_ => {
s.cast.notify(idx);
if s.cur_cursor.mode == ListCursorMode::Insert {
if cur_idx < target_idx as isize {
target_idx += 1;
}
}
} else {
s.cast.notify(idx);
cur_dist = target_idx as isize - cur_idx;
}
match diff {
ListDiff::Clear => {
s.cast.notify(&ListDiff::Clear);
if s.cur_cursor.mode == ListCursorMode::Insert {
s.cast.notify(&ListDiff::Insert { idx: 0, val: ListSegment::InsertCursor });
}
}
ListDiff::Remove(idx) => {
s.cast.notify(&ListDiff::Remove(target_idx));
}
ListDiff::Insert { idx, val } => {
s.cast.notify(&ListDiff::Insert {
idx: target_idx,
val: ListSegment::Item {
editor: val.clone(),
cur_dist
}
});
}
ListDiff::Update { idx, val } => {
s.cast.notify(&ListDiff::Update {
idx: target_idx,
val: ListSegment::Item {
editor: val.clone(),
cur_dist
}
})
}
}
}),
cast: out_port.inner().get_broadcast(),
@ -131,11 +173,10 @@ impl ListSegmentSequence {
proj.write().unwrap().proj_helper.set_proj(&proj);
out_port.inner().set_view(Some(proj.clone()));
proj
}
pub fn get_view(&self) -> OuterViewPort<dyn SequenceView<Item = ListSegment>> {
pub fn get_view(&self) -> OuterViewPort<dyn ListView<ListSegment>> {
self.port.outer()
}
}

View file

@ -44,8 +44,11 @@ impl ReprTreeBuilder {
}
/// Add a type to the set of required representations.
pub fn require(mut self, t: TypeTerm) -> Self {
self.required_leaves.push(t.normalize());
pub fn require(mut self, mut t: TypeTerm) -> Self {
t = t.normalize();
if !self.required_leaves.contains(&t) {
self.required_leaves.push(t);
}
self
}
@ -68,14 +71,14 @@ impl ReprTreeBuilder {
leaves.retain(|t| t != &mt);
let mut st_problem = laddertypes::steiner_tree::PathApproxSteinerTreeSolver::new(
mt,
mt.clone(),
leaves
);
if let Some( steiner_tree ) = st_problem.solve( &morphism_base ) {
eprintln!("--> from {}", self.ctx.read().unwrap().type_term_to_str(&mt));
for morphism_type in steiner_tree.into_edges() {
eprintln!("--> morph {} to {}",
self.ctx.read().unwrap().type_term_to_str(&morphism_type.src_type),
eprintln!("--> morph to {}",
self.ctx.read().unwrap().type_term_to_str(&morphism_type.dst_type));
if let Some(( morphism, mut τ, σ )) =

View file

@ -1,6 +1,6 @@
use {
r3vi::{
view::{ViewPort, OuterViewPort, sequence::*},
view::{ViewPort, OuterViewPort, sequence::*, list::*},
projection::decorate_sequence::*,
},
nested::{
@ -67,19 +67,19 @@ impl PTYListStyle {
}
}
pub fn get_seg_seq_view(&self, editor: &ListEditor) -> OuterViewPort<dyn SequenceView<Item = OuterViewPort<dyn TerminalView>>> {
let seg_seq = ListSegmentSequence::new(
pub fn get_seg_view_list(&self, editor: &ListEditor) -> OuterViewPort<dyn ListView<OuterViewPort<dyn TerminalView>>> {
let seg_seq = ListSegments::new(
editor.get_cursor_port(),
editor.get_edittree_seq()
editor.get_edittree_list()
);
let se = seg_seq.read().unwrap();
se.get_view().map(move |segment| segment.display_view())
}
pub fn pty_view(&self, editor: &ListEditor) -> OuterViewPort<dyn TerminalView> {
let seg_seq = ListSegmentSequence::new(
let seg_seq = ListSegments::new(
editor.get_cursor_port(),
editor.get_edittree_seq()
editor.get_edittree_list()
);
let seg_seq0 = seg_seq.read().unwrap();
@ -88,6 +88,7 @@ impl PTYListStyle {
seg_seq
.map(move |segment| segment.display_view())
.to_sequence()
.separate(make_label(&self.style.1))
.wrap(make_label(&self.style.0), make_label(&self.style.2))
.to_grid_horizontal()
@ -163,10 +164,6 @@ impl PTYListController {
node.ctrl.close_char.set(close_char);
}
pub fn get_data_port(&self) -> OuterViewPort<dyn SequenceView<Item = EditTree>> {
self.editor.read().unwrap().get_edittree_seq()
}
pub fn clear(&mut self) {
self.editor.write().unwrap().clear();
}