Enum TargetKind 

pub enum TargetKind {
    Library,
    HeaderOnly,
    Executable,
    Test,
    Example,
}

What kind of artifact a target produces.

Target kinds describe artifact role only. Source-language classification is per-file, based on source extension: .c compiles as C, .cc / .cpp / .cxx / .c++ / .C compile as C++. A single target may freely mix C/C++ sources; the planner selects the compiler per source and selects the link driver from the direct and transitive source-language closure (C++ if any object is C++, otherwise C).

The string representations are stable: they are written by the manifest parser, surfaced by cabin metadata, and consumed by the build graph planner.

Variants

Library

Static-archive library (lib<name>.a).

HeaderOnly

A header-only library. Has no translation units of its own; the planner emits no compile or archive actions, and consumers pick up its include_dirs through the dependency graph.

Executable

A linked executable. Built by default by cabin build.

Test

A test executable. Built and run by cabin test. Excluded from the default cabin build selection.

Example

An example executable. Excluded from the default cabin build selection. Today the only way an example reaches the build graph is as a transitive dep of another selected target; a dedicated explicit-kind selector flag is reserved for future work (the historic --target name is reserved for platform/toolchain target selection).

Implementations

impl TargetKind

pub const fn as_str(self) -> &'static str

pub const fn all() -> &'static [TargetKind]

All kinds, in declaration order. Useful for error messages that list the supported types.

pub const fn produces_executable(self) -> bool

Whether this kind produces an executable (linked binary). Library kinds return false.

pub const fn produces_archive(self) -> bool

Whether this kind produces a static-archive library (lib<name>.a).

pub const fn is_header_only(self) -> bool

Whether this kind is a header-only library (no compile/ archive actions; consumers pick up include_dirs).

pub const fn is_default_buildable(self) -> bool

Whether ordinary cabin build selects this kind by default. Dev-only kinds (test / example) are excluded from the default set: tests are built by cabin test, and examples only reach the build graph as a transitive dep of another selected target.

Header-only libraries are included so the dependency closure walk reaches them; the planner emits no compile or archive actions for them, so saying “yes, this is part of the default selection” is a no-op on Ninja’s side.

pub const fn is_dev_only(self) -> bool

Whether this kind is a development-only target — a target that exists to support workspace development but is not part of the package’s public surface. Production callers use this to decide whether dev-dependencies should be activated and whether the target may be run by cabin test.

pub const fn is_test(self) -> bool

Whether cabin test runs this kind after building it. Today only test runs; example is build-only.

Trait Implementations

impl Clone for TargetKind

fn clone(&self) -> TargetKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TargetKind

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TargetKind

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for TargetKind

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

Formats the value using the given formatter.

impl Hash for TargetKind

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for TargetKind

fn eq(&self, other: &TargetKind) -> 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 TargetKind

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for TargetKind

impl Eq for TargetKind

impl StructuralPartialEq for TargetKind