Struct SourceSet

pub struct SourceSet<'a> {
    pub name: &'a str,
    pub source_method: SourceMethod,
    pub depends_on: HashMap<&'a str, &'a str>,
    pub dependencies: Dependencies<'a>,
}

Represents a source set in a multiplatform project.

Fields

name: &'a str

The name of the source set.

source_method: SourceMethod

The source method for the source set, indicating whether it is obtained or created.

depends_on: HashMap<&'a str, &'a str>

The dependencies that the source set depends on.

dependencies: Dependencies<'a>

The dependencies included in the source set.

Implementations

impl<'a> SourceSet<'a>

pub fn new( name: &'a str, source_method: SourceMethod, depends_on: HashMap<&'a str, &'a str>, dependencies: Dependencies<'a>, ) -> Self

Creates a new SourceSet instance with the specified parameters.

Arguments

• name - The name of the source set.
• source_method - The source method of the source set.
• depends_on - The dependencies of the source set.
• dependencies - The dependencies of the source set.

Example

use std::collections::HashMap;
use kmmp_structure::gradle::{
    SourceSet,
    sourcesets::SourceMethod,
    dependency::Dependencies
};

let depends_on: HashMap<&str, &str> = HashMap::new();
let dependencies = Dependencies::new(&Vec::new());
let source_set = SourceSet::new("main", SourceMethod::Kotlin, &depends_on, dependencies);

Trait Implementations

impl<'a> Debug for SourceSet<'a>

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

Formats the value using the given formatter.

impl<'de: 'a, 'a> Deserialize<'de> for SourceSet<'a>

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for SourceSet<'_>

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

Formats the SourceSet as a string.

Example

use std::collections::HashMap;
use kmmp_structure::gradle::{
    SourceSet,
    sourcesets::SourceMethod,
    dependency::Dependencies
};

let depends_on: HashMap<&str, &str> = HashMap::new();
let dependencies = Dependencies::new(&Vec::new());
let source_set = SourceSet::new("main", SourceMethod::Getting, &depends_on, dependencies);
assert_eq!(
    source_set.to_string(),
    "val main by getting { }\n"
);

impl<'a> PartialEq for SourceSet<'a>

fn eq(&self, other: &SourceSet<'a>) -> bool

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

const 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<'a> Serialize for SourceSet<'a>

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a> StructuralPartialEq for SourceSet<'a>