#[non_exhaustive]pub enum Error {
Show 17 variants
ArcCycle(CycleChain),
UnresolvedLayer {
asset_path: String,
arc: ArcType,
introduced_by: String,
site_path: Path,
},
UnresolvedPrimPath {
arc: ArcType,
target_layer: String,
prim_path: Path,
introduced_by: String,
site_path: Path,
},
MissingDefaultPrim {
layer_id: String,
arc: ArcType,
site_path: Path,
},
InvalidDefaultPrim {
layer_id: String,
arc: ArcType,
site_path: Path,
},
InvalidExpression {
expression: String,
arc: ArcType,
site_path: Path,
message: String,
},
ArcPermissionDenied {
site_path: Path,
arc: ArcType,
target_path: Path,
},
ProhibitedRelocationSource {
arc: ArcType,
site: Path,
site_layer: String,
target: Path,
target_layer: String,
reloc_source: Path,
reloc_layer: String,
composing: Path,
},
InvalidExternalTargetPath {
is_connection: bool,
target: Path,
property: Path,
layer: String,
arc: ArcType,
arc_root: Path,
composing: Path,
},
InvalidInstanceTargetPath {
is_connection: bool,
target: Path,
property: Path,
layer: String,
composing: Path,
},
InconsistentPropertyType {
property: Path,
defining_layer: String,
defining_path: Path,
defining_is_attribute: bool,
conflicting_layer: String,
conflicting_path: Path,
conflicting_is_attribute: bool,
composing: Path,
},
OpinionAtRelocationSource {
source_path: Path,
layer: String,
composing: Path,
},
UnresolvedSublayer {
asset_path: String,
introduced_by: String,
},
SublayerCycle {
root_layer: String,
seen_layer: String,
},
SameTargetRelocations {
target: Path,
sources: Vec<(Path, String)>,
},
ConflictingRelocation {
source_path: Path,
target_path: Path,
layer: String,
other_source_path: Path,
other_target_path: Path,
other_layer: String,
reason: RelocateConflictReason,
},
InvalidRelocate {
source_path: Path,
target_path: Path,
layer: String,
reason: InvalidRelocateReason,
},
}Expand description
Variants (Non-exhaustive)§
This enum is marked as non-exhaustive
ArcCycle(CycleChain)
A composition arc cycle was detected (C++ PcpErrorArcCycle). The arc
closing the cycle is dropped so the rest of the prim still composes;
.0.hops is the chain of arcs from the composing prim to the cycle-closing
(CANNOT) arc, for the diagnostic.
UnresolvedLayer
A layer referenced by a composition arc was not found among loaded layers (C++ “Could not open asset … for {arc}”).
Fields
UnresolvedPrimPath
A reference/payload resolved its target layer, but the named prim path
authors no spec there (C++ PcpErrorUnresolvedPrimPath). The arc is
dropped while the rest of the prim still composes.
Fields
MissingDefaultPrim
An external reference/payload targets a layer without specifying a prim
path, but the target layer has no defaultPrim metadata.
Fields
InvalidDefaultPrim
The defaultPrim metadata on a target layer has an invalid or
unexpected value.
Fields
InvalidExpression
A reference/payload asset path is a variable expression that failed to
parse or did not evaluate to a string (C++ PcpErrorVariableExpression).
The arc is skipped and the rest of the prim still composes, so this is
recoverable.
Fields
ArcPermissionDenied
A direct composition arc (a reference/inherit/payload/specialize
authored at the prim) targets a site whose composed permission is
private (spec 10.3.3). C++ records PcpErrorArcPermissionDenied; the
arc is reported but the node is retained, so this is recoverable.
Fields
ProhibitedRelocationSource
A composition arc (inherit/specialize/reference/payload/relocate) targets
a prim that is the source of a relocation — a prohibited child of its
parent (C++ PcpErrorArcToProhibitedChild): allowing it would resurrect the
opinions the relocation moved away. The arc is dropped. Reported while
composing the prim that authored the arc (composing, stamped by the
cache).
Fields
InvalidExternalTargetPath
A relationship target or attribute connection authored across a
composition arc names a path outside that arc’s namespace scope (C++
PcpErrorInvalidExternalTargetPath). The target cannot translate through
the arc, so it is dropped. Reported while composing the owning prim.
Fields
InvalidInstanceTargetPath
A relationship target or attribute connection authored in a class (an
inherit/specialize node) names an instance of that class rather than a
path within the class (C++ PcpErrorInvalidInstanceTargetPath). Pointing
at a specific instance breaks the invertibility of path translation, so
the target is dropped. The self instance (the one being composed) keeps
the generic InvalidExternalTargetPath
“outside scope” message instead. Reported while composing the owning prim.
Fields
InconsistentPropertyType
A property composes specs of inconsistent types — an attribute spec and a
relationship spec at the same path (C++ PcpErrorInconsistentPropertyType).
The strongest (defining) spec’s type wins; weaker specs of the other type
are ignored. Reported while composing the owning prim (.composing).
Fields
OpinionAtRelocationSource
A layer authors a direct opinion at a relocation source path, which is
invalid and ignored (C++ PcpErrorOpinionAtRelocationSource): once a prim
is relocated, its source location must be empty. Reported while composing
the prim that follows the relocation (composing); the cache stamps that
path when collecting the build’s errors.
Fields
UnresolvedSublayer
A sublayer asset path could not be resolved while building a layer stack
(C++ PcpErrorInvalidSublayerPath). The missing sublayer is skipped.
Fields
SublayerCycle
A layer’s subLayers form a cycle — a layer includes itself, directly or
transitively (C++ PcpErrorSublayerCycle). Detected while building the
stage root layer stack; the cyclic sublayer is skipped and the rest of the
stack still composes. root_layer is the layer whose sublayer list
re-introduces seen_layer.
Fields
SameTargetRelocations
Several relocations in a layer stack move different sources to the same
target (C++ PcpErrorInvalidSameTargetRelocations). All of them are
invalid and dropped.
Fields
ConflictingRelocation
Two relocations in a layer stack conflict — one’s target is another’s
source, or one’s source/target is a descendant of another’s source (C++
PcpErrorInvalidConflictingRelocation). The relocate is dropped; reason
is the specific rule violated.
Fields
reason: RelocateConflictReasonThe conflict rule violated.
InvalidRelocate
An authored relocate that breaks a structural rule — source and target
identical or nested, or a root-prim source — is invalid and ignored (C++
PcpErrorInvalidAuthoredRelocates). It is dropped while the layer stack
still composes. reason is the specific rule violated.
Trait Implementations§
Source§impl Error for Error
impl Error for Error
1.30.0 · Source§fn source(&self) -> Option<&(dyn Error + 'static)>
fn source(&self) -> Option<&(dyn Error + 'static)>
1.0.0 · Source§fn description(&self) -> &str
fn description(&self) -> &str
use the Display impl or to_string()