/// <summary> /// Generate Token /// </summary> /// <param name="data">should contains UserID , FirstName , LastName /// </param> /// <returns></returns> public static TServiceResult <Token> CreateToken(this IActions <Token> repo, UserVM u, string key) { var t = new Token(); var claims = new[] { new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString("N")), new Claim(JwtRegisteredClaimNames.UniqueName, u.Id), new Claim(JwtRegisteredClaimNames.GivenName, u.FirstName), new Claim(JwtRegisteredClaimNames.FamilyName, u.LastName) }; var credentials = new SigningCredentials(new SymmetricSecurityKey(Encoding.UTF8.GetBytes(key)), SecurityAlgorithms.HmacSha256Signature); var secToken = new JwtSecurityToken( issuer: "localhost", audience: "localhost", claims: claims, signingCredentials: credentials, notBefore: null, expires: DateTime.Now.AddDays(5)); t.Hash = new JwtSecurityTokenHandler().WriteToken(secToken); t.ExpireDate = secToken.ValidTo; repo.Insert(t); repo.SaveChanges(); return(new TServiceResult <Token>(t)); }
public TestApiController( ILogger <TestApiController> logger, IActions iActions) { _iActions = iActions; _logger = logger; }
public Fenetre(IActions model) { // initialisation IHM InitializeComponent(); // initialisation de la grille grille = new Button[largeur_grille, hauteur_grille]; // initialisation des tuiles for (int i = 0; i < largeur_grille; i++) { for (int j = 0; j < hauteur_grille; j++) { // creation d'une tuile grille[i, j] = new Button(); grille[i, j].Size = new Size(taille_tuile, taille_tuile); grille[i, j].Font = new Font("Arial", 9, FontStyle.Bold); // positionnement grille[i, j].Location = new Point(i * taille_tuile, j * taille_tuile); this.GridPanel.Controls.Add(grille[i, j]); // gestionnaire des clics grille[i, j].MouseUp += new MouseEventHandler(this.CellButton_Click); } } // connection jeu = model; jeu.vue = this; jeu.CommencerPartie(largeur_grille, hauteur_grille, numero_mines); MineLabel.Text = "Mines : " + numero_mines; }
public Plugin LoadMethods() { int idPlugin = 1; actions = new List <IActions>(); itemPlugin = new Plugin() { Id = idPlugin, Name = Path.GetFileName(dllFile), LocationFile = dllFile }; Assembly myDll = Assembly.LoadFrom(dllFile); foreach (Assembly a in AppDomain.CurrentDomain.GetAssemblies()) { foreach (Type t in a.GetTypes()) { if (t.GetInterface("IActions") != null) { IActions obj = Activator.CreateInstance(t) as IActions; if (obj != null) { actions.Add(obj); itemPlugin.Action = obj; } } } } GetMenuItems(); return(itemPlugin); }
static void Main(string[] args) { Hunter h1 = new Hunter(); Console.WriteLine(h1.ToString()); Shaman s1 = new Shaman(); Console.WriteLine(s1.ToString()); IActions[] actionsArr = new IActions[4]; actionsArr[0] = h1; actionsArr[1] = s1; actionsArr[2] = new Fighter(); actionsArr[3] = new Marksman(); Printer p1 = new Printer(); foreach (IActions i in actionsArr) { p1.IAmPrinting(i); } IActions ref1 = h1 as IActions; Console.WriteLine(h1 is IActions); Console.WriteLine(ref1 is IActions); Console.WriteLine((ref1 != null)); Test test1 = new Test(); IActions ref2 = test1 as IActions; Console.WriteLine((ref2 != null)); A a = new A(); B b = new B(); b.m(3, 4); }
public ODataTypedRepository( ILogger logger, IExchanger exchanger, IActions actions, ITimeOutPolicy <T> policy) : base(logger, exchanger, actions, policy) { }
public ActionMoveUnit2D(IUnit2D unit2D, FloatPoint2D destanationPoint, float speedPerSecond, IActions nextAction = null) { MovingUnit = unit2D; DestanationPoint = destanationPoint; SpeedPerSecond = speedPerSecond; NextAction = nextAction; LastStepTime = default; }
public TwoConditionEvent(IConditions condition1, IConditions condition2, IActions action1, IActions action2, IActions action3) { Condition1 = condition1; Condition2 = condition2; Action1 = action1; Action2 = action2; Action3 = action3; }
///////////////////////////////////////////////////////////////////////////////// private IGraph ImportModels(List<String> ecoreFilenames, String grgFilename, IBackend backend, out IActions actions) { foreach(String ecoreFilename in ecoreFilenames) { String modelText = ParseModel(ecoreFilename); String modelfilename = ecoreFilename.Substring(0, ecoreFilename.LastIndexOf('.')) + "__ecore.gm"; // Do we have to update the model file (.gm)? if(!File.Exists(modelfilename) || File.GetLastWriteTime(ecoreFilename) > File.GetLastWriteTime(modelfilename)) { Console.WriteLine("Writing model file \"" + modelfilename + "\"..."); using(StreamWriter writer = new StreamWriter(modelfilename)) writer.Write(modelText); } } if(grgFilename == null) { grgFilename = ""; foreach(String ecoreFilename in ecoreFilenames) grgFilename += ecoreFilename.Substring(0, ecoreFilename.LastIndexOf('.')) + "_"; grgFilename += "_ecore.grg"; StringBuilder sb = new StringBuilder(); sb.Append("// Automatically generated\n// Do not change, changes will be lost!\n\nusing "); DateTime grgTime; if(!File.Exists(grgFilename)) grgTime = DateTime.MinValue; else grgTime = File.GetLastWriteTime(grgFilename); bool mustWriteGrg = false; bool first = true; foreach(String ecore in ecoreFilenames) { if(first) first = false; else sb.Append(", "); sb.Append(ecore.Substring(0, ecore.LastIndexOf('.')) + "__ecore"); if(File.GetLastWriteTime(ecore) > grgTime) mustWriteGrg = true; } if(mustWriteGrg) { sb.Append(";\n"); using(StreamWriter writer = new StreamWriter(grgFilename)) writer.Write(sb.ToString()); } } IGraph graph; backend.CreateFromSpec(grgFilename, "defaultname", null, ProcessSpecFlags.UseNoExistingFiles, new List<String>(), out graph, out actions); return graph; }
public Store Register(IActions Value, string Key = Constraints.DefaultKey) { if (!_Actions.ContainsKey(Key)) { _Actions.Add(Key, Value); } return(this); }
public override void Prepare(ActionsViewModelNavigationParams parameter) { DashCamActions = parameter?.DashCamActions; if (DashCamActions != null) { PrimaryData.AddRange(DashCamActions.Actions); } }
public TypedRepository( ILogger logger, IExchanger exchanger, IActions actions, ITimeOutPolicy <T> policy) : base(logger, exchanger, actions) { Policy = policy; }
public void CreateFromSpec(string grgFilename, string graphName, String statisticsPath, ProcessSpecFlags flags, List <String> externalAssemblies, out IGraph newGraph, out IActions newActions) { LGSPGraph graph; LGSPActions actions; CreateFromSpec(grgFilename, graphName, statisticsPath, flags, externalAssemblies, false, 0, out graph, out actions); newGraph = graph; newActions = actions; }
public GameItem(ItemCategory category, int itemTypeID, string name, int price, bool isUnique = false, IActions action = null) { Category = category; ItemTypeID = itemTypeID; Name = name; Price = price; IsUnique = isUnique; Action = action; }
internal void SetBehabiour(IMoventOnSurface onMoventSurface, IMoventOnAir onAirMovent, IActions action) { _onMoventSurface = onMoventSurface; _onAirMovent = onAirMovent; _actions = action; _onAirMovent.Active(); _onMoventSurface.Active(); _actions.Active(); }
/// <summary> /// Creates a new graph from the given ECore metamodels. /// If a grg file is given, the graph will use the graph model declared in it and the according /// actions object will be associated to the graph. /// If a xmi file is given, the model instance will be imported into the graph. /// Any errors will be reported by exception. /// </summary> /// <param name="backend">The backend to use to create the graph.</param> /// <param name="ecoreFilenames">A list of ECore model specification files. It must at least contain one element.</param> /// <param name="grgFilename">A grg file to be used to create the graph, or null.</param> /// <param name="xmiFilename">The filename of the model instance to be imported, or null.</param> /// <param name="noPackageNamePrefix">Prefix the types with the name of the package? Can only be used if names from the packages are disjoint.</param> /// <param name="actions">Receives the actions object in case a .grg model is given.</param> public static IGraph Import(IBackend backend, List<String> ecoreFilenames, String grgFilename, String xmiFilename, bool noPackageNamePrefix, out IActions actions) { ECoreImport imported = new ECoreImport(); imported.graph = imported.ImportModels(ecoreFilenames, grgFilename, backend, out actions); if(xmiFilename != null) { Console.WriteLine("Importing graph..."); imported.ImportGraph(xmiFilename); } return imported.graph; }
public static async Task <TServiceResult <Token> > SignUpAsync(this IActions <Token> repo, UserVM data, IAuthActions <Token> dataManager) { var u = data.MapProp <UserVM, AppUser>(new AppUser()); var result = await dataManager.GetUserManager().CreateAsync(u, data.Password); if (result.Succeeded) { return(CreateToken(repo, data, dataManager.GetSecurityKey())); } return(new TServiceResult <Token>(null, "", false)); }
IEnumerator wait(float sec, IActions action) { yield return(new WaitForSeconds(sec)); action.InvokeAction(); if (!currentRobot.GetComponent <Robot> ().GetCollision()) { audioSource.clip = sound; audioSource.Play(); } }
public void CreateNamedFromSpec(string grgFilename, string graphName, String statisticsPath, ProcessSpecFlags flags, List <String> externalAssemblies, int capacity, out INamedGraph newGraph, out IActions newActions) { LGSPGraph graph; LGSPActions actions; CreateFromSpec(grgFilename, graphName, statisticsPath, flags, externalAssemblies, true, capacity, out graph, out actions); newGraph = (LGSPNamedGraph)graph; newActions = actions; }
public void StartAction(IActions action) { if (currentAction == action) { return; } if (currentAction != null) { currentAction.Cancel(); } currentAction = action; }
/// <summary> /// Returns type object for type name string /// </summary> /// <param name="typeName">Name of the type we want some type object for</param> /// <param name="procEnv">Graph processing environment to search the types in</param> /// <returns>The type object corresponding to the given string, null if type was not found</returns> public static Type GetType(String typeName, IGraphProcessingEnvironment procEnv) { if (typeName == null) { return(null); } if (procEnv == null) { return(null); } Type typeFromModel = GetType(typeName, procEnv.Graph.Model); if (typeFromModel != null) { return(typeFromModel); } IActions actions = procEnv.Actions; Assembly assembly = Assembly.GetAssembly(actions.GetType()); typeName = typeName.Substring(6); // remove "match<" typeName = typeName.Substring(0, typeName.Length - 1); // remove ">" if (typeName.StartsWith("class ")) { typeName = typeName.Substring(6); // remove "class " } foreach (IAction action in actions.Actions) { if (action.PackagePrefixedName == typeName) { Type type = Type.GetType(action.RulePattern.MatchInterfaceName + "," + assembly.FullName); // search actions assembly return(type); } } foreach (MatchClassFilterer matchClassFilterer in actions.MatchClasses) { MatchClassInfo info = matchClassFilterer.info; if (info.PackagePrefixedName == typeName) { Type type = Type.GetType(info.matchInterfaceName + "," + assembly.FullName); // search actions assembly return(type); } } return(null); }
public static IActions GetTheStrongest(Army obj) { int s = 0; IActions temp = obj.data[0]; foreach (IActions i in obj.data) { if (i.GetAttack() > s) { s = i.GetAttack(); temp = i; } } return(temp); }
public int CompareTo(object obj) { IActions i = obj as IActions; if (GetAttack() > i.GetAttack()) { return(1); } if (GetAttack() == i.GetAttack()) { return(0); } else { return(-1); } }
public override IActions Progress() { if (TimerStep != null) { TimerStep = TimerStep.Progress(); } else { ThisAction = ThisAction.Progress(); if (IsComplete()) { return(NextAction?.Start()); } TimerStep = new ActionWaitForTime(MillisecondStepLength).Start(); } return(this); }
public FlowManager(ScreenData screenData, IAppLogger appLogger, DirectorFactory directorFactory, FlowDataCache flowDataCache, IActions actions, IDialogFunctions dialogFunctions, FlowActivityFactory flowActivityFactory, IMapper mapper) { this.screenData = screenData; this.appLogger = appLogger; this.Director = directorFactory.Create(this); this.FlowDataCache = flowDataCache; this.Actions = actions; this.DialogFunctions = dialogFunctions; this.FlowActivity = flowActivityFactory.Create(this); this.Mapper = mapper; }
public IActions Delete(int num) { if ((data.Length > 0) && (num < data.Length) && (num >= 0)) { IActions temp = data[num]; for (int i = num; i < data.Length - 1; i++) { data[i] = data[i + 1]; } Array.Resize(ref data, data.Length - 1); return(temp); } else { //Console.WriteLine("Ошибка удаления элемента"); throw new IndexOutOfRangeException("Ошибка удаления элемента номер " + num.ToString()); //return null; } }
private string GetActionName(IActions action) { if (action != null) { switch (action.GetActionType()) { case ActionType.Action_Type.GoToPage: return(Strings.ResStrings.GoToPage); case ActionType.Action_Type.OpenWeb: return(Strings.ResStrings.OpenLink); case ActionType.Action_Type.ClosePresentation: return(Strings.ResStrings.ClosePresentation); case ActionType.Action_Type.OpenApplication: return(Strings.ResStrings.OpenApplication); case ActionType.Action_Type.ShowMessageBox: return(Strings.ResStrings.ShowMessageBox); case ActionType.Action_Type.Sound: return(Strings.ResStrings.Sound); case ActionType.Action_Type.LoadPresentation: return(Strings.ResStrings.LoadPresentation); case ActionType.Action_Type.SetVisibility: return(Strings.ResStrings.Visibility); case ActionType.Action_Type.DoAnimation: return(Strings.ResStrings.DoAnimation); case ActionType.Action_Type.Position: return(Strings.ResStrings.Position); case ActionType.Action_Type.NoAction: return("-"); } } return("-"); }
public static async Task <TServiceResult <Token> > LoginAsync(this IActions <Token> repo, UserVM data, IAuthActions <Token> dataManager) { Token t = new Token(); var user = data.MapProp <UserVM, AppUser>(new AppUser()); var res = await dataManager.GetSigningManager().PasswordSignInAsync(user.UserName, data.Password, true, true); if (!res.Succeeded) { return(new TServiceResult <Token>(null, "not found", false)); } user = await dataManager.GetUserManager().FindByNameAsync(user.UserName); if (!await dataManager.GetUserManager().IsInRoleAsync(user, "User")) { /* * add memeber to roll */ } return(CreateToken(repo, data, dataManager.GetSecurityKey())); }
static void Main(string[] args) { Student s1 = new Student(); s1.displayStudent(); Console.WriteLine("**********************"); Teacher t1 = new Teacher(); t1.sleep(); //t1.eat(); //de ce nu merge? din moment ce nu merge de ce nu primesc eroare ca nu ii implementata //metoda in clasa Teacher din moment ce implementeaza IAction IActions action = t1; // ce obiect este action? teacher? action.eat(); Console.WriteLine("**********************"); Console.WriteLine(t1.pushups()); }
private Actions(Resolution resolution, IActions buttons, Layer layer) { if (resolution == null) { throw new ArgumentNullException(nameof(resolution)); } if (buttons == null) { throw new ArgumentNullException(nameof(buttons)); } if (layer == null) { throw new ArgumentNullException(nameof(layer)); } /* * * * * Up = new Events(resolution, buttons.Up, layer); * Down = new Events(resolution, buttons.Down, layer); * Left = new Events(resolution, buttons.Left, layer); * Right = new Events(resolution, buttons.Right, layer); * Cancel = new Events(resolution, buttons.Cancel, layer); * Button1 = new Events(resolution, buttons.Button1, layer); * * layer.CanvasElement.OnMouseDown = (e) => * { * InputMouseDown(e); * }; * layer.CanvasElement.OnMouseUp = (e) => * { * InputMouseUp(e); * }; * layer.CanvasElement.OnMouseMove = (e) => * { * InputMouseMove(e); * }; */ }
/// <summary> /// Imports the given graph from a file with the given filename. /// Any errors will be reported by exception. /// </summary> /// <param name="importFilename">The filename of the file to be imported.</param> /// <param name="backend">The backend to use to create the graph.</param> /// <param name="graphModel">The graph model to be used.</param> /// <param name="actions">Receives the actions object in case a .grg model is given.</param> /// <returns>The imported graph. /// An INamedGraph is returned. If you don't need it: create an LGSPGraph from it and throw the named graph away. /// (the naming requires about the same amount of memory the raw graph behind it requires).</returns> public static INamedGraph Import(String importFilename, IBackend backend, IGraphModel graphModel, out IActions actions) { FileInfo fi = new FileInfo(importFilename); long fileSize = fi.Length; return Import(new StreamReader(importFilename), fileSize, backend, graphModel, out actions); }
/// <summary> /// Imports a graph from the given file. /// The format is determined by the file extension. /// Any errors will be reported by exception. /// </summary> /// <param name="importFilename">The filename of the file to be imported, /// the model specification part will be ignored.</param> /// <param name="backend">The backend to use to create the graph.</param> /// <param name="graphModel">The graph model to be used, /// it must be conformant to the model used in the file to be imported.</param> /// <param name="actions">Receives the actions object in case a .grg model is given.</param> /// <returns>The imported graph. /// The .grs/.grsi importer returns an INamedGraph. If you don't need it: create an LGSPGraph from it and throw the named graph away. /// (the naming requires about the same amount of memory the raw graph behind it requires).</returns> public static IGraph Import(String importFilename, IBackend backend, IGraphModel graphModel, out IActions actions) { if(importFilename.EndsWith(".gxl", StringComparison.InvariantCultureIgnoreCase)) return GXLImport.Import(importFilename, backend, graphModel, out actions); else if (importFilename.EndsWith(".grs", StringComparison.InvariantCultureIgnoreCase) || importFilename.EndsWith(".grsi", StringComparison.InvariantCultureIgnoreCase)) return GRSImport.Import(importFilename, backend, graphModel, out actions); else throw new NotSupportedException("File format not supported"); }
void EventSubscription(IActions menu_actions) { menu_actions.NewElement += NewElement; menu_actions.DeleteElements += DeleteElements; }
/// <summary> /// Imports the given graph from the given text reader input stream. /// Any errors will be reported by exception. /// </summary> /// <param name="reader">The text reader input stream import source.</param> /// <param name="fileSize">The size of the input file.</param> /// <param name="backend">The backend to use to create the graph.</param> /// <param name="graphModel">The graph model to be used.</param> /// <param name="actions">Receives the actions object in case a .grg model is given.</param> /// <returns>The imported graph. /// An INamedGraph is returned. If you don't need it: create an LGSPGraph from it and throw the named graph away. /// (the naming requires about the same amount of memory the raw graph behind it requires).</returns> public static INamedGraph Import(TextReader reader, long fileSize, IBackend backend, IGraphModel graphModel, out IActions actions) { GRSImport importer = new GRSImport(reader, fileSize); importer.backend = backend; importer.modelOverride = null; importer.model = graphModel; importer.ParseGraphBuildingScript(); actions = importer.actions; return importer.graph; }
IEnumerator wait(float sec, IActions action) { yield return new WaitForSeconds (sec); action.InvokeAction (); if (!currentRobot.GetComponent<Robot> ().GetCollision()) { audioSource.clip = sound; audioSource.Play (); } }
/// <summary> /// Adds the action to panel. /// </summary> /// <param name="action">Action.</param> public void AddActionToPanel(IActions action) { //TODO }
/// <summary> /// Adds the action to the action list. /// </summary> /// <param name="addedAction">Added action.</param> public void AddAction(IActions addedAction) { actions.Add (addedAction); }
///////////////////////////////////////////////////////////////////////////////// private IGraph ImportModels(List <String> ecoreFilenames, String grgFilename, IBackend backend, out IActions actions) { foreach (String ecoreFilename in ecoreFilenames) { String modelText = ParseModel(ecoreFilename); String modelfilename = ecoreFilename.Substring(0, ecoreFilename.LastIndexOf('.')) + "__ecore.gm"; // Do we have to update the model file (.gm)? if (!File.Exists(modelfilename) || File.GetLastWriteTime(ecoreFilename) > File.GetLastWriteTime(modelfilename)) { Console.WriteLine("Writing model file \"" + modelfilename + "\"..."); using (StreamWriter writer = new StreamWriter(modelfilename)) writer.Write(modelText); } } if (grgFilename == null) { grgFilename = ""; foreach (String ecoreFilename in ecoreFilenames) { grgFilename += ecoreFilename.Substring(0, ecoreFilename.LastIndexOf('.')) + "_"; } grgFilename += "_ecore.grg"; StringBuilder sb = new StringBuilder(); sb.Append("// Automatically generated\n// Do not change, changes will be lost!\n\nusing "); DateTime grgTime; if (!File.Exists(grgFilename)) { grgTime = DateTime.MinValue; } else { grgTime = File.GetLastWriteTime(grgFilename); } bool mustWriteGrg = false; bool first = true; foreach (String ecore in ecoreFilenames) { if (first) { first = false; } else { sb.Append(", "); } sb.Append(ecore.Substring(0, ecore.LastIndexOf('.')) + "__ecore"); if (File.GetLastWriteTime(ecore) > grgTime) { mustWriteGrg = true; } } if (mustWriteGrg) { sb.Append(";\n"); using (StreamWriter writer = new StreamWriter(grgFilename)) writer.Write(sb.ToString()); } } IGraph graph; backend.CreateFromSpec(grgFilename, "defaultname", null, ProcessSpecFlags.UseNoExistingFiles, new List <String>(), out graph, out actions); return(graph); }
public void CreateNamedFromSpec(string grgFilename, string graphName, String statisticsPath, ProcessSpecFlags flags, List<String> externalAssemblies, int capacity, out INamedGraph newGraph, out IActions newActions) { LGSPGraph graph; LGSPActions actions; CreateFromSpec(grgFilename, graphName, statisticsPath, flags, externalAssemblies, true, capacity, out graph, out actions); newGraph = (LGSPNamedGraph)graph; newActions = actions; }
public void CreateFromSpec(string grgFilename, string graphName, String statisticsPath, ProcessSpecFlags flags, List<String> externalAssemblies, out IGraph newGraph, out IActions newActions) { LGSPGraph graph; LGSPActions actions; CreateFromSpec(grgFilename, graphName, statisticsPath, flags, externalAssemblies, false, 0, out graph, out actions); newGraph = graph; newActions = actions; }
public void Setup() { _actions = A.Fake<IActions>(); }
// constructor for interpreted sequences public SequenceCheckingEnvironmentInterpreted(IActions actions) { this.actions = actions; }
/// <summary> /// Imports a graph from the given files. /// If the filenames only specify a model, the graph is empty. /// The format is determined by the file extensions. /// Currently available are: .grs/.grsi or .gxl or .ecore with .xmi. /// Optionally suffixed by .gz; in this case they are expected to be gzipped. /// Any error will be reported by exception. /// </summary> /// <param name="backend">The backend to use to create the graph.</param> /// <param name="filenameParameters">The names of the files to be imported.</param> /// <param name="actions">Receives the actions object in case a .grg model is given.</param> /// <returns>The imported graph. /// The .grs/.grsi importer returns an INamedGraph. If you don't need it: create an LGSPGraph from it and throw the named graph away. /// (the naming requires about the same amount of memory the raw graph behind it requires).</returns> public static IGraph Import(IBackend backend, List<String> filenameParameters, out IActions actions) { String first = ListGet(filenameParameters, 0); FileInfo fi = new FileInfo(first); long fileSize = fi.Length; StreamReader reader = null; if (first.EndsWith(".gz", StringComparison.InvariantCultureIgnoreCase)) { FileStream filereader = new FileStream(first, FileMode.Open, FileAccess.Read); reader = new StreamReader(new GZipStream(filereader, CompressionMode.Decompress)); first = first.Substring(0, first.Length - 3); } else { reader = new StreamReader(first); } using(reader) { if(first.EndsWith(".gxl", StringComparison.InvariantCultureIgnoreCase)) return GXLImport.Import(reader, ListGet(filenameParameters, 1), backend, out actions); else if(first.EndsWith(".grs", StringComparison.InvariantCultureIgnoreCase) || first.EndsWith(".grsi", StringComparison.InvariantCultureIgnoreCase)) return GRSImport.Import(reader, fileSize, ListGet(filenameParameters, 1), backend, out actions); else if(first.EndsWith(".ecore", StringComparison.InvariantCultureIgnoreCase)) { List<String> ecores = new List<String>(); String grg = null; String xmi = null; bool noPackageNamePrefix = false; foreach(String filename in filenameParameters) { if(filename.EndsWith(".ecore")) ecores.Add(filename); else if(filename.EndsWith(".grg")) { if(grg != null) throw new NotSupportedException("Only one .grg file supported"); grg = filename; } else if(filename.EndsWith(".xmi")) { if(xmi != null) throw new NotSupportedException("Only one .xmi file supported"); xmi = filename; } else if(filename == "nopackagenameprefix") { noPackageNamePrefix = true; } } return ECoreImport.Import(backend, ecores, grg, xmi, noPackageNamePrefix, out actions); } else throw new NotSupportedException("File format not supported"); } }
/// <summary> /// Imports the given graph from a file with the given filename. /// Any errors will be reported by exception. /// </summary> /// <param name="importFilename">The filename of the file to be imported.</param> /// <param name="backend">The backend to use to create the graph.</param> /// <param name="actions">Receives the actions object in case a .grg model is given.</param> /// <returns>The imported graph. /// An INamedGraph is returned. If you don't need it: create an LGSPGraph from it and throw the named graph away. /// (the naming requires about the same amount of memory the raw graph behind it requires).</returns> public static INamedGraph Import(String importFilename, IBackend backend, out IActions actions) { return Import(importFilename, null, backend, out actions); }
internal AutoPagedActions(IActions trelloActions, int pageSize) : base(pageSize) { _trelloActions = trelloActions; }