1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106

//! Data structure for fields

use tokens::Tokens;
use java::Java;
use cons::Cons;
use con_::Con;
use super::modifier::Modifier;
use element::Element;
use into_tokens::IntoTokens;

/// Model for Java Fields.
#[derive(Debug, Clone)]
pub struct Field<'el> {
    /// Annotations of field.
    pub annotations: Tokens<'el, Java<'el>>,
    /// Modifiers of field.
    pub modifiers: Vec<Modifier>,
    /// Type of field.
    ty: Java<'el>,
    /// Name of field.
    name: Cons<'el>,
    /// Initializer of field.
    initializer: Option<Tokens<'el, Java<'el>>>,
}

impl<'el> Field<'el> {
    /// Create a new field.
    pub fn new<T, N>(ty: T, name: N) -> Field<'el>
    where
        T: Into<Java<'el>>,
        N: Into<Cons<'el>>,
    {
        use self::Modifier::*;

        Field {
            annotations: Tokens::new(),
            modifiers: vec![Private, Final],
            ty: ty.into(),
            name: name.into(),
            initializer: None,
        }
    }

    /// Push an annotation.
    pub fn annotation<A>(&mut self, annotation: A)
    where
        A: IntoTokens<'el, Java<'el>>,
    {
        self.annotations.push(annotation.into_tokens());
    }

    /// Set initializer for field.
    pub fn initializer<I>(&mut self, initializer: I)
    where
        I: IntoTokens<'el, Java<'el>>,
    {
        self.initializer = Some(initializer.into_tokens());
    }

    /// The variable of the field.
    pub fn var(&self) -> Cons<'el> {
        self.name.clone()
    }

    /// The type of the field.
    pub fn ty(&self) -> Java<'el> {
        self.ty.clone()
    }
}

into_tokens_impl_from!(Field<'el>, Java<'el>);

impl<'el> IntoTokens<'el, Java<'el>> for Field<'el> {
    fn into_tokens(self) -> Tokens<'el, Java<'el>> {
        use self::Element::*;

        let mut tokens = Tokens::new();

        if !self.annotations.is_empty() {
            tokens.push(self.annotations);
            tokens.append(PushSpacing);
        }

        if !self.modifiers.is_empty() {
            tokens.append(self.modifiers);
            tokens.append(" ");
        }

        tokens.append(self.ty);
        tokens.append(" ");
        tokens.append(self.name);

        if let Some(initializer) = self.initializer {
            tokens.append(" = ");
            tokens.append(initializer);
        }

        tokens
    }
}

impl<'el> From<Field<'el>> for Element<'el, Java<'el>> {
    fn from(f: Field<'el>) -> Self {
        Element::Append(Con::Owned(f.into_tokens()))
    }
}