public override void Load() { Hotkeys.Load(); Core.Load(); FastForwardBoost.Load(); DisableAchievements.Load(); GraphicsCore.Load(); SimplifiedGraphicsFeature.Load(); CenterCamera.Load(); AutoMute.Load(); HideGameplay.Load(); HitboxTweak.Load(); InfoHud.Load(); ConsoleEnhancements.Load(); AttributeUtils.Invoke <LoadAttribute>(); // Open unix IO pipe for interfacing with Linux / Mac Celeste Studio if (UnixRtcEnabled) { File.Delete("/tmp/celestetas"); UnixRtc = new NamedPipeServerStream("/tmp/celestetas", PipeDirection.InOut); UnixRtc.WaitForConnection(); UnixRtcStreamOut = new StreamWriter(UnixRtc); UnixRtcStreamIn = new StreamReader(UnixRtc); Logger.Log("CelesteTAS", "Unix socket is active on /tmp/celestetas"); } // Open memory mapped file for interfacing with Windows Celeste Studio StudioCommunicationClient.Run(); #if DEBUG Benchmark.Load(); #endif }
protected OptionsBase() { // default filters this.DataContractTest = m => AttributeUtils.HasAttribute <DataContractAttribute>(m, false); this.DataMemberTest = m => AttributeUtils.HasAttribute <DataMemberAttribute>(m, true); this.Hook = new NullHook(); }
private void InitPrivate(int tag, DataFormat dataFormat, bool isOptional, MemberInfo member, Delegate getValue, Delegate setValue, object defaultValue) { if (this.prefix != 0) { throw new InvalidOperationException("Can only initialise a property once"); } if (member != null) { MemberSerializationOptions options; if (!Serializer.TryGetTag(member, out tag, out name, out dataFormat, out options)) { throw new ArgumentException(member.Name + " cannot be used for serialization", "member"); } isOptional = !PropertyFactory.HasOption(options, MemberSerializationOptions.Required); { DefaultValueAttribute dva = AttributeUtils.GetAttribute <DefaultValueAttribute>(member); defaultValue = dva == null ? null : dva.Value; } #if CF this.description = null; // not used in CF; assigned to get rid of warning #else { DescriptionAttribute da = AttributeUtils.GetAttribute <DescriptionAttribute>(member); this.description = da == null ? null : da.Description; } #endif } this.isOptional = isOptional; this.defaultValue = defaultValue; this.dataFormat = dataFormat; // set initial format, and use the *field* for the "ref" so either usage is valid OnBeforeInit(member, getValue, setValue, tag, ref this.dataFormat); this.prefix = Serializer.GetFieldToken(tag, WireType); OnAfterInit(); }
private void BuildTestsFromMethod(Test parent, IMethodInfo method, string namePrefix, string nameSuffix) { try { foreach (TestAttribute2 attrib in AttributeUtils.GetAttributes <TestAttribute2>(method, true)) { BuildTest(parent, method, namePrefix, nameSuffix, attrib); } foreach (RowTestAttribute2 attrib in AttributeUtils.GetAttributes <RowTestAttribute2>(method, true)) { BuildRowTest(parent, method, namePrefix, nameSuffix, attrib); } foreach (CombinatorialTestAttribute2 attrib in AttributeUtils.GetAttributes <CombinatorialTestAttribute2>(method, true)) { BuildCombinatorialTest(parent, method, namePrefix, nameSuffix, attrib); } } catch (Exception ex) { testModel.AddAnnotation(new Annotation(AnnotationType.Error, method, "An exception was thrown while exploring an MbUnit v2 test method.", ex)); } }
/// <summary> /// Returns the set of authority tokens defined by all plugins. /// </summary> /// <returns></returns> public static AuthorityTokenDefinition[] GetAuthorityTokens() { List <AuthorityTokenDefinition> tokens = new List <AuthorityTokenDefinition>(); // scan all plugins for token definitions foreach (PluginInfo plugin in Platform.PluginManager.Plugins) { IResourceResolver resolver = new ResourceResolver(plugin.Assembly); foreach (Type type in plugin.Assembly.GetTypes()) { // look at public fields foreach (FieldInfo field in type.GetFields()) { AuthorityTokenAttribute attr = AttributeUtils.GetAttribute <AuthorityTokenAttribute>(field, false); if (attr != null) { string token = (string)field.GetValue(null); string description = resolver.LocalizeString(attr.Description); tokens.Add(new AuthorityTokenDefinition(token, description)); } } } } return(tokens.ToArray()); }
private static void PopulateMethodMetadata(ICodeElementInfo codeElement, PropertyBag metadata) { foreach (TestAttribute attr in AttributeUtils.GetAttributes <TestAttribute>(codeElement, true)) { // Add timeout if (attr.Timeout > 0) { TimeSpan timeout = TimeSpan.FromMilliseconds(attr.Timeout); metadata.Add("Timeout", timeout.Seconds.ToString("0.000")); } // Add categories string categories = attr.Categories; if (!String.IsNullOrEmpty(categories)) { foreach (string category in categories.Split(',')) { metadata.Add(MetadataKeys.Category, category); } } } // Add expected exception type foreach (ExpectedExceptionAttribute attr in AttributeUtils.GetAttributes <ExpectedExceptionAttribute>(codeElement, true)) { metadata.Add(MetadataKeys.ExpectedException, attr.ExceptionType.FullName); } PopulateCommonMetadata(codeElement, metadata); }
public void Intercept(IInvocation invocation) { // ensure the thread-static variable is initialized for the current thread if (_invocationInfo == null) { _invocationInfo = new Stack <InvocationInfo>(); } try { var recorderContexts = AttributeUtils.GetAttributes <AuditRecorderAttribute>(invocation.MethodInvocationTarget, true) .Select(a => new RecorderContext(invocation, (IServiceOperationRecorder)Activator.CreateInstance(a.RecorderClass))) .ToList(); _invocationInfo.Push(new InvocationInfo(recorderContexts)); invocation.Proceed(); _invocationInfo.Peek().PostCommit(); } finally { // clear current invocation _invocationInfo.Pop(); } }
/// <summary> /// Promotes the exception to a fault, if the exception type has a corresponding fault contract. /// Otherwise returns null. /// </summary> /// <param name="e"></param> /// <param name="serviceInstance"></param> /// <param name="method"></param> /// <param name="fault"></param> /// <returns></returns> private static bool PromoteExceptionToFault(Exception e, object serviceInstance, MethodInfo method, out Exception fault) { fault = null; // get the service contract var serviceContractAttr = AttributeUtils.GetAttribute <ServiceImplementsContractAttribute>(serviceInstance.GetType(), false); // this should never happen, but if it does, there's nothing we can do if (serviceContractAttr == null) { return(false); } // find a fault contract for this exception type var faultContract = AttributeUtils.GetAttribute <FaultContractAttribute>(method, true, a => a.DetailType.Equals(e.GetType())); if (faultContract != null) { // from Juval Lowey var faultBoundedType = typeof(FaultException <>).MakeGenericType(e.GetType()); fault = (FaultException)Activator.CreateInstance(faultBoundedType, e, new FaultReason(e.Message)); return(true); } return(false); // no fault contract for this exception }
/// <inheritdoc /> public override void Consume(IPatternScope containingScope, ICodeElementInfo codeElement, bool skipChildren) { //TODO: Review: Issue 762: Shouldn't the base method be invoked here? //base.Consume(containingScope, codeElement, skipChildren); if (!IsReadableFieldOrProperty(codeElement)) { ThrowUsageErrorException("This attribute may only be applied to fields and properties with getters."); } ISlotInfo slot = (ISlotInfo)codeElement; ITypeInfo mixinType = slot.ValueType; if (!mixinType.IsClass || !AttributeUtils.HasAttribute(mixinType, typeof(MixinAttribute), true)) { ThrowUsageErrorException(String.Format("The field or property value type must be a class with the [Mixin] attribute applied. " + "The type {0} does not appear to be a valid mixin class.", mixinType)); } // TODO: Detect cycles. // TODO: Modify how fixture types and instances are interpreted in the mixin. IPatternScope mixinScope = containingScope.CreateScope(codeElement, containingScope.TestBuilder, null, containingScope.TestDataContextBuilder.CreateChild(), false); mixinScope.Consume(mixinType, skipChildren, null); }
//------------------------------------------------------------------------------ //Callback Name: apply_cb //------------------------------------------------------------------------------ public int apply_cb() { int errorCode = 0; try { //---- Enter your callback code here ----- NXOpen.Assemblies.Component ct = selection_Work.GetSelectedObjects()[0] as NXOpen.Assemblies.Component; InterferenceBuilder builder = new InterferenceBuilder(ct.Prototype as Part); AttributeUtils.AttributeOperation("Interference", true, (ct.Prototype as Part)); if (builder.CreateInterferenceBody()) { theUI.NXMessageBox.Show("提示", NXMessageBox.DialogType.Error, "电极无过切"); } else { theUI.NXMessageBox.Show("提示", NXMessageBox.DialogType.Error, "电极有过切"); } // builder.CreateInterferenceFace(); // SewUtils.SewFeatureUF(GetSheetBodyOFPart(workPart)); // DeleteObject.DeleteParms(GetSheetBodyOFPart(workPart).ToArray()); } catch (Exception ex) { //---- Enter your exception handling code here ----- errorCode = 1; theUI.NXMessageBox.Show("Block Styler", NXMessageBox.DialogType.Error, ex.ToString()); } return(errorCode); }
//------------------------------------------------------------------------------ //Callback Name: filter_cb //------------------------------------------------------------------------------ public int filter_cb(NXOpen.BlockStyler.UIBlock block, NXOpen.TaggedObject selectedObject) { Model.MoldInfoModel info = builder.Model.Asm.MoldInfo; if (this.selePart.GetSelectedObjects().Length != 0) { Part part = (this.selePart.GetSelectedObjects()[0] as NXOpen.Assemblies.Component).Prototype as Part; string name = AttributeUtils.GetAttrForString(part, "PartType"); if (name.Equals("Workpiece", StringComparison.CurrentCultureIgnoreCase)) { return(UFConstants.UF_UI_SEL_ACCEPT); } if (selectedObject is Face) { Face seleFace = selectedObject as Face; Part selePart = (seleFace.Prototype as Face).OwningPart as Part; if (selePart.Tag != part.Tag) { return(UFConstants.UF_UI_SEL_REJECT); } } } return(NXOpen.UF.UFConstants.UF_UI_SEL_ACCEPT); }
/// <summary> /// 给齿上颜色 /// </summary> private void SetHeadColour() { Matrix4 matr = new Matrix4(); matr.Identity(); Matrix4 inv = matr.GetInversMatrix(); CartesianCoordinateSystem csys = BoundingBoxUtils.CreateCoordinateSystem(matr, inv); List <Body> bodys = Session.GetSession().Parts.Work.Bodies.ToArray().ToList(); var toolhList = bodys.GroupBy(a => AttributeUtils.GetAttrForString(a, "ToolhName")); List <ElectrodeToolhInfo[, ]> toolhInfos = new List <ElectrodeToolhInfo[, ]>(); try { foreach (var toolh in toolhList) { ElectrodeToolhInfo[,] toolhInfo = pitch.GetToolhInfosForAttribute(toolh.ToList(), matr, csys); toolhInfos.Add(toolhInfo); } if (toolhInfos.Count != 0) { gapValue.SetERToolh(toolhInfos); } } catch (Exception ex) { ClassItem.WriteLogFile("设置颜色错误!" + ex.Message); } }
/// <summary> /// 设置属性 /// </summary> public void SetAttribute(Part obj) { AttributeUtils.AttributeOperation("EleName", this.EleName, obj); AttributeUtils.AttributeOperation("BorrowName", this.BorrowName, obj); AttributeUtils.AttributeOperation("PitchX", this.PitchX, obj); AttributeUtils.AttributeOperation("PitchXNum", this.PitchXNum, obj); AttributeUtils.AttributeOperation("PitchY", this.PitchY, obj); AttributeUtils.AttributeOperation("PitchYNum", this.PitchYNum, obj); AttributeUtils.AttributeOperation("CrudeInter", this.CrudeInter, obj); AttributeUtils.AttributeOperation("CrudeNum", this.CrudeNum, obj); AttributeUtils.AttributeOperation("DuringInter", this.DuringInter, obj); AttributeUtils.AttributeOperation("DuringNum", this.DuringNum, obj); AttributeUtils.AttributeOperation("FineInter", this.FineInter, obj); AttributeUtils.AttributeOperation("FineNum", this.FineNum, obj); AttributeUtils.AttributeOperation("Material1", this.Material, obj); AttributeUtils.AttributeOperation("EleType", this.EleType, obj); AttributeUtils.AttributeOperation("Condition", this.Condition, obj); AttributeUtils.AttributeOperation("Extrudewith", this.Extrudewith, obj); AttributeUtils.AttributeOperation("CH", this.Ch, obj); AttributeUtils.AttributeOperation("IsPreparation", this.IsPreparation, obj); AttributeUtils.AttributeOperation("Remarks", this.Remarks, obj); AttributeUtils.AttributeOperation("Technology", this.Technology, obj); AttributeUtils.AttributeOperation("CamTemplate", this.CamTemplate, obj); AttributeUtils.AttributeOperation("EleSetValue", this.EleSetValue, obj); AttributeUtils.AttributeOperation("Preparation", this.Preparation, obj); AttributeUtils.AttributeOperation("ElePresentation", this.ElePresentation, obj); AttributeUtils.AttributeOperation("Area", this.Area, obj); AttributeUtils.AttributeOperation("EleNumber", this.EleNumber, obj); AttributeUtils.AttributeOperation("Positioning", this.Positioning, obj); }
//------------------------------------------------------------------------------ //Callback Name: apply_cb //------------------------------------------------------------------------------ public int apply_cb() { int errorCode = 0; try { //---- Enter your callback code here ----- NXOpen.Assemblies.Component ct = this.seleComp.GetSelectedObjects()[0] as NXOpen.Assemblies.Component; Part pt = ct.Prototype as Part; string type = AttributeUtils.GetAttrForString(pt, "PartType"); if (type.Equals("Electrode", StringComparison.CurrentCultureIgnoreCase)) { ElectrodeModel model = new ElectrodeModel(); model.GetModelForPart(pt); ReplacePart.ReplaceElectrode(model, this.strEleName.Value.ToUpper()); } else { ReplacePart.Replace(pt, this.strEleName.Value.ToUpper()); } bool anyPartsModified; PartSaveStatus saveStatus; theSession.Parts.SaveAll(out anyPartsModified, out saveStatus); } catch (Exception ex) { //---- Enter your exception handling code here ----- errorCode = 1; theUI.NXMessageBox.Show("Block Styler", NXMessageBox.DialogType.Error, ex.ToString()); } return(errorCode); }
public static string GetKey(object message) { if (message == null) { return(null); } //var keyValue = AttributeUtils.GetPropertyValue<RouteKeyAttribute>(message); //if (keyValue == null) //{ // keyValue = AttributeUtils.GetPropertyValue<KeyAttribute>(message); // //keyValue = AttributeUtils.GetPropertyValue(message, "RouteKey"); //} //return keyValue != null ? keyValue.ToString() : null; var type = message.GetType(); PropertyInfo property = null; if (RouteKeyCache.TryGetValue(type, out property)) { } else { property = AttributeUtils.GetProperty <RouteKeyAttribute>(message); if (property == null) { property = AttributeUtils.GetProperty <KeyAttribute>(message); } RouteKeyCache.TryAdd(type, property); } var keyValue = property?.GetValue(message); return(keyValue != null?keyValue.ToString() : null); }
private void SetDiceThrowLabel(ICaste caste, IRace race, string propertyName, Label label) { var casteAttributes = caste.GetCustomAttributes(propertyName); var diceThrow = AttributeUtils.GetAttribute <DiceThrowAttribute>(casteAttributes); var diceThrowModifier = AttributeUtils.GetAttribute <DiceThrowModifierAttribute>(casteAttributes); var specialTrainingAttribute = AttributeUtils.GetAttribute <SpecialTrainingAttribute>(casteAttributes); label.Text = Lng.Elem(EnumUtils.GetDescription(diceThrow.DiceThrowType)); if (diceThrowModifier != null) { label.Text += $" + {diceThrowModifier.Modifier}"; } if (specialTrainingAttribute != null) { label.Text += $" + {Lng.Elem("St")}"; } if (diceThrow.DiceThrowType.ToString().EndsWith("2_Times")) { label.Text += " (2x)"; } var raceModifier = race.GetPropertyShortValue(propertyName); if (raceModifier != 0) { label.Text += raceModifier < 0 ? $" - {Math.Abs(raceModifier)}" : $" + {raceModifier}"; } }
public override void LoadContent(bool firstLoad) { if (firstLoad) { AttributeUtils.Invoke <LoadContentAttribute>(); } }
/// <summary> /// 设置连接体 /// </summary> public void WaveBodys() { Part workPart = Session.GetSession().Parts.Work; UFSession theUFSession = UFSession.GetUFSession(); if (workPart.Tag != this.PartTag.Tag) { NXOpen.Assemblies.Component ct = AssmbliesUtils.GetPartComp(workPart, this.PartTag); PartUtils.SetPartWork(ct); } foreach (Part part in Session.GetSession().Parts) { string type = AttributeUtils.GetAttrForString(part, "PartType"); if (type.Equals("Workpiece")) { Body[] bodys = part.Bodies.ToArray(); NXOpen.Features.Feature feat = AssmbliesUtils.WaveAssociativeBodys(bodys); Body[] waveBodys = ((NXOpen.Features.BodyFeature)feat).GetBodies(); foreach (Body body in waveBodys) { body.Layer = 2; theUFSession.Layer.SetStatus(2, 2); } break; } } PartUtils.SetPartWork(null); }
public void GetInterferenceOfArea() { Body eleBody = GetOccsInBods(this.eleModel.PartTag)[0]; Body workpieceBody = GetOccsInBods(this.workpiece)[0]; List <Face> faces = AnalysisUtils.SetInterferenceOutFace(eleBody, workpieceBody); double minArea = 0; for (int i = 0; i < (faces.Count) / 2 - 1; i++) { FaceData data1 = FaceUtils.AskFaceData(faces[i * 2]); FaceData data2 = FaceUtils.AskFaceData(faces[i * 2 + 1]); if (data1.Equals(data2)) { double area1 = FaceUtils.GetFaceArea(faces[i * 2]); double area2 = FaceUtils.GetFaceArea(faces[i * 2 + 1]); if (area1 > area2) { minArea += area2; } else { minArea += area1; } } } AttributeUtils.AttributeOperation("Area", minArea, this.eleModel.PartTag); }
protected override void SetAttribute() { base.SetAttribute(); EleInfo.SetAttribute(this.PartTag); AttributeUtils.AttributeOperation("Matrx4", Matrx4ToString(this.EleMatr), this.PartTag); AttributeUtils.AttributeOperation("WorkNumber", this.WorkNumber, this.PartTag); }
/// <summary> /// Returns the set of authority tokens defined by all plugins. /// </summary> /// <returns></returns> public static AuthorityTokenDefinition[] GetAuthorityTokens() { var tokens = new List <AuthorityTokenDefinition>(); // scan all plugins for token definitions foreach (var plugin in Platform.PluginManager.Plugins) { var assembly = plugin.Assembly.Resolve(); var resolver = new ResourceResolver(assembly); foreach (var type in plugin.Assembly.Resolve().GetTypes()) { // look at public fields foreach (var field in type.GetFields()) { var attr = AttributeUtils.GetAttribute <AuthorityTokenAttribute>(field, false); if (attr != null) { var token = (string)field.GetValue(null); var description = resolver.LocalizeString(attr.Description); var formerIdentities = (attr.Formerly ?? "").Split(';'); tokens.Add(new AuthorityTokenDefinition(token, assembly.FullName, description, formerIdentities)); } } } } return(tokens.ToArray()); }
private static Dictionary <string, PropertyData> WriteProperties(EntityChange entityChange) { var propertiesData = new Dictionary <string, PropertyData>(); var entityClass = EntityRefUtils.GetClass(entityChange.EntityRef); foreach (var prop in entityChange.PropertyChanges) { var pi = entityClass.GetProperty(prop.PropertyName); // special handling of extended properties collections // note that we need to check pi != null because it may represent a field-access "property" // which has no corresponding .NET property if (pi != null && AttributeUtils.HasAttribute <ExtendedPropertiesCollectionAttribute>(pi)) { var extendedProps = WriteExtendedProperties(prop, entityChange.ChangeType); foreach (var extendedProp in extendedProps) { propertiesData.Add(extendedProp.Key, extendedProp.Value); } } else { var propertyData = WriteProperty(prop.OldValue, prop.NewValue, entityChange.ChangeType); propertiesData.Add(prop.PropertyName, propertyData); } } return(propertiesData); }
private bool PartIsAsm() { Part workPart = Session.GetSession().Parts.Work; if (!ParentAssmblieInfo.IsAsm(workPart)) { asm = ASMCollection.GetAsmModel(workPart); if (asm == null) { ClassItem.MessageBox("无法通过工作部件找到ASM!", NXMessageBox.DialogType.Error); return(false); } PartUtils.SetPartDisplay(asm.PartTag); } asm = new ASMModel(workPart); asmColl = new ASMCollection(asm); foreach (WorkModel wk in asmColl.GetWorks()) { bool isInter = AttributeUtils.GetAttrForBool(wk.PartTag, "Interference"); if (!isInter) { NXOpen.UI.GetUI().NXMessageBox.Show("提示", NXMessageBox.DialogType.Error, wk.AssembleName + "没有检查电极"); return(false); } } return(true); }
/// <summary> /// 修改电极名 /// </summary> /// <param name="model"></param> /// <param name="newName"></param> /// <returns></returns> public static Part ReplaceElectrode(ElectrodeModel model, string newName) { Session theSession = Session.GetSession(); Part workPart = theSession.Parts.Work; Component ct = model.GetPartComp(workPart); string OldName = model.EleInfo.EleName; string newPartPath = model.WorkpiecePath.Replace(OldName, newName); File.Move(model.WorkpiecePath, newPartPath); if (ct != null) { model.PartTag.Close(NXOpen.BasePart.CloseWholeTree.False, NXOpen.BasePart.CloseModified.UseResponses, null); if (Basic.AssmbliesUtils.ReplaceComp(ct, newPartPath, ct.Name.Replace(OldName, newName))) { Part elePart = ct.Prototype as Part; string dwgPath = model.WorkpieceDirectoryPath + model.AssembleName + "_dwg.prt"; AttributeUtils.AttributeOperation("EleName", newName, elePart); AttributeUtils.AttributeOperation("EleNumber", GetEleNumber(newName), elePart); if (File.Exists(dwgPath)) { UFSession theUFSession = UFSession.GetUFSession(); Tag partTag; UFPart.LoadStatus error_status; File.Move(dwgPath, dwgPath.Replace(OldName, newName)); theUFSession.Part.Open(dwgPath.Replace(OldName, newName), out partTag, out error_status); AttributeUtils.AttributeOperation("EleName", newName, NXObjectManager.Get(partTag) as Part); } return(elePart); } return(null); } return(null); }
public void AddMemberConstraint(MemberInfo member, Attribute attribute) { List <Attribute> constraints; if (!membersAttributesDictionary.TryGetValue(member, out constraints)) { constraints = new List <Attribute>(); membersAttributesDictionary.Add(member, constraints); } Attribute found = constraints.Find(x => x.TypeId.Equals(attribute.TypeId)); if (found == null || AttributeUtils.AttributeAllowsMultiple(attribute)) { #if NETFX log.Debug(string.Format("For class {0} Adding member {1} to dictionary with attribute {2}", EntityType.FullName, member.Name, attribute)); #else Log.Debug("For class {0} Adding member {1} to dictionary with attribute {2}", EntityType.FullName, member.Name, attribute); #endif membersAttributesDictionary[member].Add(attribute); } else { #if NETFX log.Debug("Duplicated Attribute avoided: Class:" + typeof(T).FullName + " Member:" + member.Name + " Attribute:" + attribute); #else Log.Debug("Duplicated Attribute avoided: Class: {0} Member: {1} Attribute: {2}", typeof(T).FullName, member.Name, attribute); #endif } }
private EnumerationInfo ReadHardEnum(Type enumValueClass, Table table) { Type enumType = _mapClassToEnum[enumValueClass]; int displayOrder = 1; // note that we process the enum constants in order of the underlying value assigned // so that the initial displayOrder reflects the natural ordering // (see msdn docs for Enum.GetValues for details) return(new EnumerationInfo(enumValueClass.FullName, table.Name, true, CollectionUtils.Map <object, EnumerationMemberInfo>(Enum.GetValues(enumType), delegate(object value) { string code = Enum.GetName(enumType, value); FieldInfo fi = enumType.GetField(code); EnumValueAttribute attr = AttributeUtils.GetAttribute <EnumValueAttribute>(fi); return new EnumerationMemberInfo( code, attr != null ? attr.Value : null, attr != null ? attr.Description : null, displayOrder++, false); }))); }
/// <summary> /// Attempts to instantiate a script engine for the specified language. /// </summary> /// <remarks> /// <para> /// Internally, this class looks for an extension of <see cref="ScriptEngineExtensionPoint"/> /// that is capable of running scripts in the specified language. /// In order to be considered a match, extensions must be decorated with a /// <see cref="LanguageSupportAttribute"/> matching the <paramref name="language"/> parameter. /// </para> /// <para> /// If the engine is marked as a singleton, and a cached instance already exists, that instance will /// be returned. /// </para> /// <para> /// This method can safely be called by multiple threads. /// </para> /// </remarks> /// <param name="language">The case-insensitive script language, so jscript is equivalent to JScript.</param> public static IScriptEngine GetEngine(string language) { lock (_syncLock) { // check for a cached singleton engine instance for this language IScriptEngine engine; if (_singletonEngineInstances.TryGetValue(language, out engine)) { return(engine); } // create a new engine instance engine = CreateEngine(language); var optionsAttr = AttributeUtils.GetAttribute <ScriptEngineOptionsAttribute>(engine.GetType()); if (optionsAttr != null) { // if the engine requires synchronization, wrap it if (optionsAttr.SynchronizeAccess) { engine = new SynchronizedScriptEngineWrapper(engine); } // if the engine is a singleton, cache this instance if (optionsAttr.Singleton) { _singletonEngineInstances.Add(language, engine); } } return(engine); } }
private void GatherNamespaceToRender(string nsPrefix, SortedList nsListToRender, Hashtable nsLocallyDeclared) { foreach (object a in nsListToRender.GetKeyList()) { if (AttributeUtils.HasNamespacePrefix((XmlAttribute)a, nsPrefix)) { return; } } int rDepth; XmlAttribute local = (XmlAttribute)nsLocallyDeclared[nsPrefix]; XmlAttribute rAncestral = GetNearestNamespaceWithMatchingPrefix(nsPrefix, out rDepth); if (local != null) { if (AttributeUtils.IsNonRedundantNamespaceDecl(local, rAncestral)) { nsLocallyDeclared.Remove(nsPrefix); nsListToRender.Add(local, null); } } else { int uDepth; XmlAttribute uAncestral = GetNearestNamespaceWithMatchingPrefix(nsPrefix, out uDepth, false); if (uAncestral != null && uDepth > rDepth && AttributeUtils.IsNonRedundantNamespaceDecl(uAncestral, rAncestral)) { nsListToRender.Add(uAncestral, null); } } }
/// <summary> /// 通过属性获取 /// </summary> /// <param name="bodys">一种齿(阵列)</param> /// <returns></returns> public ElectrodeToolhInfo[,] GetToolhInfosForAttribute(List <Body> bodys, Matrix4 matr, CartesianCoordinateSystem csys) { ElectrodeToolhInfo[,] info = new ElectrodeToolhInfo[this.PitchXNum, this.PitchYNum]; var toolhNumList = bodys.GroupBy(a => AttributeUtils.GetAttrForInt(a, "ToolhNumber")); List <BodyPitchClassify> bps = new List <BodyPitchClassify>(); foreach (var toolhNum in toolhNumList) { BodyPitchClassify bp = new BodyPitchClassify(toolhNum.ToList(), matr, csys, this.PitchXNum, this.PitchYNum); bp.SetAttribute(); bps.Add(bp); } for (int i = 0; i < this.PitchXNum; i++) { for (int k = 0; k < this.PitchYNum; k++) { List <Body> temp = new List <Body>(); foreach (BodyPitchClassify by in bps) { temp.Add(by.ClassifyBodys[i, k]); } info[i, k] = ElectrodeToolhInfo.GetToolhInfoForAttribute(temp.ToArray()); } } return(info); }
private void GetEFanERFace(List <Face> faces, out Dictionary <double, Face[]> dic) { List <Face> erFaces = new List <Face>(); List <Face> efFaces = new List <Face>(); dic = new Dictionary <double, Face[]>(); if (faces.Count > 0) { foreach (Face fe in faces) { string er = AttributeUtils.GetAttrForString(fe, "ToolhGapValue"); if (er.Equals("ER", StringComparison.CurrentCultureIgnoreCase)) { erFaces.Add(fe); } else if (er.Equals("EF", StringComparison.CurrentCultureIgnoreCase)) { efFaces.Add(fe); } } } if (!this.IsOffsetInter) { dic.Add(this.model.Info.AllInfo.GapValue.FineInter, efFaces.ToArray()); dic.Add(this.model.Info.AllInfo.GapValue.DuringInter, erFaces.ToArray()); } else { dic.Add(0, faces.ToArray()); } }