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; }