use {AngleBracketedParameterData, Generics, Ident, Lifetime, ParenthesizedParameterData, Path,
PathParameters, PathSegment, Ty, TypeBinding};
use aster::ident::ToIdent;
use aster::invoke::{Invoke, Identity};
use aster::lifetime::IntoLifetime;
use aster::ty::TyBuilder;
pub trait IntoPath {
fn into_path(self) -> Path;
}
impl IntoPath for Path {
fn into_path(self) -> Path {
self
}
}
impl IntoPath for Ident {
fn into_path(self) -> Path {
PathBuilder::new().id(self).build()
}
}
impl<'a> IntoPath for &'a str {
fn into_path(self) -> Path {
PathBuilder::new().id(self).build()
}
}
impl IntoPath for String {
fn into_path(self) -> Path {
(&*self).into_path()
}
}
impl<'a, T> IntoPath for &'a [T]
where T: ToIdent
{
fn into_path(self) -> Path {
PathBuilder::new().ids(self).build()
}
}
pub struct PathBuilder<F = Identity> {
callback: F,
global: bool,
}
impl PathBuilder {
pub fn new() -> Self {
PathBuilder::with_callback(Identity)
}
}
impl<F> PathBuilder<F>
where F: Invoke<Path>
{
pub fn with_callback(callback: F) -> Self {
PathBuilder {
callback: callback,
global: false,
}
}
pub fn build(self, path: Path) -> F::Result {
self.callback.invoke(path)
}
pub fn global(mut self) -> Self {
self.global = true;
self
}
pub fn ids<I, T>(self, ids: I) -> PathSegmentsBuilder<F>
where I: IntoIterator<Item = T>,
T: ToIdent
{
let mut ids = ids.into_iter();
let id = ids.next().expect("passed path with no id");
self.id(id).ids(ids)
}
pub fn id<I>(self, id: I) -> PathSegmentsBuilder<F>
where I: ToIdent
{
self.segment(id).build()
}
pub fn segment<I>(self, id: I) -> PathSegmentBuilder<PathSegmentsBuilder<F>>
where I: ToIdent
{
PathSegmentBuilder::with_callback(id,
PathSegmentsBuilder {
callback: self.callback,
global: self.global,
segments: Vec::new(),
})
}
}
pub struct PathSegmentsBuilder<F = Identity> {
callback: F,
global: bool,
segments: Vec<PathSegment>,
}
impl<F> PathSegmentsBuilder<F>
where F: Invoke<Path>
{
pub fn ids<I, T>(mut self, ids: I) -> PathSegmentsBuilder<F>
where I: IntoIterator<Item = T>,
T: ToIdent
{
for id in ids {
self = self.id(id);
}
self
}
pub fn id<T>(self, id: T) -> PathSegmentsBuilder<F>
where T: ToIdent
{
self.segment(id).build()
}
pub fn segment<T>(self, id: T) -> PathSegmentBuilder<Self>
where T: ToIdent
{
PathSegmentBuilder::with_callback(id, self)
}
pub fn build(self) -> F::Result {
self.callback.invoke(Path {
global: self.global,
segments: self.segments,
})
}
}
impl<F> Invoke<PathSegment> for PathSegmentsBuilder<F> {
type Result = Self;
fn invoke(mut self, segment: PathSegment) -> Self {
self.segments.push(segment);
self
}
}
pub struct PathSegmentBuilder<F = Identity> {
callback: F,
id: Ident,
lifetimes: Vec<Lifetime>,
tys: Vec<Ty>,
bindings: Vec<TypeBinding>,
}
impl<F> PathSegmentBuilder<F>
where F: Invoke<PathSegment>
{
pub fn with_callback<I>(id: I, callback: F) -> Self
where I: ToIdent
{
PathSegmentBuilder {
callback: callback,
id: id.to_ident(),
lifetimes: Vec::new(),
tys: Vec::new(),
bindings: Vec::new(),
}
}
pub fn with_generics(self, generics: Generics) -> Self {
let lifetimes = generics.lifetimes
.iter()
.map(|lifetime_def| lifetime_def.lifetime.clone());
let tys = generics.ty_params
.iter()
.map(|ty_param| TyBuilder::new().id(ty_param.ident.clone()));
self.with_lifetimes(lifetimes)
.with_tys(tys)
}
pub fn with_lifetimes<I, L>(mut self, iter: I) -> Self
where I: IntoIterator<Item = L>,
L: IntoLifetime
{
let iter = iter.into_iter().map(|lifetime| lifetime.into_lifetime());
self.lifetimes.extend(iter);
self
}
pub fn with_lifetime<L>(mut self, lifetime: L) -> Self
where L: IntoLifetime
{
self.lifetimes.push(lifetime.into_lifetime());
self
}
pub fn lifetime<N>(self, name: N) -> Self
where N: ToIdent
{
let lifetime = Lifetime { ident: name.to_ident() };
self.with_lifetime(lifetime)
}
pub fn with_tys<I>(mut self, iter: I) -> Self
where I: IntoIterator<Item = Ty>
{
self.tys.extend(iter);
self
}
pub fn with_ty(mut self, ty: Ty) -> Self {
self.tys.push(ty);
self
}
pub fn ty(self) -> TyBuilder<Self> {
TyBuilder::with_callback(self)
}
pub fn with_binding(mut self, binding: TypeBinding) -> Self {
self.bindings.push(binding);
self
}
pub fn binding<T>(self, id: T) -> TyBuilder<TypeBindingBuilder<F>>
where T: ToIdent
{
TyBuilder::with_callback(TypeBindingBuilder {
id: id.to_ident(),
builder: self,
})
}
pub fn no_return(self) -> F::Result {
self.build_return(None)
}
pub fn return_(self) -> TyBuilder<PathSegmentReturnBuilder<F>> {
TyBuilder::with_callback(PathSegmentReturnBuilder(self))
}
pub fn build_return(self, output: Option<Ty>) -> F::Result {
let data = ParenthesizedParameterData {
inputs: self.tys,
output: output,
};
let parameters = PathParameters::Parenthesized(data);
self.callback.invoke(PathSegment {
ident: self.id,
parameters: parameters,
})
}
pub fn build(self) -> F::Result {
let data = AngleBracketedParameterData {
lifetimes: self.lifetimes,
types: self.tys,
bindings: self.bindings,
};
let parameters = PathParameters::AngleBracketed(data);
self.callback.invoke(PathSegment {
ident: self.id,
parameters: parameters,
})
}
}
impl<F> Invoke<Ty> for PathSegmentBuilder<F>
where F: Invoke<PathSegment>
{
type Result = Self;
fn invoke(self, ty: Ty) -> Self {
self.with_ty(ty)
}
}
pub struct TypeBindingBuilder<F> {
id: Ident,
builder: PathSegmentBuilder<F>,
}
impl<F> Invoke<Ty> for TypeBindingBuilder<F>
where F: Invoke<PathSegment>
{
type Result = PathSegmentBuilder<F>;
fn invoke(self, ty: Ty) -> Self::Result {
let id = self.id;
self.builder.with_binding(TypeBinding {
ident: id,
ty: ty,
})
}
}
pub struct PathSegmentReturnBuilder<F>(PathSegmentBuilder<F>);
impl<F> Invoke<Ty> for PathSegmentReturnBuilder<F>
where F: Invoke<PathSegment>
{
type Result = F::Result;
fn invoke(self, ty: Ty) -> Self::Result {
self.0.build_return(Some(ty))
}
}