/// <summary>
/// Adds diagnostics from useSiteDiagnostics into diagnostics and returns True if there were any errors.
/// </summary>
internal static bool Add(
this DiagnosticBag diagnostics,
CSharpSyntaxNode node,
HashSet<DiagnosticInfo> useSiteDiagnostics)
{
return !useSiteDiagnostics.IsNullOrEmpty() && diagnostics.Add(node.Location, useSiteDiagnostics);
}
private ImmutableArray <NamedTypeSymbol> MakeAcyclicInterfaces(ConsList <TypeSymbol> basesBeingResolved, DiagnosticBag diagnostics)
{
var typeKind = this.TypeKind;
if (typeKind == TypeKind.Enum)
{
Debug.Assert(GetDeclaredInterfaces(basesBeingResolved: null).IsEmpty, "Computation skipped for enums");
return(ImmutableArray <NamedTypeSymbol> .Empty);
}
var declaredInterfaces = GetDeclaredInterfaces(basesBeingResolved: basesBeingResolved);
bool isInterface = (typeKind == TypeKind.Interface);
ArrayBuilder <NamedTypeSymbol> result = isInterface ? ArrayBuilder <NamedTypeSymbol> .GetInstance() : null;
foreach (var t in declaredInterfaces)
{
if (isInterface)
{
if (BaseTypeAnalysis.TypeDependsOn(depends: t, on: this))
{
result.Add(new ExtendedErrorTypeSymbol(t, LookupResultKind.NotReferencable,
diagnostics.Add(ErrorCode.ERR_CycleInInterfaceInheritance, Locations[0], this, t)));
continue;
}
else
{
result.Add(t);
}
}
HashSet <DiagnosticInfo> useSiteDiagnostics = null;
if (t.DeclaringCompilation != this.DeclaringCompilation)
{
t.AddUseSiteDiagnostics(ref useSiteDiagnostics);
foreach (var @interface in t.AllInterfacesNoUseSiteDiagnostics)
{
if (@interface.DeclaringCompilation != this.DeclaringCompilation)
{
@interface.AddUseSiteDiagnostics(ref useSiteDiagnostics);
}
}
}
if (!useSiteDiagnostics.IsNullOrEmpty())
{
diagnostics.Add(Locations[0], useSiteDiagnostics);
}
}
return(isInterface ? result.ToImmutableAndFree() : declaredInterfaces);
}
public BoundExpression Convert(TypeSymbol type, BoundExpression arg)
{
HashSet <DiagnosticInfo> useSiteDiagnostics = null;
Conversion c = Compilation.Conversions.ClassifyConversionFromExpression(arg, type, ref useSiteDiagnostics);
Debug.Assert(useSiteDiagnostics.IsNullOrEmpty());
// If this happens, we should probably check if the method has ObsoleteAttribute.
Debug.Assert((object)c.Method == null, "Why are we synthesizing a user-defined conversion after initial binding?");
return(Convert(type, arg, c));
}
async Task LoadAllReferencedLoggers(
List <string> apisToExtract,
ExtractorParameters extractorParameters)
{
var serviceDiagnostics = await this.diagnosticClient.GetAllAsync(extractorParameters);
foreach (var serviceDiagnostic in serviceDiagnostics)
{
string loggerId = serviceDiagnostic.Properties.LoggerId;
var serviceDiagnosticsKey = ParameterNamingHelper.GenerateValidParameterName(serviceDiagnostic.Name, ParameterPrefix.Diagnostic);
if (!this.Cache.ServiceLevelDiagnosticLoggerBindings.ContainsKey(serviceDiagnosticsKey))
{
this.Cache.ServiceLevelDiagnosticLoggerBindings.Add(serviceDiagnosticsKey, loggerId);
}
}
if (apisToExtract.IsNullOrEmpty())
{
this.logger.LogWarning("No apis to extract are passed to {0}", nameof(LoggerExtractor));
return;
}
foreach (string curApiName in apisToExtract)
{
var diagnostics = await this.diagnosticClient.GetApiDiagnosticsAsync(curApiName, extractorParameters);
if (diagnostics.IsNullOrEmpty())
{
this.logger.LogWarning("No diagnostics found for '{0}' api", curApiName);
continue;
}
var diagnosticLoggerBindings = new HashSet <DiagnosticLoggerBinding>();
foreach (var diagnostic in diagnostics)
{
diagnosticLoggerBindings.Add(new DiagnosticLoggerBinding
{
DiagnosticName = ParameterNamingHelper.GenerateValidParameterName(diagnostic.Name, ParameterPrefix.Diagnostic),
LoggerId = diagnostic.Properties.LoggerId
});
}
if (!diagnosticLoggerBindings.IsNullOrEmpty())
{
this.Cache.ApiDiagnosticLoggerBindings.Add(
ParameterNamingHelper.GenerateValidParameterName(curApiName, ParameterPrefix.Api),
diagnosticLoggerBindings);
}
}
}
public static bool ContainsAttribute([NotNull] this IAttributesOwnerDeclaration declaration, IEnumerable <string> attributeNames)
{
var clrTypeNames = new HashSet <ClrTypeName>(attributeNames.Select(x => new ClrTypeName(x)));
if (clrTypeNames.IsNullOrEmpty())
{
return(false);
}
return(declaration
.AttributesEnumerable
.Select(attribute => attribute.Name.Reference.Resolve().DeclaredElement)
.OfType <IClass>()
.Select(attributeClass => attributeClass.GetClrName())
.Any(clrTypeNames.Contains));
}
public bool Has(Texture2D tex, HashSet <EAtlasType> types)
{
foreach (var v in FloorVariations)
{
v.Has(tex, types);
}
foreach (var v in WallVariations)
{
v.Has(tex, types);
}
Edge.Has(tex, types);
DiagEdge.Has(tex, types);
return(!types.IsNullOrEmpty());
}
/// <summary>
/// Create properties
/// </summary>
/// <param name="typeBuilder">type builder</param>
/// <param name="interfaceType">type of the interface to implement</param>
public static void CreateProperties(TypeBuilder typeBuilder, Type interfaceType)
{
// build field for each property and implement these properties
var propertyInformationCollection = new HashSet <PropertyInfo>();
GetProperties(interfaceType, propertyInformationCollection);
if (!propertyInformationCollection.IsNullOrEmpty())
{
foreach (var propertyInformation in propertyInformationCollection)
{
var name = propertyInformation.Name;
var fieldName = CreateName(name);
var fieldBuilder = typeBuilder.DefineField(
fieldName,
propertyInformation.PropertyType,
FieldAttributes.Private);
var propertyBuilder = typeBuilder.DefineProperty(
name,
PropertyAttributes.HasDefault,
propertyInformation.PropertyType,
Type.EmptyTypes);
if (propertyInformation.CanRead)
{
var getMethodReference = propertyInformation.GetGetMethod();
var getMethodBuilder = CreatePropertyMethod(typeBuilder, getMethodReference);
var getIlGenerator = getMethodBuilder.GetILGenerator();
getIlGenerator.Emit(OpCodes.Ldarg_0);
getIlGenerator.Emit(OpCodes.Ldfld, fieldBuilder);
getIlGenerator.Emit(OpCodes.Ret);
propertyBuilder.SetGetMethod(getMethodBuilder);
}
if (propertyInformation.CanWrite)
{
var setMethodReference = propertyInformation.GetSetMethod();
var setMethodBuilder = CreatePropertyMethod(typeBuilder, setMethodReference);
var setIlGenerator = setMethodBuilder.GetILGenerator();
setIlGenerator.Emit(OpCodes.Ldarg_0);
setIlGenerator.Emit(OpCodes.Ldarg_1);
setIlGenerator.Emit(OpCodes.Stfld, fieldBuilder);
setIlGenerator.Emit(OpCodes.Ret);
propertyBuilder.SetSetMethod(setMethodBuilder);
}
}
}
}
/// <summary>
/// This method loads the child products into the checklist for display in the Sale message
/// </summary>
/// <param name="childProductsBelongingToUserFrom"></param>
/// <returns></returns>
private ICollection <CheckBoxItem> loadChildProductsIntoCheckItems(HashSet <ProductChild> childProductsBelongingToUserFrom)
{
List <CheckBoxItem> lst = new List <CheckBoxItem>();
if (childProductsBelongingToUserFrom.IsNullOrEmpty())
{
return(lst);
}
foreach (ProductChild productChild in childProductsBelongingToUserFrom)
{
CheckBoxItem chkBx = new CheckBoxItem(productChild);
lst.Add(chkBx);
}
return(lst);
}
internal void FinishDataReaderMap <TModel>(IDictionary <string, string> bindings, HashSet <string> ignoreMembers, bool useStandardCodeStyleForMembers)
where TModel : class, new()
{
if (!bindings.IsNullOrEmpty())
{
CasheDataReaderProvider <TModel> .SetBindingsConfiguration(bindings);
}
if (!ignoreMembers.IsNullOrEmpty())
{
CasheDataReaderProvider <TModel> .SetBindingsConfiguration(ignoreMembers);
}
if (useStandardCodeStyleForMembers)
{
CasheDataReaderProvider <TModel> .UseStandardCodeStyleForMembers(true);
}
}
private BoundExpression ConvertIndex(BoundExpression expr, TypeSymbol oldType, TypeSymbol newType)
{
HashSet <DiagnosticInfo> useSiteDiagnostics = null;
var kind = _bound.Compilation.Conversions.ClassifyConversionFromType(oldType, newType, ref useSiteDiagnostics).Kind;
Debug.Assert(useSiteDiagnostics.IsNullOrEmpty());
switch (kind)
{
case ConversionKind.Identity:
return(expr);
case ConversionKind.ExplicitNumeric:
return(Convert(expr, newType, true));
default:
return(Convert(expr, _int32Type, false));
}
}
internal static List <GUID> FilterReferencesForAsset(IDependencyData dependencyData, GUID asset, List <ObjectIdentifier> references, HashSet <ObjectIdentifier> previousSceneObjects = null)
{
var referencedAssets = new HashSet <AssetLoadInfo>();
var referencesPruned = new List <ObjectIdentifier>(references.Count);
// Remove Default Resources and Includes for Assets assigned to Bundles
foreach (ObjectIdentifier reference in references)
{
if (reference.filePath.Equals(CommonStrings.UnityDefaultResourcePath, StringComparison.OrdinalIgnoreCase))
{
continue;
}
if (dependencyData.AssetInfo.TryGetValue(reference.guid, out AssetLoadInfo referenceInfo))
{
referencedAssets.Add(referenceInfo);
continue;
}
referencesPruned.Add(reference);
}
references.Clear();
references.AddRange(referencesPruned);
var referencedAssetsGuids = new List <GUID>(referencedAssets.Count);
// Remove References also included by non-circular Referenced Assets
// Remove References also included by circular Referenced Assets if Asset's GUID is higher than Referenced Asset's GUID
foreach (AssetLoadInfo referencedAsset in referencedAssets)
{
var refObjectIdLookup = new HashSet <ObjectIdentifier>(referencedAsset.referencedObjects);
bool circularRef = refObjectIdLookup.Select(x => x.guid).Contains(asset);
if (!circularRef || (circularRef && asset > referencedAsset.asset || asset == referencedAsset.asset))
{
references.RemoveAll(refObjectIdLookup.Contains);
}
referencedAssetsGuids.Add(referencedAsset.asset);
}
// Special path for scenes, they can use data from previous sharedAssets in the same bundle
if (!previousSceneObjects.IsNullOrEmpty())
{
references.RemoveAll(previousSceneObjects.Contains);
}
return(referencedAssetsGuids);
}
private ImmutableArray <NamedTypeSymbol> MakeAcyclicInterfaces(ConsList <Symbol> basesBeingResolved, DiagnosticBag diagnostics)
{
// NOTE: this is mostly copied from SourceNamedTypeSymbol_Bases.
var declaredInterfaces = GetDeclaredInterfaces(basesBeingResolved: basesBeingResolved);
var result = ArrayBuilder <NamedTypeSymbol> .GetInstance();
foreach (var t in declaredInterfaces)
{
if (BaseTypeAnalysis.InterfaceDependsOn(depends: t, on: this))
{
result.Add(new ExtendedErrorTypeSymbol(t, LookupResultKind.NotReferencable,
diagnostics.Add(ErrorCode.ERR_CycleInInterfaceInheritance, Locations[0], this, t)));
continue;
}
else
{
result.Add(t);
}
HashSet <DiagnosticInfo> useSiteDiagnostics = null;
if (t.DeclaringCompilation != DeclaringCompilation)
{
t.AddUseSiteDiagnostics(ref useSiteDiagnostics);
foreach (var @interface in t.AllInterfacesNoUseSiteDiagnostics)
{
if (@interface.DeclaringCompilation != DeclaringCompilation)
{
@interface.AddUseSiteDiagnostics(ref useSiteDiagnostics);
}
}
}
if (!useSiteDiagnostics.IsNullOrEmpty())
{
diagnostics.Add(Locations[0], useSiteDiagnostics);
}
}
return(result.ToImmutableAndFree());
}
private void addFeatureToEveryProductWithMenuPath2(MenuPath2 menuPath2, MenuFeature menuFeature)
{
//Now add the feature to every product that has menu1 as its path.
//first find all the menuMains that contain MenuPath1
if (menuPath2.MenuPathMains.IsNullOrEmpty())
{
return;
}
List <MenuPathMain> menuPathMainList = menuPath2.MenuPathMains.ToList();
//Now get all the products that have theseMenuPaths as their path.
HashSet <Product> productHashList = new HashSet <Product>();
foreach (var menuPathMain in menuPathMainList)
{
if (!menuPathMain.Products_Fixed.IsNullOrEmpty())
{
List <Product> menuPathMainProductList = menuPathMain.Products_Fixed.ToList();
foreach (var prod in menuPathMainProductList)
{
productHashList.Add(prod);
}
}
}
if (productHashList.IsNullOrEmpty())
{
return;
}
foreach (var prod2 in productHashList)
{
ProductFeature pf = new ProductFeature();
pf.ProductId = prod2.Id;
pf.Product = prod2;
pf.MenuFeatureId = menuFeature.Id;
pf.MenuFeature = menuFeature;
pf.Name = menuFeature.Name;
ProductFeatureBiz.CreateAndSave(pf);
}
SaveChanges();
}
public BoundReturnStatement Return(BoundExpression expression = null)
{
if (expression != null)
{
// If necessary, add a conversion on the return expression.
HashSet <DiagnosticInfo> useSiteDiagnostics = null;
var conversion = Compilation.Conversions.ClassifyConversion(expression.Type, CurrentMethod.ReturnType, ref useSiteDiagnostics);
Debug.Assert(useSiteDiagnostics.IsNullOrEmpty());
Debug.Assert(conversion.Kind != ConversionKind.NoConversion);
if (conversion.Kind != ConversionKind.Identity)
{
expression = BoundConversion.Synthesized(Syntax, expression, conversion, false, false, ConstantValue.NotAvailable, CurrentMethod.ReturnType);
}
}
return(new BoundReturnStatement(Syntax, expression)
{
WasCompilerGenerated = true
});
}
void ClearIfNecessary()
{
if (mBasicEdges == null)
{
mBasicEdges = new List <BasicEdge>();
}
else
{
mBasicEdges.Clear();
}
if (!mVertices.IsNullOrEmpty())
{
mVertices.Clear();
}
if (!mEdges.IsNullOrEmpty())
{
mEdges.Clear();
}
mCentroid = Vector3.zero;
}
public ActionResult ResetPasswordSetNew(Lite <ResetPasswordRequestEntity> rpr)
{
using (AuthLogic.Disable())
{
ResetPasswordRequestEntity request = rpr.Retrieve();
var user = request.User;
var context = user.ApplyChanges(this, UserMapping.ChangePassword, "").Validate();
HashSet <string> errorNpk = null;
HashSet <string> errorNpbk = null;
context.Errors.TryGetValue(UserMapping.NewPasswordKey, out errorNpk);
context.Errors.TryGetValue(UserMapping.NewPasswordBisKey, out errorNpbk);
if (!errorNpk.IsNullOrEmpty() || !errorNpbk.IsNullOrEmpty())
{
ViewData["Title"] = AuthMessage.ChangePassword.NiceToString();
ModelState.FromContext(context);
return(ResetPasswordSetNewError(request.Id, ""));
}
string errorPasswordValidation = UserEntity.OnValidatePassword(Request.Params[UserMapping.NewPasswordKey]);
if (errorPasswordValidation.HasText())
{
return(ResetPasswordSetNewError(request.Id, errorPasswordValidation));
}
using (OperationLogic.AllowSave <UserEntity>())
{
context.Value.Save();
}
//remove pending requests
Database.Query <ResetPasswordRequestEntity>().Where(r => r.User.Email == user.Email && r.Code == request.Code).UnsafeDelete();
}
return(RedirectToAction("ResetPasswordSuccess"));
}
public static bool Add(
this DiagnosticBag diagnostics,
Location location,
HashSet <DiagnosticInfo> useSiteDiagnostics)
{
if (useSiteDiagnostics.IsNullOrEmpty())
{
return(false);
}
bool haveErrors = false;
foreach (var info in useSiteDiagnostics)
{
if (info.Severity == DiagnosticSeverity.Error)
{
haveErrors = true;
}
diagnostics.Add(info.ToDiagnostic(location));
}
return(haveErrors);
}
public static string GenerateConstructTarget(IRelationDomain targetDomain, bool useMetamodelInterface)
{
StringBuilder stringBuilder = new StringBuilder();
ISet <string> postPonedSets = new HashSet <string>();
List <IObjectTemplateExp> objectTemplates = QvtModelExplorer.FindAllObjectTemplates(targetDomain).Where(o => !o.IsAntiTemplate()).ToList();
foreach (IObjectTemplateExp objectTemplate in objectTemplates)
{
IVariable variable = objectTemplate.BindsTo;
stringBuilder.AppendLine("\n// Contructing " + variable.Name);
foreach (IPropertyTemplateItem propertyTemplateItem in objectTemplate.Part)
{
string setStatement = GenerateSetValue(propertyTemplateItem, variable.Name, (IRelation)targetDomain.Rule, useMetamodelInterface);
IVariableExp targetVariableValue = propertyTemplateItem.Value as IVariableExp;
IObjectTemplateExp targetObjTemplateValue = objectTemplates.FirstOrDefault(o => o.BindsTo == targetVariableValue?.ReferredVariable);
bool ok = targetObjTemplateValue == null || objectTemplates.IndexOf(targetObjTemplateValue) < objectTemplates.IndexOf(objectTemplate);
if (ok)
{
stringBuilder.AppendLine(setStatement);
}
else
{
postPonedSets.Add(setStatement);
}
}
}
if (!postPonedSets.IsNullOrEmpty())
{
stringBuilder.AppendLine("// Setting cycling properties");
foreach (string setStatement in postPonedSets)
{
stringBuilder.AppendLine(setStatement);
}
}
return(stringBuilder.ToString());
}
private List <MenuFeature> getAllMenuFeaturesAsPerProductsMenuPath(IProduct iproduct)
{
Product product = iproduct as Product;
product.IsNullThrowException("Product is null");
if (product.MenuPathMains.IsNullOrEmpty())
{
return(null);
}
List <MenuPathMain> menuPathList = product.MenuPathMains.Where(x => x.MetaData.IsDeleted == false).ToList();
menuPathList.IsNullOrEmptyThrowException("menuPathList is empty");
HashSet <MenuFeature> menuFeaturesAsPerMenuPaths = new HashSet <MenuFeature>();
foreach (MenuPathMain mp in menuPathList)
{
HashSet <MenuFeature> currCollection = getAllCurrentFeaturesFor(mp);
if (currCollection.IsNullOrEmpty())
{
continue;
}
foreach (MenuFeature mf in currCollection)
{
try
{
menuFeaturesAsPerMenuPaths.Add(mf);
}
catch
{
}
}
}
return(menuFeaturesAsPerMenuPaths.ToList());
}
/// <summary>
/// Appends diagnostics from useSiteDiagnostics into diagnostics and returns True if there were any errors.
/// </summary>
internal static bool AppendUseSiteDiagnostics(
SyntaxNode node,
HashSet <DiagnosticInfo> useSiteDiagnostics,
DiagnosticBag diagnostics)
{
if (useSiteDiagnostics.IsNullOrEmpty())
{
return(false);
}
bool haveErrors = false;
foreach (var info in useSiteDiagnostics)
{
if (info.Severity == DiagnosticSeverity.Error)
{
haveErrors = true;
}
Error(diagnostics, info, node);
}
return(haveErrors);
}
internal static bool Add(
this DiagnosticBag diagnostics,
Location location,
HashSet<DiagnosticInfo> useSiteDiagnostics)
{
if (useSiteDiagnostics.IsNullOrEmpty())
{
return false;
}
bool haveErrors = false;
foreach (var info in useSiteDiagnostics)
{
if (info.Severity == DiagnosticSeverity.Error)
{
haveErrors = true;
}
diagnostics.Add(new CSDiagnostic(info, location));
}
return haveErrors;
}
public static int LongestContainedRange(List <int> array)
{
// unprocessedEntries records the existence of each entry in A.
var unprocessedEntries = new HashSet <int>(array);
var maxIntervalSize = 0;
while (!unprocessedEntries.IsNullOrEmpty())
{
using var enumerator = unprocessedEntries.GetEnumerator();
enumerator.MoveNext();
var a = enumerator.Current;
unprocessedEntries.Remove(a);
// Finds the lower bound of the largest range containing a.
var lowerBound = a - 1;
while (unprocessedEntries.Contains(lowerBound))
{
unprocessedEntries.Remove(lowerBound);
--lowerBound;
}
// Finds the upper bound of the largest range containing a.
var upperBound = a + 1;
while (unprocessedEntries.Contains(upperBound))
{
unprocessedEntries.Remove(upperBound);
++upperBound;
}
maxIntervalSize = Math.Max(upperBound - lowerBound - 1, maxIntervalSize);
}
return(maxIntervalSize);
}
public static T ItemAtIndexLinear <T>(this HashSet <T> set, int index)
{
if (set.IsNullOrEmpty() || index >= set.Count)
{
return(default(T));
}
T result = default(T);
int seeker = 0;
set.ForEach(item =>
{
if (seeker == index)
{
result = item;
return(true);
}
seeker++;
return(false);
});
return(result);
}
/// <summary>
/// Appends diagnostics from useSiteDiagnostics into diagnostics and returns True if there were any errors.
/// </summary>
internal static bool AppendUseSiteDiagnostics(
SyntaxNode node,
HashSet<DiagnosticInfo> useSiteDiagnostics,
DiagnosticBag diagnostics)
{
if (useSiteDiagnostics.IsNullOrEmpty())
{
return false;
}
bool haveErrors = false;
foreach (var info in useSiteDiagnostics)
{
if (info.Severity == DiagnosticSeverity.Error)
{
haveErrors = true;
}
Error(diagnostics, info, node);
}
return haveErrors;
}
private static async Task RefreshTopics()
{
await IgnoreErrorsAsync(async() =>
{
var topics = new HashSet <string>();
await ServerConnection.ExecuteNonQuery("DELETE FROM topic");
foreach (var topic in await ServerConnection.QueryStringList("SELECT DISTINCT topics FROM query WHERE topics IS NOT NULL AND topics != ''"))
{
topics.UnionWith(topic.Split(TopicSeparator, StringSplitOptions.RemoveEmptyEntries));
}
if (topics.IsNullOrEmpty())
{
return;
}
string sql = "";
foreach (var topic in topics)
{
sql += $"INSERT INTO topic (name) VALUES ('{topic}');";
}
await ServerConnection.ExecuteNonQuery(sql);
});
}
private NamedTypeSymbol MakeAcyclicBaseType(DiagnosticBag diagnostics)
{
var typeKind = this.TypeKind;
var compilation = this.DeclaringCompilation;
NamedTypeSymbol declaredBase;
if (typeKind == TypeKind.Enum)
{
Debug.Assert((object)GetDeclaredBaseType(basesBeingResolved: null) == null, "Computation skipped for enums");
declaredBase = compilation.GetSpecialType(SpecialType.System_Enum);
}
else
{
declaredBase = GetDeclaredBaseType(basesBeingResolved: null);
}
if ((object)declaredBase == null)
{
switch (typeKind)
{
case TypeKind.Class:
if (this.SpecialType == SpecialType.System_Object)
{
return(null);
}
declaredBase = compilation.GetSpecialType(SpecialType.System_Object);
break;
case TypeKind.Struct:
case TypeKind.Interface:
return(null);
case TypeKind.Delegate:
declaredBase = compilation.GetSpecialType(SpecialType.System_MulticastDelegate);
break;
default:
throw ExceptionUtilities.UnexpectedValue(typeKind);
}
}
if (BaseTypeAnalysis.ClassDependsOn(declaredBase, this))
{
return(new ExtendedErrorTypeSymbol(declaredBase, LookupResultKind.NotReferencable,
diagnostics.Add(ErrorCode.ERR_CircularBase, Locations[0], declaredBase, this)));
}
this.SetKnownToHaveNoDeclaredBaseCycles();
HashSet <DiagnosticInfo> useSiteDiagnostics = null;
NamedTypeSymbol current = declaredBase;
do
{
if (current.DeclaringCompilation == this.DeclaringCompilation)
{
break;
}
current.AddUseSiteDiagnostics(ref useSiteDiagnostics);
current = current.BaseTypeNoUseSiteDiagnostics;
}while ((object)current != null);
if (!useSiteDiagnostics.IsNullOrEmpty())
{
diagnostics.Add(FindBaseRefSyntax(declaredBase) ?? Locations[0], useSiteDiagnostics);
}
return(declaredBase);
}
/// <summary>
/// Performs when action executing.
/// </summary>
/// <param name="context"></param>
/// <param name="next"></param>
public virtual async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
{
if (!context.ModelState.IsValid)
{
var httpContext = context.HttpContext;
IEnumerable <ModelError> modelErrors = context.ModelState.Values.SelectMany(v => v.Errors);
var errors = new HashSet <string> {
};
foreach (var item in modelErrors)
{
errors.Add(item.ErrorMessage);
}
var properties = GetProperties(DisabledProperties);
var nestedProperties = GetProperties(DisabledNestedProperties);
if (!nestedProperties.IsNullOrEmpty())
{
foreach (var nestedProp in nestedProperties)
{
var assembly = Assembly.GetAssembly(AssemblyTypeForNestedProps);
var dtoType = assembly?.GetExportedTypes()?.ToList()?.FirstOrDefault(i => i.FullName.Contains(DTOFolderAssemblyName) &&
(i.Name == $"{nestedProp}DTO" ||
i.Name == $"{nestedProp.Remove(nestedProp.Length - 1, 1)}DTO"));
if (dtoType != null)
{
var dtoProps = dtoType.GetProperties().ToList();
dtoProps.RemoveAll(i => i.Name.Contains("Id"));
foreach (var entityProp in dtoProps)
{
if (entityProp.CustomAttributes.Count() != 0)
{
if (httpContext.Items[entityProp.Name] != null)
{
errors.Remove(httpContext.Items[entityProp.Name].ToString());
}
}
}
}
}
}
if (!properties.IsNullOrEmpty())
{
foreach (var prop in properties)
{
if (httpContext.Items[prop] != null)
{
errors.Remove(httpContext.Items[prop].ToString());
}
}
}
if (!errors.IsNullOrEmpty())
{
throw new MilvaUserFriendlyException(string.Join("~", errors));
}
}
await next();
}
private static bool AppendUseSiteDiagnostics(
HashSet<DiagnosticInfo> useSiteDiagnostics,
TypeParameterSymbol typeParameter,
ref ArrayBuilder<TypeParameterDiagnosticInfo> useSiteDiagnosticsBuilder)
{
if (useSiteDiagnostics.IsNullOrEmpty())
{
return false;
}
if (useSiteDiagnosticsBuilder == null)
{
useSiteDiagnosticsBuilder = new ArrayBuilder<TypeParameterDiagnosticInfo>();
}
bool hasErrors = false;
foreach (var info in useSiteDiagnostics)
{
if (info.Severity == DiagnosticSeverity.Error)
{
hasErrors = true;
}
useSiteDiagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, info));
}
return hasErrors;
}
/// <summary>
/// Select from DOM using index. First non-class/tag/id selector will result in this being passed off to GetMatches
/// </summary>
/// <param name="document"></param>
/// <returns></returns>
public IEnumerable <IDomObject> Select(IDomDocument document, IEnumerable <IDomObject> context)
{
if (Selectors == null)
{
throw new ArgumentException("No selectors provided.");
}
if (Selectors.Count == 0)
{
yield break;
}
Document = document;
IEnumerable <IDomObject> lastResult = null;
HashSet <IDomObject> output = new HashSet <IDomObject>();
IEnumerable <IDomObject> selectionSource = context;
// Disable the index if there is no context (e.g. disconnected elements)
bool useIndex = context.IsNullOrEmpty() || !context.First().IsDisconnected;
// Copy the list because it may change during the process
ActiveSelectors = new List <Selector>(Selectors);
for (activeSelectorId = 0; activeSelectorId < ActiveSelectors.Count; activeSelectorId++)
{
var selector = ActiveSelectors[activeSelectorId];
CombinatorType combinatorType = selector.CombinatorType;
SelectorType selectorType = selector.SelectorType;
TraversalType traversalType = selector.TraversalType;
// Determine what kind of combining method we will use with previous selection results
if (activeSelectorId != 0)
{
switch (combinatorType)
{
case CombinatorType.Cumulative:
// do nothing
break;
case CombinatorType.Root:
selectionSource = context;
if (lastResult != null)
{
output.AddRange(lastResult);
lastResult = null;
}
break;
case CombinatorType.Chained:
selectionSource = lastResult;
lastResult = null;
break;
// default (chained): leave lastresult alone
}
}
HashSet <IDomObject> tempResult = null;
IEnumerable <IDomObject> interimResult = null;
string key = "";
if (useIndex && !selector.NoIndex)
{
#if DEBUG_PATH
if (type.HasFlag(SelectorType.Attribute))
{
key = "!" + selector.AttributeName;
type &= ~SelectorType.Attribute;
if (selector.AttributeValue != null)
{
InsertAttributeValueSelector(selector);
}
}
else if (type.HasFlag(SelectorType.Tag))
{
key = "+" + selector.Tag;
type &= ~SelectorType.Tag;
}
else if (type.HasFlag(SelectorType.ID))
{
key = "#" + selector.ID;
type &= ~SelectorType.ID;
}
else if (type.HasFlag(SelectorType.Class))
{
key = "." + selector.Class;
type &= ~SelectorType.Class;
}
#else
if (selectorType.HasFlag(SelectorType.Attribute))
{
key = "!" + (char)DomData.TokenID(selector.AttributeName);
selectorType &= ~SelectorType.Attribute;
if (selector.AttributeValue != null)
{
InsertAttributeValueSelector(selector);
}
}
else if (selectorType.HasFlag(SelectorType.Tag))
{
key = "+" + (char)DomData.TokenID(selector.Tag, true);
selectorType &= ~SelectorType.Tag;
}
else if (selectorType.HasFlag(SelectorType.ID))
{
key = "#" + (char)DomData.TokenID(selector.ID);
selectorType &= ~SelectorType.ID;
}
else if (selectorType.HasFlag(SelectorType.Class))
{
key = "." + (char)DomData.TokenID(selector.Class);
selectorType &= ~SelectorType.Class;
}
#endif
}
// If part of the selector was indexed, key will not be empty. Return initial set from the
// index. If any selectors remain after this they will be searched the hard way.
if (key != String.Empty)
{
int depth = 0;
bool descendants = true;
switch (traversalType)
{
case TraversalType.Child:
depth = selector.ChildDepth;;
descendants = false;
break;
case TraversalType.Filter:
depth = 0;
descendants = false;
break;
case TraversalType.Descendent:
depth = 1;
descendants = true;
break;
}
if (selectionSource == null)
{
interimResult = document.QueryIndex(key + DomData.indexSeparator, depth, descendants);
}
else
{
interimResult = new HashSet <IDomObject>();
foreach (IDomObject obj in selectionSource)
{
((HashSet <IDomObject>)interimResult)
.AddRange(document.QueryIndex(key + DomData.indexSeparator + obj.Path,
depth, descendants));
}
}
}
else if (selectorType.HasFlag(SelectorType.Elements))
{
selectorType &= ~SelectorType.Elements;
HashSet <IDomObject> source = new HashSet <IDomObject>(selectionSource);
interimResult = new HashSet <IDomObject>();
foreach (IDomObject obj in selectionSource)
{
key = DomData.indexSeparator + obj.Path;
HashSet <IDomObject> srcKeys = new HashSet <IDomObject>(document.QueryIndex(key));
foreach (IDomObject match in selector.SelectElements)
{
if (srcKeys.Contains(match))
{
((HashSet <IDomObject>)interimResult).Add(match);
}
}
}
}
// TODO - GetMatch should work if passed with no selectors (returning nothing), now it returns everything
// 12/10/11 - this todo is not verified, much has changed since it was written. TODO confirm this and
// fix if needed. If having the conversation with self again, remove comments and forget it. This is
// an example of why comments can do more harm than good.
if ((selectorType & ~(SelectorType.SubSelectorNot | SelectorType.SubSelectorHas)) != 0)
{
IEnumerable <IDomObject> finalSelectWithin =
interimResult
?? (combinatorType == CombinatorType.Chained ? lastResult : null)
?? selectionSource
?? document.ChildElements;
// if there are no temporary results (b/c there was no indexed selector) then use the whole set
interimResult = GetMatches(finalSelectWithin, selector);
}
// Deal with subselectors: has() and not() test for the presence of a selector within the children of
// an element. This is essentially similar to the manual selection above.
if (selectorType.HasFlag(SelectorType.SubSelectorHas) ||
selectorType.HasFlag(SelectorType.SubSelectorNot))
{
bool isHasSelector = selectorType.HasFlag(SelectorType.SubSelectorHas);
IEnumerable <IDomObject> subSelectWithin = interimResult
?? (combinatorType == CombinatorType.Chained ? lastResult : null)
?? selectionSource;
// subselects are a filter. start a new interim result.
HashSet <IDomObject> filteredResults = new HashSet <IDomObject>();
foreach (IDomObject obj in subSelectWithin)
{
bool match = true;
foreach (var sub in selector.SubSelectors)
{
List <IDomObject> listOfOne = new List <IDomObject>();
listOfOne.Add(obj);
bool has = !sub.Select(document, listOfOne).IsNullOrEmpty();
match &= isHasSelector == has;
}
if (match)
{
filteredResults.Add(obj);
}
}
interimResult = filteredResults;
}
tempResult = new HashSet <IDomObject>();
if (lastResult != null)
{
tempResult.AddRange(lastResult);
}
if (interimResult != null)
{
tempResult.AddRange(interimResult);
}
lastResult = tempResult;
}
if (lastResult != null)
{
output.AddRange(lastResult);
}
if (output.IsNullOrEmpty())
{
yield break;
}
else
{
// Selectors always return in DOM order. Selections may end up in a different order but
// we always sort here.
foreach (IDomObject item in output.OrderBy(item => item.Path, StringComparer.Ordinal))
{
yield return(item);
}
}
ActiveSelectors.Clear();
}
private BoundForEachStatement BindForEachPartsWorker(DiagnosticBag diagnostics, Binder originalBinder)
{
BoundExpression collectionExpr = this.Next.BindValue(_syntax.Expression, diagnostics, BindValueKind.RValue); //bind with next to avoid seeing iteration variable
ForEachEnumeratorInfo.Builder builder = new ForEachEnumeratorInfo.Builder();
TypeSymbol inferredType;
bool hasErrors = !GetEnumeratorInfoAndInferCollectionElementType(ref builder, ref collectionExpr, diagnostics, out inferredType);
// These should only occur when special types are missing or malformed.
hasErrors = hasErrors ||
(object)builder.GetEnumeratorMethod == null ||
(object)builder.MoveNextMethod == null ||
(object)builder.CurrentPropertyGetter == null;
// Check for local variable conflicts in the *enclosing* binder; obviously the *current*
// binder has a local that matches!
var hasNameConflicts = this.ValidateDeclarationNameConflictsInScope(IterationVariable, diagnostics);
// If the type in syntax is "var", then the type should be set explicitly so that the
// Type property doesn't fail.
TypeSyntax typeSyntax = _syntax.Type;
bool isVar;
AliasSymbol alias;
TypeSymbol declType = BindType(typeSyntax, diagnostics, out isVar, out alias);
TypeSymbol iterationVariableType;
if (isVar)
{
iterationVariableType = inferredType ?? CreateErrorType("var");
}
else
{
Debug.Assert((object)declType != null);
iterationVariableType = declType;
}
BoundTypeExpression boundIterationVariableType = new BoundTypeExpression(typeSyntax, alias, iterationVariableType);
this.IterationVariable.SetTypeSymbol(iterationVariableType);
BoundStatement body = originalBinder.BindPossibleEmbeddedStatement(_syntax.Statement, diagnostics);
hasErrors = hasErrors || iterationVariableType.IsErrorType();
// Skip the conversion checks and array/enumerator differentiation if we know we have an error (except local name conflicts).
if (hasErrors)
{
return(new BoundForEachStatement(
_syntax,
null, // can't be sure that it's complete
default(Conversion),
boundIterationVariableType,
this.IterationVariable,
collectionExpr,
body,
CheckOverflowAtRuntime,
this.BreakLabel,
this.ContinueLabel,
hasErrors));
}
hasErrors |= hasNameConflicts;
var foreachKeyword = _syntax.ForEachKeyword;
ReportDiagnosticsIfObsolete(diagnostics, builder.GetEnumeratorMethod, foreachKeyword, hasBaseReceiver: false);
ReportDiagnosticsIfObsolete(diagnostics, builder.MoveNextMethod, foreachKeyword, hasBaseReceiver: false);
ReportDiagnosticsIfObsolete(diagnostics, builder.CurrentPropertyGetter, foreachKeyword, hasBaseReceiver: false);
ReportDiagnosticsIfObsolete(diagnostics, builder.CurrentPropertyGetter.AssociatedSymbol, foreachKeyword, hasBaseReceiver: false);
// We want to convert from inferredType in the array/string case and builder.ElementType in the enumerator case,
// but it turns out that these are equivalent (when both are available).
HashSet <DiagnosticInfo> useSiteDiagnostics = null;
Conversion elementConversion = this.Conversions.ClassifyConversionForCast(inferredType, iterationVariableType, ref useSiteDiagnostics);
if (!elementConversion.IsValid)
{
ImmutableArray <MethodSymbol> originalUserDefinedConversions = elementConversion.OriginalUserDefinedConversions;
if (originalUserDefinedConversions.Length > 1)
{
diagnostics.Add(ErrorCode.ERR_AmbigUDConv, _syntax.ForEachKeyword.GetLocation(), originalUserDefinedConversions[0], originalUserDefinedConversions[1], inferredType, iterationVariableType);
}
else
{
SymbolDistinguisher distinguisher = new SymbolDistinguisher(this.Compilation, inferredType, iterationVariableType);
diagnostics.Add(ErrorCode.ERR_NoExplicitConv, _syntax.ForEachKeyword.GetLocation(), distinguisher.First, distinguisher.Second);
}
hasErrors = true;
}
else
{
ReportDiagnosticsIfObsolete(diagnostics, elementConversion, _syntax.ForEachKeyword, hasBaseReceiver: false);
}
// Spec (§8.8.4):
// If the type X of expression is dynamic then there is an implicit conversion from >>expression<< (not the type of the expression)
// to the System.Collections.IEnumerable interface (§6.1.8).
builder.CollectionConversion = this.Conversions.ClassifyConversionFromExpression(collectionExpr, builder.CollectionType, ref useSiteDiagnostics);
builder.CurrentConversion = this.Conversions.ClassifyConversion(builder.CurrentPropertyGetter.ReturnType, builder.ElementType, ref useSiteDiagnostics);
builder.EnumeratorConversion = this.Conversions.ClassifyConversion(builder.GetEnumeratorMethod.ReturnType, GetSpecialType(SpecialType.System_Object, diagnostics, _syntax), ref useSiteDiagnostics);
diagnostics.Add(_syntax.ForEachKeyword.GetLocation(), useSiteDiagnostics);
// Due to the way we extracted the various types, these conversions should always be possible.
// CAVEAT: if we're iterating over an array of pointers, the current conversion will fail since we
// can't convert from object to a pointer type. Similarly, if we're iterating over an array of
// Nullable<Error>, the current conversion will fail because we don't know if an ErrorType is a
// value type. This doesn't matter in practice, since we won't actually use the enumerator pattern
// when we lower the loop.
Debug.Assert(builder.CollectionConversion.IsValid);
Debug.Assert(builder.CurrentConversion.IsValid ||
(builder.ElementType.IsPointerType() && collectionExpr.Type.IsArray()) ||
(builder.ElementType.IsNullableType() && builder.ElementType.GetMemberTypeArgumentsNoUseSiteDiagnostics().Single().IsErrorType() && collectionExpr.Type.IsArray()));
Debug.Assert(builder.EnumeratorConversion.IsValid ||
this.Compilation.GetSpecialType(SpecialType.System_Object).TypeKind == TypeKind.Error ||
!useSiteDiagnostics.IsNullOrEmpty(),
"Conversions to object succeed unless there's a problem with the object type or the source type");
// If user-defined conversions could occur here, we would need to check for ObsoleteAttribute.
Debug.Assert((object)builder.CollectionConversion.Method == null,
"Conversion from collection expression to collection type should not be user-defined");
Debug.Assert((object)builder.CurrentConversion.Method == null,
"Conversion from Current property type to element type should not be user-defined");
Debug.Assert((object)builder.EnumeratorConversion.Method == null,
"Conversion from GetEnumerator return type to System.Object should not be user-defined");
// We're wrapping the collection expression in a (non-synthesized) conversion so that its converted
// type (i.e. builder.CollectionType) will be available in the binding API.
BoundConversion convertedCollectionExpression = new BoundConversion(
collectionExpr.Syntax,
collectionExpr,
builder.CollectionConversion,
CheckOverflowAtRuntime,
false,
ConstantValue.NotAvailable,
builder.CollectionType);
return(new BoundForEachStatement(
_syntax,
builder.Build(this.Flags),
elementConversion,
boundIterationVariableType,
this.IterationVariable,
convertedCollectionExpression,
body,
CheckOverflowAtRuntime,
this.BreakLabel,
this.ContinueLabel,
hasErrors));
}
public void IsNullOrEmpty_EmptyCollectionGiven_ShouldReturnTrue()
{
ICollection <int> input = new HashSet <int>();
Assert.True(input.IsNullOrEmpty());
}
/// <summary>
/// Performs when action executing.
/// </summary>
/// <param name="context"></param>
public override void OnActionExecuting(ActionExecutingContext context)
{
async Task <ActionExecutingContext> RewriteResponseAsync(string message)
{
var validationResponse = new ExceptionResponse
{
Success = false,
Message = message,
StatusCode = MilvaStatusCodes.Status600Exception,
Result = new object(),
ErrorCodes = new List <int>()
};
var json = JsonConvert.SerializeObject(validationResponse);
context.HttpContext.Response.ContentType = "application/json";
context.HttpContext.Items.Add(new KeyValuePair <object, object>("StatusCode", MilvaStatusCodes.Status600Exception));
context.HttpContext.Response.StatusCode = MilvaStatusCodes.Status200OK;
await context.HttpContext.Response.WriteAsync(json).ConfigureAwait(false);
context.Result = new OkResult();
return(context);
};
if (!context.ModelState.IsValid)
{
var httpContext = context.HttpContext;
IEnumerable <ModelError> modelErrors = context.ModelState.Values.SelectMany(v => v.Errors);
var errors = new HashSet <string> {
};
foreach (var item in modelErrors)
{
errors.Add(item.ErrorMessage);
}
var properties = GetProperties(DisabledProperties);
var nestedProperties = GetProperties(DisabledNestedProperties);
if (!nestedProperties.IsNullOrEmpty())
{
foreach (var nestedProp in nestedProperties)
{
var assembly = Assembly.GetAssembly(AssemblyTypeForNestedProps);
var dtoType = assembly?.GetExportedTypes()?.ToList()?.FirstOrDefault(i => i.FullName.Contains(DTOFolderAssemblyName) &&
(i.Name == $"{nestedProp}DTO" ||
i.Name == $"{nestedProp.Remove(nestedProp.Length - 1, 1)}DTO"));
if (dtoType != null)
{
var dtoProps = dtoType.GetProperties().ToList();
dtoProps.RemoveAll(i => i.Name.Contains("Id"));
foreach (var entityProp in dtoProps)
{
if (entityProp.CustomAttributes.Count() != 0)
{
if (httpContext.Items[entityProp.Name] != null)
{
errors.Remove(httpContext.Items[entityProp.Name].ToString());
httpContext.Items.Remove(entityProp.Name);
}
}
}
}
}
}
if (!properties.IsNullOrEmpty())
{
foreach (var prop in properties)
{
if (httpContext.Items[prop] != null)
{
errors.Remove(httpContext.Items[prop].ToString());
httpContext.Items.Remove(prop);
}
}
}
if (!errors.IsNullOrEmpty())
{
base.OnActionExecuting(RewriteResponseAsync(string.Join("~", errors)).Result);
}
}
}
private List <string> joinCurrPicsAndPictureAddresses(List <string> pictureAddresses, List <string> currPcs)
{
if (!currPcs.IsNullOrEmpty())
{
currPcs.Remove(UploadedFile.DefaultBlankPictureLocation());
}
if (!pictureAddresses.IsNullOrEmpty())
{
pictureAddresses.Remove(UploadedFile.DefaultBlankPictureLocation());
}
if (currPcs.IsNullOrEmpty())
{
if (pictureAddresses.IsNullOrEmpty())
{
}
else
{
pictureAddresses = pictureAddresses.Concat(currPcs).ToList();
}
}
else
{
if (pictureAddresses.IsNullOrEmpty())
{
pictureAddresses = currPcs;
}
else
{
//remove currPcs from pictureAddress
//remove duplicates from CurrPic
int returnNoOfPictures = MenuPath1.MaxNumberOfPicturesInMenu() + 1;
currPcs = new HashSet <string>(currPcs).ToList();
if (!currPcs.IsNullOrEmpty())
{
foreach (string currPic in currPcs)
{
pictureAddresses.Remove(currPic);
}
}
if (pictureAddresses.IsNullOrEmpty())
{
return(currPcs);
}
//now currPcs has its own pics
//and picture address has its own
if (currPcs.Count >= returnNoOfPictures)
{
return(currPcs.GetRange(0, returnNoOfPictures));
}
else
{
int noOfPicsRequried = returnNoOfPictures - currPcs.Count;
//if there are more pics in picture address than required....
if (pictureAddresses.Count >= noOfPicsRequried)
{
pictureAddresses = getRandomPictures(pictureAddresses);
pictureAddresses = pictureAddresses.GetRange(0, noOfPicsRequried);
}
pictureAddresses = pictureAddresses.Concat(currPcs).ToList();
pictureAddresses = new HashSet <string>(pictureAddresses).ToList();
}
}
}
return(pictureAddresses);
}
internal static BoundCall GenerateObjectConstructorInitializer(MethodSymbol constructor, DiagnosticBag diagnostics)
{
NamedTypeSymbol objectType = constructor.ContainingType.BaseTypeNoUseSiteDiagnostics;
Debug.Assert(objectType.SpecialType == SpecialType.System_Object);
MethodSymbol objectConstructor = null;
LookupResultKind resultKind = LookupResultKind.Viable;
foreach (MethodSymbol objectCtor in objectType.InstanceConstructors)
{
if (objectCtor.ParameterCount == 0)
{
objectConstructor = objectCtor;
break;
}
}
// UNDONE: If this happens then something is deeply wrong. Should we give a better error?
if ((object)objectConstructor == null)
{
diagnostics.Add(ErrorCode.ERR_BadCtorArgCount, constructor.Locations[0], objectType, /*desired param count*/ 0);
return(null);
}
// UNDONE: If this happens then something is deeply wrong. Should we give a better error?
bool hasErrors = false;
HashSet <DiagnosticInfo> useSiteDiagnostics = null;
if (!AccessCheck.IsSymbolAccessible(objectConstructor, constructor.ContainingType, ref useSiteDiagnostics))
{
diagnostics.Add(ErrorCode.ERR_BadAccess, constructor.Locations[0], objectConstructor);
resultKind = LookupResultKind.Inaccessible;
hasErrors = true;
}
if (!useSiteDiagnostics.IsNullOrEmpty())
{
diagnostics.Add(constructor.Locations.IsEmpty ? NoLocation.Singleton : constructor.Locations[0], useSiteDiagnostics);
}
CSharpSyntaxNode syntax = constructor.GetNonNullSyntaxNode();
BoundExpression receiver = new BoundThisReference(syntax, constructor.ContainingType)
{
WasCompilerGenerated = true
};
return(new BoundCall(
syntax: syntax,
receiverOpt: receiver,
method: objectConstructor,
arguments: ImmutableArray <BoundExpression> .Empty,
argumentNamesOpt: ImmutableArray <string> .Empty,
argumentRefKindsOpt: ImmutableArray <RefKind> .Empty,
isDelegateCall: false,
expanded: false,
invokedAsExtensionMethod: false,
argsToParamsOpt: ImmutableArray <int> .Empty,
resultKind: resultKind,
type: objectType,
hasErrors: hasErrors)
{
WasCompilerGenerated = true
});
}
/// <summary>
/// Select from DOM using index. First non-class/tag/id selector will result in this being passed off to GetMatches
/// </summary>
/// <param name="document"></param>
/// <returns></returns>
public IEnumerable<IDomObject> Select(IDomDocument document, IEnumerable<IDomObject> context)
{
if (Selectors == null )
{
throw new ArgumentException("No selectors provided.");
}
if (Selectors.Count == 0)
{
yield break;
}
Document = document;
IEnumerable<IDomObject> lastResult = null;
HashSet<IDomObject> output = new HashSet<IDomObject>();
IEnumerable<IDomObject> selectionSource = context;
// Disable the index if there is no context (e.g. disconnected elements)
bool useIndex = context.IsNullOrEmpty() || !context.First().IsDisconnected;
// Copy the list because it may change during the process
ActiveSelectors = new List<Selector>(Selectors);
for (activeSelectorId = 0; activeSelectorId < ActiveSelectors.Count; activeSelectorId++)
{
var selector = ActiveSelectors[activeSelectorId];
CombinatorType combinatorType = selector.CombinatorType;
SelectorType selectorType = selector.SelectorType;
TraversalType traversalType = selector.TraversalType;
// Determine what kind of combining method we will use with previous selection results
if (activeSelectorId != 0)
{
switch (combinatorType)
{
case CombinatorType.Cumulative:
// do nothing
break;
case CombinatorType.Root:
selectionSource = context;
if (lastResult != null)
{
output.AddRange(lastResult);
lastResult = null;
}
break;
case CombinatorType.Chained:
selectionSource = lastResult;
lastResult = null;
break;
// default (chained): leave lastresult alone
}
}
HashSet<IDomObject> tempResult = null;
IEnumerable<IDomObject> interimResult = null;
string key = "";
if (useIndex && !selector.NoIndex)
{
#if DEBUG_PATH
if (type.HasFlag(SelectorType.Attribute))
{
key = "!" + selector.AttributeName;
type &= ~SelectorType.Attribute;
if (selector.AttributeValue != null)
{
InsertAttributeValueSelector(selector);
}
}
else if (type.HasFlag(SelectorType.Tag))
{
key = "+"+selector.Tag;
type &= ~SelectorType.Tag;
}
else if (type.HasFlag(SelectorType.ID))
{
key = "#" + selector.ID;
type &= ~SelectorType.ID;
}
else if (type.HasFlag(SelectorType.Class))
{
key = "." + selector.Class;
type &= ~SelectorType.Class;
}
#else
if (selectorType.HasFlag(SelectorType.Attribute))
{
key = "!" + (char)DomData.TokenID(selector.AttributeName);
selectorType &= ~SelectorType.Attribute;
if (selector.AttributeValue != null)
{
InsertAttributeValueSelector(selector);
}
}
else if (selectorType.HasFlag(SelectorType.Tag))
{
key = "+" + (char)DomData.TokenID(selector.Tag, true);
selectorType &= ~SelectorType.Tag;
}
else if (selectorType.HasFlag(SelectorType.ID))
{
key = "#" + (char)DomData.TokenID(selector.ID);
selectorType &= ~SelectorType.ID;
}
else if (selectorType.HasFlag(SelectorType.Class))
{
key = "." + (char)DomData.TokenID(selector.Class);
selectorType &= ~SelectorType.Class;
}
#endif
}
// If part of the selector was indexed, key will not be empty. Return initial set from the
// index. If any selectors remain after this they will be searched the hard way.
if (key != String.Empty)
{
int depth = 0;
bool descendants = true;
switch (traversalType)
{
case TraversalType.Child:
depth = selector.ChildDepth; ;
descendants = false;
break;
case TraversalType.Filter:
depth = 0;
descendants = false;
break;
case TraversalType.Descendent:
depth = 1;
descendants = true;
break;
}
if (selectionSource == null)
{
interimResult = document.QueryIndex(key + DomData.indexSeparator, depth, descendants);
}
else
{
interimResult = new HashSet<IDomObject>();
foreach (IDomObject obj in selectionSource)
{
((HashSet<IDomObject>)interimResult)
.AddRange(document.QueryIndex(key + DomData.indexSeparator + obj.Path,
depth, descendants));
}
}
}
else if (selectorType.HasFlag(SelectorType.Elements))
{
selectorType &= ~SelectorType.Elements;
HashSet<IDomObject> source = new HashSet<IDomObject>(selectionSource);
interimResult = new HashSet<IDomObject>();
foreach (IDomObject obj in selectionSource)
{
key = DomData.indexSeparator + obj.Path;
HashSet<IDomObject> srcKeys = new HashSet<IDomObject>(document.QueryIndex(key));
foreach (IDomObject match in selector.SelectElements)
{
if (srcKeys.Contains(match))
{
((HashSet<IDomObject>)interimResult).Add(match);
}
}
}
}
// TODO - GetMatch should work if passed with no selectors (returning nothing), now it returns everything
// 12/10/11 - this todo is not verified, much has changed since it was written. TODO confirm this and
// fix if needed. If having the conversation with self again, remove comments and forget it. This is
// an example of why comments can do more harm than good.
if ((selectorType & ~(SelectorType.SubSelectorNot | SelectorType.SubSelectorHas)) != 0)
{
IEnumerable<IDomObject> finalSelectWithin =
interimResult
?? (combinatorType == CombinatorType.Chained ? lastResult : null)
?? selectionSource
?? document.ChildElements;
// if there are no temporary results (b/c there was no indexed selector) then use the whole set
interimResult = GetMatches(finalSelectWithin, selector);
}
// Deal with subselectors: has() and not() test for the presence of a selector within the children of
// an element. This is essentially similar to the manual selection above.
if (selectorType.HasFlag(SelectorType.SubSelectorHas)
|| selectorType.HasFlag(SelectorType.SubSelectorNot))
{
bool isHasSelector = selectorType.HasFlag(SelectorType.SubSelectorHas);
IEnumerable<IDomObject> subSelectWithin = interimResult
?? (combinatorType == CombinatorType.Chained ? lastResult : null)
?? selectionSource;
// subselects are a filter. start a new interim result.
HashSet<IDomObject> filteredResults = new HashSet<IDomObject>();
foreach (IDomObject obj in subSelectWithin)
{
bool match = true;
foreach (var sub in selector.SubSelectors)
{
List<IDomObject> listOfOne = new List<IDomObject>();
listOfOne.Add(obj);
bool has = !sub.Select(document, listOfOne).IsNullOrEmpty();
match &= isHasSelector == has;
}
if (match)
{
filteredResults.Add(obj);
}
}
interimResult = filteredResults;
}
tempResult = new HashSet<IDomObject>();
if (lastResult != null)
{
tempResult.AddRange(lastResult);
}
if (interimResult != null)
{
tempResult.AddRange(interimResult);
}
lastResult = tempResult;
}
if (lastResult != null)
{
output.AddRange(lastResult);
}
if (output.IsNullOrEmpty())
{
yield break;
}
else
{
// Selectors always return in DOM order. Selections may end up in a different order but
// we always sort here.
foreach (IDomObject item in output.OrderBy(item => item.Path, StringComparer.Ordinal))
{
yield return item;
}
}
ActiveSelectors.Clear();
}
