Enum DesignPattern 

pub enum DesignPattern {
    Singleton {
        class: String,
        instance_method: String,
        instance_field: Option<String>,
        private_constructor: bool,
    },
    Factory {
        class: String,
        create_methods: Vec<String>,
        products: Vec<String>,
        is_abstract: bool,
    },
    Builder {
        class: String,
        build_method: String,
        setters: Vec<String>,
        target_type: Option<String>,
    },
    Adapter {
        class: String,
        adaptee: String,
        target_interface: Option<String>,
    },
    Decorator {
        class: String,
        base_interface: String,
        component_field: Option<String>,
    },
    Proxy {
        class: String,
        subject: String,
        proxy_type: Option<String>,
    },
    Observer {
        subject: String,
        observers: Vec<String>,
        notify_method: String,
        subscribe_methods: Vec<String>,
    },
    Strategy {
        interface: String,
        implementations: Vec<String>,
        context: Option<String>,
    },
    Command {
        interface: String,
        commands: Vec<String>,
        execute_method: String,
        has_undo: bool,
    },
    DependencyInjection {
        class: String,
        dependencies: Vec<(String, String)>,
    },
    Repository {
        class: String,
        entity_type: Option<String>,
        methods: Vec<String>,
    },
}

Detected design pattern with associated metadata.

Variants

Singleton

Singleton pattern: ensures a class has only one instance.

Heuristics:

• Private/protected constructor
• Static instance field
• Static getter method (getInstance, instance, shared, etc.)

Fields

class: String

The singleton class name.

instance_method: String

Method name for getting the instance.

instance_field: Option<String>

Instance field name (if detected).

private_constructor: bool

Whether constructor is private.

Factory

Factory pattern: creates objects without specifying exact class.

Heuristics:

• Method returns interface/abstract type
• Creates different concrete types based on input
• Named Factory or has create methods

Fields

class: String

The factory class name.

create_methods: Vec<String>

Factory method name(s).

products: Vec<String>

Product types that can be created.

is_abstract: bool

Whether it’s an abstract factory.

Builder

Builder pattern: constructs complex objects step by step.

Heuristics:

• Method chaining (methods return self/Self)
• Has build() or create() method
• Setter-like methods

Fields

class: String

The builder class name.

build_method: String

The build/create method name.

setters: Vec<String>

Setter/configuration methods.

target_type: Option<String>

Target type being built (if detected).

Adapter

Adapter pattern: allows incompatible interfaces to work together.

Heuristics:

• Wraps another class
• Implements different interface than wrapped class
• Delegates to wrapped object

Fields

class: String

The adapter class name.

adaptee: String

The adapted (wrapped) class.

target_interface: Option<String>

Interface being adapted to.

Decorator

Decorator pattern: adds behavior to objects dynamically.

Heuristics:

• Implements same interface as decorated object
• Has reference to decorated object
• Delegates most calls to decorated object

Fields

class: String

The decorator class name.

base_interface: String

Base interface/class being decorated.

component_field: Option<String>

The decorated component field.

Proxy

Proxy pattern: provides a surrogate for another object.

Heuristics:

• Same interface as real subject
• Controls access to real subject
• May add lazy loading, access control, logging

Fields

class: String

The proxy class name.

subject: String

The real subject class.

proxy_type: Option<String>

Type of proxy (lazy, protection, remote, etc.).

Observer

Observer pattern: defines one-to-many dependency.

Heuristics:

• Has collection of listeners/observers
• Methods like add/remove/notify
• Callback invocation pattern

Fields

subject: String

The subject (observable) class.

observers: Vec<String>

Observer interface or types.

notify_method: String

Method for notifying observers.

subscribe_methods: Vec<String>

Methods for subscribing/unsubscribing.

Strategy

Strategy pattern: defines family of interchangeable algorithms.

Heuristics:

• Interface with multiple implementations
• Strategy injected via constructor or setter
• Context class uses strategy

Fields

interface: String

The strategy interface name.

implementations: Vec<String>

Concrete strategy implementations.

context: Option<String>

Context class using the strategy.

Command

Command pattern: encapsulates request as an object.

Heuristics:

• Has execute() or similar method
• Encapsulates all info needed for action
• Often with undo() support

Fields

interface: String

The command interface name.

commands: Vec<String>

Concrete command implementations.

execute_method: String

Execute method name.

has_undo: bool

Whether undo is supported.

DependencyInjection

Dependency Injection pattern (modern alternative to many patterns).

Heuristics:

• Dependencies passed via constructor
• Interface-typed parameters
• No internal instantiation of dependencies

Fields

class: String

Class using dependency injection.

dependencies: Vec<(String, String)>

Injected dependencies (field name -> type).

Repository

Repository pattern: abstracts data access logic.

Heuristics:

• Named *Repository
• Has CRUD-like methods (find, save, delete)
• Works with entity types

Fields

class: String

The repository class name.

entity_type: Option<String>

Entity type managed.

methods: Vec<String>

CRUD methods present.

Implementations

impl DesignPattern

pub fn name(&self) -> &'static str

Get the human-readable name of the pattern.

pub fn category(&self) -> PatternCategory

Get the category of this pattern.

pub fn primary_class(&self) -> &str

Get the primary class/type name associated with this pattern.

Trait Implementations

impl Clone for DesignPattern

fn clone(&self) -> DesignPattern

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DesignPattern

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DesignPattern

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for DesignPattern

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

where __S: Serializer,

Serialize this value into the given Serde serializer.