Struct RequirementsAnalysis 

pub struct RequirementsAnalysis {
    pub original_task: String,
    pub functional_requirements: Vec<String>,
    pub non_functional_requirements: Vec<String>,
    pub assumptions: Vec<String>,
    pub questions: Vec<String>,
    pub scope: ScopeDefinition,
}

Requirements analysis result

Fields

original_task: String

Original task/requirements

functional_requirements: Vec<String>

Parsed functional requirements

non_functional_requirements: Vec<String>

Parsed non-functional requirements

assumptions: Vec<String>

Assumptions made

questions: Vec<String>

Questions/clarifications needed

scope: ScopeDefinition

Scope boundaries

Implementations

impl RequirementsAnalysis

pub fn new(task: impl Into<String>) -> Self

Create a new requirements analysis

pub fn with_functional_requirements(self, reqs: Vec<String>) -> Self

Add functional requirements

pub fn with_non_functional_requirements(self, reqs: Vec<String>) -> Self

Add non-functional requirements

pub fn with_assumptions(self, assumptions: Vec<String>) -> Self

Add assumptions

pub fn with_questions(self, questions: Vec<String>) -> Self

Add questions

pub fn with_scope(self, scope: ScopeDefinition) -> Self

Set scope

Trait Implementations

impl Clone for RequirementsAnalysis

fn clone(&self) -> RequirementsAnalysis

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RequirementsAnalysis

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for RequirementsAnalysis

fn default() -> RequirementsAnalysis

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for RequirementsAnalysis

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for RequirementsAnalysis

fn eq(&self, other: &RequirementsAnalysis) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for RequirementsAnalysis

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for RequirementsAnalysis