public void SwitchRowIntoEditMode(int index, BocColumnDefinition[] columns) { ArgumentUtility.CheckNotNullOrItemsNull("columns", columns); if (_editModeHost.Value == null) { throw new InvalidOperationException( string.Format("Cannot initialize row edit mode: The BocList '{0}' does not have a Value.", _editModeHost.ID)); } if (index < 0) { throw new ArgumentOutOfRangeException("index"); } if (index >= _editModeHost.Value.Count) { throw new ArgumentOutOfRangeException("index"); } RestoreAndEndEditMode(columns); if (_editModeHost.IsReadOnly || IsListEditModeActive || IsRowEditModeActive) { return; } _editedRowIDs = new List <string> { _editModeHost.RowIDProvider.GetItemRowID(new BocListRow(index, (IBusinessObject)_editModeHost.Value[index])) }; _editMode = EditMode.RowEditMode; CreateEditModeControls(columns); SetFocus(_rows.First()); LoadValues(false); }
public void Succeed_ICollection() { ArrayList list = new ArrayList(); ArrayList result = ArgumentUtility.CheckNotNullOrItemsNull("arg", list); Assert.That(result, Is.SameAs(list)); }
public void Fail_zItemNullICollection() { ArrayList list = new ArrayList(); list.Add(null); ArgumentUtility.CheckNotNullOrItemsNull("arg", list); }
public bool AddAndEditRow(IBusinessObject businessObject, BocColumnDefinition[] columns) { ArgumentUtility.CheckNotNull("businessObject", businessObject); ArgumentUtility.CheckNotNullOrItemsNull("columns", columns); RestoreAndEndEditMode(columns); if (_editModeHost.IsReadOnly || IsListEditModeActive || IsRowEditModeActive) { return(false); } int index = AddRow(businessObject, columns); if (index < 0) { return(false); } SwitchRowIntoEditMode(index, columns); if (!IsRowEditModeActive) { throw new InvalidOperationException( string.Format("BocList '{0}': Could not switch newly added row into edit mode.", _editModeHost.ID)); } _isEditNewRow = true; return(true); }
public void SwitchListIntoEditMode(BocColumnDefinition[] columns) { ArgumentUtility.CheckNotNullOrItemsNull("columns", columns); if (_editModeHost.Value == null) { throw new InvalidOperationException( string.Format("Cannot initialize list edit mode: The BocList '{0}' does not have a Value.", _editModeHost.ID)); } RestoreAndEndEditMode(columns); if (_editModeHost.IsReadOnly || IsRowEditModeActive || IsListEditModeActive) { return; } _editedRowIDs = _editModeHost.Value.Cast <IBusinessObject>().Select((o, i) => _editModeHost.RowIDProvider.GetItemRowID(new BocListRow(i, o))).ToList(); _editMode = EditMode.ListEditMode; CreateEditModeControls(columns); if (_rows.Any()) { SetFocus(_rows.First()); } LoadValues(false); }
public void RemoveRows(IBusinessObject[] businessObjects) { ArgumentUtility.CheckNotNullOrItemsNull("businessObjects", businessObjects); var bocListRows = _editModeHost.RemoveRows(businessObjects); if (_editModeHost.Value != null) { if (IsRowEditModeActive) { throw new InvalidOperationException( string.Format( "Cannot remove rows while the BocList '{0}' is in row edit mode. Call EndEditMode() before removing the rows.", _editModeHost.ID)); } else if (IsListEditModeActive) { foreach (var row in bocListRows.OrderByDescending(r => r.Index)) { RemoveRowFromDataStructure(row.Index); _editedRowIDs.RemoveAt(row.Index); } } } }
public BocListRow[] AddRows(IBusinessObject[] businessObjects, BocColumnDefinition[] columns) { ArgumentUtility.CheckNotNullOrItemsNull("businessObjects", businessObjects); ArgumentUtility.CheckNotNullOrItemsNull("columns", columns); var bocListRows = _editModeHost.AddRows(businessObjects); if (_editModeHost.Value != null) { EnsureEditModeRestored(columns); if (IsListEditModeActive) { var newRows = new List <EditableRow>(); foreach (var bocListRow in bocListRows.OrderBy(r => r.Index)) { var newRow = AddRowToDataStructure(bocListRow, columns); _editedRowIDs.Add(_editModeHost.RowIDProvider.GetItemRowID(bocListRow)); newRow.GetDataSource().LoadValues(false); newRows.Add(newRow); } if (newRows.Any()) { SetFocus(newRows.First()); } } } return(bocListRows); }
public AccessInformation(AccessTypeDefinition[] allowedAccessTypes, AccessTypeDefinition[] deniedAccessTypes) { ArgumentUtility.CheckNotNullOrItemsNull("allowedAccessTypes", allowedAccessTypes); ArgumentUtility.CheckNotNullOrItemsNull("deniedAccessTypes", deniedAccessTypes); _allowedAccessTypes = allowedAccessTypes; _deniedAccessTypes = deniedAccessTypes; }
/// <summary> /// Creates an <see cref="IPipeline"/> with the given participant configuration ID containing the specified participants. /// </summary> /// <remarks> /// <see cref="IPipeline"/> instances with equal participant configuration IDs must generate equivalent types. /// </remarks> /// <param name="pipelineFactory">The <see cref="IPipelineFactory"/> to use for creation. Usually retrieved from the application's IoC container.</param> /// <param name="participantConfigurationID">The participant configuration ID.</param> /// <param name="participants">The participants that should be used by this object factory.</param> /// <returns>An new instance of <see cref="IPipeline"/>.</returns> public static IPipeline Create(this IPipelineFactory pipelineFactory, string participantConfigurationID, params IParticipant[] participants) { ArgumentUtility.CheckNotNull("pipelineFactory", pipelineFactory); ArgumentUtility.CheckNotNullOrEmpty("participantConfigurationID", participantConfigurationID); ArgumentUtility.CheckNotNullOrItemsNull("participants", participants); return(pipelineFactory.Create(participantConfigurationID, PipelineSettings.Defaults, participants)); }
public LocalizingMetadataConverter(IMetadataLocalizationConverter localizationConverter, CultureInfo[] cultures) { ArgumentUtility.CheckNotNull("localizationConverter", localizationConverter); ArgumentUtility.CheckNotNullOrItemsNull("cultures", cultures); _localizationConverter = localizationConverter; _cultures = cultures; }
public BocListSortingOrderChangeEventArgs( BocListSortingOrderEntry[] oldSortingOrder, BocListSortingOrderEntry[] newSortingOrder) { ArgumentUtility.CheckNotNullOrItemsNull("oldSortingOrder", oldSortingOrder); ArgumentUtility.CheckNotNullOrItemsNull("newSortingOrder", newSortingOrder); _oldSortingOrder = oldSortingOrder; _newSortingOrder = newSortingOrder; }
public WxeVariablesContainer(WxeFunction function, object[] actualParameters, WxeParameterDeclaration[] parameterDeclarations) { ArgumentUtility.CheckNotNull("function", function); ArgumentUtility.CheckNotNull("actualParameters", actualParameters); ArgumentUtility.CheckNotNullOrItemsNull("parameterDeclarations", parameterDeclarations); _function = function; _variables = new NameObjectCollection(); _parameterDeclarations = parameterDeclarations; _actualParameters = actualParameters; }
public bool MatchesStates(IList <StateDefinition> states) { ArgumentUtility.CheckNotNullOrItemsNull("states", states); if (StateUsages.Count == 0 && states.Count > 0) { return(false); } return(StateUsages.Select(stateUsage => stateUsage.StateDefinition).All(usedState => states.Contains(usedState))); }
public override MethodInfo MakeGenericMethod(params Type[] typeArguments) { ArgumentUtility.CheckNotNullOrItemsNull("typeArguments", typeArguments); if (!IsGenericMethodDefinition) { throw new InvalidOperationException("MakeGenericMethod can only be called on generic method definitions (IsGenericMethodDefinition must be true)."); } return(this.MakeTypePipeGenericMethod(typeArguments)); }
protected virtual XmlSchemaSet GetSchemas(SchemaLoaderBase[] schemas) { ArgumentUtility.CheckNotNullOrItemsNull("schemas", schemas); XmlSchemaSet schemaSet = new XmlSchemaSet(); foreach (SchemaLoaderBase schema in schemas) { schemaSet.Add(schema.LoadSchemaSet()); } return(schemaSet); }
public int AddRow(IBusinessObject businessObject, BocColumnDefinition[] columns) { ArgumentUtility.CheckNotNull("businessObject", businessObject); ArgumentUtility.CheckNotNullOrItemsNull("columns", columns); var bocListRows = AddRows(new[] { businessObject }, columns); if (bocListRows.Length == 0) { return(-1); } return(bocListRows.Single().Index); }
private AssemblyCompiler(string sourceDirectory, params string[] referencedAssemblies) { ArgumentUtility.CheckNotNullOrEmpty("sourceDirectory", sourceDirectory); ArgumentUtility.CheckNotNullOrItemsNull("referencedAssemblies", referencedAssemblies); _sourceDirectory = sourceDirectory; _compilerParameters = new CompilerParameters(); _compilerParameters.GenerateExecutable = false; _compilerParameters.OutputAssembly = null; _compilerParameters.GenerateInMemory = true; _compilerParameters.TreatWarningsAsErrors = false; _compilerParameters.ReferencedAssemblies.AddRange(referencedAssemblies); }
/// <summary> Sorts the <paramref name="menuItems"/> by their categories." </summary> /// <param name="menuItems"> Must not be <see langword="null"/> or contain items that are <see langword="null"/>. </param> /// <param name="generateSeparators"> <see langword="true"/> to generate a separator before starting a new category. </param> /// <returns> The <paramref name="menuItems"/>, sorted by their categories. </returns> public static WebMenuItem[] GroupMenuItems(WebMenuItem[] menuItems, bool generateSeparators) { ArgumentUtility.CheckNotNullOrItemsNull("menuItems", menuItems); // <string category, ArrayList menuItems> NameObjectCollection groupedMenuItems = new NameObjectCollection(); ArrayList categories = new ArrayList(); for (int i = 0; i < menuItems.Length; i++) { WebMenuItem menuItem = menuItems[i]; string category = menuItem.Category ?? string.Empty; ArrayList menuItemsForCategory; if (groupedMenuItems.Contains(category)) { menuItemsForCategory = (ArrayList)groupedMenuItems[category]; } else { menuItemsForCategory = new ArrayList(); groupedMenuItems.Add(category, menuItemsForCategory); categories.Add(category); } menuItemsForCategory.Add(menuItem); } ArrayList arrayList = new ArrayList(); bool isFirst = true; for (int i = 0; i < categories.Count; i++) { string category = (string)categories[i]; if (generateSeparators) { if (isFirst) { isFirst = false; } else { arrayList.Add(WebMenuItem.GetSeparator()); } } arrayList.AddRange((ArrayList)groupedMenuItems[category]); } return((WebMenuItem[])arrayList.ToArray(typeof(WebMenuItem))); }
/// <summary> Creates a new instance. </summary> /// <param name="ownerControl"> Owner control. </param> /// <param name="supportedTypes"> /// Supported types must implement <see cref="IControlItem"/>. /// Must not be <see langword="null"/> or contain items that are <see langword="null"/>. /// </param> public ControlItemCollection(IControl ownerControl, Type[] supportedTypes) { ArgumentUtility.CheckNotNullOrItemsNull("supportedTypes", supportedTypes); for (int i = 0; i < supportedTypes.Length; i++) { Type type = supportedTypes[i]; if (!typeof(IControlItem).IsAssignableFrom(type)) { throw new ArgumentException( string.Format("Type '{0}' at index {1} does not implement interface 'IControlItem'.", type.FullName, i), "supportedTypes"); } } _ownerControl = ownerControl; _supportedTypes = supportedTypes; }
public virtual void CreateControls(IBusinessObject value, BocColumnDefinition[] columns) { ArgumentUtility.CheckNotNull("value", value); ArgumentUtility.CheckNotNullOrItemsNull("columns", columns); if (_dataSourceFactory == null) { throw new InvalidOperationException( string.Format("BocList '{0}': DataSourceFactory has not been set prior to invoking CreateControls().", _editModeHost.ID)); } if (_controlFactory == null) { throw new InvalidOperationException( string.Format("BocList '{0}': ControlFactory has not been set prior to invoking CreateControls().", _editModeHost.ID)); } CreatePlaceHolders(columns); _dataSource = _dataSourceFactory.Create(value); _rowEditModeControls = new IBusinessObjectBoundEditableWebControl[columns.Length]; for (int idxColumns = 0; idxColumns < columns.Length; idxColumns++) { BocSimpleColumnDefinition simpleColumn = columns[idxColumns] as BocSimpleColumnDefinition; if (IsColumnEditable(simpleColumn)) { IBusinessObjectBoundEditableWebControl control = _controlFactory.Create(simpleColumn, idxColumns); if (control != null) { control.ID = idxColumns.ToString(); control.DataSource = _dataSource; IBusinessObjectPropertyPath propertyPath = simpleColumn.GetPropertyPath(); control.Property = propertyPath.Properties[0]; SetEditControl(idxColumns, control); _rowEditModeControls[idxColumns] = control; } } } _isRowEditModeValidatorsRestored = false; }
public XmlDocument Convert(LocalizedName[] localizedNames, string culture) { ArgumentUtility.CheckNotNullOrItemsNull("localizedNames", localizedNames); ArgumentUtility.CheckNotNull("culture", culture); XmlDocument document = new XmlDocument(); if (!document.Schemas.Contains(_schema.SchemaUri)) { document.Schemas.Add(_schema.LoadSchemaSet()); } XmlDeclaration declaration = document.CreateXmlDeclaration("1.0", string.Empty, string.Empty); document.AppendChild(declaration); XmlElement rootElement = document.CreateElement("localizedNames", _schema.SchemaUri); XmlAttribute cultureAttribute = document.CreateAttribute("culture"); cultureAttribute.Value = culture; rootElement.Attributes.Append(cultureAttribute); foreach (LocalizedName localizedName in localizedNames) { XmlElement localizedNameElement = document.CreateElement("localizedName", _schema.SchemaUri); XmlAttribute refAttribute = document.CreateAttribute("ref"); refAttribute.Value = localizedName.ReferencedObjectID; XmlAttribute commentAttribute = document.CreateAttribute("comment"); commentAttribute.Value = localizedName.Comment; XmlText text = document.CreateTextNode("\r\n " + localizedName.Text + "\r\n "); localizedNameElement.Attributes.Append(refAttribute); localizedNameElement.Attributes.Append(commentAttribute); localizedNameElement.AppendChild(text); rootElement.AppendChild(localizedNameElement); } document.AppendChild(rootElement); return(document); }
public MethodWrapperEmitter(ILGenerator ilGenerator, MethodInfo wrappedMethod, Type[] wrapperParameterTypes, Type wrapperReturnType) { ArgumentUtility.CheckNotNull("ilGenerator", ilGenerator); ArgumentUtility.CheckNotNull("wrappedMethod", wrappedMethod); ArgumentUtility.CheckNotNullOrItemsNull("wrapperParameterTypes", wrapperParameterTypes); ArgumentUtility.CheckNotNull("wrapperReturnType", wrapperReturnType); if (wrappedMethod.ContainsGenericParameters) { throw new ArgumentException("Open generic method definitions are not supported by the MethodWrapperGenerator.", "wrappedMethod"); } CheckParameterCount(wrappedMethod, wrapperParameterTypes); CheckInstanceParameterType(wrappedMethod, wrapperParameterTypes); CheckParameterTypes(wrappedMethod, wrapperParameterTypes); CheckReturnTypes(wrappedMethod, wrapperReturnType); _ilGenerator = ilGenerator; _wrappedMethod = wrappedMethod; _wrapperParameterTypes = wrapperParameterTypes; _wrapperReturnType = wrapperReturnType; }
public void EnsureEditModeRestored(BocColumnDefinition[] columns) { ArgumentUtility.CheckNotNullOrItemsNull("columns", columns); if (_isEditModeRestored) { return; } _isEditModeRestored = true; if (IsRowEditModeActive || IsListEditModeActive) { if (_editModeHost.Value == null) { throw new InvalidOperationException( string.Format("Cannot restore edit mode: The BocList '{0}' does not have a Value.", _editModeHost.ID)); } CreateEditModeControls(columns); LoadValues(true); } }
public ForwardingProxyBuilder(string name, ModuleScope moduleScope, Type proxiedType, Type[] interfaces) { ArgumentUtility.CheckNotNullOrEmpty("name", name); ArgumentUtility.CheckNotNull("moduleScope", moduleScope); ArgumentUtility.CheckNotNull("proxiedType", proxiedType); ArgumentUtility.CheckNotNullOrItemsNull("interfaces", interfaces); _proxiedType = proxiedType; _classEmitter = CreateClassEmitter(name, interfaces, moduleScope); _proxied = CreateProxiedField(); CreateProxyCtor(proxiedType); _classEmitter.TypeBuilder.AddInterfaceImplementation(typeof(IProxy)); var setProxiedMethod = _classEmitter.CreateInterfaceMethodImplementation( typeof(IProxy).GetMethod("SetProxied", _declaredInstanceBindingFlags)); var arg = setProxiedMethod.ArgumentReferences[0]; var argAsProxiedType = new ConvertExpression(proxiedType, arg.ToExpression()); setProxiedMethod.AddStatement(new AssignStatement(_proxied, argAsProxiedType)); setProxiedMethod.AddStatement(new ReturnStatement()); }
/// <summary>Tests whether the <paramref name="property"/>'s type is part of the <paramref name="supportedPropertyInterfaces"/> array.</summary> /// <param name="property">The <see cref="IBusinessObjectProperty"/> to be tested. Must not be <see langword="null"/>.</param> /// <param name="supportedPropertyInterfaces"> /// The list of interfaces to test the <paramref name="property"/> against. Use <see langword="null"/> if no restrictions are made. Items must /// not be <see langword="null"/>. /// </param> /// <returns> /// <see langword="true"/> if the <paramref name="property"/>'s type is found in the <paramref name="supportedPropertyInterfaces"/> array. /// </returns> public bool IsPropertyInterfaceSupported(IBusinessObjectProperty property, Type[] supportedPropertyInterfaces) { ArgumentUtility.CheckNotNull("property", property); if (supportedPropertyInterfaces == null) { return(true); } ArgumentUtility.CheckNotNullOrItemsNull("supportedPropertyInterfaces", supportedPropertyInterfaces); bool isSupportedPropertyInterface = false; for (int i = 0; i < supportedPropertyInterfaces.Length; i++) { Type supportedInterface = supportedPropertyInterfaces[i]; if (supportedInterface.IsAssignableFrom(property.GetType())) { isSupportedPropertyInterface = true; break; } } return(isSupportedPropertyInterface); }
/// <summary> /// Substitutes the type parameters of the generic type definition and returns a <see cref="MethodInfo"/> object representing the resulting /// constructed method. Use this as a replacement for <see cref="MethodInfo.MakeGenericMethod"/>. /// </summary> /// <param name="genericMethodDefinition">The generic method definition.</param> /// <param name="typeArguments">The type arguments.</param> /// <returns>The generic method instantiation.</returns> public static MethodInfo MakeTypePipeGenericMethod(this MethodInfo genericMethodDefinition, params Type[] typeArguments) { ArgumentUtility.CheckNotNull("genericMethodDefinition", genericMethodDefinition); ArgumentUtility.CheckNotNullOrItemsNull("typeArguments", typeArguments); if (!genericMethodDefinition.IsGenericMethodDefinition) { var message = string.Format( "'{0}' is not a generic method definition. MakeTypePipeGenericMethod may only be called on a method for which " + "MethodInfo.IsGenericMethodDefinition is true.", genericMethodDefinition.Name); throw new InvalidOperationException(message); } var typeParameters = genericMethodDefinition.GetGenericArguments(); GenericArgumentUtility.ValidateGenericArguments(typeParameters, typeArguments, genericMethodDefinition.Name); var instantiationInfo = new MethodInstantiationInfo(genericMethodDefinition, typeArguments); return(instantiationInfo.Instantiate()); }
/// <summary> /// Substitutes the type parameters of the generic type definition and returns a <see cref="Type"/> object representing the resulting /// constructed generic type. Use this as a replacement for <see cref="Type.MakeGenericType"/>. /// </summary> /// <param name="genericTypeDefinition">The generic type definition.</param> /// <param name="typeArguments">The type arguments.</param> /// <returns>The generic type instantiation.</returns> public static Type MakeTypePipeGenericType(this Type genericTypeDefinition, params Type[] typeArguments) { ArgumentUtility.CheckNotNull("typeArguments", typeArguments); ArgumentUtility.CheckNotNullOrItemsNull("typeArguments", typeArguments); if (!genericTypeDefinition.IsGenericTypeDefinition) { var message = string.Format( "'{0}' is not a generic type definition. {1} may only be called on a type for which Type.IsGenericTypeDefinition is true.", genericTypeDefinition.Name, MethodInfo.GetCurrentMethod().Name); throw new InvalidOperationException(message); } var typeParameters = genericTypeDefinition.GetGenericArguments(); GenericArgumentUtility.ValidateGenericArguments(typeParameters, typeArguments, genericTypeDefinition.Name); var instantiationContext = new TypeInstantiationContext(); var instantiationInfo = new TypeInstantiationInfo(genericTypeDefinition, typeArguments); return(instantiationContext.Instantiate(instantiationInfo)); }
/// <summary> /// Converts a list of parameter values into a <see cref="NameValueCollection"/>. /// </summary> /// <param name="parameterDeclarations"> /// The <see cref="WxeParameterDeclaration"/> list used for serializing the <paramref name="parameterValues"/>. /// Must not be <see langword="null"/> or contain items that are <see langword="null"/>. /// </param> /// <param name="parameterValues"> /// The list parameter values. Must not be <see langword="null"/>. /// </param> /// <returns> /// A <see cref="NameValueCollection"/> containing the serialized <paramref name="parameterValues"/>. /// The names of the parameters are used as keys. /// </returns> public static NameValueCollection SerializeParametersForQueryString(WxeParameterDeclaration[] parameterDeclarations, object[] parameterValues) { ArgumentUtility.CheckNotNullOrItemsNull("parameterDeclarations", parameterDeclarations); ArgumentUtility.CheckNotNull("parameterValues", parameterValues); NameValueCollection serializedParameters = new NameValueCollection(); for (int i = 0; i < parameterDeclarations.Length; i++) { WxeParameterDeclaration parameterDeclaration = parameterDeclarations[i]; object parameterValue = null; if (i < parameterValues.Length) { parameterValue = parameterValues[i]; } string serializedValue = parameterDeclaration.Converter.ConvertToString(parameterValue, null); if (serializedValue != null) { serializedParameters.Add(parameterDeclaration.Name, serializedValue); } } return(serializedParameters); }
public void Fail_zItemNullIEnumerable() { ArgumentUtility.CheckNotNullOrItemsNull("arg", GetEnumerableWithNullValue()); }
public void Fail_NullICollection() { ArgumentUtility.CheckNotNullOrItemsNull("arg", (ICollection)null); }