static void
_RemoveSpecFromLayer(
const SdfLayerHandle& dstLayer, const _SpecDataEntry& specData)
{
switch (dstLayer->GetSpecType(specData.dstPath)) {
case SdfSpecTypeAttribute:
_DoRemoveSpec<Sdf_AttributeChildPolicy>(dstLayer, specData);
break;
case SdfSpecTypeConnection:
_DoRemoveSpec<Sdf_AttributeConnectionChildPolicy>(dstLayer, specData);
break;
case SdfSpecTypeExpression:
_DoRemoveSpec<Sdf_ExpressionChildPolicy>(dstLayer, specData);
break;
case SdfSpecTypeMapper:
_DoRemoveSpec<Sdf_MapperChildPolicy>(dstLayer, specData);
break;
case SdfSpecTypeMapperArg:
_DoRemoveSpec<Sdf_MapperArgChildPolicy>(dstLayer, specData);
break;
case SdfSpecTypePrim:
_DoRemoveSpec<Sdf_PrimChildPolicy>(dstLayer, specData);
break;
case SdfSpecTypeRelationship:
_DoRemoveSpec<Sdf_RelationshipChildPolicy>(dstLayer, specData);
break;
case SdfSpecTypeRelationshipTarget:
_DoRemoveSpec<Sdf_RelationshipTargetChildPolicy>(dstLayer, specData);
break;
case SdfSpecTypeVariant:
_DoRemoveSpec<Sdf_VariantChildPolicy>(dstLayer, specData);
break;
case SdfSpecTypeVariantSet:
_DoRemoveSpec<Sdf_VariantSetChildPolicy>(dstLayer, specData);
break;
case SdfSpecTypePseudoRoot:
case SdfSpecTypeUnknown:
case SdfNumSpecTypes:
break;
}
}
bool
SdfCopySpec(
const SdfLayerHandle& srcLayer, const SdfPath& srcPath,
const SdfLayerHandle& dstLayer, const SdfPath& dstPath,
const SdfShouldCopyValueFn& shouldCopyValueFn,
const SdfShouldCopyChildrenFn& shouldCopyChildrenFn)
{
if (!srcLayer || !dstLayer) {
TF_CODING_ERROR("Invalid layer handle");
return false;
}
if (srcPath.IsEmpty() || dstPath.IsEmpty()) {
TF_CODING_ERROR("Invalid empty path");
return false;
}
// Validate compatible source and destination path types.
if ((srcPath.IsAbsoluteRootOrPrimPath()
|| srcPath.IsPrimVariantSelectionPath())
!= (dstPath.IsAbsoluteRootOrPrimPath()
|| dstPath.IsPrimVariantSelectionPath())
|| srcPath.IsPropertyPath() != dstPath.IsPropertyPath()
|| srcPath.IsTargetPath() != dstPath.IsTargetPath()
|| srcPath.IsMapperPath() != dstPath.IsMapperPath()
|| srcPath.IsMapperArgPath() != dstPath.IsMapperArgPath()
|| srcPath.IsExpressionPath() != dstPath.IsExpressionPath()) {
TF_CODING_ERROR("Incompatible source and destination paths");
return false;
}
// For target paths (relationship targets and connections), verify the
// destination spec already exists. See the documentation comment.
if (dstPath.IsTargetPath() && !dstLayer->HasSpec(dstPath)) {
TF_CODING_ERROR("Spec does not exist at destination target path");
return false;
}
// This function collects all of the data that will be copied for each
// spec into this list, then applies it to the layer at the very end.
// This allows us to do some analysis on the data first.
_CopyEntryList dataToCopy;
// Create a stack of source/dest copy requests, initially populated with
// the passed parameters. The copy routine will add additional requests
// as needed to handle children etc... and runs until the stack is empty.
_CopyStack copyStack(1, _CopyStackEntry(srcPath, dstPath));
while (!copyStack.empty()) {
const _CopyStackEntry toCopy = copyStack.front();
copyStack.pop_front();
// If the source path is empty, it indicates that the spec at the
// destination path should be removed. Add an entry to the queue
// to reflect that.
if (toCopy.srcPath.IsEmpty()) {
_SpecDataEntry removeEntry(toCopy.dstPath, SdfSpecTypeUnknown);
dataToCopy.push_back(removeEntry);
continue;
}
// Figure out the concrete type of the spec we're copying. The spec type
// dictates copying behavior below.
const SdfSpecType specType = srcLayer->GetSpecType(toCopy.srcPath);
if (specType == SdfSpecTypeUnknown) {
TF_CODING_ERROR("Cannot copy unknown spec at <%s> from layer <%s>",
srcPath.GetText(), srcLayer->GetIdentifier().c_str());
return false;
}
_SpecDataEntry copyEntry(toCopy.dstPath, specType);
// Determine what data is present for the current source and dest specs
// and what needs to be copied. Divide the present fields into those
// that contain values and those that index children specs.
std::vector<TfToken> dstValueFields;
std::vector<TfToken> dstChildrenFields;
_GetFieldNames(
dstLayer, toCopy.dstPath, &dstValueFields, &dstChildrenFields);
std::vector<TfToken> srcValueFields;
std::vector<TfToken> srcChildrenFields;
_GetFieldNames(
srcLayer, toCopy.srcPath, &srcValueFields, &srcChildrenFields);
// From the list of value fields, retrieve all values that the copy
// policy says we need to copy over to the destination.
_ForEachField(
srcValueFields, dstValueFields,
[&](const TfToken& field, bool fieldInSrc, bool fieldInDst) {
_AddFieldValueToCopy(
specType, field,
srcLayer, toCopy.srcPath, fieldInSrc,
dstLayer, toCopy.dstPath, fieldInDst,
shouldCopyValueFn, ©Entry.dataToCopy);
});
// Add an entry for all of the data we're copying for this spec.
dataToCopy.push_back(copyEntry);
// Now add any children specs that need to be copied to our
// copy stack.
_ForEachField(
srcChildrenFields, dstChildrenFields,
[&](const TfToken& field, bool fieldInSrc, bool fieldInDst) {
_ProcessChildField(
field,
srcLayer, toCopy.srcPath, fieldInSrc,
dstLayer, toCopy.dstPath, fieldInDst,
shouldCopyChildrenFn, ©Stack);
});
}
// Now that we have all the data we want to copy, set it into the
// destination layer.
SdfChangeBlock block;
for (const _SpecDataEntry& specData : dataToCopy) {
if (specData.specType == SdfSpecTypeUnknown) {
_RemoveSpecFromLayer(dstLayer, specData);
}
else {
_AddNewSpecToLayer(dstLayer, specData);
}
for (const _FieldValuePair& fieldValue : specData.dataToCopy) {
dstLayer->SetField(
specData.dstPath, fieldValue.first, fieldValue.second);
}
}
return true;
}
