aquaengine 0.0.2

AquaEngine is a RAD framework for graphics and computes
Documentation 
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
107
108
109
110
111
112
113
114
115
116
117

//! Builder `AquaEngine` application

use std::result;
use version::Version;
use error::Application as Error;
use extensions::Extension;

/// Result for an application
pub type Result<T> = result::Result<T, Error>;

/// An `AquaEngine` application
///
/// # Example
/// ```
/// use aquaengine::version::Version;
/// use aquaengine::engine::Aqua;
/// use aquaengine::application::{Application, Result};
///
/// pub struct AnApplication {}
///
/// impl Application for AnApplication {
///     fn name(&self) -> Result<String> {
///         let name = String::from("AnApplication");
///         Ok(name)
///     }
///
///     fn version(&self) -> Result<Version> {
///         Ok(Version::new(1, 0, 0))
///     }
/// }
///
/// fn main() {
///     let engine = Aqua::default();
///     let application = AnApplication{};
/// }
/// ```
pub trait Application
{
    /// Returns the application name
    ///
    /// # Example
    /// ```
    /// use aquaengine::error::Application as Error;
    /// use aquaengine::application::{Application, Example};
    ///
    /// fn application_name() -> Result<String, Error> {
    ///     let application = Example{};
    ///     let name = application.name()?;
    ///
    ///     Ok(name)
    /// }
    ///
    /// fn main() {
    ///     let name = application_name().unwrap();
    ///     assert_eq!(name, "ExampleApplication");
    /// }
    /// ```
    fn name(&self) -> Result<String>;

    /// Returns the application version
    ///
    /// # Example
    /// ```
    /// use aquaengine::version::Version;
    /// use aquaengine::error::Application as Error;
    /// use aquaengine::application::{Application, Example};
    ///
    /// fn application_version() -> Result<Version, Error> {
    ///     let application = Example{};
    ///     let version = application.version()?;
    ///
    ///     Ok(version)
    /// }
    ///
    /// fn main() {
    ///     let version = application_version().unwrap();
    ///     assert_eq!(version, Version::new(1, 0, 0));
    /// }
    /// ```
    fn version(&self) -> Result<Version>;

    /// Returns the application version
    ///
    /// # Example
    /// ```
    /// use aquaengine::extensions::Extension;
    /// use aquaengine::application::{Application, Example};
    ///
    /// fn main() {
    ///     let application = Example{};
    ///     let extensions = application.need_extensions();
    ///     assert_eq!(extensions, vec![Extension::Debug, Extension::Devel, Extension::Surface]);
    /// }
    /// ```
    fn need_extensions(&self) -> Vec<Extension> {
        vec![]
    }
}

/// Minimal example application
#[derive(Debug, Clone, Copy)]
pub struct Example {}

impl Application for Example {
    fn name(&self) -> Result<String> {
        let name = String::from("ExampleApplication");
        Ok(name)
    }

    fn version(&self) -> Result<Version> {
        Ok(Version::new(1, 0, 0))
    }

    fn need_extensions(&self) -> Vec<Extension> {
        vec![Extension::Debug, Extension::Devel, Extension::Surface]
    }
}