private void ЗакешироватьЭлементКоллекции(УзелМетаданных узелМетаданных, MetadataNode node)
{
if (this.cache != null)
{
this.cache.УстановитьЗначение(узелМетаданных.Путь(), УзелМетаданных.ОбъектВXML(node));
}
}
/// <summary>
/// Reference item groups
/// </summary>
public IEnumerable <FrameworkSpecificGroup> GetReferenceGroups()
{
var ns = MetadataNode.GetDefaultNamespace().NamespaceName;
var groupFound = false;
foreach (var group in MetadataNode.Elements(XName.Get(References, ns)).Elements(XName.Get(Group, ns)))
{
groupFound = true;
var groupFramework = GetAttributeValue(group, TargetFramework);
var items = group.Elements(XName.Get(Reference, ns)).Select(n => GetAttributeValue(n, File)).Where(n => !string.IsNullOrEmpty(n)).ToArray();
var framework = string.IsNullOrEmpty(groupFramework) ? NuGetFramework.AnyFramework : NuGetFramework.Parse(groupFramework, _frameworkProvider);
yield return(new FrameworkSpecificGroup(framework, items));
}
// pre-2.5 flat list of references, this should only be used if there are no groups
if (!groupFound)
{
var items = MetadataNode.Elements(XName.Get(References, ns))
.Elements(XName.Get(Reference, ns)).Select(n => GetAttributeValue(n, File)).Where(n => !string.IsNullOrEmpty(n)).ToArray();
if (items.Length > 0)
{
yield return(new FrameworkSpecificGroup(NuGetFramework.AnyFramework, items));
}
}
yield break;
}
private void OnTypeSelected(object selectedType)
{
if (selectedType == null)
{
return;
}
MetadataNodeViewModel vm = selectedType as MetadataNodeViewModel;
if (vm == null)
{
return;
}
MetadataNode model = vm.Model;
if (model == null)
{
return;
}
Entity entity = model.Metadata as Entity;
if (entity == null)
{
return;
}
this.Type = entity;
this.Value = null;
this.SetupValueView();
this.OnPropertyChanged("IsClearButtonVisible");
this.OnPropertyChanged("IsReferenceObjectSelectionEnabled");
}
public static void InitializeNew(bool cache, int nonencrypteddsts, int encrypteddsts)
{
MetadataNode vfsroot = CreateBasicVirtualFS(nonencrypteddsts + encrypteddsts);
BPlusTree <byte[]> datastore = new(10);
var vfsisrc = new VirtualFSInterop(vfsroot, datastore);
List <ICoreDstDependencies> destinations = new();
for (int i = 0; i < nonencrypteddsts + encrypteddsts; i++)
{
IDstFSInterop vfsidst;
if (i < nonencrypteddsts)
{
vfsidst = VirtualFSInterop.InitializeNewDst(vfsroot, datastore, Path.Combine("dst", i.ToString()));
}
else
{
vfsidst = VirtualFSInterop.InitializeNewDst(vfsroot, datastore, Path.Combine("dst", i.ToString()), "password");
}
destinations.Add(CoreDstDependencies.InitializeNew("test", false, vfsidst, true));
}
var vfsicache = VirtualFSInterop.InitializeNewDst(vfsroot, datastore, "cache");
ICoreSrcDependencies srcdeps = FSCoreSrcDependencies.InitializeNew("test", "src", vfsisrc);
if (cache)
{
ICoreDstDependencies cachedeps = CoreDstDependencies.InitializeNew("test", true, vfsicache, false);
_ = new Core(srcdeps, destinations, cachedeps);
}
else
{
_ = new Core(srcdeps, destinations);
}
}
/// <summary>
/// Handles the AfterSelect event of MetadataTreeView object.
/// </summary>
private void metadataTreeView_AfterSelect(object sender, TreeViewEventArgs e)
{
// get metadata node
MetadataNode metadataNode = metadataTreeView.SelectedMetadataNode;
// show metadata node properties
ShowMetadataNodeProperties(metadataNode);
string selectedNodeDescription = string.Empty;
string addButtonText = "Add DICOM Data Element...";
// if metadata node is selected
if (metadataNode != null)
{
// update metadata node description
selectedNodeDescription = string.Format("{0} ({1})", metadataNode.Name, metadataNode.GetType().Name);
#if !REMOVE_DICOM_PLUGIN
if (metadataNode is DicomDataElementMetadata &&
((DicomDataElementMetadata)metadataNode).ValueRepresentation == DicomValueRepresentation.SQ)
{
addButtonText = "Add DICOM Sequence Item";
}
#endif
}
selectedNodeGroupBox.Text = selectedNodeDescription;
addButton.Text = addButtonText;
UpdateUI();
}
/// <summary>
/// Updates the user interface of this form.
/// </summary>
private void UpdateUI()
{
MetadataNode metadataNode = metadataTreeView.SelectedMetadataNode;
bool canAddSubNode = false;
splitContainer1.Enabled = RootMetadataNode != null;
#if !REMOVE_DICOM_PLUGIN
if (metadataNode is DicomFrameMetadata ||
metadataNode is DicomDataSetMetadata)
{
canAddSubNode = true;
}
if (metadataNode is DicomDataElementMetadata &&
((DicomDataElementMetadata)metadataNode).ValueRepresentation == DicomValueRepresentation.SQ)
{
canAddSubNode = true;
}
#endif
addButton.Enabled = CanEdit && canAddSubNode;
if (metadataNode == null)
{
removeButton.Enabled = false;
}
else
{
removeButton.Enabled = CanEdit && metadataNode.CanRemove;
}
}
private void GenerateMetadataNodes(
MetadataNode parentNode,
string nodeName,
OrderPreservingMultiDictionary <string, MetadataDefinition> .ValueSet definitionsWithSameName)
{
if (!UnicodeCharacterUtilities.IsValidIdentifier(nodeName))
{
return;
}
var childNode = MetadataNode.Allocate(nodeName);
_parentToChildren.Add(parentNode, childNode);
// Add all child members
var definitionMap = OrderPreservingMultiDictionary <string, MetadataDefinition> .GetInstance();
try
{
foreach (var definition in definitionsWithSameName)
{
LookupMetadataDefinitions(definition, definitionMap);
}
foreach (var kvp in definitionMap)
{
GenerateMetadataNodes(childNode, kvp.Key, kvp.Value);
}
}
finally
{
definitionMap.Free();
}
}
public void AddChild_WithExistingResourceName_ThrowException()
{
var metadataNode = new MetadataNode("Default");
var child = metadataNode.AddChild("Child.Resource");
metadataNode.AddChild("Child.Resource");
}
public AggregateNode Build()
{
IBindingMetadata metadata = this.Schema.GetMetadata <IBindingMetadata>();
AggregateNode aggrNode = new AggregateNode()
{
Metadata = metadata,
Index = this.State.Indexer.GetListIndex(metadata.Item.Identity),
};
if (this.State.Aggregate.Targets.Count > 0)
{
aggrNode.Item = new MetadataNode(metadata.Item);
}
foreach (MetadataIdentity identity in this.State.Aggregate.Targets)
{
IBindingMetadata targetMetadata = identity.GetMetadata <IBindingMetadata>();
IBindingMetadata valueMetadata = targetMetadata.HasFlag(BindingMetadataFlags.Item) ? targetMetadata.Parent : targetMetadata;
MetadataNode valueNode = new MetadataNode(valueMetadata)
{
ListIndex = this.State.Indexer.GetListIndex(identity),
};
this.AddListNode(aggrNode, valueNode);
}
return(aggrNode);
}
private MetadataNode AddDynamicNode(List <MetadataNode> itemNodes, MetadataIdentity identity, IBindingMetadata metadata, ColumnIdentity value)
{
this.AddStaticNode(itemNodes, metadata, null);
MetadataNode thisNode = this.FindNode(itemNodes, identity);
MetadataIdentity parentIdentity = identity.Pop();
if (thisNode != null)
{
thisNode.Column ??= value;
}
else if (parentIdentity != null)
{
MetadataNode parentNode = this.FindNode(itemNodes, parentIdentity) ?? this.AddDynamicNode(itemNodes, parentIdentity, metadata, null);
if (parentNode != null)
{
thisNode = new MetadataNode(identity)
{
Column = value,
Metadata = metadata,
Flags = NodeFlags.Dynamic,
};
parentNode.Properties.Add(thisNode);
}
}
return(thisNode);
}
private static void ValidateDynamic(MetadataNode node)
{
if (node.Metadata.Composition?.AddDynamic == null)
{
throw BindingException.FromProperty(node.Identity.Name, $"Dynamic add method not found.");
}
}
/// <summary>
/// Nuspec Metadata
/// </summary>
public virtual IEnumerable <KeyValuePair <string, string> > GetMetadata()
{
return(MetadataNode
.Elements()
.Where(e => !e.HasElements && !string.IsNullOrEmpty(e.Value))
.Select(e => new KeyValuePair <string, string>(e.Name.LocalName, e.Value)));
}
private void AssignEmptyChildKeys(ElementNode elementNode)
{
IList <MetadataNode> allNodes = elementNode.Value.Tree().ToList();
foreach (KeyNode parentKey in elementNode.ParentKeys)
{
IReference childReference = parentKey.Reference.Other;
IBindingMetadata childMetadata;
if (childReference.HasFlag(ReferenceFlags.Many))
{
childMetadata = childReference.List.Identity.GetMetadata <IBindingMetadata>();
}
else
{
childMetadata = childReference.Metadata.Identity.GetMetadata <IBindingMetadata>();
}
MetadataNode thisNode = this.FindNode(allNodes, childMetadata);
MetadataNode parentNode = this.FindNode(allNodes, childMetadata?.Parent);
if (thisNode == null && parentNode != null && parentNode.Column == null)
{
MetadataNode joinNode = new MetadataNode(childMetadata)
{
ListIndex = parentKey.ParentIndex,
ElementIndex = this.GetKeyIndex(parentKey.Reference.Other),
};
parentNode.Properties.Add(joinNode);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="AddDicomDataElementForm"/> class.
/// </summary>
/// <param name="metadata">The metadata of DICOM file.</param>
public AddDicomDataElementForm(MetadataNode metadata)
{
if (metadata == null)
{
throw new ArgumentNullException();
}
InitializeComponent();
// init combo-box with supported DICOM value types
valueRepresentationComboBox.BeginUpdate();
foreach (DicomValueRepresentation vr in Enum.GetValues(typeof(DicomValueRepresentation)))
{
if (vr == DicomValueRepresentation.UN)
{
continue;
}
valueRepresentationComboBox.Items.Add(vr);
}
valueRepresentationComboBox.SelectedItem = DicomValueRepresentation.UT;
valueRepresentationComboBox.EndUpdate();
_metadata = metadata;
}
private void AddMetadataObjects(List <MetadataNodeViewModel> root, IMetadataService service)
{
InfoBase metadata = service.GetSystemInfoBase();
MetadataNode metadataNode = new MetadataNode(metadata);
metadataNode.Children = new List <MetadataNode>();
MetadataNodeViewModel metadataVM = new MetadataNodeViewModel(null, metadataNode);
metadataVM.Children = new ObservableCollection <MetadataNodeViewModel>();
foreach (Namespace ns in metadata.Namespaces)
{
MetadataNode child = new MetadataNode(ns);
child.Children = new List <MetadataNode>();
metadataNode.Children.Add(child);
MetadataNodeViewModel childVM = new MetadataNodeViewModel(metadataVM, child);
childVM.Children = new ObservableCollection <MetadataNodeViewModel>();
metadataVM.Children.Add(childVM);
foreach (Entity entity in ns.Entities)
{
MetadataNode grandchild = new MetadataNode(entity);
child.Children.Add(grandchild);
MetadataNodeViewModel grandchildVM = new MetadataNodeViewModel(childVM, grandchild);
childVM.Children.Add(grandchildVM);
}
}
root.Add(metadataVM);
}
/// <inheritdoc />
protected override void PopulateMetadataImpl(PropertyBag map)
{
for (MetadataNode node = metadata; node != null; node = node.Predecessor)
{
map.Add(node.Key, node.Value);
}
}
public void AddToReadyToRunHeader(ReadyToRunHeaderNode header)
{
var metadataNode = new MetadataNode();
header.Add(BlobIdToReadyToRunSection(ReflectionMapBlob.EmbeddedMetadata), metadataNode, metadataNode, metadataNode.EndSymbol);
var externalReferencesTableNode = new ExternalReferencesTableNode();
var typeMapNode = new TypeMetadataMapNode(externalReferencesTableNode);
header.Add(BlobIdToReadyToRunSection(ReflectionMapBlob.TypeMap), typeMapNode, typeMapNode, typeMapNode.EndSymbol);
var cctorContextMapNode = new ClassConstructorContextMap(externalReferencesTableNode);
header.Add(BlobIdToReadyToRunSection(ReflectionMapBlob.CCtorContextMap), cctorContextMapNode, cctorContextMapNode, cctorContextMapNode.EndSymbol);
var invokeMapNode = new ReflectionInvokeMapNode(externalReferencesTableNode);
header.Add(BlobIdToReadyToRunSection(ReflectionMapBlob.InvokeMap), invokeMapNode, invokeMapNode, invokeMapNode.EndSymbol);
var arrayMapNode = new ArrayMapNode(externalReferencesTableNode);
header.Add(BlobIdToReadyToRunSection(ReflectionMapBlob.ArrayMap), arrayMapNode, arrayMapNode, arrayMapNode.EndSymbol);
var fieldMapNode = new ReflectionFieldMapNode(externalReferencesTableNode);
header.Add(BlobIdToReadyToRunSection(ReflectionMapBlob.FieldAccessMap), fieldMapNode, fieldMapNode, fieldMapNode.EndSymbol);
// This one should go last
header.Add(BlobIdToReadyToRunSection(ReflectionMapBlob.CommonFixupsTable),
externalReferencesTableNode, externalReferencesTableNode, externalReferencesTableNode.EndSymbol);
}
private int CalculateNodeValue(MetadataNode node)
{
if (_nodeValuePair.TryGetValue(node, out int value))
{
return(value);
}
var children = _nodes.Where(n => n.ParentId == node.Id).ToList();
if (children.Any())
{
foreach (int metadata in node.Metadata)
{
if (metadata > 0 && metadata <= children.Count)
{
value += CalculateNodeValue(children[metadata - 1]);
}
}
}
else
{
value = node.Metadata.Sum(_ => _);
}
_nodeValuePair.Add(node, value);
return(value);
}
public void HasChild_NoChildForSpecificResource_ReturnFalse()
{
var metadataNode = new MetadataNode("Default");
metadataNode.AddChild("Child.Resource1");
Assert.IsFalse(metadataNode.HasChild("Child.Resource2"));
}
public void AddChild_WithValidParameter_ChildrenPropertyHasOneItem()
{
var metadataNode = new MetadataNode("Default");
metadataNode.AddChild("Child.Resource");
Assert.AreEqual(1, metadataNode.Children.Count);
}
public void AddChild_WithValidResourceName_CreatedAMetadataNode()
{
var metadataNode = new MetadataNode("Default");
var child = metadataNode.AddChild("Child.Resource");
Assert.IsNotNull(child);
Assert.IsInstanceOfType(child, typeof(MetadataNode));
}
public void MetadataItems_Add_Succeed()
{
var metadataNode = new MetadataNode("Default");
metadataNode.MetadataItems.Add(new Mock <IMetadataItem>().Object);
Assert.AreEqual(1, metadataNode.MetadataItems.Count);
}
public void FindChildMetadata_NoChildForSpecificResource_ReturnNull()
{
var metadataNode = new MetadataNode("Default");
metadataNode.AddChild("Child.Resource1");
Assert.IsNull(metadataNode.FindChildMetadata("Child.Resource2"));
}
public void DestroyMetadataRoot_WithMetadataNode_ThrowException()
{
var metadataRepository = new Mock <IMetadataRepository>();
var factory = new MetadataFactory(metadataRepository.Object);
var metadataNode = new MetadataNode("MyResource");
factory.DestroyMetadataRoot(metadataNode);
}
public static IMetadata MultiMetadataInThreeLayersWithTwoLevelsChildren_ExpectedResult()
{
var metadata = new MetadataNode("MyResource")
{
MetadataItems = new List <IMetadataItem>
{
new ReadonlyMetadataItem {
IsReadonly = true
},
new RequiredMetadataItem {
IsRequired = true
},
new HiddenMetadataItem {
IsHidden = false
}
}
};
var child1 = metadata.AddChild("FirstName");
child1.MetadataItems = new List <IMetadataItem>
{
new ReadonlyMetadataItem {
IsReadonly = true
},
new DisplayNameMetadataItem {
Name = "Child-MD Customize"
},
new RequiredMetadataItem {
IsRequired = true
}
};
var child2 = metadata.AddChild("Age");
child2.MetadataItems = new List <IMetadataItem>
{
new HiddenMetadataItem {
IsHidden = true
}
};
var child1Level2 = child1.AddChild("Level2");
child1Level2.MetadataItems = new List <IMetadataItem>
{
new ReadonlyMetadataItem {
IsReadonly = true
},
new DisplayNameMetadataItem {
Name = "Child-MD Customize Level2"
},
new RequiredMetadataItem {
IsRequired = true
}
};
return(metadata);
}
public void HasChild_SpecificResourceIsThere_ReturnTrue()
{
var metadataNode = new MetadataNode("Default");
metadataNode.AddChild("Child.Resource1");
metadataNode.AddChild("Child.Resource2");
Assert.IsTrue(metadataNode.HasChild("Child.Resource2"));
}
/// <summary>
/// Nuspec Metadata
/// </summary>
public IEnumerable <KeyValuePair <string, string> > GetMetadata()
{
foreach (var element in MetadataNode.Elements().Where(n => !n.HasElements && !String.IsNullOrEmpty(n.Value)))
{
yield return(new KeyValuePair <string, string>(element.Name.LocalName, element.Value));
}
yield break;
}
public void AddChild_WithValidParameterTwice_ChildrenPropertyHasTwoItems()
{
var metadataNode = new MetadataNode("Default");
metadataNode.AddChild("Child.Resource1");
metadataNode.AddChild("Child.Resource2");
Assert.AreEqual(2, metadataNode.Children.Count);
}
/// <summary>
/// Determines whether the specified metadata node can be removed.
/// </summary>
/// <param name="metadataNode">The metadata node.</param>
/// <returns>
/// <b>True</b> - the metadata node can be removed; otherwise, <b>false</b>.
/// </returns>
private bool CanRemoveMetadataNode(MetadataNode metadataNode)
{
if (metadataNode != null)
{
return(metadataNode.CanRemove);
}
return(false);
}
public override void AddToReadyToRunHeader(ReadyToRunHeaderNode header, NodeFactory nodeFactory, ExternalReferencesTableNode commonFixupsTableNode)
{
var metadataNode = new MetadataNode();
header.Add(BlobIdToReadyToRunSection(ReflectionMapBlob.EmbeddedMetadata), metadataNode, metadataNode, metadataNode.EndSymbol);
var stackTraceMethodMappingNode = new StackTraceMethodMappingNode();
header.Add(BlobIdToReadyToRunSection(ReflectionMapBlob.BlobIdStackTraceMethodRvaToTokenMapping), stackTraceMethodMappingNode, stackTraceMethodMappingNode, stackTraceMethodMappingNode.EndSymbol);
}
private DataRow(object[] values, MetadataNode metadata)
{
this.values = values;
this.metadata = metadata;
}
public MetadataNode(MetadataNode predecessor, string key, string value)
{
Predecessor = predecessor;
Key = key;
Value = value;
}
public MetadataInfoCreator(
Solution solution, VersionStamp version, PortableExecutableReference reference, CancellationToken cancellationToken)
{
_solution = solution;
_version = version;
_reference = reference;
_cancellationToken = cancellationToken;
_metadataReader = null;
_allTypeDefinitions = new List<MetadataDefinition>();
_inheritanceMap = OrderPreservingMultiDictionary<string, string>.GetInstance();
_parentToChildren = OrderPreservingMultiDictionary<MetadataNode, MetadataNode>.GetInstance();
_rootNode = MetadataNode.Allocate(name: "");
}
private void GenerateMetadataNodes(
MetadataNode parentNode,
string nodeName,
OrderPreservingMultiDictionary<string, MetadataDefinition>.ValueSet definitionsWithSameName)
{
if (!UnicodeCharacterUtilities.IsValidIdentifier(nodeName))
{
return;
}
var childNode = MetadataNode.Allocate(nodeName);
_parentToChildren.Add(parentNode, childNode);
// Add all child members
var definitionMap = OrderPreservingMultiDictionary<string, MetadataDefinition>.GetInstance();
try
{
foreach (var definition in definitionsWithSameName)
{
LookupMetadataDefinitions(definition, definitionMap);
}
foreach (var kvp in definitionMap)
{
GenerateMetadataNodes(childNode,kvp.Key, kvp.Value);
}
}
finally
{
definitionMap.Free();
}
}
private static TestTreeNode FindOrAddMetadataNode(string metadataType,
TestTreeNode rootTestDataNode, string metadata)
{
TestTreeNode metadataNode;
var nodes = rootTestDataNode.Find(metadata, false);
if (nodes.Count > 0)
{
metadataNode = nodes[0];
}
else
{
metadataNode = new MetadataNode(metadata, metadataType);
rootTestDataNode.Nodes.Add(metadataNode);
}
return metadataNode;
}
private MetadataNode GetOrCreateChildNode(
MetadataNode currentNode, string simpleName)
{
foreach (var childNode in _parentToChildren[currentNode])
{
if (childNode.Name == simpleName)
{
// Found an existing child node. Just return that and all
// future parts off of it.
return childNode;
}
}
// Couldn't find a child node with this name. Make a new node for
// it and return that for all future parts to be added to.
var newChildNode = MetadataNode.Allocate(simpleName);
_parentToChildren.Add(currentNode, newChildNode);
return newChildNode;
}
public static void Free(MetadataNode node)
{
Debug.Assert(node.Name != null);
node.Name = null;
s_pool.Free(node);
}
private void AddUnsortedNodes(
ArrayBuilder<BuilderNode> unsortedNodes, MetadataNode parentNode, int parentIndex)
{
foreach (var child in _parentToChildren[parentNode])
{
var childNode = new BuilderNode(child.Name, parentIndex);
var childIndex = unsortedNodes.Count;
unsortedNodes.Add(childNode);
AddUnsortedNodes(unsortedNodes, child, childIndex);
}
}
