ELEMENT

ELEMENT

#Overview

name: ELEMENT

This variable is created as a Console Variable (cvar).

It is referenced in 24 C++ source files.

#Summary

#Usage in the C++ source code

The purpose of ELEMENT is to serve as a text identifier for various XML elements in the DASH (Dynamic Adaptive Streaming over HTTP) manifest parsing system within the Electra Player plugin for Unreal Engine 5. It is used to define and identify different elements of the DASH MPD (Media Presentation Description) structure.

ELEMENT is primarily used in the ElectraPlayerRuntime module, specifically in the DASH manifest parser implementation. This variable is part of the Electra namespace and is used extensively in the ManifestParserDASH.cpp file.

The value of this variable is set using a macro definition:

#define DEF_ELEMENT(name) \
const TCHAR* const Element_##name = TEXT(#name)
#define ELEMENT(name) Tags::Element_##name

This macro is then used to define various DASH MPD elements, such as:

DEF_ELEMENT(MPD);
DEF_ELEMENT(EssentialProperty);
DEF_ELEMENT(SupplementalProperty);
DEF_ELEMENT(UTCTiming);
DEF_ELEMENT(ProgramInformation);
DEF_ELEMENT(Title);

The ELEMENT macro is used extensively throughout the manifest parsing process to identify and process different parts of the DASH MPD structure. It interacts with other parts of the code, such as the StringHelpers::StringEquals function, to compare element names during parsing.

Developers must be aware that this variable is crucial for correctly parsing DASH manifests. Modifying or misusing these element identifiers could lead to incorrect parsing of the MPD structure.

Best practices when using this variable include:

  1. Ensuring that all required DASH MPD elements are properly defined using the DEF_ELEMENT macro.
  2. Using the ELEMENT macro consistently when comparing element names during parsing.
  3. Keeping the element definitions up-to-date with any changes in the DASH specification.
  4. Being cautious when modifying existing element definitions, as it may affect the entire parsing process.

In addition to its use in the Electra Player plugin, there’s also a reference to an “ELEMENT” command in the UnrealEdSrv.cpp file, which appears to be part of the Unreal Editor’s command system. However, this usage is separate from the DASH manifest parsing system and likely serves a different purpose within the editor’s functionality.

#References in C++ code

#Callsites

This variable is referenced in the following C++ source code:

#Loc: <Workspace>/Engine/Plugins/Media/ElectraPlayer/Source/ElectraPlayerRuntime/Private/Runtime/Player/DASH/ManifestParserDASH.cpp:43

Scope (from outer to inner):

file
namespace    Electra
namespace    Tags

Source code excerpt:

#define DEF_ELEMENT(name) \
const TCHAR* const Element_##name = TEXT(#name)
#define ELEMENT(name) Tags::Element_##name
DEF_ELEMENT(MPD);
DEF_ELEMENT(EssentialProperty);
DEF_ELEMENT(SupplementalProperty);
DEF_ELEMENT(UTCTiming);
DEF_ELEMENT(ProgramInformation);
DEF_ELEMENT(Title);

#Loc: <Workspace>/Engine/Plugins/Media/ElectraPlayer/Source/ElectraPlayerRuntime/Private/Runtime/Player/DASH/ManifestParserDASH.cpp:581

Scope (from outer to inner):

file
namespace    Electra
function     bool FManifestParserDASH::ProcessElement

Source code excerpt:

			return false;
		}
		if (StringHelpers::StringEquals(ElementName, ELEMENT(MPD)))
		{
			RootEntities.MPDs.Emplace(MakeSharedTS<FDashMPD_MPDType>(ElementName, *ElementData));
			PushNewElement(RootEntities.MPDs.Last(), XmlFileLineNumber);
		}
		else if (StringHelpers::StringEquals(ElementName, ELEMENT(Period)))
		{
			RootEntities.Periods.Emplace(MakeSharedTS<FDashMPD_PeriodType>(ElementName, *ElementData));
			PushNewElement(RootEntities.Periods.Last(), XmlFileLineNumber);
		}
		else if (StringHelpers::StringEquals(ElementName, ELEMENT(AdaptationSet)))
		{
			RootEntities.AdaptationSets.Emplace(MakeSharedTS<FDashMPD_AdaptationSetType>(ElementName, *ElementData));
			PushNewElement(RootEntities.AdaptationSets.Last(), XmlFileLineNumber);
		}
		else if (StringHelpers::StringEquals(ElementName, ELEMENT(up_UrlQueryInfo)) || StringHelpers::StringEquals(ElementName, ELEMENT(up_ExtUrlQueryInfo)) || StringHelpers::StringEquals(ElementName, ELEMENT(up_ExtHttpHeaderInfo)))
		{
			RootEntities.UrlQueries.Emplace(MakeSharedTS<FDashMPD_UrlQueryInfoType>(ElementName, *ElementData));
			PushNewElement(RootEntities.UrlQueries.Last(), XmlFileLineNumber);
		}
		else if (StringHelpers::StringEquals(ElementName, ELEMENT(InitializationSet)))
		{
			RootEntities.InitializationSets.Emplace(MakeSharedTS<FDashMPD_InitializationSetType>(ElementName, *ElementData));
			PushNewElement(RootEntities.InitializationSets.Last(), XmlFileLineNumber);
		}
		else if (StringHelpers::StringEquals(ElementName, ELEMENT(EventStream)))
		{
			RootEntities.EventStreams.Emplace(MakeSharedTS<FDashMPD_EventStreamType>(ElementName, *ElementData));
			PushNewElement(RootEntities.EventStreams.Last(), XmlFileLineNumber);
		}
		else if (StringHelpers::StringEquals(ElementName, ELEMENT(SegmentList)))
		{
			RootEntities.SegmentLists.Emplace(MakeSharedTS<FDashMPD_SegmentListType>(ElementName, *ElementData));
			PushNewElement(RootEntities.SegmentLists.Last(), XmlFileLineNumber);
		}
		else
		{

#Loc: <Workspace>/Engine/Plugins/Media/ElectraPlayer/Source/ElectraPlayerRuntime/Private/Runtime/Player/DASH/ManifestParserDASH.cpp:847

Scope (from outer to inner):

file
namespace    Electra
function     bool FDashMPD_MPDType::ProcessElement

Source code excerpt:

bool FDashMPD_MPDType::ProcessElement(FManifestParserDASH* Builder, const TCHAR* ElementName, const TCHAR* ElementData, int32 XmlFileLineNumber)
{
	if (StringHelpers::StringEquals(ElementName, ELEMENT(Period)))
	{
		Periods.Emplace(MakeSharedTS<FDashMPD_PeriodType>(ElementName, ElementData));
		return Builder->PushNewElement(Periods.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(BaseURL)))
	{
		BaseURLs.Emplace(MakeSharedTS<FDashMPD_BaseURLType>(ElementName, ElementData));
		return Builder->PushNewElement(BaseURLs.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(Location)))
	{
		Locations.Emplace(MakeSharedTS<FDashMPD_OtherType>(ElementName, ElementData));
		return Builder->PushNewElement(Locations.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(ProgramInformation)))
	{
		ProgramInformations.Emplace(MakeSharedTS<FDashMPD_ProgramInformationType>(ElementName, ElementData));
		return Builder->PushNewElement(ProgramInformations.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(EssentialProperty)))
	{
		EssentialProperties.Emplace(MakeSharedTS<FDashMPD_DescriptorType>(ElementName, ElementData));
		return Builder->PushNewElement(EssentialProperties.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(SupplementalProperty)))
	{
		SupplementalProperties.Emplace(MakeSharedTS<FDashMPD_DescriptorType>(ElementName, ElementData));
		return Builder->PushNewElement(SupplementalProperties.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(UTCTiming)))
	{
		UTCTimings.Emplace(MakeSharedTS<FDashMPD_DescriptorType>(ElementName, ElementData));
		return Builder->PushNewElement(UTCTimings.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(ServiceDescription)))
	{
		ServiceDescriptions.Emplace(MakeSharedTS<FDashMPD_ServiceDescriptionType>(ElementName, ElementData));
		return Builder->PushNewElement(ServiceDescriptions.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(InitializationSet)))
	{
		InitializationSets.Emplace(MakeSharedTS<FDashMPD_InitializationSetType>(ElementName, ElementData));
		return Builder->PushNewElement(InitializationSets.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(InitializationGroup)))
	{
		InitializationGroups.Emplace(MakeSharedTS<FDashMPD_UIntVWithIDType>(ElementName, ElementData));
		return Builder->PushNewElement(InitializationGroups.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(InitializationPresentation)))
	{
		InitializationPresentations.Emplace(MakeSharedTS<FDashMPD_UIntVWithIDType>(ElementName, ElementData));
		return Builder->PushNewElement(InitializationPresentations.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(LeapSecondInformation)))
	{
		LeapSecondInformation = MakeSharedTS<FDashMPD_LeapSecondInformationType>(ElementName, ElementData);
		return Builder->PushNewElement(LeapSecondInformation, XmlFileLineNumber);
	}
	else
	{

#Loc: <Workspace>/Engine/Plugins/Media/ElectraPlayer/Source/ElectraPlayerRuntime/Private/Runtime/Player/DASH/ManifestParserDASH.cpp:1033

Scope (from outer to inner):

file
namespace    Electra
function     bool FDashMPD_ProgramInformationType::ProcessElement

Source code excerpt:

bool FDashMPD_ProgramInformationType::ProcessElement(FManifestParserDASH* Builder, const TCHAR* ElementName, const TCHAR* ElementData, int32 XmlFileLineNumber)
{
	if (StringHelpers::StringEquals(ElementName, ELEMENT(Title)))
	{
		Title = MakeSharedTS<FDashMPD_OtherType>(ElementName, ElementData);
		return Builder->PushNewElement(Title, XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(Source)))
	{
		Source = MakeSharedTS<FDashMPD_OtherType>(ElementName, ElementData);
		return Builder->PushNewElement(Source, XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(Copyright)))
	{
		Copyright = MakeSharedTS<FDashMPD_OtherType>(ElementName, ElementData);
		return Builder->PushNewElement(Copyright, XmlFileLineNumber);
	}
	else
	{

#Loc: <Workspace>/Engine/Plugins/Media/ElectraPlayer/Source/ElectraPlayerRuntime/Private/Runtime/Player/DASH/ManifestParserDASH.cpp:1192

Scope (from outer to inner):

file
namespace    Electra
function     bool FDashMPD_DescriptorType::ProcessElement

Source code excerpt:

{
	// Handle well-known DASH types here for convenience and easier access.
	if (StringHelpers::StringEquals(ElementName, ELEMENT(up_UrlQueryInfo)) && StringHelpers::StringEquals(*SchemeIdUri, Tags::Scheme_urn_mpeg_dash_urlparam_2014))
	{
		if (StringHelpers::StringEquals(*GetName(), ELEMENT(EssentialProperty)) || StringHelpers::StringEquals(*GetName(), ELEMENT(SupplementalProperty)))
		{
			WellKnownDescriptors.Emplace(MakeSharedTS<FDashMPD_UrlQueryInfoType>(ElementName, ElementData));
			return Builder->PushNewElement(WellKnownDescriptors.Last(), XmlFileLineNumber);
		}
		else
		{

#Loc: <Workspace>/Engine/Plugins/Media/ElectraPlayer/Source/ElectraPlayerRuntime/Private/Runtime/Player/DASH/ManifestParserDASH.cpp:1204

Scope (from outer to inner):

file
namespace    Electra
function     bool FDashMPD_DescriptorType::ProcessElement

Source code excerpt:

		}
	}
	else if ((StringHelpers::StringEquals(ElementName, ELEMENT(up_ExtUrlQueryInfo)) || StringHelpers::StringEquals(ElementName, ELEMENT(up_ExtHttpHeaderInfo))) && StringHelpers::StringEquals(*SchemeIdUri, Tags::Scheme_urn_mpeg_dash_urlparam_2016))
	{
		if (StringHelpers::StringEquals(*GetName(), ELEMENT(EssentialProperty)) || StringHelpers::StringEquals(*GetName(), ELEMENT(SupplementalProperty)))
		{
			WellKnownDescriptors.Emplace(MakeSharedTS<FDashMPD_UrlQueryInfoType>(ElementName, ElementData,
				StringHelpers::StringEquals(ElementName, ELEMENT(up_ExtUrlQueryInfo)) ? FDashMPD_UrlQueryInfoType::EExtendedUrlInfoType::ExtUrlQueryInfo : FDashMPD_UrlQueryInfoType::EExtendedUrlInfoType::ExtHttpHeaderInfo));
			return Builder->PushNewElement(WellKnownDescriptors.Last(), XmlFileLineNumber);
		}
		else
		{
			return Super::ProcessElement(Builder, ElementName, ElementData, XmlFileLineNumber);
		}

#Loc: <Workspace>/Engine/Plugins/Media/ElectraPlayer/Source/ElectraPlayerRuntime/Private/Runtime/Player/DASH/ManifestParserDASH.cpp:1307

Scope (from outer to inner):

file
namespace    Electra
function     bool FDashMPD_EventStreamType::ProcessElement

Source code excerpt:

bool FDashMPD_EventStreamType::ProcessElement(FManifestParserDASH* Builder, const TCHAR* ElementName, const TCHAR* ElementData, int32 XmlFileLineNumber)
{
	if (StringHelpers::StringEquals(ElementName, ELEMENT(Event)))
	{
		Events.Emplace(MakeSharedTS<FDashMPD_EventType>(ElementName, ElementData));
		return Builder->PushNewElement(Events.Last(), XmlFileLineNumber);
	}
	else
	{

#Loc: <Workspace>/Engine/Plugins/Media/ElectraPlayer/Source/ElectraPlayerRuntime/Private/Runtime/Player/DASH/ManifestParserDASH.cpp:1350

Scope (from outer to inner):

file
namespace    Electra
function     bool FDashMPD_PeriodType::ProcessElement

Source code excerpt:

bool FDashMPD_PeriodType::ProcessElement(FManifestParserDASH* Builder, const TCHAR* ElementName, const TCHAR* ElementData, int32 XmlFileLineNumber)
{
	if (StringHelpers::StringEquals(ElementName, ELEMENT(AdaptationSet)))
	{
		AdaptationSets.Emplace(MakeSharedTS<FDashMPD_AdaptationSetType>(ElementName, ElementData));
		return Builder->PushNewElement(AdaptationSets.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(BaseURL)))
	{
		BaseURLs.Emplace(MakeSharedTS<FDashMPD_BaseURLType>(ElementName, ElementData));
		return Builder->PushNewElement(BaseURLs.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(SupplementalProperty)))
	{
		SupplementalProperties.Emplace(MakeSharedTS<FDashMPD_DescriptorType>(ElementName, ElementData));
		return Builder->PushNewElement(SupplementalProperties.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(SegmentBase)))
	{
		SegmentBase = MakeSharedTS<FDashMPD_SegmentBaseType>(ElementName, ElementData);
		return Builder->PushNewElement(SegmentBase, XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(SegmentList)))
	{
		SegmentList = MakeSharedTS<FDashMPD_SegmentListType>(ElementName, ElementData);
		return Builder->PushNewElement(SegmentList, XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(SegmentTemplate)))
	{
		SegmentTemplate = MakeSharedTS<FDashMPD_SegmentTemplateType>(ElementName, ElementData);
		return Builder->PushNewElement(SegmentTemplate, XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(AssetIdentifier)))
	{
		AssetIdentifier = MakeSharedTS<FDashMPD_DescriptorType>(ElementName, ElementData);
		return Builder->PushNewElement(AssetIdentifier, XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(EventStream)))
	{
		EventStreams.Emplace(MakeSharedTS<FDashMPD_EventStreamType>(ElementName, ElementData));
		return Builder->PushNewElement(EventStreams.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(Subset)))
	{
		Subsets.Emplace(MakeSharedTS<FDashMPD_SubsetType>(ElementName, ElementData));
		return Builder->PushNewElement(Subsets.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(ServiceDescription)))
	{
		ServiceDescriptions.Emplace(MakeSharedTS<FDashMPD_ServiceDescriptionType>(ElementName, ElementData));
		return Builder->PushNewElement(ServiceDescriptions.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(EmptyAdaptationSet)))
	{
		EmptyAdaptationSets.Emplace(MakeSharedTS<FDashMPD_AdaptationSetType>(ElementName, ElementData));
		return Builder->PushNewElement(EmptyAdaptationSets.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(Preselection)))
	{
		Preselections.Emplace(MakeSharedTS<FDashMPD_PreselectionType>(ElementName, ElementData));
		return Builder->PushNewElement(Preselections.Last(), XmlFileLineNumber);
	}
	else
	{

#Loc: <Workspace>/Engine/Plugins/Media/ElectraPlayer/Source/ElectraPlayerRuntime/Private/Runtime/Player/DASH/ManifestParserDASH.cpp:1524

Scope (from outer to inner):

file
namespace    Electra
function     bool FDashMPD_RepresentationBaseType::ProcessElement

Source code excerpt:

bool FDashMPD_RepresentationBaseType::ProcessElement(FManifestParserDASH* Builder, const TCHAR* ElementName, const TCHAR* ElementData, int32 XmlFileLineNumber)
{
	if (StringHelpers::StringEquals(ElementName, ELEMENT(FramePacking)))
	{
		FramePackings.Emplace(MakeSharedTS<FDashMPD_DescriptorType>(ElementName, ElementData));
		return Builder->PushNewElement(FramePackings.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(AudioChannelConfiguration)))
	{
		AudioChannelConfigurations.Emplace(MakeSharedTS<FDashMPD_DescriptorType>(ElementName, ElementData));
		return Builder->PushNewElement(AudioChannelConfigurations.Last(), XmlFileLineNumber);
	}

	else if (StringHelpers::StringEquals(ElementName, ELEMENT(ContentProtection)))
	{
		ContentProtections.Emplace(MakeSharedTS<FDashMPD_DescriptorType>(ElementName, ElementData));
		return Builder->PushNewElement(ContentProtections.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(EssentialProperty)))
	{
		EssentialProperties.Emplace(MakeSharedTS<FDashMPD_DescriptorType>(ElementName, ElementData));
		return Builder->PushNewElement(EssentialProperties.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(SupplementalProperty)))
	{
		SupplementalProperties.Emplace(MakeSharedTS<FDashMPD_DescriptorType>(ElementName, ElementData));
		return Builder->PushNewElement(SupplementalProperties.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(InbandEventStream)))
	{
		InbandEventStreams.Emplace(MakeSharedTS<FDashMPD_EventStreamType>(ElementName, ElementData));
		return Builder->PushNewElement(InbandEventStreams.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(Switching)))
	{
		Switchings.Emplace(MakeSharedTS<FDashMPD_SwitchingType>(ElementName, ElementData));
		return Builder->PushNewElement(Switchings.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(RandomAccess)))
	{
		RandomAccesses.Emplace(MakeSharedTS<FDashMPD_RandomAccessType>(ElementName, ElementData));
		return Builder->PushNewElement(RandomAccesses.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(GroupLabel)))
	{
		GroupLabels.Emplace(MakeSharedTS<FDashMPD_LabelType>(ElementName, ElementData));
		return Builder->PushNewElement(GroupLabels.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(Label)))
	{
		Labels.Emplace(MakeSharedTS<FDashMPD_LabelType>(ElementName, ElementData));
		return Builder->PushNewElement(Labels.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(ProducerReferenceTime)))
	{
		ProducerReferenceTimes.Emplace(MakeSharedTS<FDashMPD_ProducerReferenceTimeType>(ElementName, ElementData));
		return Builder->PushNewElement(ProducerReferenceTimes.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(ContentPopularityRate)))
	{
		ContentPopularityRates.Emplace(MakeSharedTS<FDashMPD_ContentPopularityRateType>(ElementName, ElementData));
		return Builder->PushNewElement(ContentPopularityRates.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(Resync)))
	{
		Resyncs.Emplace(MakeSharedTS<FDashMPD_ResyncType>(ElementName, ElementData));
		return Builder->PushNewElement(Resyncs.Last(), XmlFileLineNumber);
	}
	else
	{

#Loc: <Workspace>/Engine/Plugins/Media/ElectraPlayer/Source/ElectraPlayerRuntime/Private/Runtime/Player/DASH/ManifestParserDASH.cpp:1702

Scope (from outer to inner):

file
namespace    Electra
function     bool FDashMPD_ContentComponentType::ProcessElement

Source code excerpt:

bool FDashMPD_ContentComponentType::ProcessElement(FManifestParserDASH* Builder, const TCHAR* ElementName, const TCHAR* ElementData, int32 XmlFileLineNumber)
{
	if (StringHelpers::StringEquals(ElementName, ELEMENT(Accessibility)))
	{
		Accessibilities.Emplace(MakeSharedTS<FDashMPD_DescriptorType>(ElementName, ElementData));
		return Builder->PushNewElement(Accessibilities.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(Role)))
	{
		Roles.Emplace(MakeSharedTS<FDashMPD_DescriptorType>(ElementName, ElementData));
		return Builder->PushNewElement(Roles.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(Rating)))
	{
		Ratings.Emplace(MakeSharedTS<FDashMPD_DescriptorType>(ElementName, ElementData));
		return Builder->PushNewElement(Ratings.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(Viewpoint)))
	{
		Viewpoints.Emplace(MakeSharedTS<FDashMPD_DescriptorType>(ElementName, ElementData));
		return Builder->PushNewElement(Viewpoints.Last(), XmlFileLineNumber);
	}
	else
	{

#Loc: <Workspace>/Engine/Plugins/Media/ElectraPlayer/Source/ElectraPlayerRuntime/Private/Runtime/Player/DASH/ManifestParserDASH.cpp:1764

Scope (from outer to inner):

file
namespace    Electra
function     bool FDashMPD_AdaptationSetType::ProcessElement

Source code excerpt:

bool FDashMPD_AdaptationSetType::ProcessElement(FManifestParserDASH* Builder, const TCHAR* ElementName, const TCHAR* ElementData, int32 XmlFileLineNumber)
{
	if (StringHelpers::StringEquals(ElementName, ELEMENT(Representation)))
	{
		Representations.Emplace(MakeSharedTS<FDashMPD_RepresentationType>(ElementName, ElementData));
		return Builder->PushNewElement(Representations.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(SegmentBase)))
	{
		SegmentBase = MakeSharedTS<FDashMPD_SegmentBaseType>(ElementName, ElementData);
		return Builder->PushNewElement(SegmentBase, XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(SegmentList)))
	{
		SegmentList = MakeSharedTS<FDashMPD_SegmentListType>(ElementName, ElementData);
		return Builder->PushNewElement(SegmentList, XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(SegmentTemplate)))
	{
		SegmentTemplate = MakeSharedTS<FDashMPD_SegmentTemplateType>(ElementName, ElementData);
		return Builder->PushNewElement(SegmentTemplate, XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(BaseURL)))
	{
		BaseURLs.Emplace(MakeSharedTS<FDashMPD_BaseURLType>(ElementName, ElementData));
		return Builder->PushNewElement(BaseURLs.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(Accessibility)))
	{
		Accessibilities.Emplace(MakeSharedTS<FDashMPD_DescriptorType>(ElementName, ElementData));
		return Builder->PushNewElement(Accessibilities.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(Role)))
	{
		Roles.Emplace(MakeSharedTS<FDashMPD_DescriptorType>(ElementName, ElementData));
		return Builder->PushNewElement(Roles.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(Rating)))
	{
		Ratings.Emplace(MakeSharedTS<FDashMPD_DescriptorType>(ElementName, ElementData));
		return Builder->PushNewElement(Ratings.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(Viewpoint)))
	{
		Viewpoints.Emplace(MakeSharedTS<FDashMPD_DescriptorType>(ElementName, ElementData));
		return Builder->PushNewElement(Viewpoints.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(ContentComponent)))
	{
		ContentComponents.Emplace(MakeSharedTS<FDashMPD_ContentComponentType>(ElementName, ElementData));
		return Builder->PushNewElement(ContentComponents.Last(), XmlFileLineNumber);
	}
	else
	{

#Loc: <Workspace>/Engine/Plugins/Media/ElectraPlayer/Source/ElectraPlayerRuntime/Private/Runtime/Player/DASH/ManifestParserDASH.cpp:2066

Scope (from outer to inner):

file
namespace    Electra
function     bool FDashMPD_ProducerReferenceTimeType::ProcessElement

Source code excerpt:

bool FDashMPD_ProducerReferenceTimeType::ProcessElement(FManifestParserDASH* Builder, const TCHAR* ElementName, const TCHAR* ElementData, int32 XmlFileLineNumber)
{
	if (StringHelpers::StringEquals(ElementName, ELEMENT(UTCTiming)))
	{
		if (UTCTiming.IsValid())
		{
			return Builder->SetLastError(FString::Printf(TEXT("<%s> element cannot have more than one <%s> children in line %d"), *GetName(), ElementName, GetXMLLineNumber()), ERRCODE_DASH_MPD_PARSER_ELEMENT_CANNOT_HAVE_CHILDREN);
		}
		UTCTiming = MakeSharedTS<FDashMPD_DescriptorType>(ElementName, ElementData);

#Loc: <Workspace>/Engine/Plugins/Media/ElectraPlayer/Source/ElectraPlayerRuntime/Private/Runtime/Player/DASH/ManifestParserDASH.cpp:2159

Scope (from outer to inner):

file
namespace    Electra
function     bool FDashMPD_ContentPopularityRateType::ProcessElement

Source code excerpt:

bool FDashMPD_ContentPopularityRateType::ProcessElement(FManifestParserDASH* Builder, const TCHAR* ElementName, const TCHAR* ElementData, int32 XmlFileLineNumber)
{
	if (StringHelpers::StringEquals(ElementName, ELEMENT(PR)))
	{
		PR_Elements.Emplace(MakeSharedTS<FPRElement>(ElementName, ElementData));
		return Builder->PushNewElement(PR_Elements.Last(), XmlFileLineNumber);
	}
	else
	{

#Loc: <Workspace>/Engine/Plugins/Media/ElectraPlayer/Source/ElectraPlayerRuntime/Private/Runtime/Player/DASH/ManifestParserDASH.cpp:2190

Scope (from outer to inner):

file
namespace    Electra
function     bool FDashMPD_InitializationSetType::ProcessElement

Source code excerpt:

bool FDashMPD_InitializationSetType::ProcessElement(FManifestParserDASH* Builder, const TCHAR* ElementName, const TCHAR* ElementData, int32 XmlFileLineNumber)
{
	if (StringHelpers::StringEquals(ElementName, ELEMENT(Accessibility)))
	{
		Accessibilities.Emplace(MakeSharedTS<FDashMPD_DescriptorType>(ElementName, ElementData));
		return Builder->PushNewElement(Accessibilities.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(Role)))
	{
		Roles.Emplace(MakeSharedTS<FDashMPD_DescriptorType>(ElementName, ElementData));
		return Builder->PushNewElement(Roles.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(Rating)))
	{
		Ratings.Emplace(MakeSharedTS<FDashMPD_DescriptorType>(ElementName, ElementData));
		return Builder->PushNewElement(Ratings.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(Viewpoint)))
	{
		Viewpoints.Emplace(MakeSharedTS<FDashMPD_DescriptorType>(ElementName, ElementData));
		return Builder->PushNewElement(Viewpoints.Last(), XmlFileLineNumber);
	}
	else
	{

#Loc: <Workspace>/Engine/Plugins/Media/ElectraPlayer/Source/ElectraPlayerRuntime/Private/Runtime/Player/DASH/ManifestParserDASH.cpp:2264

Scope (from outer to inner):

file
namespace    Electra
function     bool FDashMPD_PreselectionType::ProcessElement

Source code excerpt:

bool FDashMPD_PreselectionType::ProcessElement(FManifestParserDASH* Builder, const TCHAR* ElementName, const TCHAR* ElementData, int32 XmlFileLineNumber)
{
	if (StringHelpers::StringEquals(ElementName, ELEMENT(Accessibility)))
	{
		Accessibilities.Emplace(MakeSharedTS<FDashMPD_DescriptorType>(ElementName, ElementData));
		return Builder->PushNewElement(Accessibilities.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(Role)))
	{
		Roles.Emplace(MakeSharedTS<FDashMPD_DescriptorType>(ElementName, ElementData));
		return Builder->PushNewElement(Roles.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(Rating)))
	{
		Ratings.Emplace(MakeSharedTS<FDashMPD_DescriptorType>(ElementName, ElementData));
		return Builder->PushNewElement(Ratings.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(Viewpoint)))
	{
		Viewpoints.Emplace(MakeSharedTS<FDashMPD_DescriptorType>(ElementName, ElementData));
		return Builder->PushNewElement(Viewpoints.Last(), XmlFileLineNumber);
	}
	else
	{

#Loc: <Workspace>/Engine/Plugins/Media/ElectraPlayer/Source/ElectraPlayerRuntime/Private/Runtime/Player/DASH/ManifestParserDASH.cpp:2467

Scope (from outer to inner):

file
namespace    Electra
function     bool FDashMPD_LatencyType::ProcessElement

Source code excerpt:

bool FDashMPD_LatencyType::ProcessElement(FManifestParserDASH* Builder, const TCHAR* ElementName, const TCHAR* ElementData, int32 XmlFileLineNumber)
{
	if (StringHelpers::StringEquals(ElementName, ELEMENT(QualityLatency)))
	{
		QualityLatencies.Emplace(MakeSharedTS<FDashMPD_UIntPairsWithIDType>(ElementName, ElementData));
		return Builder->PushNewElement(QualityLatencies.Last(), XmlFileLineNumber);
	}
	else
	{

#Loc: <Workspace>/Engine/Plugins/Media/ElectraPlayer/Source/ElectraPlayerRuntime/Private/Runtime/Player/DASH/ManifestParserDASH.cpp:2506

Scope (from outer to inner):

file
namespace    Electra
function     bool FDashMPD_ServiceDescriptionType::ProcessElement

Source code excerpt:

bool FDashMPD_ServiceDescriptionType::ProcessElement(FManifestParserDASH* Builder, const TCHAR* ElementName, const TCHAR* ElementData, int32 XmlFileLineNumber)
{
	if (StringHelpers::StringEquals(ElementName, ELEMENT(Scope)))
	{
		Scopes.Emplace(MakeSharedTS<FDashMPD_DescriptorType>(ElementName, ElementData));
		return Builder->PushNewElement(Scopes.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(Latency)))
	{
		Latencies.Emplace(MakeSharedTS<FDashMPD_LatencyType>(ElementName, ElementData));
		return Builder->PushNewElement(Latencies.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(PlaybackRate)))
	{
		PlaybackRates.Emplace(MakeSharedTS<FDashMPD_PlaybackRateType>(ElementName, ElementData));
		return Builder->PushNewElement(PlaybackRates.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(OperatingQuality)))
	{
		OperatingQualities.Emplace(MakeSharedTS<FDashMPD_OperatingQualityType>(ElementName, ElementData));
		return Builder->PushNewElement(OperatingQualities.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(OperatingBandwidth)))
	{
		OperatingBandwidths.Emplace(MakeSharedTS<FDashMPD_OperatingBandwidthType>(ElementName, ElementData));
		return Builder->PushNewElement(OperatingBandwidths.Last(), XmlFileLineNumber);
	}
	else
	{

#Loc: <Workspace>/Engine/Plugins/Media/ElectraPlayer/Source/ElectraPlayerRuntime/Private/Runtime/Player/DASH/ManifestParserDASH.cpp:2596

Scope (from outer to inner):

file
namespace    Electra
function     bool FDashMPD_RepresentationType::ProcessElement

Source code excerpt:

bool FDashMPD_RepresentationType::ProcessElement(FManifestParserDASH* Builder, const TCHAR* ElementName, const TCHAR* ElementData, int32 XmlFileLineNumber)
{
	if (StringHelpers::StringEquals(ElementName, ELEMENT(SegmentBase)))
	{
		SegmentBase = MakeSharedTS<FDashMPD_SegmentBaseType>(ElementName, ElementData);
		return Builder->PushNewElement(SegmentBase, XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(SegmentList)))
	{
		SegmentList = MakeSharedTS<FDashMPD_SegmentListType>(ElementName, ElementData);
		return Builder->PushNewElement(SegmentList, XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(SegmentTemplate)))
	{
		SegmentTemplate = MakeSharedTS<FDashMPD_SegmentTemplateType>(ElementName, ElementData);
		return Builder->PushNewElement(SegmentTemplate, XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(BaseURL)))
	{
		BaseURLs.Emplace(MakeSharedTS<FDashMPD_BaseURLType>(ElementName, ElementData));
		return Builder->PushNewElement(BaseURLs.Last(), XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(SubRepresentation)))
	{
		SubRepresentations.Emplace(MakeSharedTS<FDashMPD_SubRepresentationType>(ElementName, ElementData));
		return Builder->PushNewElement(SubRepresentations.Last(), XmlFileLineNumber);
	}
	else
	{

#Loc: <Workspace>/Engine/Plugins/Media/ElectraPlayer/Source/ElectraPlayerRuntime/Private/Runtime/Player/DASH/ManifestParserDASH.cpp:2694

Scope (from outer to inner):

file
namespace    Electra
function     bool FDashMPD_SegmentBaseType::ProcessElement

Source code excerpt:

bool FDashMPD_SegmentBaseType::ProcessElement(FManifestParserDASH* Builder, const TCHAR* ElementName, const TCHAR* ElementData, int32 XmlFileLineNumber)
{
	if (StringHelpers::StringEquals(ElementName, ELEMENT(Initialization)))
	{
		Initialization = MakeSharedTS<FDashMPD_URLType>(ElementName, ElementData);
		return Builder->PushNewElement(Initialization, XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(RepresentationIndex)))
	{
		RepresentationIndex = MakeSharedTS<FDashMPD_URLType>(ElementName, ElementData);
		return Builder->PushNewElement(RepresentationIndex, XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(FailoverContent)))
	{
		FailoverContent = MakeSharedTS<FDashMPD_FailoverContentType>(ElementName, ElementData);
		return Builder->PushNewElement(FailoverContent, XmlFileLineNumber);
	}
	else
	{

#Loc: <Workspace>/Engine/Plugins/Media/ElectraPlayer/Source/ElectraPlayerRuntime/Private/Runtime/Player/DASH/ManifestParserDASH.cpp:2763

Scope (from outer to inner):

file
namespace    Electra
function     bool FDashMPD_MultipleSegmentBaseType::ProcessElement

Source code excerpt:

bool FDashMPD_MultipleSegmentBaseType::ProcessElement(FManifestParserDASH* Builder, const TCHAR* ElementName, const TCHAR* ElementData, int32 XmlFileLineNumber)
{
	if (StringHelpers::StringEquals(ElementName, ELEMENT(SegmentTimeline)))
	{
		SegmentTimeline = MakeSharedTS<FDashMPD_SegmentTimelineType>(ElementName, ElementData);
		return Builder->PushNewElement(SegmentTimeline, XmlFileLineNumber);
	}
	else if (StringHelpers::StringEquals(ElementName, ELEMENT(BitstreamSwitching)))
	{
		BitstreamSwitching = MakeSharedTS<FDashMPD_URLType>(ElementName, ElementData);
		return Builder->PushNewElement(BitstreamSwitching, XmlFileLineNumber);
	}
	else
	{

#Loc: <Workspace>/Engine/Plugins/Media/ElectraPlayer/Source/ElectraPlayerRuntime/Private/Runtime/Player/DASH/ManifestParserDASH.cpp:2803

Scope (from outer to inner):

file
namespace    Electra
function     bool FDashMPD_SegmentListType::ProcessElement

Source code excerpt:

bool FDashMPD_SegmentListType::ProcessElement(FManifestParserDASH* Builder, const TCHAR* ElementName, const TCHAR* ElementData, int32 XmlFileLineNumber)
{
	if (StringHelpers::StringEquals(ElementName, ELEMENT(SegmentURL)))
	{
		SegmentURLs.Emplace(MakeSharedTS<FDashMPD_SegmentURLType>(ElementName, ElementData));
		return Builder->PushNewElement(SegmentURLs.Last(), XmlFileLineNumber);
	}
	else
	{

#Loc: <Workspace>/Engine/Plugins/Media/ElectraPlayer/Source/ElectraPlayerRuntime/Private/Runtime/Player/DASH/ManifestParserDASH.cpp:2856

Scope (from outer to inner):

file
namespace    Electra
function     bool FDashMPD_SegmentTimelineType::ProcessElement

Source code excerpt:

bool FDashMPD_SegmentTimelineType::ProcessElement(FManifestParserDASH* Builder, const TCHAR* ElementName, const TCHAR* ElementData, int32 XmlFileLineNumber)
{
	if (StringHelpers::StringEquals(ElementName, ELEMENT(S)))
	{
		// Add a new element to our chunked array.
		Builder->GetSBuilder()->SetCurrentElement(&S_Elements[S_Elements.Add(1)]);
		return Builder->PushNewElement(Builder->GetSBuilder(), XmlFileLineNumber);
	}
	else

#Loc: <Workspace>/Engine/Plugins/Media/ElectraPlayer/Source/ElectraPlayerRuntime/Private/Runtime/Player/DASH/ManifestParserDASH.cpp:2933

Scope (from outer to inner):

file
namespace    Electra
function     bool FDashMPD_FailoverContentType::ProcessElement

Source code excerpt:

bool FDashMPD_FailoverContentType::ProcessElement(FManifestParserDASH* Builder, const TCHAR* ElementName, const TCHAR* ElementData, int32 XmlFileLineNumber)
{
	if (StringHelpers::StringEquals(ElementName, ELEMENT(FCS)))
	{
		Builder->GetFCSBuilder()->SetCurrentElement(&FCS_Elements[FCS_Elements.Add(1)]);
		return Builder->PushNewElement(Builder->GetFCSBuilder(), XmlFileLineNumber);
	}
	else
	{

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/UnrealEdSrv.cpp:727

Scope (from outer to inner):

file
function     bool UUnrealEdEngine::Exec

Source code excerpt:

	// ELEMENT: Element-related functions
	//
	else if (FParse::Command(&Str,TEXT("ELEMENT")))
	{
		return Exec_Element( InWorld, Str, Ar );
	}
	//------------------------------------------------------------------------------------
	// MODE management (Global EDITOR mode):
	//