/// <summary> /// /// </summary> /// <param name="collection"></param> /// <returns></returns> public override bool AddAll(ICollection <E> collection) { if (0 == collection.Count || this == collection) { return(false); } if (collection is EnumSet <E> ) { EnumSet <E> set = (EnumSet <E>)collection; if (!IsValidType(set.elementClass)) { throw new Exception("ClassCastException"); } HugeEnumSet <E> hugeSet = (HugeEnumSet <E>)set; bool addSuccessful = false; for (int i = 0; i < bits.Length; i++) { oldBits = bits[i]; bits[i] |= hugeSet.bits[i]; if (oldBits != bits[i]) { addSuccessful = true; size = size - Int64Helper.BitCount(oldBits) + Int64Helper.BitCount(bits[i]); } } return(addSuccessful); } return(base.AddAll(collection)); }
/// <summary> /// Adds all of the elements of the "c" collection to the "target" collection. /// </summary> /// <param name="target">Collection where the new elements will be added.</param> /// <param name="c">Collection whose elements will be added.</param> /// <returns>Returns true if at least one element was added, false otherwise.</returns> public static bool AddAll(System.Collections.ICollection target, System.Collections.ICollection c) { System.Collections.IEnumerator e = new System.Collections.ArrayList(c).GetEnumerator(); bool added = false; //Reflection. Invoke "addAll" method for proprietary classes System.Reflection.MethodInfo method; try { method = target.GetType().GetMethod("addAll"); if (method != null) { added = (bool)method.Invoke(target, new System.Object[] { c }); } else { method = target.GetType().GetMethod("Add"); while (e.MoveNext() == true) { bool tempBAdded = (int)method.Invoke(target, new System.Object[] { e.Current }) >= 0; added = added ? added : tempBAdded; } } } catch (System.Exception ex) { throw ex; } return(added); }
public static void Apply(System.Collections.ICollection coll, FunctionDelegate <object> func) { foreach (object obj in coll) { func(obj); } }
/// <summary> /// Adds a new element to the specified collection. /// </summary> /// <param name="c">Collection where the new element will be added.</param> /// <param name="obj">Object to add.</param> /// <returns>true</returns> public static bool Add(System.Collections.ICollection c, System.Object obj) { bool added = false; //Reflection. Invoke either the "add" or "Add" method. System.Reflection.MethodInfo method; try { //Get the "add" method for proprietary classes method = c.GetType().GetMethod("Add"); if (method == null) { method = c.GetType().GetMethod("add"); } int index = (int)method.Invoke(c, new System.Object[] { obj }); if (index >= 0) { added = true; } } catch (System.Exception e) { throw e; } return(added); }
/// <summary> /// Retains the elements in the target collection that are contained in the specified collection /// </summary> /// <param name="target">Collection where the elements will be removed.</param> /// <param name="c">Elements to be retained in the target collection.</param> /// <returns>true</returns> public static bool RetainAll(System.Collections.ICollection target, System.Collections.ICollection c) { System.Collections.IEnumerator e = new System.Collections.ArrayList(target).GetEnumerator(); System.Collections.ArrayList al = new System.Collections.ArrayList(c); //Reflection. Invoke "retainAll" method for proprietary classes or "Remove" for each element in the collection System.Reflection.MethodInfo method; try { method = c.GetType().GetMethod("retainAll"); if (method != null) { method.Invoke(target, new System.Object[] { c }); } else { method = c.GetType().GetMethod("Remove"); while (e.MoveNext() == true) { if (al.Contains(e.Current) == false) { method.Invoke(target, new System.Object[] { e.Current }); } } } } catch (System.Exception ex) { throw ex; } return(true); }
/// <summary> /// Removes all the elements from the collection. /// </summary> /// <param name="c">The collection to remove elements.</param> public static void Clear(System.Collections.ICollection c) { //Reflection. Invoke "Clear" method or "clear" method for proprietary classes System.Reflection.MethodInfo method; try { #if NETFX_CORE && UNITY_METRO && !UNITY_EDITOR method = Type_WP_8_1.Type.GetMethod(c.GetType(), "Clear"); #else method = c.GetType().GetMethod("Clear"); #endif if (method == null) #if NETFX_CORE && UNITY_METRO && !UNITY_EDITOR { method = Type_WP_8_1.Type.GetMethod(c.GetType(), "clear"); } #else { method = c.GetType().GetMethod("clear"); } #endif method.Invoke(c, new System.Object[] {}); } catch (System.Exception e) { throw e; } }
/// <summary> /// Removes the specified element from the collection. /// </summary> /// <param name="c">The collection where the element will be removed.</param> /// <param name="obj">The element to remove from the collection.</param> public static bool Remove(System.Collections.ICollection c, System.Object obj) { bool changed = false; //Reflection. Invoke "remove" method for proprietary classes or "Remove" method System.Reflection.MethodInfo method; try { method = c.GetType().GetMethod("remove"); if (method != null) { method.Invoke(c, new System.Object[] { obj }); } else { method = c.GetType().GetMethod("Contains"); changed = (bool)method.Invoke(c, new System.Object[] { obj }); method = c.GetType().GetMethod("Remove"); method.Invoke(c, new System.Object[] { obj }); } } catch (System.Exception e) { throw e; } return(changed); }
public object Serialize(System.Collections.ICollection objects) { ComponentSerializationService componentSerializationService = _serviceProvider.GetService(typeof(ComponentSerializationService)) as ComponentSerializationService; SerializationStore returnObject = null; using (SerializationStore serializationStore = componentSerializationService.CreateStore()) { foreach (object obj in objects) { if (obj is Control control) { //if (control is SMGroup group) //{ // foreach (object obj2 in control.Controls) // { // componentSerializationService.Serialize(serializationStore, obj2); // } //} //if(control is SplitContainerControl split) //{ // componentSerializationService.SerializeAbsolute(serializationStore, split.Panel1.Controls[0]); // componentSerializationService.SerializeAbsolute(serializationStore, split.Panel2.Controls[0]); //} componentSerializationService.SerializeAbsolute(serializationStore, obj); } returnObject = serializationStore; } } return(returnObject); }
public CasoDeUso(String nome, String resumo, String preCondicoes, String posCondicoes, FluxoBasico fluxoBasico, System.Collections.ICollection subFluxos, System.Collections.ICollection atores, Projeto projeto, Usuario usuario, ICollection casosDeUsoIncluidos, ICollection casosDeUsoExtendidos) { this.Nome = nome; this.Resumo = resumo; this.PreCondicoes = preCondicoes; this.PosCondicoes = posCondicoes; this.FluxosBasicos.Add(fluxoBasico); fluxoBasico.CasoDeUso = this; this.SubFluxos.AddAll(subFluxos); foreach (SubFluxo subFluxo in subFluxos) { subFluxo.CasoDeUso = this; subFluxo.FluxoPai = fluxoBasico; } if (atores.Count < 1) { throw new NegocioException("É necessário pelo menos um ator para criar um caso de uso. "); } this.AtoresEnvolvidos.AddAll(atores); this.Projeto = projeto; AdicionarHistorico("Criação do documento. ", usuario); this.CasosDeUsoIncluidos.AddAll(casosDeUsoIncluidos); this.CasosDeUsoExtendidos.AddAll(casosDeUsoExtendidos); IRepositoryCasoDeUso repositorioCasoDeUso = (IRepositoryCasoDeUso)AbstractFactoryRepository.GetInstance( ConfigurationManager.AppSettings["METODO_FABRICA"]).GetRepository("CasoDeUso"); this.Codigo = repositorioCasoDeUso.GetMaxCodigo(this.projeto.Id) + 1; }
/// <summary> /// PostFlush /// </summary> /// <param name="entities"></param> public override void PostFlush(System.Collections.ICollection entities) { try { if (m_logRecords.Count > 0) { AuditLogRecord log = CreateNew(null, null, AuditLogType.TransactionBegin); m_session.Save(log); for (int i = 0; i < m_logRecords.Count; ++i) { m_session.Save(m_logRecords[i]); } log = CreateNew(null, null, AuditLogType.TransactionCompletion); m_session.Save(log); } } catch (HibernateException ex) { throw new CallbackException(ex); } finally { m_logRecords.Clear(); } }
static void ICollection_SyncRoot(JSVCall vc) { System.Collections.ICollection _this = (System.Collections.ICollection)vc.csObj; var result = _this.SyncRoot; JSMgr.datax.setWhatever((int)JSApi.SetType.Rval, result); }
/// <inheritdoc/> public override bool TrySetDeletedPropertyValue(string name, System.Collections.ICollection value) { // TODO: already existing key? _deletedResources.Add(name, value); return(true); }
/// <summary> /// 序列化控件,包括容器控件的子控件 /// </summary> /// <param name="objects"></param> /// <returns></returns> public object Serialize(System.Collections.ICollection objects) { List <EntityFormCtrl> serializedData = new List <EntityFormCtrl>(); System.Collections.ICollection comps = objects; if (comps == null) { return(serializedData); } Hashtable nametable = new Hashtable(); serializedData.Clear(); foreach (IComponent comp in comps) { //等LayoutControl内部内容都加载到serializedData以后再次处理 if (!nametable.ContainsKey(comp) && !(comp is DevExpress.XtraTab.XtraTabPage) && !(comp is DevExpress.XtraLayout.LayoutControl)) { SerializeControl(nametable, string.Empty, comp, serializedData, true); } } foreach (IComponent comp in comps) { //处理LayoutControl的关系 if (!nametable.ContainsKey(comp) && !(comp is DevExpress.XtraTab.XtraTabPage)) { SerializeControl(nametable, string.Empty, comp, serializedData, false); } } SerializeControl(nametable, string.Empty, this.designerHost.RootComponent, serializedData, false); return(serializedData); }
/// <summary> /// Constructora que inicializa los valores de la acción con valores dados. /// </summary> /// <param name="key"></param> /// <param name="obj"></param> /// <param name="dictionary"></param> /// <param name="isAdd"></param> public AddDelListAction(object key, object obj, System.Collections.ICollection dictionary, bool isAdd) { this.key = key; this.obj = obj; this.collection = dictionary; this.isAdd = isAdd; }
/// <summary> /// /// </summary> /// <param name="collection"></param> /// <returns></returns> public override bool RemoveAll(ICollection <E> collection) { if (0 == collection.Count) { return(false); } if (collection is EnumSet <E> ) { EnumSet <E> set = (EnumSet <E>)collection; if (!IsValidType(set.elementClass)) { return(false); } bool removeSuccessful = false; long mask = 0; for (int i = 0; i < bits.Length; i++) { oldBits = bits[i]; mask = bits[i] & ((HugeEnumSet <E>)set).bits[i]; if (mask != 0) { bits[i] -= mask; size = (size - Int64Helper.BitCount(oldBits) + Int64Helper.BitCount(bits[i])); removeSuccessful = true; } } return(removeSuccessful); } return(base.RemoveAll(collection)); }
/// <summary> /// Determines whether the collection contains all the elements in the specified collection. /// </summary> /// <param name="target">The collection to check.</param> /// <param name="c">Collection whose elements would be checked for containment.</param> /// <returns>true id the target collection contains all the elements of the specified collection.</returns> public static bool ContainsAll(System.Collections.ICollection target, System.Collections.ICollection c) { System.Collections.IEnumerator e = c.GetEnumerator(); bool contains = false; //Reflection. Invoke "containsAll" method for proprietary classes or "Contains" method for each element in the collection System.Reflection.MethodInfo method; try { method = target.GetType().GetMethod("containsAll"); if (method != null) { contains = (bool)method.Invoke(target, new Object[] { c }); } else { method = target.GetType().GetMethod("Contains"); while (e.MoveNext() == true) { if ((contains = (bool)method.Invoke(target, new Object[] { e.Current })) == false) { break; } } } } catch (System.Exception ex) { throw ex; } return(contains); }
/// <summary> /// /// </summary> /// <param name="collection"></param> /// <returns></returns> public override bool RetainAll(ICollection <E> collection) { if (collection is EnumSet <E> ) { EnumSet <E> set = (EnumSet <E>)collection; if (!IsValidType(set.elementClass)) { Clear(); return(true); } bool retainSuccessful = false; oldBits = 0; for (int i = 0; i < bits.Length; i++) { oldBits = bits[i]; bits[i] &= ((HugeEnumSet <E>)set).bits[i]; if (oldBits != bits[i]) { size = size - Int64Helper.BitCount(oldBits) + Int64Helper.BitCount(bits[i]); retainSuccessful = true; } } return(retainSuccessful); } return(base.RetainAll(collection)); }
private static IRecord CreateRecord(object item, System.Collections.Generic.IList <string> aliases) { System.Collections.ICollection collection = item as System.Collections.ICollection; if (collection != null) { System.Collections.Generic.List <object> list = collection.Cast <object>().ToList <object>(); if (aliases != null && aliases.Count != list.Count) { aliases = null; } if (list.Count != 1) { int counter = 0; DictionaryRecord record = new DictionaryRecord(); list.ForEach(delegate(object obj) { record.SetValue((aliases != null) ? aliases[counter++] : ("Value" + ++counter), obj); }); return(record); } if (aliases != null) { aliases[0] = Pluralizer.ToSingular(aliases[0]); } item = list[0]; } if (aliases == null || aliases.Count != 1) { return(RecordBase.CreateRecord(item)); } return(RecordBase.CreateRecord(item, aliases[0])); }
////////////////////// ICollection /////////////////////////////////////// // constructors // fields // properties static void ICollection_Count(JSVCall vc) { System.Collections.ICollection _this = (System.Collections.ICollection)vc.csObj; var result = _this.Count; JSApi.setInt32((int)JSApi.SetType.Rval, (System.Int32)(result)); }
/// <summary> /// Determines whether the collection contains the specified element. /// </summary> /// <param name="c">The collection to check.</param> /// <param name="obj">The object to locate in the collection.</param> /// <returns>true if the element is in the collection.</returns> public static bool Contains(System.Collections.ICollection c, System.Object obj) { bool contains = false; //Reflection. Invoke "contains" method for proprietary classes System.Reflection.MethodInfo method; try { #if NETFX_CORE && UNITY_METRO && !UNITY_EDITOR method = Type_WP_8_1.Type.GetMethod(c.GetType(), "Contains"); #else method = c.GetType().GetMethod("Contains"); #endif if (method == null) #if NETFX_CORE && UNITY_METRO && !UNITY_EDITOR { method = Type_WP_8_1.Type.GetMethod(c.GetType(), "contains"); } #else { method = c.GetType().GetMethod("contains"); } #endif contains = (bool)method.Invoke(c, new System.Object[] { obj }); } catch (System.Exception e) { throw e; } return(contains); }
static void ICollection_IsSynchronized(JSVCall vc) { System.Collections.ICollection _this = (System.Collections.ICollection)vc.csObj; var result = _this.IsSynchronized; JSApi.setBooleanS((int)JSApi.SetType.Rval, (System.Boolean)(result)); }
public CasoDeUso CriarNovoCasoDeUso(String nome, String resumo, String preCondicoes, String posCondicoes, Projeto projeto, Usuario usuario, FluxoBasico fluxoBasico, System.Collections.ICollection subFluxos, System.Collections.ICollection atores, ICollection casosDeUsoIncluidos, ICollection casosDeUsoExtendidos) { try { CasoDeUso casoUso = new CasoDeUso(nome, resumo, preCondicoes, posCondicoes, fluxoBasico, subFluxos, atores, projeto, usuario, casosDeUsoIncluidos, casosDeUsoExtendidos); repositorioCasoDeUso.Add(casoUso); return(casoUso); } catch (NegocioException nex) { throw nex; } catch (ArgumentOutOfRangeException aor) { throw new NegocioException(aor.Message + " Valor inserido: " + aor.ActualValue.ToString()); } catch (DaoException daoex) { throw new NegocioException("Erro ao adicionar ao repositório. ", daoex); } }
public override bool RemoveAll(ICollection <E> collection) { bool result = false; if (Count <= collection.Count) { IIterator <E> it = Iterator(); while (it.HasNext()) { if (collection.Contains(it.Next())) { it.Remove(); result = true; } } } else { foreach (E e in collection) { result = Remove(e) || result; } } return(result); }
/// <summary> /// Adds a new element to the specified collection. /// </summary> /// <param name="c">Collection where the new element will be added.</param> /// <param name="obj">Object to add.</param> /// <returns>true</returns> public static bool Add(System.Collections.ICollection c, System.Object obj) { bool added = false; //Reflection. Invoke either the "add" or "Add" method. System.Reflection.MethodInfo method; try { //Get the "add" method for proprietary classes #if NETFX_CORE && UNITY_METRO && !UNITY_EDITOR method = Type_WP_8_1.Type.GetMethod(c.GetType(), "Add"); #else method = c.GetType().GetMethod("Add"); #endif if (method == null) #if NETFX_CORE && UNITY_METRO && !UNITY_EDITOR { method = Type_WP_8_1.Type.GetMethod(c.GetType(), "add"); } #else { method = c.GetType().GetMethod("add"); } #endif int index = (int)method.Invoke(c, new System.Object[] { obj }); if (index >= 0) { added = true; } } catch (System.Exception e) { throw e; } return(added); }
private void Init(string description, string title, ICollection types) { this.description = description; this.title = title; this.types = types; control = new ZedGraphControl(); }
private void Init( string description, string title, ICollection types ) { this.description = description; this.title = title; this.types = types; control = new ZedGraphControl(); }
public void SetSelectedComponents(System.Collections.ICollection components, SelectionTypes selectionType) { //TODO: Use .NET 2.0 SelectionTypes Primary, Add, Replace, Remove, Toggle if ((selectionType & SelectionTypes.Valid) == SelectionTypes.Valid) { SetSelectedComponents(components); } }
public static List <T> ToList <T>(this System.Collections.ICollection collection) { var list = new List <T>(collection.Count); list.AddRange(collection.Cast <T>()); return(list); }
internal static System.Collections.IList CreateArrayList(System.Collections.ICollection collection) { System.Collections.IList result = new List <object>(collection.Count); foreach (object o in collection) { result.Add(o); } return(result); }
public static IList <T> Cast <T>(System.Collections.ICollection coll) { var result = new List <T>(coll.Count); foreach (object obj in coll) { result.Add((T)obj); } return(result); }
public static System.Collections.IList Transform(System.Collections.ICollection coll, FunctionDelegate <object> func) { var result = new List <object>(); foreach (object obj in coll) { result.Add(func(obj)); } return(result); }
private void supplier_SelectionChanged_1(object sender, SelectionChangedEventArgs e) { if (bySupplierRadio.IsChecked.Value) { Company supplier = supplierList.SelectedItem as Company; ReportItems = DBResources.Instance.Context.SP_JoGRN(SupplierID, JobOrderId).ToList(); } }
private void getBtn_Click_1(object sender, RoutedEventArgs e) { if (byJoNumber.IsChecked.Value) ReportItems = DBResources.Instance.Context.SP_JoGRN(SupplierID, JobOrderId).ToList(); }
/// <summary>Initializes the <code>Session</code>. Initializes Channel Zero and its /// listener. Sends a greeting and waits for corresponding greeting.</summary> /// <exception cref="BEEPException" /> protected internal virtual void init() { this.peerSupportedProfiles = null; GreetingListener greetingListener = new GreetingListener(this); #if MESSAGELISTENER zero = ChannelImpl.createChannelZero(this, greetingListener, new ChannelImpl.MessageListenerAdapter(new ChannelZeroListener(this))); #else zero = ChannelImpl.createChannelZero(this, greetingListener, new ChannelZeroListener(this)); #endif channels[CHANNEL_ZERO] = zero; // send greeting sendGreeting(); changeState(core.SessionState.SESSION_STATE_GREETING_SENT); // start our listening thread we can now receive a greeting this.enableIO(); // blocks until greeting is received or MAX_GREETING_WAIT is reached int waitCount = 0; while ((state < core.SessionState.SESSION_STATE_ACTIVE) && (waitCount < MAX_START_CHANNEL_WAIT)) { try { lock (greetingListener) { //zero.wait(MAX_START_CHANNEL_INTERVAL); System.Threading.Monitor.Wait(greetingListener, TimeSpan.FromMilliseconds(MAX_START_CHANNEL_INTERVAL)); waitCount += MAX_START_CHANNEL_INTERVAL; } } catch (System.Threading.ThreadInterruptedException) { waitCount += MAX_START_CHANNEL_INTERVAL; } } // check the channel state and return the appropriate exception if (state != core.SessionState.SESSION_STATE_ACTIVE) { throw new BEEPException("Greeting exchange failed"); } }
/// <summary>A reentrant version of init() that doesn't block the /// first I/O thread waiting on a greeting when it should die /// and go away.</summary> /// <exception cref="BEEPException" /> protected internal virtual void tuningInit() { log.debug("Session.tuningInit"); this.peerSupportedProfiles = null; GreetingListener greetingListener = new GreetingListener(this); #if MESSAGELISTENER zero = ChannelImpl.createChannelZero(this, greetingListener, new ChannelImpl.MessageListenerAdapter(new ChannelZeroListener(this))); #else zero = ChannelImpl.createChannelZero(this, greetingListener, new ChannelZeroListener(this)); #endif channels[CHANNEL_ZERO] = zero; // send greeting sendGreeting(); changeState(core.SessionState.SESSION_STATE_GREETING_SENT); // start our listening thread we can now receive a greeting this.enableIO(); }
private static bool CollectionsEqual(ICollection o1, ICollection o2) { IEnumerator e1 = o1.GetEnumerator(); IEnumerator e2 = o2.GetEnumerator(); int count; for (count = 0; e1.MoveNext() && e2.MoveNext(); count++) { if (!AreEqual(e1.Current, e2.Current)) break; } if (count == o1.Count && count == o2.Count) return true; return false; }
public DemoBase( string description, string title, ICollection types ) { Init( description, title, types ); }