FString UMulticastDelegateProperty::GetCPPType( FString* ExtendedTypeText/*=NULL*/, uint32 CPPExportFlags/*=0*/ ) const { #if HACK_HEADER_GENERATOR // We have this test because sometimes the delegate hasn't been set up by FixupDelegateProperties at the time // we need the type for an error message. We deliberately format it so that it's unambiguously not CPP code, but is still human-readable. if (!SignatureFunction) { return FString(TEXT("{multicast delegate type}")); } #endif FString UnmangledFunctionName = SignatureFunction->GetName().LeftChop( FString( HEADER_GENERATED_DELEGATE_SIGNATURE_SUFFIX ).Len() ); const UClass* OwnerClass = SignatureFunction->GetOwnerClass(); const bool bBlueprintCppBackend = (0 != (CPPExportFlags & EPropertyExportCPPFlags::CPPF_BlueprintCppBackend)); const bool bNative = SignatureFunction->IsNative(); if (bBlueprintCppBackend && bNative) { UStruct* StructOwner = Cast<UStruct>(SignatureFunction->GetOuter()); if (StructOwner) { return FString::Printf(TEXT("%s%s::F%s"), StructOwner->GetPrefixCPP(), *StructOwner->GetName(), *UnmangledFunctionName); } } else { if ((0 != (CPPExportFlags & EPropertyExportCPPFlags::CPPF_BlueprintCppBackend)) && OwnerClass && !OwnerClass->HasAnyClassFlags(CLASS_Native)) { // The name must be valid, this removes spaces, ?, etc from the user's function name. It could // be slightly shorter because the postfix ("__pf") is not needed here because we further post- // pend to the string. Normally the postfix is needed to make sure we don't mangle to a valid // identifier and collide: UnmangledFunctionName = UnicodeToCPPIdentifier(UnmangledFunctionName, false, TEXT("")); // the name must be unique const FString OwnerName = UnicodeToCPPIdentifier(OwnerClass->GetName(), false, TEXT("")); const FString NewUnmangledFunctionName = FString::Printf(TEXT("%s__%s"), *UnmangledFunctionName, *OwnerName); UnmangledFunctionName = NewUnmangledFunctionName; } if (0 != (CPPExportFlags & EPropertyExportCPPFlags::CPPF_CustomTypeName)) { UnmangledFunctionName += TEXT("__MulticastDelegate"); } } return FString(TEXT("F")) + UnmangledFunctionName; }
void FEmitDefaultValueHelper::OuterGenerate(FEmitterLocalContext& Context , const UProperty* Property , const FString& OuterPath , const uint8* DataContainer , const uint8* OptionalDefaultDataContainer , EPropertyAccessOperator AccessOperator , bool bAllowProtected) { // Determine if the given property contains an instanced default subobject reference. We only get here if the values are not identical. auto IsInstancedSubobjectLambda = [&](int32 ArrayIndex) -> bool { if (auto ObjectProperty = Cast<UObjectProperty>(Property)) { check(DataContainer); check(OptionalDefaultDataContainer); auto ObjectPropertyValue = ObjectProperty->GetObjectPropertyValue_InContainer(DataContainer, ArrayIndex); auto DefaultObjectPropertyValue = ObjectProperty->GetObjectPropertyValue_InContainer(OptionalDefaultDataContainer, ArrayIndex); if (ObjectPropertyValue && ObjectPropertyValue->IsDefaultSubobject() && DefaultObjectPropertyValue && DefaultObjectPropertyValue->IsDefaultSubobject() && ObjectPropertyValue->GetFName() == DefaultObjectPropertyValue->GetFName()) { return true; } } return false; }; if (Property->HasAnyPropertyFlags(CPF_EditorOnly | CPF_Transient)) { UE_LOG(LogK2Compiler, Verbose, TEXT("FEmitDefaultValueHelper Skip EditorOnly or Transient property: %s"), *Property->GetPathName()); return; } for (int32 ArrayIndex = 0; ArrayIndex < Property->ArrayDim; ++ArrayIndex) { if (!OptionalDefaultDataContainer || (!Property->Identical_InContainer(DataContainer, OptionalDefaultDataContainer, ArrayIndex) && !IsInstancedSubobjectLambda(ArrayIndex))) { FString PathToMember; UBlueprintGeneratedClass* PropertyOwnerAsBPGC = Cast<UBlueprintGeneratedClass>(Property->GetOwnerClass()); UScriptStruct* PropertyOwnerAsScriptStruct = Cast<UScriptStruct>(Property->GetOwnerStruct()); const bool bNoexportProperty = PropertyOwnerAsScriptStruct && PropertyOwnerAsScriptStruct->IsNative() && (PropertyOwnerAsScriptStruct->StructFlags & STRUCT_NoExport) // && !PropertyOwnerAsScriptStruct->GetBoolMetaData(TEXT("BlueprintType")) && ensure(EPropertyAccessOperator::Dot == AccessOperator); if (PropertyOwnerAsBPGC && !Context.Dependencies.WillClassBeConverted(PropertyOwnerAsBPGC)) { ensure(EPropertyAccessOperator::None != AccessOperator); const FString OperatorStr = (EPropertyAccessOperator::Dot == AccessOperator) ? TEXT("&") : TEXT(""); const FString ContainerStr = (EPropertyAccessOperator::None == AccessOperator) ? TEXT("this") : FString::Printf(TEXT("%s(%s)"), *OperatorStr, *OuterPath); PathToMember = FString::Printf(TEXT("FUnconvertedWrapper__%s(%s).GetRef__%s()"), *FEmitHelper::GetCppName(PropertyOwnerAsBPGC), *ContainerStr , *UnicodeToCPPIdentifier(Property->GetName(), false, nullptr)); } else if (bNoexportProperty || Property->HasAnyPropertyFlags(CPF_NativeAccessSpecifierPrivate) || (!bAllowProtected && Property->HasAnyPropertyFlags(CPF_NativeAccessSpecifierProtected))) { ensure(EPropertyAccessOperator::None != AccessOperator); const FString OperatorStr = (EPropertyAccessOperator::Dot == AccessOperator) ? TEXT("&") : TEXT(""); const FString ContainerStr = (EPropertyAccessOperator::None == AccessOperator) ? TEXT("this") : OuterPath; const FString GetPtrStr = bNoexportProperty ? FEmitHelper::AccessInaccessiblePropertyUsingOffset(Context, Property, ContainerStr, OperatorStr, ArrayIndex) : FEmitHelper::AccessInaccessibleProperty(Context, Property, ContainerStr, OperatorStr, ArrayIndex, false); PathToMember = Context.GenerateUniqueLocalName(); Context.AddLine(FString::Printf(TEXT("auto& %s = %s;"), *PathToMember, *GetPtrStr)); } else { const FString AccessOperatorStr = (EPropertyAccessOperator::None == AccessOperator) ? TEXT("") : ((EPropertyAccessOperator::Pointer == AccessOperator) ? TEXT("->") : TEXT(".")); const bool bStaticArray = (Property->ArrayDim > 1); const FString ArrayPost = bStaticArray ? FString::Printf(TEXT("[%d]"), ArrayIndex) : TEXT(""); PathToMember = FString::Printf(TEXT("%s%s%s%s"), *OuterPath, *AccessOperatorStr, *FEmitHelper::GetCppName(Property), *ArrayPost); } const uint8* ValuePtr = Property->ContainerPtrToValuePtr<uint8>(DataContainer, ArrayIndex); const uint8* DefaultValuePtr = OptionalDefaultDataContainer ? Property->ContainerPtrToValuePtr<uint8>(OptionalDefaultDataContainer, ArrayIndex) : nullptr; InnerGenerate(Context, Property, PathToMember, ValuePtr, DefaultValuePtr); } } }