public ObjectContent(object value, ITypeDescriptor descriptor, bool isPrimitive, IReference reference) : base(descriptor, isPrimitive, reference) { if (reference is ObjectReference) throw new ArgumentException($"An {nameof(ObjectContent)} cannot contain an {nameof(ObjectReference)}"); this.value = value; }
public IDeclaredElement GetPrimaryDeclaredElement(IDeclaredElement declaredElement, IReference reference) { IDeclaredElement derivedElement = null; var method = declaredElement as IMethod; if (method != null) { derivedElement = DerivedDeclaredElementUtil.GetPrimaryDeclaredElementForMethod(method); } var @class = declaredElement as IClass; if (@class != null) derivedElement = DerivedDeclaredElementUtil.GetPrimaryDeclaredElementForClass(@class); var @interface = declaredElement as IInterface; if (@interface != null) derivedElement = DerivedDeclaredElementUtil.GetPrimaryDeclaredElementForInterface(@interface); if(derivedElement != null) { return derivedElement; } return declaredElement; }
public MethodInvocation(IReference reference, IType type, IMethod method, ISubstitution substitution) { Reference = reference; Type = type; Method = method; Substitution = substitution; }
public static bool ReinstallPackageOn(ILogger logger, IReference newPackage, string sourceDirectory, IEnumerable<string> installDirs) { foreach (string installDir in installDirs) if (!InstallPackage(logger, newPackage, installDir, sourceDirectory)) return false; return true; }
public virtual void PrintAttribute(IReference target, ICustomAttribute attribute, bool newLine, string targetType) { this.sourceEmitterOutput.Write("[", newLine); if (targetType != null) { this.sourceEmitterOutput.Write(targetType); this.sourceEmitterOutput.Write(": "); } this.PrintTypeReferenceName(attribute.Constructor.ContainingType); if (attribute.NumberOfNamedArguments > 0 || IteratorHelper.EnumerableIsNotEmpty(attribute.Arguments)) { this.sourceEmitterOutput.Write("("); bool first = true; foreach (var argument in attribute.Arguments) { if (first) first = false; else this.sourceEmitterOutput.Write(", "); this.Traverse(argument); } foreach (var namedArgument in attribute.NamedArguments) { if (first) first = false; else this.sourceEmitterOutput.Write(", "); this.Traverse(namedArgument); } this.sourceEmitterOutput.Write(")"); } this.sourceEmitterOutput.Write("]"); if (newLine) this.sourceEmitterOutput.WriteLine(""); }
public static AssetLogMessage From(Package package, IReference assetReference, ILogMessage logMessage, string assetPath, int line = 0, int character = 0) { // Transform to AssetLogMessage var assetLogMessage = logMessage as AssetLogMessage; if (assetLogMessage == null) { assetLogMessage = new AssetLogMessage(null, assetReference, logMessage.Type, AssetMessageCode.CompilationMessage, assetReference?.Location, logMessage.Text) { Exception = (logMessage as LogMessage)?.Exception }; } // Set file (and location if available) assetLogMessage.File = assetPath; assetLogMessage.Line = line; assetLogMessage.Character = character; // Generate location (if it's a Yaml exception) var yamlException = (logMessage as LogMessage)?.Exception as YamlException; if (yamlException != null) { assetLogMessage.Line = yamlException.Start.Line; assetLogMessage.Character = yamlException.Start.Column; // We've already got everything, no need to pollute log with stack trace of exception assetLogMessage.Exception = null; } return assetLogMessage; }
public IReference[] GetReferences(ITreeNode element, IReference[] oldReferences) { var literal = element as ILiteralExpression; if (literal != null && literal.ConstantValue.Value is string) { var attribute = AttributeNavigator.GetByConstructorArgumentExpression(literal as ICSharpExpression); if (attribute != null) { var @class = attribute.Name.Reference.Resolve().DeclaredElement as IClass; if (@class != null && Equals(@class.GetClrName(), DataAttributeName)) { var typeElement = (from a in attribute.PropertyAssignments where a.PropertyNameIdentifier.Name == TypeMemberName select GetTypeof(a.Source as ITypeofExpression)).FirstOrDefault(); var member = MethodDeclarationNavigator.GetByAttribute(attribute); if (member != null && member.DeclaredElement != null && typeElement == null) typeElement = member.DeclaredElement.GetContainingType(); if (typeElement == null) return EmptyArray<IReference>.Instance; var reference = CreateReference(typeElement, literal); return oldReferences != null && oldReferences.Length == 1 && Equals(oldReferences[0], reference) ? oldReferences : new[] {reference}; } } } return EmptyArray<IReference>.Instance; }
public IReference[] GetReferences(ITreeNode element, IReference[] oldReferences) { var literal = element as ILiteralExpression; if (literal != null && literal.ConstantValue.Value is string) { var agument = literal.Parent as IVBArgument; var attribute = AttributeNavigator.GetByArgument(agument); if (attribute != null) { var @class = attribute.AttributeType.Reference.Resolve().DeclaredElement as IClass; if (@class != null && Equals(@class.GetClrName(), DataAttributeName)) { var typeElement = (from a in attribute.Arguments where a is INamedArgument && a.ArgumentName == TypeMemberName select GetTypeof(a.Expression as IGetTypeExpression)).FirstOrDefault(); var member = MethodDeclarationNavigator.GetByAttribute(attribute) as ITypeMemberDeclaration; if (member != null && member.DeclaredElement != null && typeElement == null) typeElement = member.DeclaredElement.GetContainingType(); if (typeElement == null) return EmptyArray<IReference>.Instance; var reference = CreateReference(typeElement, literal); return oldReferences != null && oldReferences.Length == 1 && Equals(oldReferences[0], reference) ? oldReferences : new[] { reference }; } } } return EmptyArray<IReference>.Instance; }
protected ContentBase(ITypeDescriptor descriptor, bool isPrimitive, IReference reference) { if (descriptor == null) throw new ArgumentNullException(nameof(descriptor)); Reference = reference; Descriptor = descriptor; IsPrimitive = isPrimitive; }
public PsiUnresolvedVariableReferenceHighlighting(IVariableName element) { myElement = element; myReference = (element as VariableName).Reference; }
protected override bool CheckResolve(IReference reference, IElement element) { if (reference is TableReference && !DatabaseManager.GetInstance(element.GetManager().Solution).Enabled) return false; return base.CheckResolve(reference, element); }
public void VisitMethodBodyReference(IReference reference) { var typeReference = reference as ITypeReference; if (typeReference != null) { this.typeReferenceNeedsToken = true; this.Visit(typeReference); Debug.Assert(!this.typeReferenceNeedsToken); } else { var fieldReference = reference as IFieldReference; if (fieldReference != null) { if (fieldReference.IsContextualNamedEntity) { ((IContextualNamedEntity)fieldReference).AssociateWithMetadataWriter(this.metadataWriter); } this.Visit(fieldReference); } else { var methodReference = reference as IMethodReference; if (methodReference != null) { this.Visit(methodReference); } } } }
public PsiUnresolvedPathReferenceHighlighting(IPathName element) { myElement = element; myReference = (element as PathName).Reference; }
public DeclaredElementInfo([NotNull] IDeclaredElement declaredElement, [NotNull] ISubstitution substitution, [NotNull] IFile file, TextRange sourceRange, [CanBeNull] IReference reference) { DeclaredElement = declaredElement; Substitution = substitution; File = file; SourceRange = sourceRange; Reference = reference; }
public AssetLogger(Package package, IReference assetReference, string assetFullPath, ILogger loggerToForward) { this.package = package; this.assetReference = assetReference; this.assetFullPath = assetFullPath; this.loggerToForward = loggerToForward; ActivateLog(LogMessageType.Debug); }
public StorageManager(IReference storage) { var g=CodeGenerator.Instance; var f=FuncBuilder.Instance; //don't use statics for storage this.storage=g.GetStaticVariableInfo(storage, false)!=null ? f.Declare.Int("temp2") : storage; this.temp=f.Declare.Int("temp"); }
public bool Equals(IReference obj) { if (obj == null) return false; if (obj == this) return true; var fr = obj as FileReference; if (fr != null) return fr.Filename == this.Filename; return false; }
/// <summary> /// Initializes a new instance of <see cref="AssetMigrationContext"/>. /// </summary> /// <param name="package"></param> /// <param name="assetReference"></param> /// <param name="assetFullPath"></param> /// <param name="log"></param> public AssetMigrationContext(Package package, IReference assetReference, string assetFullPath, ILogger log) { if (log == null) throw new ArgumentNullException(nameof(log)); Package = package; AssetReference = assetReference; AssetFullPath = assetFullPath; Log = new AssetLogger(package, assetReference, assetFullPath, log); }
protected virtual IReference DeclareHelper(string name, IReference variable, Expression optionalInitialValue) { FuncBuilder.Instance.BindLocalVariableToRepresentation(variable, name); if(!ReferenceEquals(optionalInitialValue, null)) { Assignment.AssignAny(variable, optionalInitialValue); } return variable; }
public void AddReference(IReference reference) { var assembly = reference.GetAssembly(); references.Add(assembly); compiler.Parameters.AddAssembly(assembly); }
/// <summary> /// Initializes a new instance of the <see cref="AssetLogMessage" /> class. /// </summary> /// <param name="package">The package.</param> /// <param name="assetReference">The asset reference.</param> /// <param name="type">The type.</param> /// <param name="messageCode">The message code.</param> /// <param name="arguments">The arguments.</param> /// <exception cref="System.ArgumentNullException">asset</exception> public AssetLogMessage(Package package, IReference assetReference, LogMessageType type, string text) { this.package = package; AssetReference = assetReference; Type = type; Related = new List<IReference>(); Text = text; }
public static Mock<IVsProject> ConstructMockProject(IReference[] references = null, string outputAssembly = null) { var project = new Mock<IVsProject>(); project.Setup(proj => proj.GetBinaryReferences()).Returns(references ?? new IReference[0]); outputAssembly = outputAssembly ?? "randomAssemblyName" + Path.GetTempFileName(); project.SetupGet(p => p.AssemblyName).Returns(outputAssembly); return project; }
/// <summary> /// Create an asset dependency of type <paramref name="type"/> and pointing to <paramref name="item"/> /// </summary> /// <param name="item">The item the dependency is pointing to</param> /// <param name="type">The type of the dependency between the items</param> public AssetLink(AssetItem item, ContentLinkType type) { if (item == null) throw new ArgumentNullException("item"); Item = item; this.type = type; reference = item.ToReference(); }
// This constructor exists for better factorization of code in AssetDependencies. // It should not be turned into public as AssetItem is not valid. internal AssetLink(IReference reference, ContentLinkType type) { if (reference == null) throw new ArgumentNullException("reference"); Item = null; this.type = type; this.reference = reference; }
public bool Equals(IReference obj) { if (obj == null) return false; if (obj == this) return true; var fr = obj as ProjectReference; if (fr != null) return fr.Name == this.Name; return false; }
public MemberContent(INodeBuilder nodeBuilder, IContent container, IMemberDescriptor member, bool isPrimitive, IReference reference) : base(nodeBuilder.TypeDescriptorFactory.Find(member.Type), isPrimitive, reference) { if (container == null) throw new ArgumentNullException(nameof(container)); Member = member; Container = container; nodeContainer = nodeBuilder.NodeContainer; }
public static AddressOf FromStaticVariable(IReference variable) { var vi=CodeGenerator.Instance.GetStaticVariableInfo(variable, false); if(vi==null) { throw new Exception("Can't take the address of a non-static variable"); } var rep=vi.Representation; return new AddressOf(rep.StorageLabel, false); }
public override ReferenceCollection GetFirstClassReferences() { if (!myInitReference) { myReference = new PsiOptionReference(this); myInitReference = true; } return new ReferenceCollection(myReference); }
public IReadable EvaluateTo(IReference storage) { var result=EvaluateToHelper(storage); var reference=result as IReference; if(reference!=null) { FuncBuilder.Instance.NoteRead(reference); } return result; }
public ResolveResultWithInfo Resolve() { if (!myInitReference) { myReference = new PsiVariableReference(this); myInitReference = true; } return myReference.Resolve(); }
public MemberReference(IReference parentFieldCollection, MemberInfo memberInfo) { this.parentReference = parentFieldCollection; this.parentValue = parentFieldCollection.GetValue(); this.memberInfo = memberInfo; }
/// <summary> /// Adds a node to the set. /// </summary> public void Export(ISystemContext context, NodeState node) { if (node == null) { throw new ArgumentNullException("node"); } if (Opc.Ua.NodeId.IsNull(node.NodeId)) { throw new ArgumentException("A non-null NodeId must be specified."); } UANode exportedNode = null; switch (node.NodeClass) { case NodeClass.Object: { BaseObjectState o = (BaseObjectState)node; UAObject value = new UAObject(); value.EventNotifier = o.EventNotifier; if (o.Parent != null) { value.ParentNodeId = ExportAlias(o.Parent.NodeId, context.NamespaceUris); } exportedNode = value; break; } case NodeClass.Variable: { BaseVariableState o = (BaseVariableState)node; UAVariable value = new UAVariable(); value.DataType = ExportAlias(o.DataType, context.NamespaceUris); value.ValueRank = o.ValueRank; value.ArrayDimensions = Export(o.ArrayDimensions); value.AccessLevel = o.AccessLevel; value.UserAccessLevel = o.UserAccessLevel; value.MinimumSamplingInterval = o.MinimumSamplingInterval; value.Historizing = o.Historizing; if (o.Parent != null) { value.ParentNodeId = ExportAlias(o.Parent.NodeId, context.NamespaceUris); } if (o.Value != null) { XmlEncoder encoder = CreateEncoder(context); Variant variant = new Variant(o.Value); encoder.WriteVariantContents(variant.Value, variant.TypeInfo); XmlDocument document = new XmlDocument(); document.InnerXml = encoder.Close(); value.Value = document.DocumentElement; } exportedNode = value; break; } case NodeClass.Method: { MethodState o = (MethodState)node; UAMethod value = new UAMethod(); value.Executable = o.Executable; value.UserExecutable = o.UserExecutable; if (o.TypeDefinitionId != o.NodeId) { value.MethodDeclarationId = Export(o.TypeDefinitionId, context.NamespaceUris); } if (o.Parent != null) { value.ParentNodeId = ExportAlias(o.Parent.NodeId, context.NamespaceUris); } exportedNode = value; break; } case NodeClass.View: { ViewState o = (ViewState)node; UAView value = new UAView(); value.ContainsNoLoops = o.ContainsNoLoops; exportedNode = value; break; } case NodeClass.ObjectType: { BaseObjectTypeState o = (BaseObjectTypeState)node; UAObjectType value = new UAObjectType(); value.IsAbstract = o.IsAbstract; exportedNode = value; break; } case NodeClass.VariableType: { BaseVariableTypeState o = (BaseVariableTypeState)node; UAVariableType value = new UAVariableType(); value.IsAbstract = o.IsAbstract; value.DataType = ExportAlias(o.DataType, context.NamespaceUris); value.ValueRank = o.ValueRank; value.ArrayDimensions = Export(o.ArrayDimensions); if (o.Value != null) { XmlEncoder encoder = CreateEncoder(context); Variant variant = new Variant(o.Value); encoder.WriteVariantContents(variant.Value, variant.TypeInfo); XmlDocument document = new XmlDocument(); document.InnerXml = encoder.Close(); value.Value = document.DocumentElement; } exportedNode = value; break; } case NodeClass.DataType: { DataTypeState o = (DataTypeState)node; UADataType value = new UADataType(); value.IsAbstract = o.IsAbstract; value.Definition = Export(o.Definition, context.NamespaceUris); exportedNode = value; break; } case NodeClass.ReferenceType: { ReferenceTypeState o = (ReferenceTypeState)node; UAReferenceType value = new UAReferenceType(); value.IsAbstract = o.IsAbstract; value.InverseName = Export(new Opc.Ua.LocalizedText[] { o.InverseName }); value.Symmetric = o.Symmetric; exportedNode = value; break; } } exportedNode.NodeId = Export(node.NodeId, context.NamespaceUris); exportedNode.BrowseName = Export(node.BrowseName, context.NamespaceUris); exportedNode.DisplayName = Export(new Opc.Ua.LocalizedText[] { node.DisplayName }); exportedNode.Description = Export(new Opc.Ua.LocalizedText[] { node.Description }); exportedNode.WriteMask = (uint)node.WriteMask; exportedNode.UserWriteMask = (uint)node.UserWriteMask; if (!String.IsNullOrEmpty(node.SymbolicName) && node.SymbolicName != node.BrowseName.Name) { exportedNode.SymbolicName = node.SymbolicName; } // export references. INodeBrowser browser = node.CreateBrowser(context, null, null, true, BrowseDirection.Both, null, null, true); List <Reference> exportedReferences = new List <Reference>(); IReference reference = browser.Next(); while (reference != null) { if (node.NodeClass == NodeClass.Method) { if (!reference.IsInverse && reference.ReferenceTypeId == ReferenceTypeIds.HasTypeDefinition) { reference = browser.Next(); continue; } } Reference exportedReference = new Reference(); exportedReference.ReferenceType = ExportAlias(reference.ReferenceTypeId, context.NamespaceUris); exportedReference.IsForward = !reference.IsInverse; exportedReference.Value = Export(reference.TargetId, context.NamespaceUris, context.ServerUris); exportedReferences.Add(exportedReference); reference = browser.Next(); } exportedNode.References = exportedReferences.ToArray(); // add node to list. UANode[] nodes = null; int count = 1; if (this.Items == null) { nodes = new UANode[count]; } else { count += this.Items.Length; nodes = new UANode[count]; Array.Copy(this.Items, nodes, this.Items.Length); } nodes[count - 1] = exportedNode; this.Items = nodes; // recusively process children. List <BaseInstanceState> children = new List <BaseInstanceState>(); node.GetChildren(context, children); for (int ii = 0; ii < children.Count; ii++) { Export(context, children[ii]); } }
/// <summary cref="ICollection{T}.Add" /> public void Add(IReference item) { m_references.Add(item, null); }
/// <summary> /// Adds a broken link out. /// </summary> /// <param name="reference">the reference to the missing element</param> /// <param name="contentLinkType">The type of link</param> /// <exception cref="ArgumentException">A broken link to this element already exists</exception> public void AddBrokenLinkOut(IReference reference, ContentLinkType contentLinkType) { AddLink(ref missingChildren, new AssetLink(reference, contentLinkType)); }
public CacheReference(IReference <T> entry, Cache <T> cache) { _entry = entry; _cache = cache; }
protected override IReadable EvaluateToHelper(IReference storage) { return(inner.EvaluateTo(storage)); }
/// <summary> /// Initializes a new instance of the <see cref = "CreateOnUIThreadInspector" /> class. /// </summary> /// <param name = "config">The config.</param> /// <param name = "converter"></param> public CreateOnUIThreadInspector(IConfiguration config, IConversionManager converter) { marshalingControl = new MarshalingControl(); controlProxyHook = ObtainProxyHook(config, converter); }
public IDeclaredElement GetPrimaryDeclaredElement(IDeclaredElement declaredElement, IReference reference) { IDeclaredElement derivedElement = null; var method = declaredElement as IMethod; if (method != null) { derivedElement = DerivedDeclaredElementUtil.GetPrimaryDeclaredElementForMethod(method); } var @class = declaredElement as IClass; if (@class != null) { derivedElement = DerivedDeclaredElementUtil.GetPrimaryDeclaredElementForClass(@class); } var @interface = declaredElement as IInterface; if (@interface != null) { derivedElement = DerivedDeclaredElementUtil.GetPrimaryDeclaredElementForInterface(@interface); } if (derivedElement != null) { return(derivedElement); } return(declaredElement); }
/// <summary> /// Creates view model for Editing factor data ie EditFactorItem.ascx /// </summary> /// <param name="user"></param> /// <param name="taxon"></param> /// <param name="factorData"></param> /// <param name="factorDataType"></param> /// <param name="model"></param> /// <returns></returns> public FactorViewModel CreateFactorViewData(IUserContext user, ITaxon taxon, DyntaxaSpeciesFact factorData, int factorDataType, int dataTypeId, FactorViewModel model, IList <DyntaxaIndividualCategory> allIndividualCategories, string referenceId, bool isHost) { model.FactorDataTypeId = factorDataType; model.DataTypeId = dataTypeId; model.FactorName = factorData.Label; if (isHost) { model.FactorName = factorData.HostName; } model.IndividualCategoryName = factorData.IndividualCatgory.Label; model.QualityId = factorData.Quality.QualityId; model.QualityValueList = new List <SpeciesFactDropDownModelHelper>(); foreach (KeyValuePair <int, string> quality in factorData.Quality.Qualities) { model.QualityValueList.Add(new SpeciesFactDropDownModelHelper(quality.Key, quality.Value)); } model.FactorFieldComment = factorData.Comments; model.FactorFieldEnumLabel = factorData.FactorEnumLabel; model.FactorFieldEnumValueList = new List <SpeciesFactDropDownModelHelper>(); foreach (KeyValuePair <int, string> factorFieldEnum in factorData.FactorEnumValueList) { // Only add 0 and positiv values for Substrate and Biotope. if ((factorFieldEnum.Key >= 0 && factorDataType == (int)DyntaxaFactorDataType.AF_BIOTOPE) || (factorFieldEnum.Key >= 0 && factorDataType == (int)DyntaxaFactorDataType.AF_SUBSTRATE) || factorDataType == (int)DyntaxaFactorDataType.AF_INFLUENCE) { model.FactorFieldEnumValueList.Add(new SpeciesFactDropDownModelHelper(factorFieldEnum.Key, factorFieldEnum.Value)); } } model.FactorFieldEnumValue = factorData.FactorEnumValue; model.FactorFieldEnumValueList2 = new List <SpeciesFactDropDownModelHelper>(); foreach (KeyValuePair <int, string> factorFieldEnum2 in factorData.FactorEnumValueList2) { // Only add 0 and positiv values for Substrate and Biotope. if (factorDataType == (int)DyntaxaFactorDataType.AF_SUBSTRATE || factorDataType == (int)DyntaxaFactorDataType.AF_INFLUENCE) { model.FactorFieldEnumValueList2.Add(new SpeciesFactDropDownModelHelper(factorFieldEnum2.Key, factorFieldEnum2.Value)); } } model.FactorFieldEnumValueList2.Add(new SpeciesFactDropDownModelHelper(SpeciesFactModelManager.SpeciesFactNoValueSet, DyntaxaResource.SpeciesFactNoValueSet)); model.FactorFieldEnumValue2 = factorData.FactorEnumValue2; model.FactorFieldEnumLabel2 = factorData.FactorEnumLabel2; model.FaktorReferenceList = new List <SpeciesFactDropDownModelHelper>(); bool isReferenceSet = false; int dyntaxaReferenceId = 0; int userReferenceId = 0; if (referenceId.IsNotEmpty()) { isReferenceSet = true; var referenceList = ReferenceHelper.GetReferenceList(user); foreach (IReference reference in referenceList) { if (reference.Id == Convert.ToInt32(referenceId)) { model.FaktorReferenceList.Add(new SpeciesFactDropDownModelHelper(reference.Id, reference.Name + " " + reference.Year)); userReferenceId = reference.Id; model.FactorReferenceId = reference.Id; } } if (factorData.ReferenceName.IsNotEmpty()) { model.FactorReferenceOld = factorData.ReferenceName; } else { model.FactorReferenceOld = "-"; } } if (factorData.DyntaxaFactorReference.IsNotNull()) { if (!isReferenceSet) { isReferenceSet = true; model.FactorReferenceId = factorData.DyntaxaFactorReference.GetReference(user).Id; } dyntaxaReferenceId = factorData.DyntaxaFactorReference.GetReference(user).Id; IReference reference = factorData.DyntaxaFactorReference.GetReference(user); Int32 year = reference.Year.HasValue ? reference.Year.Value : -1; model.FaktorReferenceList.Add(new SpeciesFactDropDownModelHelper(reference.Id, reference.Name + " " + year)); } // Here we get the dyntaxa references... foreach (IReferenceRelation referenceRelation in taxon.GetReferenceRelations(user)) { IReference reference = referenceRelation.GetReference(user); Int32 year = reference.Year.HasValue ? reference.Year.Value : -1; if (reference.Id != dyntaxaReferenceId && reference.Id != userReferenceId) { model.FaktorReferenceList.Add( new SpeciesFactDropDownModelHelper( reference.Id, reference.Name + " " + year)); } if (!isReferenceSet) { isReferenceSet = true; model.FactorReferenceId = reference.Id; } } model.IndividualCategoryId = factorData.IndividualCatgory.Id; model.IndividualCategoryName = factorData.IndividualCatgory.Label; model.IndividualCategoryList = new List <SpeciesFactDropDownModelHelper>(); // Add all individual categories that exist List <DyntaxaIndividualCategory> exitingCategories = factorData.IndividualCategoryList as List <DyntaxaIndividualCategory>; foreach (DyntaxaIndividualCategory category in allIndividualCategories) { model.IndividualCategoryList.Add(new SpeciesFactDropDownModelHelper(category.Id, category.Label)); } model.ExistingEvaluations = factorData.ExistingEvaluations; string message = Resources.DyntaxaResource.SpeciesFactLatestUpdateByText.Replace("[UpdateDate]", factorData.UpdateDate.ToShortDateString()); message = message.Replace("[UpdateUserFullName]", factorData.UpdateUserFullName); model.UpdateUserData = message; return(model); }
/// <summary cref="IDictionary.Remove" /> public bool Remove(IReference key) { // validate key. if (!ValidateReference(key, false)) { return(false); } m_version++; // look up the reference type. ReferenceTypeEntry entry = null; if (!m_references.TryGetValue(key.ReferenceTypeId, out entry)) { return(false); } // handle reference to external targets. if (key.TargetId.IsAbsolute) { Dictionary <ExpandedNodeId, LinkedListNode <KeyValuePair <IReference, T> > > targets = null; if (key.IsInverse) { targets = entry.InverseExternalTargets; } else { targets = entry.ForwardExternalTargets; } if (targets == null) { return(false); } LinkedListNode <KeyValuePair <IReference, T> > node; if (!targets.TryGetValue(key.TargetId, out node)) { return(false); } m_list.Remove(node); targets.Remove(key.TargetId); } // handle reference to internal target. else { NodeIdDictionary <LinkedListNode <KeyValuePair <IReference, T> > > targets = null; if (key.IsInverse) { targets = entry.InverseTargets; } else { targets = entry.ForwardTargets; } if (targets == null) { return(false); } LinkedListNode <KeyValuePair <IReference, T> > node; if (!targets.TryGetValue((NodeId)key.TargetId, out node)) { return(false); } m_list.Remove(node); targets.Remove((NodeId)key.TargetId); } // remove empty reference. if (entry.IsEmpty) { m_references.Remove(key.ReferenceTypeId); } return(true); }
/// <summary cref="IDictionary.Add" /> public void Add(IReference key, T value) { Add(key, value, false); }
public static bool TryParse(string rootDirectory, string projFilePath, XElement element, out IReference reference) { reference = null; var projDirectory = Path.GetDirectoryName(projFilePath); var includeAttr = element.Attribute("Include"); if (projDirectory == null || includeAttr == null) { return(false); } var hintPathElement = element.Element(Constants.MsBuild + "HintPath"); var hintPath = hintPathElement == null ? null : Path.GetFullPath(Path.Combine(projDirectory, hintPathElement.Value)); reference = new Reference <XElement>(rootDirectory, "", includeAttr.Value, hintPath, "", element, RelationTypes.Reference); return(true); }
/// <summary> /// Returns the target entry associated with the reference. /// </summary> /// <param name="key">The key.</param> /// <param name="value">The value.</param> /// <returns>The target entry associated with the reference.</returns> private bool TryGetEntry(IReference key, out KeyValuePair <IReference, T> value) { value = new KeyValuePair <IReference, T>(); // validate key. if (!ValidateReference(key, false)) { return(false); } // look up the reference type. ReferenceTypeEntry entry = null; if (!m_references.TryGetValue(key.ReferenceTypeId, out entry)) { return(false); } // handle reference to external targets. if (key.TargetId.IsAbsolute) { Dictionary <ExpandedNodeId, LinkedListNode <KeyValuePair <IReference, T> > > targets = null; if (key.IsInverse) { targets = entry.InverseExternalTargets; } else { targets = entry.ForwardExternalTargets; } if (targets == null) { return(false); } LinkedListNode <KeyValuePair <IReference, T> > node; if (targets.TryGetValue(key.TargetId, out node)) { value = node.Value; return(true); } } // handle reference to internal target. else { NodeIdDictionary <LinkedListNode <KeyValuePair <IReference, T> > > targets = null; if (key.IsInverse) { targets = entry.InverseTargets; } else { targets = entry.ForwardTargets; } if (targets == null) { return(false); } LinkedListNode <KeyValuePair <IReference, T> > node; if (targets.TryGetValue((NodeId)key.TargetId, out node)) { value = node.Value; return(true); } } return(false); }
protected void HandleEnter(IReference reference, bool appear) { Exited = false; // StateHasChanged(); }
public override bool HasConflictWith(IReference storage) { return(inner.HasConflictWith(storage)); }
/// <inheritdoc/> public bool Equals(IReference other) { var otherEnumerable = other as ReferenceEnumerable; return(otherEnumerable != null && DesignExtensions.Equals <IReference>(references, otherEnumerable.references)); }
public ICommentAspect Load(IReference reference) { return(_commentAspectMapper.Map(_commentRepository.FindById(reference.Code))); }
public ObjectContent(object value, ITypeDescriptor descriptor, bool isPrimitive, IReference reference) : base(descriptor, isPrimitive, reference) { if (reference is ObjectReference) { throw new ArgumentException($"An {nameof(ObjectContent)} cannot contain an {nameof(ObjectReference)}"); } this.value = value; }
public ObjectNode([NotNull] INodeBuilder nodeBuilder, object value, Guid guid, [NotNull] ITypeDescriptor descriptor, IReference reference) : base(nodeBuilder.SafeArgument(nameof(nodeBuilder)).NodeContainer, guid, descriptor) { if (reference is ObjectReference) { throw new ArgumentException($"An {nameof(ObjectNode)} cannot contain an {nameof(ObjectReference)}"); } this.value = value; ItemReferences = reference as ReferenceEnumerable; }
protected override object Read(PushbackTextReader r, char caret, object opts) { int startLine = -1; int startCol = -1; LineNumberingTextReader lntr = r as LineNumberingTextReader; if (lntr != null) { startLine = lntr.LineNumber; startCol = lntr.ColumnNumber; } IPersistentMap metaAsMap; { object meta = ReadAux(r, opts); if (meta is Symbol || meta is String) { metaAsMap = RT.map(RT.TagKey, meta); } else if (meta is Keyword) { metaAsMap = RT.map(meta, true); } else if ((metaAsMap = meta as IPersistentMap) == null) { throw new ArgumentException("Metadata must be Symbol,Keyword,String or Map"); } } object o = ReadAux(r, opts); if (o is IMeta) { if (startLine != -1 && o is ISeq) { metaAsMap = metaAsMap.assoc(RT.LineKey, startLine) .assoc(RT.ColumnKey, startCol) .assoc(RT.SourceSpanKey, RT.map( RT.StartLineKey, startLine, RT.StartColumnKey, startCol, RT.EndLineKey, lntr.LineNumber, RT.EndColumnKey, lntr.ColumnNumber)); } IReference iref = o as IReference; if (iref != null) { iref.resetMeta(metaAsMap); return(o); } object ometa = RT.meta(o); for (ISeq s = RT.seq(metaAsMap); s != null; s = s.next()) { IMapEntry kv = (IMapEntry)s.first(); ometa = RT.assoc(ometa, kv.key(), kv.val()); } return(((IObj)o).withMeta((IPersistentMap)ometa)); } else { throw new ArgumentException("Metadata can only be applied to IMetas"); } }
/// <summary> /// Initializes a new instance of the <see cref = "CreateOnUIThreadInspector" /> class. /// </summary> /// <param name = "kernel">The kernel.</param> /// <param name = "config">The config.</param> public CreateOnUIThreadInspector(IKernel kernel, IConfiguration config) { marshalingControl = new MarshalingControl(); controlProxyHook = ObtainProxyHook(kernel, config); }
void InvokeTyped(VMContext ctx, MethodBase targetMethod, byte opCode, ref uint sp, out ExecutionState state) { var parameters = targetMethod.GetParameters(); int paramCount = parameters.Length; if (!targetMethod.IsStatic && opCode != Constants.ECALL_NEWOBJ) { paramCount++; } Type constrainType = null; if (opCode == Constants.ECALL_CALLVIRT_CONSTRAINED) { constrainType = (Type)ctx.Instance.Data.LookupReference(ctx.Stack[sp--].U4); } int indexOffset = (targetMethod.IsStatic || opCode == Constants.ECALL_NEWOBJ) ? 0 : 1; IReference[] references = new IReference[paramCount]; Type[] types = new Type[paramCount]; for (int i = paramCount - 1; i >= 0; i--) { Type paramType; if (!targetMethod.IsStatic && opCode != Constants.ECALL_NEWOBJ) { if (i == 0) { if (!targetMethod.IsStatic) { var thisSlot = ctx.Stack[sp]; if (thisSlot.O is ValueType && !targetMethod.DeclaringType.IsValueType) { Debug.Assert(targetMethod.DeclaringType.IsInterface); Debug.Assert(opCode == Constants.ECALL_CALLVIRT); // Interface dispatch on valuetypes => use constrained. invocation constrainType = thisSlot.O.GetType(); } } if (constrainType != null) { paramType = constrainType.MakeByRefType(); } else if (targetMethod.DeclaringType.IsValueType) { paramType = targetMethod.DeclaringType.MakeByRefType(); } else { paramType = targetMethod.DeclaringType; } } else { paramType = parameters[i - 1].ParameterType; } } else { paramType = parameters[i].ParameterType; } references[i] = PopRef(ctx, paramType, ref sp); if (paramType.IsByRef) { paramType = paramType.GetElementType(); } types[i] = paramType; } OpCode callOp; Type retType; if (opCode == Constants.ECALL_CALL) { callOp = System.Reflection.Emit.OpCodes.Call; retType = targetMethod is MethodInfo ? ((MethodInfo)targetMethod).ReturnType : typeof(void); } else if (opCode == Constants.ECALL_CALLVIRT || opCode == Constants.ECALL_CALLVIRT_CONSTRAINED) { callOp = System.Reflection.Emit.OpCodes.Callvirt; retType = targetMethod is MethodInfo ? ((MethodInfo)targetMethod).ReturnType : typeof(void); } else if (opCode == Constants.ECALL_NEWOBJ) { callOp = System.Reflection.Emit.OpCodes.Newobj; retType = targetMethod.DeclaringType; } else { throw new InvalidProgramException(); } var proxy = DirectCall.GetTypedInvocationProxy(targetMethod, callOp, constrainType); object result = proxy(ctx, references, types); if (retType != typeof(void)) { ctx.Stack[++sp] = VMSlot.FromObject(result, retType); } else if (opCode == Constants.ECALL_NEWOBJ) { ctx.Stack[++sp] = VMSlot.FromObject(result, retType); } ctx.Stack.SetTopPosition(sp); ctx.Registers[Constants.REG_SP].U4 = sp; state = ExecutionState.Next; }
public void Add(IReference reference) { objects.Add(reference); }
/// <summary> /// Adds or replaces a reference. /// </summary> /// <param name="key">The key.</param> /// <param name="value">The value.</param> /// <param name="replace">if set to <c>true</c> reference is replaced.</param> private void Add(IReference key, T value, bool replace) { // validate key. ValidateReference(key, true); m_version++; // look up the reference type. ReferenceTypeEntry entry = null; if (!m_references.TryGetValue(key.ReferenceTypeId, out entry)) { entry = new ReferenceTypeEntry(); m_references.Add(key.ReferenceTypeId, entry); } // handle reference to external targets. if (key.TargetId.IsAbsolute) { Dictionary <ExpandedNodeId, LinkedListNode <KeyValuePair <IReference, T> > > targets = null; if (key.IsInverse) { if (entry.InverseExternalTargets == null) { entry.InverseExternalTargets = new Dictionary <ExpandedNodeId, LinkedListNode <KeyValuePair <IReference, T> > >(); } targets = entry.InverseExternalTargets; } else { if (entry.ForwardExternalTargets == null) { entry.ForwardExternalTargets = new Dictionary <ExpandedNodeId, LinkedListNode <KeyValuePair <IReference, T> > >(); } targets = entry.ForwardExternalTargets; } // create a new target. LinkedListNode <KeyValuePair <IReference, T> > node = new LinkedListNode <KeyValuePair <IReference, T> >(new KeyValuePair <IReference, T>(key, value)); // check if target already exists. LinkedListNode <KeyValuePair <IReference, T> > existingNode = null; if (!targets.TryGetValue(key.TargetId, out existingNode)) { existingNode = node; m_list.AddLast(node); } // need to replace reference in linked linked as well as the target list. else { if (!replace) { throw new ArgumentException("Key already exists in dictionary.", "key"); } m_list.AddAfter(existingNode, node); m_list.Remove(existingNode); } targets[key.TargetId] = node; } // handle reference to internal target. else { NodeIdDictionary <LinkedListNode <KeyValuePair <IReference, T> > > targets = null; if (key.IsInverse) { if (entry.InverseTargets == null) { entry.InverseTargets = new NodeIdDictionary <LinkedListNode <KeyValuePair <IReference, T> > >(); } targets = entry.InverseTargets; } else { if (entry.ForwardTargets == null) { entry.ForwardTargets = new NodeIdDictionary <LinkedListNode <KeyValuePair <IReference, T> > >(); } targets = entry.ForwardTargets; } NodeId targetId = (NodeId)key.TargetId; // create a new target. LinkedListNode <KeyValuePair <IReference, T> > node = new LinkedListNode <KeyValuePair <IReference, T> >(new KeyValuePair <IReference, T>(key, value)); // check if target already exists. LinkedListNode <KeyValuePair <IReference, T> > existingNode = null; if (!targets.TryGetValue(targetId, out existingNode)) { existingNode = node; m_list.AddLast(node); } // need to replace reference in linked linked as well as the target list. else { if (!replace) { throw new ArgumentException("Key already exists in dictionary.", "key"); } m_list.AddAfter(existingNode, node); m_list.Remove(existingNode); } targets[targetId] = node; } }
public IReferenceOrISignature(IReference item) => _item = item;
public ProxyHookDescriptor(IReference <IProxyGenerationHook> hook) { this.hook = hook; }
public AddChildMenuItem(IReference containment, System.Type newElementType, IModelElement element) { this.containment = containment; this.newElementType = newElementType; this.element = element; }
public IReferenceOrISignatureEquivalent(IReference item) => _item = item;
/// <summary cref="ICollection{T}.Remove" /> public bool Remove(IReference item) { return(m_references.Remove(item)); }
/// <summary cref="ICollection{T}.Contains" /> public bool Contains(IReference item) { return(m_references.ContainsKey(item)); }