public MainPageViewModel(Interfaces.IDialogService dialogService, IEventAggregator eventAggregator,INavigationService navigationService) { this._dialogService = dialogService; this._eventAggregator = eventAggregator; this._navigationService = navigationService; }
public Dictionary <string, List <Interfaces> > GetChoosedInterfaceByIsValid(string isValid = "") { var userInterList = db.GetCollection <UserInterface>().Where(o => o.AccessID == Session["AccessID"].ToString()).ToList(); if (isValid != "") { userInterList = db.GetCollection <UserInterface>().Where(o => o.AccessID == Session["AccessID"].ToString()).Where(o => o.IsValid == isValid).ToList(); } Dictionary <string, List <Interfaces> > selectDic = new Dictionary <string, List <Interfaces> >(); foreach (UserInterface inter in userInterList) { Interfaces sel = db.GetCollection <Interfaces>().Where(o => o.CategoryCode == inter.CategoryCode).ToList().First(); if (sel != null) { if (!selectDic.ContainsKey(inter.TypeName)) { selectDic.Add(inter.TypeName, new List <Interfaces>()); } selectDic[inter.TypeName].Add(sel); } } return(selectDic); }
public override bool Apply(Interfaces.IVimHost host) { string reg_text = _register.GetText(host); if (reg_text == null) { return false; } if (_register.IsTextLines) { string text = reg_text; for (int i = 0; i < (this.Repeat - 1); i++) { text = text + host.LineBreak + reg_text; } host.OpenLineBelow(); host.InsertTextAtCurrentPosition(text); } else { string text = ""; for (int i = 0; i < this.Repeat; i++) { text = text + reg_text; } host.CaretRight(); host.InsertTextAtCurrentPosition(text); } if (host.IsCurrentPositionAtEndOfLine()) { host.MoveToEndOfLine(); host.CaretLeft(); } return true; }
public void RemoveConnections() { foreach (Interface inter in Interfaces.Where(x => x.IsConnected).ToList()) { inter.RemoveConnection(); } }
private void TrackStatus(Interfaces i) { SAPTestHelper.Current.SAPGuiSession.StartTransaction("ZIDOCAUDREP"); SAPTestHelper.Current.MainWindow.FindByName <GuiCTextField>("S_CREDAT-LOW").Text = DateTime.Now.AddMonths(-1).ToString("dd.MM.yyyy"); SAPTestHelper.Current.MainWindow.FindByName <GuiCTextField>("S_CREDAT-HIGH").Text = DateTime.Now.ToString("dd.MM.yyyy"); SAPTestHelper.Current.MainWindow.FindByName <GuiCTextField>("S_CRETIM-LOW").Text = "00:00:00"; SAPTestHelper.Current.MainWindow.FindByName <GuiCTextField>("S_CRETIM-HIGH").Text = "24:00:00"; SAPTestHelper.Current.MainWindow.FindByName <GuiCTextField>("S_STATUS-LOW").Text = "*"; SAPTestHelper.Current.MainWindow.FindByName <GuiCTextField>("P_DIRECT").Text = "2"; SAPTestHelper.Current.MainWindow.FindByName <GuiRadioButton>("R_OTHERS").Select(); SAPTestHelper.Current.MainWindow.FindByName <GuiCTextField>("S_MESTYP-LOW").Text = i.MsgType; SAPTestHelper.Current.MainWindow.FindByName <GuiCheckBox>("P_DOWNLD").Selected = true; SAPTestHelper.Current.MainWindow.FindByName <GuiRadioButton>("P_FILE").Select(); SAPTestHelper.Current.MainWindow.FindByName <GuiTextField>("P_CPATH").Text = _data.GetAIF56File(i.Id); SAPTestHelper.Current.MainWindow.FindByName <GuiRadioButton>("P_DOC").Select(); SAPTestHelper.Current.MainWindow.FindByName <GuiButton>("%_S_IDOCNO_%_APP_%-VALU_PUSH").Press(); List <string> idocNumbers = new List <string>(); var myTasks = i.Tasks.Where(m => m.Mid == _data.MissionId).ToList(); foreach (var t in myTasks) { idocNumbers.AddRange(t.LH7IDocs.Select(s => s.IDocNumber)); } SAPTestHelper.Current.PopupWindow.FindDescendantByProperty <GuiTableControl>().SetBatchValues(idocNumbers); SAPTestHelper.Current.PopupWindow.FindByName <GuiButton>("btn[8]").Press(); SAPTestHelper.Current.MainWindow.FindByName <GuiButton>("btn[8]").Press(); if (SAPTestHelper.Current.PopupWindow != null) { SAPTestHelper.Current.PopupWindow.FindByName <GuiButton>("btn[0]").Press(); } var itg_IDocNumbers = Tools.GetDataEntites <IDoc>(_data.GetAIF56File(i.Id)); using (var db = new AIFDbContext()) { foreach (var item in itg_IDocNumbers) { var iDoc = item.GetIDocs(); var iDocInDB = db.LH7IDocs.SingleOrDefault(s => s.IDocNumber == iDoc.IDocNumber); if (iDocInDB != null) { db.LH7IDocs.Remove(iDocInDB); } db.LH7IDocs.Add(iDoc); } db.SaveChanges(); } }
public static Interfaces GetInterfaces() { var UnformattedInterfaces = Analyzer.GetInterfaces(); var FormattedInterfaces = Interfaces.GetFromStringResult(UnformattedInterfaces); return(FormattedInterfaces); }
/// <summary> /// Remove the selected profile. /// </summary> private async Task RemoveProfileAsync() { BusyStateManager.EnterBusy(); BusyStateManager.SetMessage(SeverityType.Info, "Removing selected profile."); /* Temporary store selected interface and WiFi profile so they can be restored after deletion. */ Guid selectedInterfaceId = SelectedInterface.Id; int profilePosition = SelectedWiFiProfile.Position; await _mainController.DeleteProfileAsync(SelectedWiFiProfile); await DownloadProfilesAsync(); /* Restore selected interface and position of selected WiFi profile. */ Profile selectedWifiProfile = WiFiProfiles.Where(x => x.Id == selectedInterfaceId && x.Position == profilePosition).FirstOrDefault(); if (selectedWifiProfile == default(Profile)) { selectedWifiProfile = WiFiProfiles.Where(x => x.Id == selectedInterfaceId).OrderByDescending(x => x.Position).FirstOrDefault(); } Interface selectedInterface = Interfaces.Where(x => x.Id == selectedInterfaceId).FirstOrDefault(); SelectedInterface = selectedInterface == default(Interface) ? Interfaces.FirstOrDefault() : selectedInterface; if (selectedWifiProfile != default(Profile)) { SelectedWiFiProfile = selectedWifiProfile; } BusyStateManager.SetMessage(SeverityType.None); BusyStateManager.ExitBusy(); }
public void QueryTest() { var query = new RestRequest(Method.GET); query.Resource = "api/device"; query.RequestFormat = DataFormat.Json; var resp = _client.Execute(query); Assert.AreEqual(HttpStatusCode.OK, resp.StatusCode); const String ExpectedResponse = "[{\"Enabled\":false,\"Value\":0.0,\"ID\":0,\"LastUpdate\":\"2015-04-21T13:28:10.5439104\",\"Name\":\"light1\",\"Class\":\"LightSwitch\"},{\"Enabled\":false,\"State\":0,\"ID\":1,\"LastUpdate\":\"2015-04-21T13:28:10.5442048\",\"Name\":\"Kitchen Ceiling Fan\",\"Class\":\"CeilingFan\"},{\"Enabled\":false,\"SetPoint\":0.0,\"Value\":0.0,\"ID\":2,\"LastUpdate\":\"2015-04-21T13:28:10.5442048\",\"Name\":\"HVAC\",\"Class\":\"Thermostat\"}]"; Assert.IsTrue(resp.Content.Length > 0); var resp_obj = JArray.Parse(resp.Content); var test_obj = JArray.Parse(ExpectedResponse); Assert.AreEqual(resp_obj.Count, test_obj.Count); foreach (var obj in resp_obj) { var resp_dev = Interfaces.DeserializeDevice(obj.ToString(), null, null, _frame); foreach (var exp_obj in test_obj) { var exp_dev = Interfaces.DeserializeDevice(exp_obj.ToString(), null, null, _frame); if (resp_dev.ID.DeviceID == exp_dev.ID.DeviceID) { Assert.AreEqual(resp_dev.ID.DeviceID, exp_dev.ID.DeviceID); Assert.IsTrue(resp_dev.UpdateOk); Assert.AreEqual(exp_dev.Name, resp_dev.Name); Assert.AreEqual(exp_dev.Class, resp_dev.Class); break; } } } }
/// <summary> /// Create a new interface instance and context /// </summary> /// <param name="name"></param> /// <returns>New context created</returns> public IntPtr CreateInterface(int pipe_id, string name) { // Always try to make a map var(context, iface, is_map) = Context.CreateInterface(name, true); if (context == IntPtr.Zero) { return(IntPtr.Zero); } if (!is_map) { Log.WriteLine("Context.CreateInterface didnt create map (is_map expected to be true)"); return(IntPtr.Zero); } iface.ClientId = Id; iface.InterfaceId = -1; if (is_map) { iface.InterfaceId = Server.CreateInterface(pipe_id, Id, name); var map = (IBaseInterfaceMap)iface; map.PipeId = pipe_id; } Interfaces.Add(iface); return(context); }
public void AddMessage(Protocol.IMessage message, Interfaces.IUserAgent user) { lock (this) { mQueue.Enqueue(new MessageToken { Message = message, UserAgent = user }); } }
public override bool Apply(Interfaces.IVimHost host) { this.OnBeforeInsert(host); Modes.ModeInsert mode = new Modes.ModeInsert(host, host.CurrentMode, this); host.CurrentMode = mode; return true; }
public void SendPacketNeededAck(Interfaces.IPacket Packet) { lock (DictionaryLock) { packetIdCounter.Next(); Packet.PacketId = new UDPClientServerCommons.Usefull.PacketIdCounter(packetIdCounter.Value); packetsWaitingForAck.Add(packetIdCounter.Value, Packet); } if (packetsWaitingForAck.Count == 0) { //theres no packages that needed ack //so the timer has stoped //it needs to be started again when needed AckTimer.Change(0, 10); } else switch (packetsWaitingForAck.Count) { case (1): AckTimer.Change(0, 2*_SENDING_DELAY); break; default: AckTimer.Change(0, _SENDING_DELAY); break; } }
public PolicyDesignerErrorProvider( Interfaces.IErrorProviderCollection errorProviderCollection, ErrorProvider errorProvider) { m_parentCollection = errorProviderCollection; m_errorProvider = errorProvider; }
public override void Clear() { Accessibility = default; DeclarationModifiers = default; if (Interfaces == null) { Interfaces = new List <ReferenceBuilder>(); } else { Interfaces.Clear(); } Name = default; if (TypeParameters == null) { TypeParameters = new List <TypeParameterConfig>(); } else { TypeParameters.Clear(); } _members.Clear(); }
/// <summary> /// Inicjalizuje obiekt. /// </summary> /// <param name="name"></param> /// <param name="nation"></param> /// <param name="controller"></param> /// <param name="showStatistics"></param> public PlayerInfo(string name, Interfaces.Units.INation nation, IPlayerController controller, bool showStatistics) { this.Name = name; this.Nation = nation; this.Controller = controller; this.ShowStatistics = showStatistics; }
/// <summary> /// Filters <see cref="Type"/>s based on the interfaces they implement. /// </summary> /// <param name="type">The <see cref="Type"/> to filter.</param> /// <param name="mustBeRequired">This check will only be performed with this argument matches the value of the /// <see cref="RequireInterfaces"/> property.</param> /// <returns>True if the <paramref name="type"/> should be included; false if it was filtered out.</returns> /// <exception cref="TypeFilterException"><paramref name="mustBeRequired"/> is true, <see cref="RequireInterfaces"/> /// is true, and the <paramref name="type"/> does not implement the required <see cref="Interfaces"/>.</exception> bool FilterInterfaces(Type type, bool mustBeRequired) { if (mustBeRequired != RequireInterfaces) { return(true); } if (Interfaces == null || Interfaces.IsEmpty()) { return(true); } var i = type.GetInterfaces(); var isValid = (MatchAllInterfaces ? Interfaces.All(i.Contains) : Interfaces.Any(i.Contains)); if (!isValid) { if (RequireInterfaces) { const string errmsg = "Type `{0}` does not have the required interfaces: `{1}`."; var err = string.Format(errmsg, type, GetTypeString(Interfaces)); if (log.IsFatalEnabled) { log.Fatal(err); } throw new TypeFilterException(err); } else { return(false); } } return(true); }
private void ImplementInterfaceHelper() { foreach (var method in Interfaces.SelectMany(i => i.GetMethods())) { var newMethod = TypeBuilder.DefineMethod( method.Name, method.Attributes ^ MethodAttributes.Abstract, method.CallingConvention, method.ReturnType, method.ReturnParameter.GetRequiredCustomModifiers(), method.ReturnParameter.GetOptionalCustomModifiers(), method.GetParameters().Select(p => p.ParameterType).ToArray(), method.GetParameters().Select(p => p.GetRequiredCustomModifiers()).ToArray(), method.GetParameters().Select(p => p.GetOptionalCustomModifiers()).ToArray() ); var methodBody = newMethod.GetILGenerator(); var hasReturnType = method.ReturnType != typeof(void); if (hasReturnType) { methodBody.Emit(OpCodes.Ldnull); } // return; methodBody.Emit(OpCodes.Ret); } }
public void OnMouseRightClick(Interfaces.MouseEventArgs e) { if (MouseRightClick != null) { MouseRightClick(this, e); } }
protected virtual EditableEntity GetEditableEntity(Interfaces.IValueHolder valueHolder) { if (valueHolder == null) throw new NullReferenceException("valueHolder can't be null"); valueHolder.GetKeySynonym = new Interfaces.GetKeySynonymDelegate(this.GetKeySynonym); EditableEntity entity = this.CreateEditableEntityInstance(); string[] keys; if (this.IsNew) { keys = this.GetPrimaryKeysForNewEntity(); entity.AddNew(); foreach (string key in keys) { entity[key] = valueHolder[key]; } return entity; } keys = this.GetPrimaryKeys(); foreach (string key in keys) { if (!entity.SetWhereParamValue(key, valueHolder[key])) throw new Exception(string.Format("Can't set SqlClientEntity where parameter [{0}] to value [{1}]", key, valueHolder[key])); } if (!entity.Load()) throw new Exception("Can't load SqlClientEntity of type " + entity.GetType()); return entity; }
/// <summary> /// Should be called after a node is created to set parent referneces /// This allows interfaces, volumes, etc. to poll through the provider /// </summary> public void SetReferences() { Interfaces?.ForEach(i => i.Node = this); Volumes?.ForEach(v => v.Node = this); Apps?.ForEach(a => a.Node = this); Services?.ForEach(s => s.Node = this); }
public void OnMouseMove(Interfaces.MouseMoveEventArgs e) { if (MouseMove != null) { MouseMove(this, e); } }
private void AddInterface(ITypeDefinition interfce, StringBuilder key) { if (interfce.Namespace == "") { lock (Interfaces) { foreach (var typeArg in interfce.TypeParameters) { foreach (var constraint in typeArg.DirectBaseTypes) { key.Append(constraint.Name); } } if (Interfaces.ContainsKey(key.ToString())) { return; } Interfaces.Add(key.ToString(), new InterfaceProperties(interfce)); } } else { AddNamespace(key, interfce); } }
public override bool DisplayOptionToUser(IOption option, Interfaces.IScriptBaseObject iteratorObject) { try { if (option.DisplayToUserValue.HasValue) { return option.DisplayToUserValue.Value; } if (string.IsNullOrEmpty(option.DisplayToUserFunction)) { return true; } if (iteratorObject == null) { object[] parameters = new object[0]; return (bool)Loader.Instance.CallTemplateFunction(option.DisplayToUserFunction, ref parameters); } else { object[] parameters = new object[] { iteratorObject }; return (bool)Loader.Instance.CallTemplateFunction(option.DisplayToUserFunction, ref parameters); } } catch (MissingMethodException) { object[] parameters = new object[] { iteratorObject }; return (bool)Loader.Instance.CallTemplateFunction(option.DisplayToUserFunction, ref parameters); } }
public DebugLogEventArgs(Data.DebugLogLevel level, Interfaces.IPlugin p, Exception e, string msg) { Plugin = p; Message = msg; Level = level; Exception = e; }
public NamespaceInfo(AssemblyInfo assemblyInfo, string @namespace, List <Type> types, XElement xmlDocs) { Assembly = assemblyInfo; Namespace = @namespace; foreach (var type in types) { var typeInfo = new TypeInfo(type, xmlDocs); Types.Add(typeInfo); if (type.IsClass) { Classes.Add(typeInfo); } else if (type.IsInterface) { Interfaces.Add(typeInfo); } else if (type.IsEnum) { Enums.Add(typeInfo); } } }
public SyncMenuViewModel( Interfaces.ICollectorReceiptManager receiptManager, Interfaces.IGoogleManager googleManager, IEventAggregator eventAggregator) { if (receiptManager == null) { throw new ArgumentNullException("receiptManager"); } if (googleManager == null) { throw new ArgumentNullException("googleManager"); } if (eventAggregator == null) { throw new ArgumentNullException("eventAggregator"); } this.eventAggregator = eventAggregator; this.receiptManager = receiptManager; this.googleManager = googleManager; this.eventAggregator.GetEvent<Events.StartSyncEvent>().Subscribe((o) => { this.StartSync(); }); }
public override async Task Load() { BaseClassStr = Node.GetAttribute("baseClass"); _abstract = Node.GetAttribute <bool>("abstract", false); _nullableDefault = Node.GetAttribute <bool>("nullableDefault", ProtoGen.NullableDefault); if (NeedsReflectionGeneration) { Interfaces.Add(LoquiInterfaceDefinitionType.ISetter, nameof(ILoquiReflectionSetter)); } if (ObjectNamedKey.TryFactory(BaseClassStr, ProtoGen.Protocol, out var baseClassObjKey)) { if (!gen.ObjectGenerationsByObjectNameKey.TryGetValue(baseClassObjKey, out ObjectGeneration baseObj) || !(baseObj is ClassGeneration)) { throw new ArgumentException($"Could not resolve base class object: {BaseClassStr}"); } else { ClassGeneration baseClass = baseObj as ClassGeneration; BaseClass = baseClass; baseClass._derivativeClasses.Add(this); } } #if NETSTANDARD2_0 WiredBaseClassTCS.TrySetResult(true); #else WiredBaseClassTCS.TrySetResult(); #endif await base.Load(); }
public string GetContractType() { if (ContractTags != null) { if (ContractTags.Contains("fa2")) { return("FA2"); } if (ContractTags.Contains("fa1-2")) { return("FA12"); } } if (Interfaces == null) { return("FA2"); } if (Interfaces.FirstOrDefault(i => i == "TZIP-12" || i == "TZIP-012" || i.StartsWith("TZIP-012")) != null) { return("FA2"); } if (Interfaces.FirstOrDefault(i => i == "TZIP-7" || i == "TZIP-007" || i.StartsWith("TZIP-007")) != null) { return("FA12"); } return("FA2"); }
/// <summary> /// Gets the interface info for the given interface type (defined in managed code) /// </summary> /// <param name="type">The interface type</param> /// <returns>The interface info for the given type</returns> public static ManagedInterface GetManagedInterface(Type type) { ManagedInterface result; Interfaces.TryGetValue(type, out result); return(result); }
public static void Inscribe(Game.ConquerStructures.Society.ArsenalType Type, uint Donation, Interfaces.IConquerItem item, Game.Entity Entity) { MySqlCommand cmd = new MySqlCommand(MySqlCommandType.INSERT); cmd.Insert("guild_arsenalsdonation").Insert("d_uid", Entity.UID).Insert("guild_uid", Entity.GuildID).Insert("name", Entity.Name).Insert("item_uid", item.UID).Insert("item_donation", Donation).Insert("item_arsenal_type", (byte)Type).Execute(); cmd = new MySqlCommand(MySqlCommandType.UPDATE); cmd.Update("items").Set("Inscribed", 1).Where("UID", item.UID).Execute(); }
private void DetectElementsInFile(CodeElements elements) { foreach (CodeElement element in elements) { if (element is CodeClass) { Classes.Add(element as CodeClass); } if (element is CodeEnum) { Enums.Add(element as CodeEnum); } if (element is CodeStruct) { Structs.Add(element as CodeStruct); } if (element is CodeInterface) { Interfaces.Add(element as CodeInterface); } DetectElementsInFile(element.Children); } }
protected override void DoInteraction(Client client, Interfaces.ItemStack item) { base.DoInteraction(client, item); if (client != null && !Chraft.Interfaces.ItemStack.IsVoid(item)) { if (item.Type == (short)Chraft.World.BlockData.Items.Shears && !Data.Sheared) { // Drop wool when sheared sbyte count = (sbyte)Server.Rand.Next(2, 4); if (count > 0) Server.DropItem(World, UniversalCoords.FromWorld(Position.X, Position.Y, Position.Z), new Interfaces.ItemStack((short)Chraft.World.BlockData.Blocks.Wool, count, (short)Data.WoolColor)); Data.Sheared = true; SendMetadataUpdate(); } else if (item.Type == (short)Chraft.World.BlockData.Items.Ink_Sack) { // Set the wool colour of this Sheep based on the item.Durability // Safety check. Values of 16 and higher (color do not exist) may crash the client v1.8.1 and below if (item.Durability >= 0 && item.Durability <= 15) { //this.Data.WoolColor = (WoolColor)Enum.ToObject(typeof(WoolColor), (15 - item.Durability)); Data.WoolColor = DyeColorToWoolColor((MetaData.Dyes)Enum.ToObject(typeof(MetaData.Dyes), item.Durability)); SendMetadataUpdate(); } } } }
static void Main(string region = null, string session = null, string package = null, string project = null, string[] args = null) { switch (region) { case "OO1": Basic.RunStuff(null); break; case "OO2": Interfaces.RunStuff(null); break; case "OO3": AbstractClasses.RunStuff(null); break; case "OO4": Polymorphism.RunStuff(null); break; default: break; } }
public MethodParamPair( MethodParamResult method, Interfaces.IEventInput input) { _method = method; _params = input; }
public ActionResult Import(HttpPostedFileBase file, int?id, string name, int?year, string budgetType) { if (!Authorized(RoleType.SystemManager)) { return(Error(Loc.Dic.error_no_permission)); } if (file != null && file.ContentLength <= 0) { return(Error(Loc.Dic.error_invalid_form)); } if (string.IsNullOrEmpty(budgetType)) { return(Error(Loc.Dic.Error_chooseMonthelyOrYearlyBudget)); } if (!(budgetType == "Month" || budgetType == "Year")) { return(Error(Loc.Dic.Error_no_budgetType)); } if (id.HasValue) { string moved = Interfaces.ImportBudget(file.InputStream, CurrentUser.CompanyId, id.Value, budgetType); if (moved == "OK") { return(RedirectToAction("index")); } else { return(Error(moved)); } } else if (year.HasValue) { if (year.Value > DateTime.Now.Year + 10 || year.Value < DateTime.Now.Year - 1) { return(Error(Loc.Dic.error_invalid_budget_year)); } using (BudgetsRepository budgetsRepository = new BudgetsRepository(CurrentUser.CompanyId)) { Budget newBudget = new Budget(); newBudget.Name = name; newBudget.Year = year.Value; newBudget.CompanyId = CurrentUser.CompanyId; newBudget.IsActive = false; budgetsRepository.Create(newBudget); string moved = Interfaces.ImportBudget(file.InputStream, CurrentUser.CompanyId, newBudget.Id, budgetType); if (moved == "OK") { return(RedirectToAction("index")); } else { return(Error(moved)); } } } return(Error(Loc.Dic.error_invalid_form)); }
public override INHibernateProxy GetProxy(object id, ISessionImplementor session) { INHibernateProxy proxy; try { var behaviorInfo = _behaviorConfigurator.GetProxyInformation(PersistentClass); var initializer = new LazyInitializer(EntityName, PersistentClass, id, GetIdentifierMethod, SetIdentifierMethod, ComponentIdType, session); IInterceptor[] interceptors = behaviorInfo.Interceptors .Select(i => _kernel.Resolve(i)) .OfType <IInterceptor>() .Union(new[] { initializer }).ToArray(); Type[] interfaces = Interfaces.Union(behaviorInfo.AdditionalInterfaces).ToArray(); object obj2 = IsClassProxy ? ProxyGenerator.CreateClassProxy(PersistentClass, interfaces, interceptors) : ProxyGenerator.CreateInterfaceProxyWithoutTarget(interfaces[0], interfaces, new IInterceptor[] { initializer }); initializer._constructed = true; proxy = (INHibernateProxy)obj2; } catch (Exception exception) { log.Error("Creating a proxy instance failed", exception); throw new HibernateException("Creating a proxy instance failed", exception); } return(proxy); }
public override string ToString() { StringBuilder sb = new StringBuilder(); foreach (var attr in Attributes) { sb.AppendLine(attr.ToString()); } sb.AppendLine($"namespace {NamespaceName}"); sb.AppendLine("{"); foreach (string interfaceLine in Interfaces.BreakIntoLines()) { sb.AppendLine($"\t{interfaceLine}"); } foreach (string classLine in Classes.BreakIntoLines()) { sb.AppendLine($"\t{classLine}"); } foreach (string enumLine in Enums.BreakIntoLines()) { sb.AppendLine($"\t{enumLine}"); } foreach (string structLine in Structs.BreakIntoLines()) { sb.AppendLine($"\t{structLine}"); } sb.AppendLine("}"); return(sb.ToString()); }
public void Configure(Interfaces.Configuration c) { foreach (Uri uri in c.SlaveWsdlUrls) { clients.Add(new KeyValueBaseSlaveClient(uri)); } }
private void InitializeNetworkMeter() { _interfaces = new List <NetworkInterface>(); /// Detecting Network Adaptors Using List <NetworkInterface> nics = NetworkInterface.GetAllNetworkInterfaces().Where(network => network.OperationalStatus == OperationalStatus.Up && (network.NetworkInterfaceType == NetworkInterfaceType.Ethernet || network.NetworkInterfaceType == NetworkInterfaceType.Wireless80211)).ToList(); /// If none is active get all of them :) if (nics.Count == 0) { nics = NetworkInterface.GetAllNetworkInterfaces().Where(network => (network.NetworkInterfaceType == NetworkInterfaceType.Ethernet || network.NetworkInterfaceType == NetworkInterfaceType.Wireless80211)).ToList(); } /// Add Items To the combo item source nics.ForEach(i => Interfaces.Add(i)); //Set the selected interface to the first one if (Interfaces.Count > 0) { SelectedInterface = Interfaces.First(); } OnPropertyChanged("Interfaces"); OnPropertyChanged("SelectedInterface"); }
protected override async Task GenerateClassLine(StructuredStringBuilder sb) { using (var args = sb.Class(ObjectName)) { args.Abstract = Abstract; args.Partial = true; if (HasLoquiBaseObject && HasNonLoquiBaseObject) { throw new ArgumentException("Cannot define both a loqui and non-loqui base class"); } if (HasLoquiBaseObject) { args.BaseClass = BaseClassName; } else if (HasNonLoquiBaseObject && SetBaseClass) { args.BaseClass = NonLoquiBaseClass; } args.Interfaces.Add(Interface(getter: false, internalInterface: true)); args.Interfaces.Add($"ILoquiObjectSetter<{ObjectName}>"); args.Interfaces.Add(Interfaces.Get(LoquiInterfaceType.Direct)); args.Interfaces.Add(await GetApplicableInterfaces(LoquiInterfaceType.Direct).ToListAsync()); args.Interfaces.Add(ProtoGen.Interfaces); args.Interfaces.Add(gen.Interfaces); args.Interfaces.Add($"IEquatable<{Interface(getter: true, internalInterface: true)}>"); } }
public void DrawWithEffect(Interfaces.IDrawableGeom geom) { /*if (_cNode != null) { View = _cNode.View; Projection = _cNode.Projection; }*/ if (geom.Ready) { object oldState = null; if (_samplerstate != null) { oldState = BasicEffect.GraphicsDevice.SamplerStates[0]; BasicEffect.GraphicsDevice.SamplerStates[0] = _samplerstate; } _deviceReference.BlendState = BlendState.AlphaBlend; _deviceReference.DepthStencilState = EquestriEngine.DepthState; foreach (EffectPass pass in _effect.CurrentTechnique.Passes) { pass.Apply(); _deviceReference.DrawUserIndexedPrimitives<VertexPositionNormalTexture>( PrimitiveType.TriangleList, geom.Vertices, 0, geom.Vertices.Length, geom.Indices, 0, 2); } if (oldState != null) BasicEffect.GraphicsDevice.SamplerStates[0] = oldState as SamplerState; } else Systems.ConsoleWindow.WriteLine("Failed to draw geometry"); }
public bool IsOfType(IObjectSpecImmutable specification) { if (specification == this) { return(true); } if (Interfaces.Any(interfaceSpec => interfaceSpec.IsOfType(specification))) { return(true); } // match covariant generic types if (Type.IsGenericType && IsCollection) { Type otherType = specification.Type; if (otherType.IsGenericType && Type.GetGenericArguments().Count() == 1 && otherType.GetGenericArguments().Count() == 1) { if (Type.GetGenericTypeDefinition() == (typeof(IQueryable <>)) && Type.GetGenericTypeDefinition() == otherType.GetGenericTypeDefinition()) { Type genericArgument = Type.GetGenericArguments().Single(); Type otherGenericArgument = otherType.GetGenericArguments().Single(); Type otherGenericParameter = otherType.GetGenericTypeDefinition().GetGenericArguments().Single(); if ((otherGenericParameter.GenericParameterAttributes & GenericParameterAttributes.Covariant) != 0) { if (otherGenericArgument.IsAssignableFrom(genericArgument)) { return(true); } } } } } return(Superclass != null && Superclass.IsOfType(specification)); }
static Local() { NativeFunctions = (GameModeBaseInterface *)Interfaces.Get(Core.Name.Make("GameModeBase")).ToPointer(); Debug.Assert(NativeFunctions != null); NativeFunctions->Validate(); Unused = Marshal.GetDelegateForFunctionPointer <UnusedDelegate>(NativeFunctions->Unused); }
/*************** END DEBUG MODE METHOD *************/ static public bool AddDeviceBlob(JObject blob) { string blob_string = blob.ToString(); Device dev = Interfaces.CreateDevices(blob_string, new TimeFrame()); // to convert the JSON blob to an actual Device object. ulong devID = (ulong)blob ["deviceID"]; ulong roomID = (ulong)blob ["roomID"]; ulong houseID = (ulong)blob ["houseID"]; FullID fullID = new FullID(); fullID.DeviceID = devID; fullID.RoomID = roomID; fullID.HouseID = houseID; deviceBlobs.Add(fullID, dev); if (deviceBlobs.Contains(dev)) { // Arjun -- add push notification code here return(true); } return(false); }
public override VimPoint Move(Interfaces.IVimHost host) { if (host.IsCurrentPositionAtEndOfLine()) { return host.CurrentPosition; } VimPoint bak = host.CurrentPosition; for (int i = 0; i < this.Repeat; i++) { do { if (host.IsCurrentPositionAtEndOfLine()) { host.MoveCursor(bak); return host.CurrentPosition; } host.CaretRight(); char ch = host.GetCharAtCurrentPosition(); if (ch == _toSearch) { break; } } while (true); } return host.CurrentPosition; }
private void HandleItem(TypeDefinition tdef) { _tdef = tdef; Attributes.Bind(tdef); Interfaces.Bind(tdef); CustomAttributes.Bind(tdef); }
private async Task PollNetworkUtilizationAsync() { var utilizationTable = _canQueryAdapterUtilization ? "Win32_PerfRawData_Tcpip_NetworkAdapter" : "Win32_PerfRawData_Tcpip_NetworkInterface"; var query = $@" SELECT Name, Timestamp_Sys100NS, BytesReceivedPersec, BytesSentPersec, PacketsReceivedPersec, PacketsSentPersec FROM {utilizationTable}"; var queryTime = DateTime.UtcNow.ToEpochTime(); var combinedUtil = new Interface.InterfaceUtilization { DateEpoch = queryTime, InAvgBps = 0, OutAvgBps = 0 }; using (var q = Wmi.Query(Endpoint, query)) { foreach (var data in await q.GetDynamicResultAsync().ConfigureAwait(false)) { var perfData = new PerfRawData(this, data); var name = perfData.Identifier; var iface = Interfaces.Find(i => name == GetCounterName(i.Name)); if (iface == null) { continue; } iface.InBps = (float)perfData.GetCalculatedValue("BytesReceivedPersec", 10000000); iface.OutBps = (float)perfData.GetCalculatedValue("BytesSentPersec", 10000000); iface.InPps = (float)perfData.GetCalculatedValue("PacketsReceivedPersec", 10000000); iface.OutPps = (float)perfData.GetCalculatedValue("PacketsSentPersec", 10000000); var util = new Interface.InterfaceUtilization { DateEpoch = queryTime, InAvgBps = iface.InBps, OutAvgBps = iface.OutBps }; var netData = NetHistory.GetOrAdd(iface.Name, k => new List <Interface.InterfaceUtilization>(1024)); UpdateHistoryStorage(netData, util); if (PrimaryInterfaces.Contains(iface)) { combinedUtil.InAvgBps += util.InAvgBps; combinedUtil.OutAvgBps += util.OutAvgBps; } } } UpdateHistoryStorage(CombinedNetHistory, combinedUtil); }
private void RipUpdateEvent(object source, ElapsedEventArgs e) { foreach (var @interface in Interfaces.Where(item => (item.RipEnabled))) { @interface.Send(RipPacketFactory.CreateEthernetPacket(@interface, Routes.Where(item => !Equals(item.Origin, @interface)))); } }
private Interfaces.IAuthenticationResponse RequestAuthentication(Interfaces.IAuthenticationRequest request) { Identifier id; if (!Identifier.TryParse(request.Url, out id)) { _logger.Info(string.Format("OpenID Error...invalid url. url='{0}'", request.Url)); return Factory.AuthenticationResponse(Interfaces.AuthenticationState.Errored); } try { var authenticationRequest = _openIdRelyingParty.CreateRequest(request.Url); var fetch = new FetchRequest(); fetch.Attributes.AddRequired(WellKnownAttributes.Contact.Email); fetch.Attributes.AddRequired(WellKnownAttributes.Name.First); fetch.Attributes.AddRequired(WellKnownAttributes.Name.Last); authenticationRequest.AddExtension(fetch); var actionResult = authenticationRequest.RedirectingResponse.AsActionResult(); return Factory.AuthenticationResponse(actionResult); } catch (ProtocolException ex) { _logger.Error("OpenID Exception...", ex); return Factory.AuthenticationResponse(Interfaces.AuthenticationState.Errored); } }
public bool Add(Interfaces.IConquerItem item, Enums.ItemUse use) { try { if (item.Position < 20) { if (objects[item.Position - 1] == null) { objects[item.Position - 1] = item; item.Mode = Enums.ItemMode.Default; if (use != Enums.ItemUse.None) { UpdateItemview(item); EntityEquipment equips = new EntityEquipment(true); equips.ParseHero(Owner); Owner.Send(equips); item.Send(Owner); Owner.LoadItemStats(item); } return true; } else return false; } else return false; } catch { return false; } }
public bool Add(Interfaces.IConquerItem item) { try { if (item.Position > 19) return false; if (objects[item.Position - 1] == null) { UpdateItemview(item); objects[item.Position - 1] = item; item.Position = item.Position; item.Send(Owner); EntityEquipment equips = new EntityEquipment(true); equips.ParseHero(Owner); Owner.Send(equips); Owner.LoadItemStats(item); Owner.SendScreenSpawn(Owner.Entity, false); return true; } else return false; } catch (Exception e) { Program.SaveException(e); Console.WriteLine(e.ToString()); return false; } }
public string FindPathToType(string name) { var classType = Classes.Where(c => c.IsExported).FirstOrDefault(cl => cl.Name == name); if (classType != null) { return(classType.GetPath()); } var interfaceType = Interfaces.Where(i => i.IsExported).FirstOrDefault(cl => cl.Name == name); if (interfaceType != null) { return(interfaceType.GetPath()); } var enumType = Enumerations.Where(e => e.IsExported).FirstOrDefault(cl => cl.Name == name); if (enumType != null) { return(enumType.GetPath()); } foreach (var nspace in Namespaces.Where(n => n.IsExported)) { var path = nspace.FindPathToType(name); if (path != null) { return(path); } } return(null); }
public static Track ConvertToTrack(Interfaces.ITrack item) { return new Track { Name = item.Name, Greyhounds = GetGreyHounds(item.Greyhounds) }; }
public override void Deploy(Interfaces.IPasswordInterface ui, Interfaces.IUIHandler current) { base.Deploy(ui, current); ui.Password = "******"; ui.PasswordChar = (char)'\0'; ui.Prompt = "Set Password"; }
/// <summary> /// Print matrix /// </summary> /// <param name="matrix">Input matrix to print</param> /// <param name="player">Input player</param> public override void PrintMatrix(Interfaces.IMatrix matrix, Interfaces.IPlayer player) { Console.Clear(); var output = new StringBuilder(); output.AppendLine("Light Mode"); output.AppendLine(this.GetPrintFrame(matrix, player)); this.PrintLine(output.ToString()); }
public Interfaces.IConnector ConnectTcp(IPAddress ip, int port, Interfaces.IFactory factory) { Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); socket.Blocking = true; socket.Connect(new IPEndPoint(ip, port)); this.AddConnection(socket, factory); return new Connector(this, socket); }
public override VimPoint Move(Interfaces.IVimHost host) { VimGlobalInfo.FindWordRecord = new VimFindWordRecord(_wordToSearch, VimFindWordRecord.FindOptions.UserRegex); host.FindNextWord(VimGlobalInfo.FindWordRecord); return host.CurrentPosition; }
public override VimPoint Move(Interfaces.IVimHost host) { for (int i = 0; i < this.Repeat; i++) { host.MoveToNextWord(); } return host.CurrentPosition; }
public override bool Apply(Interfaces.IVimHost host) { for (int i = 0; i < this.Repeat; i++) { host.Redo(); } return true; }
public void KontoOeffnen(Interfaces.IKonto Konto) { if (_Konten.Any(r => r.KtoNr == Konto.KtoNr)) throw new Exception("Der Kunde hat bereits ein Konto mit der Kontonummer " + Konto.KtoNr); _Konten.Add(Konto); }