chore(js+java): prelude imports

Author: zaaarf

src/ffi/java/buffer.rs

@@ -2,54 +2,50 @@ use jni_toolbox::jni;
 
 use crate::{
 	errors::ControllerError,
-	prelude::{
-		CodempAsyncReceiver as AsyncReceiver, CodempAsyncSender as AsyncSender,
-		CodempBufferController as BufferController, CodempBufferUpdate as BufferUpdate,
-		CodempTextChange as TextChange, CodempWorkspaceIdentifier as WorkspaceIdentifier,
-	},
+	prelude::*
 };
 
 /// Get the name of the buffer.
 #[jni(package = "mp.code", class = "BufferController")]
-fn path(controller: &mut BufferController) -> String {
+fn path(controller: &mut CodempBufferController) -> String {
 	controller.path().to_string()
 }
 
 /// Get the [WorkspaceIdentifier] of the workspace that contains this buffer.
 #[jni(package = "mp.code", class = "BufferController")]
-fn workspace_id(controller: &mut BufferController) -> WorkspaceIdentifier {
+fn workspace_id(controller: &mut CodempBufferController) -> CodempWorkspaceIdentifier {
 	controller.workspace_id().clone()
 }
 
 /// Get the contents of the buffers.
 #[jni(package = "mp.code", class = "BufferController")]
-fn content(controller: &mut BufferController) -> Result<String, ControllerError> {
+fn content(controller: &mut CodempBufferController) -> Result<String, ControllerError> {
 	super::tokio().block_on(controller.content())
 }
 
 /// Try to fetch a [TextChange], or return null if there's nothing.
 #[jni(package = "mp.code", class = "BufferController")]
-fn try_recv(controller: &mut BufferController) -> Result<Option<BufferUpdate>, ControllerError> {
+fn try_recv(controller: &mut CodempBufferController) -> Result<Option<CodempBufferUpdate>, ControllerError> {
 	super::tokio().block_on(controller.try_recv())
 }
 
 /// Block until it receives a [TextChange].
 #[jni(package = "mp.code", class = "BufferController")]
-fn recv(controller: &mut BufferController) -> Result<BufferUpdate, ControllerError> {
+fn recv(controller: &mut CodempBufferController) -> Result<CodempBufferUpdate, ControllerError> {
 	super::tokio().block_on(controller.recv())
 }
 
 /// Send a [TextChange] to the server.
 #[jni(package = "mp.code", class = "BufferController")]
-fn send(controller: &mut BufferController, change: TextChange) -> Result<(), ControllerError> {
+fn send(controller: &mut CodempBufferController, change: CodempTextChange) -> Result<(), ControllerError> {
 	controller.send(change)
 }
 
 /// Register a callback for buffer changes.
 #[jni(package = "mp.code", class = "BufferController")]
 fn callback<'local>(
 	env: &mut jni::Env<'local>,
-	controller: &mut BufferController,
+	controller: &mut CodempBufferController,
 	cb: jni::objects::JObject<'local>,
 ) -> Result<(), jni::errors::Error> {
 	if cb.is_null() {
@@ -61,7 +57,7 @@ fn callback<'local>(
 	let cb_ref = env.new_global_ref(cb)?;
 	let jvm = env.get_java_vm()?;
 
-	controller.callback(move |controller: BufferController| {
+	controller.callback(move |controller: CodempBufferController| {
 		let result: Result<(), jni::errors::Error> = jvm.attach_current_thread(|env| {
 			env.with_local_frame(5, |env| {
 				use jni_toolbox::IntoJavaObject;
@@ -88,25 +84,25 @@ fn callback<'local>(
 
 /// Clear the callback for buffer changes.
 #[jni(package = "mp.code", class = "BufferController")]
-fn clear_callback(controller: &mut BufferController) {
+fn clear_callback(controller: &mut CodempBufferController) {
 	controller.clear_callback()
 }
 
 /// Block until there is a new value available.
 #[jni(package = "mp.code", class = "BufferController")]
-fn poll(controller: &mut BufferController) -> Result<(), ControllerError> {
+fn poll(controller: &mut CodempBufferController) -> Result<(), ControllerError> {
 	super::tokio().block_on(controller.poll())
 }
 
 /// Acknowledge that a change has been correctly applied.
 #[jni(package = "mp.code", class = "BufferController")]
-fn ack(controller: &mut BufferController, version: Vec<i64>) {
+fn ack(controller: &mut CodempBufferController, version: Vec<i64>) {
 	controller.ack(version)
 }
 
 /// Called by the Java GC to drop a [crate::buffer::Controller].
 #[allow(unsafe_code)]
 #[jni(package = "mp.code", class = "BufferController")]
 fn free(input: jni::sys::jlong) {
-	let _ = unsafe { Box::from_raw(input as *mut BufferController) };
+	let _ = unsafe { Box::from_raw(input as *mut CodempBufferController) };
 }

src/ffi/java/client.rs

@@ -2,69 +2,65 @@ use jni_toolbox::jni;
 
 use crate::{
 	errors::{ConnectionError, ControllerError, RemoteError},
-	prelude::{
-		CodempAsyncReceiver as AsyncReceiver, CodempClient as Client, CodempConfig as Config,
-		CodempSessionEvent as SessionEvent, CodempUserInfo as UserInfo,
-		CodempWorkspace as Workspace, CodempWorkspaceIdentifier as WorkspaceIdentifier,
-	},
+	prelude::*
 };
 
 /// Connect using the given credentials to the default server, and return a [Client] to interact with it.
 #[jni(package = "mp.code", class = "Client")]
-fn connect(config: Config) -> Result<Client, ConnectionError> {
-	super::tokio().block_on(Client::connect(config))
+fn connect(config: CodempConfig) -> Result<CodempClient, ConnectionError> {
+	super::tokio().block_on(CodempClient::connect(config))
 }
 
 /// Gets the [UserInfo] for the current user.
 #[jni(package = "mp.code", class = "Client")]
-fn current_user(client: &mut Client) -> UserInfo {
+fn current_user(client: &mut CodempClient) -> CodempUserInfo {
 	client.current_user().clone()
 }
 
 /// Join a [Workspace] and return a pointer to it.
 #[jni(package = "mp.code", class = "Client")]
 fn attach_workspace(
-	client: &mut Client,
+	client: &mut CodempClient,
 	user: String,
 	workspace: String,
-) -> Result<Workspace, ConnectionError> {
+) -> Result<CodempWorkspace, ConnectionError> {
 	super::tokio().block_on(client.attach_workspace(user, workspace))
 }
 
 /// Accepts an invitation to a workspace.
 #[jni(package = "mp.code", class = "Client")]
-fn accept_invite(client: &mut Client, user: String, workspace: String) -> Result<(), RemoteError> {
+fn accept_invite(client: &mut CodempClient, user: String, workspace: String) -> Result<(), RemoteError> {
 	super::tokio().block_on(client.accept_invite(user, workspace))
 }
 
 /// Rejects an invitation to a workspace.
 #[jni(package = "mp.code", class = "Client")]
-fn reject_invite(client: &mut Client, user: String, workspace: String) -> Result<(), RemoteError> {
+fn reject_invite(client: &mut CodempClient, user: String, workspace: String) -> Result<(), RemoteError> {
 	super::tokio().block_on(client.reject_invite(user, workspace))
 }
 
 /// Quit a joined [Workspace].
 #[jni(package = "mp.code", class = "Client")]
-fn quit_workspace(client: &mut Client, user: String, workspace: String) -> Result<(), RemoteError> {
+fn quit_workspace(client: &mut CodempClient, user: String, workspace: String) -> Result<(), RemoteError> {
 	super::tokio().block_on(client.quit_workspace(user, workspace))
 }
 
 /// Create a workspace on server, if allowed to.
 #[jni(package = "mp.code", class = "Client")]
-fn create_workspace(client: &mut Client, workspace: String) -> Result<(), RemoteError> {
+fn create_workspace(client: &mut CodempClient, workspace: String) -> Result<(), RemoteError> {
 	super::tokio().block_on(client.create_workspace(workspace))
 }
 
 /// Delete a workspace on server, if allowed to.
 #[jni(package = "mp.code", class = "Client")]
-fn delete_workspace(client: &mut Client, workspace: String) -> Result<(), RemoteError> {
+fn delete_workspace(client: &mut CodempClient, workspace: String) -> Result<(), RemoteError> {
 	super::tokio().block_on(client.delete_workspace(workspace))
 }
 
 /// Invite another user to an owned workspace.
 #[jni(package = "mp.code", class = "Client")]
 fn invite_to_workspace(
-	client: &mut Client,
+	client: &mut CodempClient,
 	workspace: String,
 	user: String,
 ) -> Result<(), RemoteError> {
@@ -73,57 +69,57 @@ fn invite_to_workspace(
 
 /// List owned workspaces.
 #[jni(package = "mp.code", class = "Client")]
-fn fetch_owned_workspaces(client: &mut Client) -> Result<Vec<WorkspaceIdentifier>, RemoteError> {
+fn fetch_owned_workspaces(client: &mut CodempClient) -> Result<Vec<CodempWorkspaceIdentifier>, RemoteError> {
 	super::tokio().block_on(client.fetch_owned_workspaces())
 }
 
 /// List joined workspaces.
 #[jni(package = "mp.code", class = "Client")]
-fn fetch_joined_workspaces(client: &mut Client) -> Result<Vec<WorkspaceIdentifier>, RemoteError> {
+fn fetch_joined_workspaces(client: &mut CodempClient) -> Result<Vec<CodempWorkspaceIdentifier>, RemoteError> {
 	super::tokio().block_on(client.fetch_joined_workspaces())
 }
 
 /// List available workspaces.
 #[jni(package = "mp.code", class = "Client")]
-fn active_workspaces(client: &mut Client) -> Vec<WorkspaceIdentifier> {
+fn active_workspaces(client: &mut CodempClient) -> Vec<CodempWorkspaceIdentifier> {
 	client.active_workspaces()
 }
 
 /// Leave a [Workspace] and return whether or not the client was in such workspace.
 #[jni(package = "mp.code", class = "Client")]
-fn leave_workspace(client: &mut Client, user: String, workspace: String) -> bool {
+fn leave_workspace(client: &mut CodempClient, user: String, workspace: String) -> bool {
 	client.leave_workspace(user, workspace)
 }
 
 /// Get a [Workspace] by name and returns a pointer to it.
 #[jni(package = "mp.code", class = "Client")]
-fn get_workspace(client: &mut Client, user: String, workspace: String) -> Option<Workspace> {
+fn get_workspace(client: &mut CodempClient, user: String, workspace: String) -> Option<CodempWorkspace> {
 	client.get_workspace(user, workspace)
 }
 
 /// Fetches information about a user.
 #[jni(package = "mp.code", class = "Client")]
-fn get_user_info(client: &mut Client, user: String) -> Result<UserInfo, RemoteError> {
+fn get_user_info(client: &mut CodempClient, user: String) -> Result<CodempUserInfo, RemoteError> {
 	super::tokio().block_on(client.get_user_info(user))
 }
 
 /// Try to fetch a [TextChange], or return null if there's nothing.
 #[jni(package = "mp.code", class = "Client")]
-fn try_recv(client: &mut Client) -> Result<Option<SessionEvent>, ControllerError> {
+fn try_recv(client: &mut CodempClient) -> Result<Option<CodempSessionEvent>, ControllerError> {
 	super::tokio().block_on(client.try_recv())
 }
 
 /// Block until it receives a [TextChange].
 #[jni(package = "mp.code", class = "Client")]
-fn recv(client: &mut Client) -> Result<SessionEvent, ControllerError> {
+fn recv(client: &mut CodempClient) -> Result<CodempSessionEvent, ControllerError> {
 	super::tokio().block_on(client.recv())
 }
 
 /// Register a callback for client changes.
 #[jni(package = "mp.code", class = "Client")]
 fn callback<'local>(
 	env: &mut jni::Env<'local>,
-	client: &mut Client,
+	client: &mut CodempClient,
 	cb: jni::objects::JObject<'local>,
 ) -> Result<(), jni::errors::Error> {
 	if cb.is_null() {
@@ -135,7 +131,7 @@ fn callback<'local>(
 	let cb_ref = env.new_global_ref(cb)?;
 	let jvm = env.get_java_vm()?;
 
-	client.callback(move |controller: Client| {
+	client.callback(move |controller: CodempClient| {
 		let result: Result<(), jni::errors::Error> = jvm.attach_current_thread(|env| {
 			env.with_local_frame(5, |env| {
 				use jni_toolbox::IntoJavaObject;
@@ -162,25 +158,25 @@ fn callback<'local>(
 
 /// Clear the callback for client changes.
 #[jni(package = "mp.code", class = "Client")]
-fn clear_callback(client: &mut Client) {
+fn clear_callback(client: &mut CodempClient) {
 	client.clear_callback()
 }
 
 /// Block until there is a new value available.
 #[jni(package = "mp.code", class = "Client")]
-fn poll(client: &mut Client) -> Result<(), ControllerError> {
+fn poll(client: &mut CodempClient) -> Result<(), ControllerError> {
 	super::tokio().block_on(client.poll())
 }
 
 /// Refresh the client's session token.
 #[jni(package = "mp.code", class = "Client")]
-fn refresh(client: &mut Client) -> Result<(), RemoteError> {
+fn refresh(client: &mut CodempClient) -> Result<(), RemoteError> {
 	super::tokio().block_on(client.refresh())
 }
 
 /// Called by the Java GC to drop a [Client].
 #[allow(unsafe_code)]
 #[jni(package = "mp.code", class = "Client")]
 fn free(input: jni::sys::jlong) {
-	let _ = unsafe { Box::from_raw(input as *mut Client) };
+	let _ = unsafe { Box::from_raw(input as *mut CodempClient) };
 }

src/ffi/java/cursor.rs

@@ -2,42 +2,38 @@ use jni_toolbox::jni;
 
 use crate::{
 	errors::ControllerError,
-	prelude::{
-		CodempAsyncReceiver as AsyncReceiver, CodempAsyncSender as AsyncSender,
-		CodempCursorController as CursorController, CodempCursorEvent as CursorEvent,
-		CodempCursorUpdate as CursorUpdate, CodempWorkspaceIdentifier as WorkspaceIdentifier,
-	},
+	prelude::*,
 };
 
 /// Get the [WorkspaceIdentifier] of the workspace that contains this buffer.
 #[jni(package = "mp.code", class = "CursorController")]
-fn workspace_id(controller: &mut CursorController) -> WorkspaceIdentifier {
+fn workspace_id(controller: &mut CodempCursorController) -> CodempWorkspaceIdentifier {
 	controller.workspace_id().clone()
 }
 
 /// Try to fetch a [Cursor], or returns null if there's nothing.
 #[jni(package = "mp.code", class = "CursorController")]
-fn try_recv(controller: &mut CursorController) -> Result<Option<CursorEvent>, ControllerError> {
+fn try_recv(controller: &mut CodempCursorController) -> Result<Option<CodempCursorEvent>, ControllerError> {
 	super::tokio().block_on(controller.try_recv())
 }
 
 /// Block until it receives a [Cursor].
 #[jni(package = "mp.code", class = "CursorController")]
-fn recv(controller: &mut CursorController) -> Result<CursorEvent, ControllerError> {
+fn recv(controller: &mut CodempCursorController) -> Result<CodempCursorEvent, ControllerError> {
 	super::tokio().block_on(controller.recv())
 }
 
 /// Receive from Java, converts and sends a [Cursor].
 #[jni(package = "mp.code", class = "CursorController")]
-fn send(controller: &mut CursorController, sel: CursorUpdate) -> Result<(), ControllerError> {
+fn send(controller: &mut CodempCursorController, sel: CodempCursorUpdate) -> Result<(), ControllerError> {
 	controller.send(sel)
 }
 
 /// Register a callback for cursor changes.
 #[jni(package = "mp.code", class = "CursorController")]
 fn callback<'local>(
 	env: &mut jni::Env<'local>,
-	controller: &mut CursorController,
+	controller: &mut CodempCursorController,
 	cb: jni::objects::JObject<'local>,
 ) -> Result<(), jni::errors::Error> {
 	if cb.is_null() {
@@ -47,7 +43,7 @@ fn callback<'local>(
 	let cb_ref = env.new_global_ref(cb)?;
 	let jvm = env.get_java_vm()?;
 
-	controller.callback(move |controller: CursorController| {
+	controller.callback(move |controller: CodempCursorController| {
 		let res: Result<(), jni::errors::Error> = jvm.attach_current_thread(|env| {
 			env.with_local_frame(5, |env| {
 				use jni_toolbox::IntoJavaObject;
@@ -74,19 +70,19 @@ fn callback<'local>(
 
 /// Clear the callback for cursor changes.
 #[jni(package = "mp.code", class = "CursorController")]
-fn clear_callback(controller: &mut CursorController) {
+fn clear_callback(controller: &mut CodempCursorController) {
 	controller.clear_callback()
 }
 
 /// Block until there is a new value available.
 #[jni(package = "mp.code", class = "CursorController")]
-fn poll(controller: &mut CursorController) -> Result<(), ControllerError> {
+fn poll(controller: &mut CodempCursorController) -> Result<(), ControllerError> {
 	super::tokio().block_on(controller.poll())
 }
 
 /// Called by the Java GC to drop a [crate::cursor::Controller].
 #[allow(unsafe_code)]
 #[jni(package = "mp.code", class = "CursorController")]
 fn free(input: jni::sys::jlong) {
-	let _ = unsafe { Box::from_raw(input as *mut CursorController) };
+	let _ = unsafe { Box::from_raw(input as *mut CodempCursorController) };
 }