mirror of
https://github.com/GraphiteEditor/Graphite.git
synced 2026-09-17 23:38:06 +08:00
5dab7de68d
* Implement type inference Add type hints to node trait Add type annotation infrastructure Refactor type ascription infrastructure Run cargo fix Insert infer types stub Remove types from node identifier * Implement covariance * Disable rejection of generic inputs + parameters * Fix lints * Extend type checking to cover Network inputs * Implement generic specialization * Relax covariance rules * Fix type annotations for TypErasedComposeNode * Fix type checking errors * Keep connection information during node resolution * Fix TypeDescriptor PartialEq implementation * Apply review suggestions * Add documentation to type inference * Add Imaginate node to document node types * Fix whitespace in macros * Add types to imaginate node * Fix type declaration for imaginate node + add console logging * Use fully qualified type names as fallback during comparison --------- Co-authored-by: Keavon Chambers <keavon@keavon.com>
95 lines
2.0 KiB
Rust
95 lines
2.0 KiB
Rust
#![cfg_attr(not(feature = "std"), no_std)]
|
|
|
|
#[cfg(feature = "alloc")]
|
|
extern crate alloc;
|
|
|
|
#[cfg_attr(feature = "log", macro_use)]
|
|
#[cfg(feature = "log")]
|
|
extern crate log;
|
|
|
|
pub mod generic;
|
|
pub mod ops;
|
|
pub mod structural;
|
|
pub mod uuid;
|
|
pub mod value;
|
|
|
|
#[cfg(feature = "gpu")]
|
|
pub mod gpu;
|
|
|
|
pub mod raster;
|
|
|
|
#[cfg(feature = "alloc")]
|
|
pub mod vector;
|
|
|
|
use core::any::TypeId;
|
|
|
|
// pub trait Node: for<'n> NodeIO<'n> {
|
|
pub trait Node<'i, Input: 'i>: 'i {
|
|
type Output: 'i;
|
|
fn eval<'s: 'i>(&'s self, input: Input) -> Self::Output;
|
|
}
|
|
|
|
#[cfg(feature = "alloc")]
|
|
mod types;
|
|
pub use types::*;
|
|
|
|
pub trait NodeIO<'i, Input: 'i>: 'i + Node<'i, Input>
|
|
where
|
|
Self::Output: 'i + StaticType,
|
|
Input: 'i + StaticType,
|
|
{
|
|
fn input_type(&self) -> TypeId {
|
|
TypeId::of::<Input::Static>()
|
|
}
|
|
fn input_type_name(&self) -> &'static str {
|
|
core::any::type_name::<Input>()
|
|
}
|
|
fn output_type(&self) -> core::any::TypeId {
|
|
TypeId::of::<<Self::Output as StaticType>::Static>()
|
|
}
|
|
fn output_type_name(&self) -> &'static str {
|
|
core::any::type_name::<Self::Output>()
|
|
}
|
|
#[cfg(feature = "alloc")]
|
|
fn to_node_io(&self, parameters: Vec<Type>) -> NodeIOTypes {
|
|
NodeIOTypes {
|
|
input: concrete!(<Input as StaticType>::Static),
|
|
output: concrete!(<Self::Output as StaticType>::Static),
|
|
parameters,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'i, N: Node<'i, I>, I> NodeIO<'i, I> for N
|
|
where
|
|
N::Output: 'i + StaticType,
|
|
I: 'i + StaticType,
|
|
{
|
|
}
|
|
|
|
/*impl<'i, I: 'i, O: 'i> Node<'i, I> for &'i dyn for<'n> Node<'n, I, Output = O> {
|
|
type Output = O;
|
|
|
|
fn eval<'s: 'i>(&'s self, input: I) -> Self::Output {
|
|
(**self).eval(input)
|
|
}
|
|
}*/
|
|
impl<'i, 'n: 'i, I: 'i, O: 'i> Node<'i, I> for &'n dyn for<'a> Node<'a, I, Output = O> {
|
|
type Output = O;
|
|
|
|
fn eval<'s: 'i>(&'s self, input: I) -> Self::Output {
|
|
(**self).eval(input)
|
|
}
|
|
}
|
|
use core::pin::Pin;
|
|
|
|
use dyn_any::StaticType;
|
|
#[cfg(feature = "alloc")]
|
|
impl<'i, I: 'i, O: 'i> Node<'i, I> for Pin<Box<dyn for<'a> Node<'a, I, Output = O> + 'i>> {
|
|
type Output = O;
|
|
|
|
fn eval<'s: 'i>(&'s self, input: I) -> Self::Output {
|
|
(**self).eval(input)
|
|
}
|
|
}
|