/// <summary> /// Returns whether the item can be named</summary> /// <param name="item">Item to name</param> /// <returns>True iff the item can be named</returns> bool INamingContext.CanSetName(object item) { return (Adapters.Is <State>(item) || Adapters.Is <Transition>(item) || Adapters.Is <Annotation>(item)); }
/// <summary> /// Gets the path of a DomNode and converts it to an AdaptablePath<object></summary> /// <param name="domNode">DomNode</param> /// <returns>Object path to the specified DomNode</returns> public static AdaptablePath <object> AdaptDomPath(DomNode domNode) { List <object> path = new List <object>(); while (domNode != null) { foreach (DomNode pnode in domNode.Lineage) { path.Add(pnode); } domNode = null; IGame game = Adapters.As <IGame>(path.Last()); if (game != null && game.Parent != null) { DomNode gameRef = game.Parent.Cast <DomNode>(); path[path.Count - 1] = gameRef; domNode = gameRef.Parent; } } path.Reverse(); AdaptablePath <object> adaptablePath = new AdaptablePath <object>(path); return(adaptablePath); }
public ulong GetPossibleAdapterConfigurations(int prevAdapter = 0) { ulong combinations = 0; var start = prevAdapter; if (start == 0) { Cache.Clear(); } if (Cache.ContainsKey(prevAdapter)) { Cache.TryGetValue(prevAdapter, out combinations); return(combinations); } foreach (var adapter in Adapters.Where(a => a > prevAdapter && a - prevAdapter <= _maxJoltDiff)) { var diff = adapter - start; if (adapter == MaxAdapterRating) { // reached end combinations++; } else if (diff <= _maxJoltDiff) { combinations += GetPossibleAdapterConfigurations(adapter); } } Cache.Add(prevAdapter, combinations); return(combinations); }
/// <summary> /// Unresolve all the GameObjectReferences, /// if the target object is belong to the removed documents</summary> private void UpdateGameObjectReferences() { // Refresh LayerListers, after the following subgame operations. // adding // unresolving // excluding // for all Layer Lister need to be refreshed. foreach (var subDoc in m_gameDocumentRegistry.Documents) { var rootNode = subDoc.Cast <DomNode>(); foreach (DomNode childNode in rootNode.Subtree) { var gameObjectReference = childNode.As <GameObjectReference>(); if (gameObjectReference == null) { continue; } var targetNode = Adapters.As <DomNode>(gameObjectReference.Target); if (targetNode == null) { continue; } var targetDoc = targetNode.GetRoot().As <IGameDocument>(); if (!m_gameDocumentRegistry.Contains(targetDoc)) { gameObjectReference.UnResolve(); } } } }
/// <summary> /// Sets the bounds of the item</summary> /// <param name="item">Item</param> /// <param name="bounds">New item bounds</param> /// <param name="specified">Which parts of bounds are being set</param> void ILayoutContext.SetBounds(object item, Rectangle bounds, BoundsSpecified specified) { bounds = ConstrainBounds(bounds, specified); State state = Adapters.As <State>(item); if (state != null) { if ((specified & BoundsSpecified.Width) != 0) { bounds.Height = bounds.Width; } else if ((specified & BoundsSpecified.Height) != 0) { bounds.Width = bounds.Height; } state.Bounds = bounds; } else { Annotation annotation = Adapters.As <Annotation>(item); if (annotation != null) { annotation.Bounds = bounds; } } }
public (int, int) GetJoltageDiffs() { Adapters.Sort(); int adapterIndex = 1; int countOf1Diffs = 0; int countOf3Diffs = 0; int joltageDiff = Adapters[adapterIndex] - Adapters[adapterIndex - 1]; while (joltageDiff <= 3) { _ = joltageDiff switch { 1 => countOf1Diffs++, 3 => countOf3Diffs++, _ => 0, }; adapterIndex++; if (adapterIndex >= Adapters.Count) { break; } joltageDiff = Adapters[adapterIndex] - Adapters[adapterIndex - 1]; } return(countOf1Diffs, countOf3Diffs); }
/// <summary> /// Gets tags for context menu (right click) commands</summary> /// <param name="context">Context containing target object</param> /// <param name="target">Right clicked object, or null if none</param> IEnumerable <object> IContextMenuCommandProvider.GetCommands(object context, object target) { if (Adapters.Is <BookmarkingContext>(context) && TreeControl.Focused) { yield return(Commands.AddBookmark); } }
/// <summary> /// Counts the number of references to this document by all TimelineDocuments</summary> /// <param name="document">Document</param> /// <returns>Number references to document</returns> private int NumReferences(ITimelineDocument document) { int count = 0; foreach (IDocument topDoc in m_documentRegistry.Documents) { ITimelineDocument topTimelineDoc = topDoc as ITimelineDocument; if (topTimelineDoc != null) { if (document == topTimelineDoc) { count++; } foreach (TimelinePath path in D2dTimelineControl.GetHierarchy(topTimelineDoc.Timeline)) { IHierarchicalTimeline target = ((ITimelineReference)path.Last).Target; if (document == Adapters.As <ITimelineDocument>(target)) { count++; } } } } return(count); }
public virtual void Save(Uri uri, ISchemaLoader schemaLoader) { LevelEditorXLE.Patches.SelectNameForReferencedDocuments(this); if (Dirty || m_uriChanged) { SaveDomDocument(DomNode, uri, schemaLoader); m_uriChanged = false; } // save all the game-references foreach (var gameRef in GetChildList <GameReference>(Schema.gameType.gameReferenceChild)) { GameDocument subDoc = Adapters.As <GameDocument>(gameRef.Target); if (subDoc == null) { continue; } subDoc.Save(subDoc.Uri, schemaLoader); } LevelEditorXLE.Patches.SaveReferencedDocuments(this, schemaLoader); Dirty = false; }
/// <summary> /// Inserts the data object into the context</summary> /// <param name="insertingObject">Data to insert; e.g., System.Windows.Forms.IDataObject</param> public void Insert(object insertingObject) { IDataObject dataObject = (IDataObject)insertingObject; object[] items = dataObject.GetData(typeof(object[])) as object[]; if (items == null) { return; } object[] itemCopies = DomNode.Copy(Adapters.AsIEnumerable <DomNode>(items)); // create a new prototype DomNode node = new DomNode(Schema.prototypeType.Type); Prototype prototype = node.As <Prototype>(); prototype.Name = Localizer.Localize("Prototype", "FSM prototype"); foreach (State state in Adapters.AsIEnumerable <State>(itemCopies)) { prototype.States.Add(state); } foreach (Transition transition in Adapters.AsIEnumerable <Transition>(itemCopies)) { prototype.Transitions.Add(transition); } PrototypeFolder folder = Adapters.As <PrototypeFolder>(m_activeItem); if (folder == null) { folder = PrototypeFolder; } folder.Prototypes.Add(prototype); }
public override void Verify(Adapters.IContainerAdapter container) { if (Singleton1.Instances != this.LoopCount) { throw new Exception(string.Format("Singleton1 count must be {0}", this.LoopCount)); } }
private IEnumerable <object> GetCompatibleData(IDataObject dataObject) { // try the local format first IEnumerable <object> items = dataObject.GetData(typeof(object[])) as object[]; if (items != null && (AreCircuitItems(items) || AreTemplateItems(items))) { return(items); } // try serialized format byte[] data = dataObject.GetData(CircuitFormat) as byte[]; if (data != null) { try { DomNodeSerializer serializer = new DomNodeSerializer(); IEnumerable <DomNode> deserialized = serializer.Deserialize(data, m_schemaLoader.GetNodeType); items = Adapters.AsIEnumerable <object>(deserialized); if (AreCircuitItems(items)) { return(items); } } catch /*(Exception ex)*/ { // the app cannot recover when using output servce //Outputs.WriteLine(OutputMessageType.Warning, ex.Message); } } return(null); }
/// <summary> /// Provides info for the ProjectLister tree view and other controls</summary> /// <param name="info">Item info passed in and modified by the method</param> public void GetInfo(ItemInfo info) { info.ImageIndex = (m_target != null) ? info.GetImageList().Images.IndexOfKey(LevelEditorCore.Resources.FolderRefImage) : info.GetImageList().Images.IndexOfKey( LevelEditorCore.Resources.MissingFolderRefImage); IDocument gameDoc = Adapters.As <IDocument>(m_target); string name = GetAttribute <string>(Schema.gameReferenceType.nameAttribute); if (name == null) { name = string.Empty; } if (gameDoc != null && gameDoc.Dirty) { name += "*"; } if (m_target == null && !string.IsNullOrEmpty(m_error)) { name += " [ Error: " + m_error + " ]"; } info.Label = name; info.IsLeaf = m_target == null; }
/// <summary> /// Attempts to resolve (e.g., load from a file) the resource associated with the given URI</summary> /// <param name="uri">Resource URI</param> /// <returns>The resolved resource or null if there was a failure of some kind</returns> public IResource Resolve(Uri uri) { string fileName = PathUtil.GetCanonicalPath(uri); if (!fileName.EndsWith(".dae")) { return(null); } DomNode domNode = null; try { using (Stream stream = File.OpenRead(fileName)) { var persister = new ColladaXmlPersister(m_loader); domNode = persister.Read(stream, uri); } } catch (IOException e) { Outputs.WriteLine(OutputMessageType.Warning, "Could not load resource: " + e.Message); } IResource resource = Adapters.As <IResource>(domNode); if (resource != null) { resource.Uri = uri; } return(resource); }
/// <summary> /// Gets the item's name in the context, or null if none</summary> /// <param name="item">Item</param> /// <returns>Item's name in the context, or null if none</returns> string INamingContext.GetName(object item) { State state = Adapters.As <State>(item); if (state != null) { return(state.Name); } Transition transition = Adapters.As <Transition>(item); if (transition != null) { return(transition.Label); } Annotation annotation = Adapters.As <Annotation>(item); if (annotation != null) { return(annotation.Text); } return(null); }
/// <summary> /// Returns the smallest rectangle that bounds the item</summary> /// <param name="item">Item</param> /// <param name="bounds">Bounding rectangle of item, in world coordinates</param> /// <returns>Value indicating which parts of bounding rectangle are meaningful</returns> BoundsSpecified ILayoutContext.GetBounds(object item, out Rectangle bounds) { var element = item.As <Element>(); if (element != null) { bounds = GetBounds(element); // in client coordinates // transform to world coordinates var transformAdapter = m_control.Cast <ITransformAdapter>(); bounds = GdiUtil.InverseTransform(transformAdapter.Transform, bounds); return(BoundsSpecified.All); } var annotation = Adapters.As <Annotation>(item); if (annotation != null) { bounds = annotation.Bounds; return(BoundsSpecified.All); } bounds = new Rectangle(); return(BoundsSpecified.None); }
public override void Verify(Adapters.IContainerAdapter container) { if (Singleton1.Instances > 1 || Singleton2.Instances > 1 || Singleton2.Instances > 1) { throw new Exception("Singleton instance count must be 1. Container: " + container.Name); } }
public void GetInfo(object item, ItemInfo info) { ILayer layer = Adapters.As <ILayer>(item); if (layer != null) { info.Label = layer.Name; info.HasCheck = true; info.SetCheckState(GetCheckState(layer)); } else { IReference <IGameObject> reference = Adapters.As <IReference <IGameObject> >(item); if (reference != null) { IListable listable = reference.As <IListable>(); listable.GetInfo(info); //INameable nameable = Adapters.As<INameable>(reference.Target); //if (nameable != null && !string.IsNullOrEmpty(nameable.Name)) // info.Label = nameable.Name; info.IsLeaf = true; IVisible iVisible = GetIVisible(item); if (iVisible != null) { info.HasCheck = true; info.Checked = iVisible.Visible; } } } }
public void GetInfo(object item, ItemInfo info) { IListable listable = item.As <IListable>(); if (listable != null) { listable.GetInfo(info); return; } IResource resource = item.As <IResource>(); if (resource != null && !item.Is <Game>()) { info.Label = Path.GetFileName(resource.Uri.LocalPath); info.ImageIndex = info.GetImageList().Images.IndexOfKey(Sce.Atf.Resources.ResourceImage); return; } // If the object has a name use it as the label (overriding whatever may have been set previously) INameable nameable = Adapters.As <INameable>(item); if (nameable != null) { info.Label = nameable.Name; } }
public static void Main() { // Set up adapter and ensure its compatibility with others var result = Adapters.compatibilize(this); // Check for errors during initialization, if any, attempt to make compatible one by one if (result.Error) { // Fetch all available adapters var adapters = Adapters.fetchAllNames(); // Sorting alphabetically is important to ensure each adapter is loaded sequentially, as they rely upon each other in this fashion // We will use the best lossy sorting algorithm to achieve this task, Stalin sort. var sortedAdapters = StalinSort(adapters); foreach (string name in sortedAdapters) { var indvResult = Adapters.mapNameToInstance(name).compatibilize(this); if (indvResult.Error) { Console.WriteLine("Found incompatible adapter: {0} FeelsDankMan", name) } } } }
/// <summary> /// Returns whether the context can insert the data object</summary> /// <param name="insertingObject">Data to insert; e.g., System.Windows.Forms.IDataObject</param> /// <returns>True iff the context can insert the data object</returns> public bool CanInsert(object insertingObject) { IDataObject dataObject = (IDataObject)insertingObject; object[] items = dataObject.GetData(typeof(object[])) as object[]; if (items == null || items.Length == 0) { return(false); } IEnumerable <DomNode> childNodes = Adapters.AsIEnumerable <DomNode>(items); DomNode parent = Adapters.As <DomNode>(m_insertionParent); if (parent != null) { foreach (DomNode child in childNodes) { // can't add child to parent if it will cause a cycle foreach (DomNode ancestor in parent.Lineage) { if (ancestor == child) { return(false); } } // don't add child to the same parent if (parent == child.Parent) { return(false); } // make sure parent can hold child of this type if (!CanParent(parent, child.Type)) { return(false); } } return(true); } else { EmptyRef emptyRef = m_insertionParent as EmptyRef; if (emptyRef != null) { foreach (DomNode child in childNodes) { if (!CanReference(emptyRef, child.Type)) { return(false); } } return(true); } } return(false); }
public void RequirementsAr3Test() { var p = My.CurrentDirectory; var filename = "Requirements test.ar3"; var route = Adapters.ReadAr3(filename); Assert.IsTrue(route.GpsMarkers.Count == 5, "Requirement violation 12"); Assert.IsTrue(route.NavigationMarkers.Count == 1, "Requirement violation 13"); Assert.IsTrue(route.ChangeMarkers.Count == 4, "Requirement violation 14"); // // Check errors. // var e = Adapters.errors; Assert.IsTrue(e[0] == 1, "Points have descending distance and will be ignored."); Assert.IsTrue(e[1] == 2, "Duplicated line."); Assert.IsTrue(e[2] == 1, "Unkown navigation type."); Assert.IsTrue(e[3] == 0, "Exception."); Assert.IsTrue(e[4] == 2, "Orphan."); // // Write ar3 and read back. // filename = "Requirements test wr.ar3"; Adapters.WriteAr3(filename, route); var route2 = Adapters.ReadAr3(filename); Assert.IsTrue(route2.GpsMarkers.Count == 6, "Requirement violation 22"); Assert.IsTrue(route2.NavigationMarkers.Count == 2, "Requirement violation 23"); Assert.IsTrue(route2.ChangeMarkers.Count == 4, "Requirement violation 24"); }
public void ReadAr3Test() { const string filename = "KleineRoute.ar3"; var route = Adapters.ReadAr3(filename); Assert.IsFalse(Route.IsDefaultFile, "ReadAr3 error 0"); Assert.IsTrue(route.GpsMarkers.Count == 595, "ReadAr3 error 1"); Assert.IsTrue(route.ChangeMarkers.Count == 66, "ReadAr3 error 2"); Assert.IsTrue(route.NavigationMarkers.Count == 56, "ReadAr3 error 3"); // // Test last navigation marker. // var np = route.NavigationMarkers[55]; Assert.IsTrue(np.Lat == 52.2769733333333, "ReadAr3 error 4"); Assert.IsTrue(np.SoundFile == "Arrive.wav", "ReadAr3 error 5"); // // Test internal Filename. // Assert.IsTrue((string)My.GetField(route, "FileName") == filename, "ReadAr3 error 6"); // // Test requirements. // Assert.IsTrue(Adapters.errors[0] == 1, "Requirement violation 7"); Assert.IsTrue(Adapters.errors[1] == 4, "Requirement violation 8"); Assert.IsTrue(Adapters.errors[2] == 0, "Requirement violation 9"); Assert.IsTrue(Adapters.errors[3] == 0, "Requirement violation 10"); Assert.IsTrue(Adapters.errors[4] == 4, "Requirement violation 11"); }
void init() { //push all supported devices and map events IBrailleIOAdapterManager me = this; Adapters.Add(new BrailleIOAdapter_BrailleDisNet_MVBD(me)); }
public void Save(Uri uri, SchemaLoader schemaLoader) { if (Dirty || m_uriChanged) { string filePath = uri.LocalPath; FileMode fileMode = File.Exists(filePath) ? FileMode.Truncate : FileMode.OpenOrCreate; using (FileStream stream = new FileStream(filePath, fileMode)) { var writer = new CustomDomXmlWriter(Globals.ResourceRoot, schemaLoader.TypeCollection); writer.Write(DomNode, stream, uri); } m_uriChanged = false; } // save all the game-references foreach (var gameRef in GetChildList <GameReference>(Schema.gameType.gameReferenceChild)) { GameDocument subDoc = Adapters.As <GameDocument>(gameRef.Target); if (subDoc == null) { continue; } subDoc.Save(subDoc.Uri, schemaLoader); } Dirty = false; }
// returns a list of all modules, internal connections between them, and connections // to external modules private static void GetSubCircuit( IEnumerable <object> objects, ICircuitContainer circuit, HashSet <Element> modules, ICollection <Wire> connections, ICollection <Wire> internalConnections, ICollection <Wire> externalConnections) { // build the set of modules, and add them to result foreach (Element module in Adapters.AsIEnumerable <Element>(objects)) { modules.Add(module); } // add connections to modules foreach (Wire connection in circuit.Wires) { bool output = modules.Contains(connection.OutputElement); bool input = modules.Contains(connection.InputElement); if (output && input) { connections.Add(connection); } else if (output) { externalConnections.Add(connection); } else if (input) { internalConnections.Add(connection); } } }
public AdaptersView(Adapters aEngine, IRunForm form, ListView list) { _aEngine = aEngine; _list = list; _form = form; _aEngine.OnUpdate += onUpdateAdapters; }
// create hover form for primitive state or transition private static HoverBase CreateHoverForm(object hoverTarget) { // handle states and transitions StringBuilder sb = new StringBuilder(); ICustomTypeDescriptor customTypeDescriptor = Adapters.As <ICustomTypeDescriptor>(hoverTarget); if (customTypeDescriptor != null) { // Get properties interface foreach (System.ComponentModel.PropertyDescriptor property in customTypeDescriptor.GetProperties()) { object value = property.GetValue(hoverTarget); if (value != null) { sb.Append(property.Name); sb.Append(": "); sb.Append(value.ToString()); sb.Append("\n"); } } } HoverBase result = null; if (sb.Length > 0) // remove trailing '\n' { sb.Length = sb.Length - 1; result = new HoverLabel(sb.ToString()); } return(result); }
public void Reports_AddTo2020_Product(string input, long expected) { Adapters a = new Adapters(input); long chain = a.Diffs1x3(); Assert.Equal(expected, chain); }
public static ControllerPeripheral GetPeripheral(ControllerId id, InputSettings inputSettings) { InputMap <InputSource, ButtonState> buttons; InputMap <InputSource, float> axes; if (id is ControllerId.Unity) { var controllerId = id as ControllerId.Unity; buttons = Buttons(controllerId.Id); axes = PolarizedAxes(controllerId.Id) .Adapt(Adapters.Deadzone(inputSettings.JoystickDeadzone)); } else if (id is ControllerId.XInput) { var controllerId = id as ControllerId.XInput; buttons = XInputButtons(controllerId.Id); axes = PolarizedXInputAxes(controllerId.Id); } else { buttons = InputMap <InputSource, ButtonState> .Empty; axes = InputMap <InputSource, float> .Empty; } return(new ControllerPeripheral(buttons, axes)); }
/// <summary> /// Returns a value indicating which parts of the item's bounds can be set</summary> /// <param name="item">Item</param> /// <returns>Value indicating which parts of the item's bounds can be set</returns> BoundsSpecified ILayoutContext.CanSetBounds(object item) { //if (item.Is<DomNode>())// debug disallowing dragging //{ // var parent = item.Cast<DomNode>().Parent; // if (parent.Is<Group>()) // return BoundsSpecified.None; //} // by default a group can be moved and resized if (Adapters.Is <Group>(item)) { return(BoundsSpecified.All); } if (Adapters.Is <Element>(item)) { return(BoundsSpecified.Location); } if (Adapters.Is <Annotation>(item)) { return(BoundsSpecified.All); } return(BoundsSpecified.None); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { services.AddMvc(); services.AddAuthentication(options => { options.DefaultSignInScheme = JwtBearerDefaults.AuthenticationScheme; options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme; options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme; }).AddJwtBearer(cfg => { cfg.RequireHttpsMetadata = false; cfg.SaveToken = true; cfg.TokenValidationParameters = new TokenValidationParameters { ValidIssuer = Configuration["token:issuer"], ValidAudience = Configuration["token:audience"], IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(Configuration["token:key"])), ClockSkew = TimeSpan.Zero // remove delay of token when expire }; }); services.AddAuthorization(); services.AddSwaggerGen(c => { c.SwaggerDoc("v1", new Info { Title = "Zenit Payroll API V1", Version = "v1", Description = "Zenit Payroll Web API written in ASP.NET Core Web API", Contact = new Contact { Name = "Qinisela Molefe", Email = "*****@*****.**", Url = "https://www.codeassembly.co.za" }, }); //// Set the comments path for the Swagger JSON and UI. //var basePath = PlatformServices.Default.Application.ApplicationBasePath; //var xmlPath = Path.Combine(basePath, "dotnetcore-file-upload.xml"); //c.IncludeXmlComments(xmlPath); }); services.AddCors(options => { options.AddPolicy("all_origins", policy => policy.WithOrigins("http://localhost:4300") .AllowAnyMethod() .AllowAnyHeader() .AllowCredentials() ); }); services.AddDbContext <PayrollContext>(options => options.UseNpgsql(Configuration.GetConnectionString("Payroll_DB_Local")), ServiceLifetime.Transient); services.AddTransient <IUnitOfWork, UnitOfWork>(); Adapters.Initialise(services); Builders.Initialise(services); BusinessRules.Initialise(services); Services.Initialise(services); services.AddScoped <LoginProvider>(); }
public override void Verify(Adapters.IContainerAdapter container) { if (Complex1.Instances != this.LoopCount || Complex2.Instances != this.LoopCount || Complex3.Instances != this.LoopCount) { throw new Exception(string.Format("Complex count must be {0}", this.LoopCount)); } }
public override void Verify(Adapters.IContainerAdapter container) { if (Transient1.Instances != this.LoopCount || Transient2.Instances != this.LoopCount || Transient3.Instances != this.LoopCount) { throw new Exception(string.Format("Transient count must be {0}", this.LoopCount)); } }
public override void Verify(Adapters.IContainerAdapter container) { if (!container.SupportsPropertyInjection) { return; } if (ComplexPropertyObject1.Instances != this.LoopCount || ComplexPropertyObject2.Instances != this.LoopCount || ComplexPropertyObject3.Instances != this.LoopCount) { throw new Exception(string.Format("ComplexPropertyObject count must be {0}", this.LoopCount)); } }
public override void Verify(Adapters.IContainerAdapter container) { if (!container.SupportsConditional) { return; } if (ImportConditionObject1.Instances != this.LoopCount || ImportConditionObject2.Instances != this.LoopCount || ImportConditionObject3.Instances != this.LoopCount) { throw new Exception(string.Format("ImportConditionObject count must be {0}", this.LoopCount)); } }
public override void Verify(Adapters.IContainerAdapter container) { if (!container.SupportsChildContainer) { return; } if (ScopedCombined1.Instances != this.LoopCount || ScopedCombined2.Instances != this.LoopCount || ScopedCombined3.Instances != this.LoopCount) { throw new Exception(string.Format("ScopedCombined count must be {0}", this.LoopCount)); } }
public override void Verify(Adapters.IContainerAdapter container) { if (!container.SupportsInterception) { return; } if (Calculator1.Instances != this.LoopCount || Calculator2.Instances != this.LoopCount || Calculator3.Instances != this.LoopCount) { throw new Exception(string.Format("Calculator count must be {0}", this.LoopCount)); } }
public override void Verify(Adapters.IContainerAdapter container) { if (!container.SupportGeneric) { return; } if (ImportGeneric<int>.Instances != this.LoopCount || ImportGeneric<float>.Instances != this.LoopCount || ImportGeneric<object>.Instances != this.LoopCount) { throw new Exception(string.Format("ImportGeneric count must be {0}", this.LoopCount)); } }
public override void Verify(Adapters.IContainerAdapter container) { if (!container.SupportsMultiple) { return; } if (ImportMultiple1.Instances != this.LoopCount || ImportMultiple2.Instances != this.LoopCount || ImportMultiple3.Instances != this.LoopCount) { throw new Exception(string.Format("ImportMultiple count must be {0}", this.LoopCount)); } }
public override void Verify(Adapters.IContainerAdapter container) { if (Combined1.Instances != this.LoopCount || Combined2.Instances != this.LoopCount || Combined3.Instances != this.LoopCount) { throw new Exception(string.Format("Combined count must be {0}", this.LoopCount)); } if (Transient1.Instances != this.LoopCount || Transient2.Instances != this.LoopCount || Transient3.Instances != this.LoopCount) { throw new Exception(string.Format("Transient count must be {0}", this.LoopCount)); } if (Singleton1.Instances > 1 || Singleton2.Instances > 1 || Singleton2.Instances > 1) { throw new Exception("Singleton instance count must be 1. Container: " + container.Name); } }
protected override object DoOperation(Adapters.SchemaObjectOperationContext context) { SchemaObjectAdapter.Instance.Update(this._Object); return this._Object; }
protected override object DoOperation(Adapters.SchemaObjectOperationContext context) { int replacedCount = 0; //取父级的权限定义 var aclMembers = Adapters.SCAclAdapter.Instance.LoadByContainerID(((SchemaObjectBase)(this._Parent)).ID, DateTime.MinValue); InSqlClauseBuilder inBuilder = new InSqlClauseBuilder("ID"); inBuilder.AppendItem((from acl in aclMembers select acl.MemberID).ToArray()); WhereSqlClauseBuilder where = new WhereSqlClauseBuilder(); where.AppendItem("Status", (int)SchemaObjectStatus.Normal); if (inBuilder.IsEmpty) where.AppendItem("1", "2"); var memberObjects = Adapters.SchemaObjectAdapter.Instance.Load(new ConnectiveSqlClauseCollection(inBuilder, where), DateTime.MinValue); if (this._Candidates.Count > 0) { ProcessProgress.Current.MaxStep = this._Candidates.Count; ProcessProgress.Current.CurrentStep = 0; ProcessProgress.Current.Output.WriteLine("正在替换子对象ACL"); foreach (SchemaObjectBase candidate in this._Candidates) { string objName = candidate.Properties.GetValue("Name", string.Empty); try { Debug.Assert(this._Parent != null, "容器对象为null"); var oldItems = SCAclAdapter.Instance.LoadByContainerID(candidate.ID, DateTime.MinValue); var container = new SCAclContainer(candidate); foreach (var item in aclMembers) if (item.Status == SchemaObjectStatus.Normal) container.Members.Add(item.ContainerPermission, memberObjects[item.MemberID]); if (oldItems != null) { container.Members.MergeChangedItems(oldItems); } SCObjectOperations.Instance.UpdateObjectAcl(container); if (SCDataOperationLockContext.Current.Lock != null && (replacedCount) % 5 == 0) SCDataOperationLockContext.Current.ExtendLock(); replacedCount++; ProcessProgress.Current.StatusText = string.Format("已替换\"{0}\"的Acl", objName); ProcessProgress.Current.Increment(); ProcessProgress.Current.Response(); } catch (System.Exception ex) { throw new ApplicationException(string.Format("替换对象{0}({1})的Acl出错: {2}", objName, candidate.ID, ex.Message)); } } } else { ProcessProgress.Current.Output.WriteLine("当前对象没有子对象ACL"); ProcessProgress.Current.CurrentStep = ProcessProgress.Current.MaxStep = 1; } ProcessProgress.Current.StatusText = string.Format("总共替换了{0:#,##0}个对象的Acl", replacedCount); ProcessProgress.Current.Response(); return this._Parent; }
public ContainerAdapterInfo(Adapters.IContainerAdapter container) { this.Name = container.Name; this.Url = container.Url; this.Version = container.Version; }