[features]

default = ["ffi"]

ffi = [] # see src/ffi/mod.rs

ffi_pseudo_socket_api = ["ffi", "libc", "os_socketaddr"]# see src/ffi/pseudo_socket_api.rs.

endpoint_logging = [] # see src/macros.rs

## Compilation instructions

1. Install the latest stable Rust toolchain (`rustup install stable`) using the [rustup](https://rustup.rs/) CLI tool, available for most platforms.

1. Have `cargo` (the Rust language package manager) download source dependencies, and compile the library with release-level optimizations with `cargo build --release`: 

	- The resulting dylib can be found in `./target/release/`, to be used with the header file: `./reowolf.h`.

	- *Note*: A list of immediate ancestor dependencies is visible in `./Cargo.toml`.

	- *Note*: Run `cargo test --release` to run unit tests with release-level optimizations.

## Using the library

- The library may be used as a Rust dependency by adding it as a git dependency, i.e., by adding line `reowolf_rs = { git = "https://scm.cwi.nl/FM/reowolf" }` to downstream crate's manifest file, `Cargo.toml`.

- The library may be used as a dynamically-linked library using its C ABI as the cdylib written to `./target/release` when compiled with release optimizations, in combination to the header file `./reowolf.h`.

- When compiled on Linux, the compiled library will include definitions of pseudo-socket procedures declared in `./pseudo-socket.h` when compiled with `cargo build --release --features ffi_pseudo_socket_api`. The added functionality is only needed when requiring that connectors expose a socket-like API.

    (@ENDPT, $logger:expr, $($arg:tt)*) => {{

        // if let Some(w) = $logger.line_writer() {

        //     let _ = writeln!(w, $($arg)*);

        // }

    }};

    ($logger:expr, $($arg:tt)*) => {{

    }};

}

// CuUndecided provides a mostly immutable view into the ConnectorUnphased structure,

// making it harder to accidentally mutate its contents in a way that cannot be rolled back.

impl CuUndecided for ConnectorUnphased {

    fn logger_and_protocol_description(&mut self) -> (&mut dyn Logger, &ProtocolDescription) {

        (&mut *self.logger, &self.proto_description)

    }

    fn logger(&mut self) -> &mut dyn Logger {

        &mut *self.logger

    }

    fn proto_description(&self) -> &ProtocolDescription {

        &self.proto_description

    }

                logger,

                proto_component_id,

                unrun_components: &mut unrun_components,

            };

            let blocker = component.nonsync_run(&mut ctx, proto_description);

            log!(

                "proto component {:?} ran to nonsync blocker {:?}",

                proto_component_id,

                &blocker

            );

            use NonsyncBlocker as B;

            match blocker {

                // the result is a rollback.

                Err(Se::RoundFailure)

            }

            Decision::Success(predicate) => {

                // commit changes to component states

                cu.proto_components.clear();

                    // "flatten" branching components, committing the speculation

                    // consistent with the predicate decided upon.

                    branching_proto_components

                        .into_iter()

                );

                // commit changes to ports and id_manager

                log!(

                    "End round with (updated) component states {:?}",

                );

                // consume native

                Ok(Some(round_ok))

            }

        };

        log!(cu.logger(), "Sync round ending! Cleaning up");

        ret

    }

            if branch.is_ended() && branch_predicate.assigns_subset(solution_predicate) {

                let NativeBranch { index, gotten, .. } = branch;

                log!(logger, "Collapsed native has gotten {:?}", &gotten);

                return RoundEndedNative { batch_index: index, gotten };

            }

        }

        panic!("Native had no branches matching pred {:?}", solution_predicate);

    }

}

impl BranchingProtoComponent {

    // Create a singleton-branch branching protocol component as

    // speculation begins, with the given protocol state.

            }

        }

    }

    // Given the predicate for the round's solution, collapse this

    // branching native to an ended branch whose predicate is consistent with it.

        let BranchingProtoComponent { branches } = self;

        for (branch_predicate, branch) in branches {

            if branch.ended && branch_predicate.assigns_subset(solution_predicate) {

                let ProtoComponentBranch { state, .. } = branch;

                return state;

            }

        }

        panic!("ProtoComponent had no branches matching pred {:?}", solution_predicate);

    }

}

impl ProtoComponentBranch {

    // Feed this branch received message.

    // It's safe to receive the same message repeatedly,

// back any changes.

trait CuUndecided {

    fn logger(&mut self) -> &mut dyn Logger;

    fn proto_description(&self) -> &ProtocolDescription;

    fn native_component_id(&self) -> ComponentId;

    fn logger_and_protocol_description(&mut self) -> (&mut dyn Logger, &ProtocolDescription);

}

// Represents a set of synchronous port operations that the native component

// has described as an "option" for completing during the synchronous rounds.

// Operations contained here succeed together or not at all.

// A native with N=2+ batches are expressing an N-way nondeterministic choice

        c.sync(None).unwrap();

        assert_eq!(&[expecting], c.gotten(g0).unwrap().as_slice());

    }

    c.sync(None).unwrap();

}

#[test]

fn eq_no_causality() {

    let test_log_path = Path::new("./logs/eq_no_causality");

    let pdl = b"

    composite eq(in a, in b, out c) {

        channel leftfirsto -> leftfirsti;

        new eqinner(a, b, c, leftfirsto, leftfirsti);

    }

    primitive eqinner(in a, in b, out c, out leftfirsto, in leftfirsti) {

        msg ma = null;

        msg mb = null;

        while(true) synchronous {

            }

        }

    }

    ";

    let pd = reowolf::ProtocolDescription::parse(pdl).unwrap();

    let mut c = file_logged_configured_connector(0, test_log_path, Arc::new(pd));

    let [p2, g2] = c.new_port_pair();

    let [p3, g3] = c.new_port_pair();

    c.add_component(b"eq", &[g3, g2, p3]).unwrap();

    c.connect(None).unwrap();

    for _ in 0..32 {

        c.put(p0, TEST_MSG.clone()).unwrap();

        c.put(p2, TEST_MSG.clone()).unwrap();

        c.sync(SEC1).unwrap();

    }

}