Compare commits
2 commits
01dddbe3f8
...
0d073ba82e
Author | SHA1 | Date | |
---|---|---|---|
0d073ba82e | |||
278296cfbb |
12 changed files with 337 additions and 163 deletions
|
@ -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;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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(
|
||||
|
|
|
@ -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()
|
||||
}
|
||||
)
|
||||
);
|
||||
}
|
||||
}
|
||||
);
|
||||
|
|
|
@ -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()
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
);
|
||||
|
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
|
|
@ -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()
|
||||
);
|
||||
|
|
|
@ -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();
|
||||
|
|
|
@ -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
|
||||
};
|
||||
|
||||
|
|
|
@ -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()
|
||||
}
|
||||
}
|
||||
|
|
|
@ -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 τ, σ )) =
|
||||
|
|
|
@ -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();
|
||||
}
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue