public void Parsing_Of_Sc_Query_Output()
{
string output = Resources.ScQueryOutput;
HashSet<ServiceItem> expected = new HashSet<ServiceItem>
{
new ServiceItem
{
ServiceName = "TermService",
DisplayName = "Terminal Services"
},
new ServiceItem
{
ServiceName = "Themes",
DisplayName = "Themes"
},
new ServiceItem
{
ServiceName = "UNS",
DisplayName = "Intel(R) Management and Security Application User Notification Service"
}
};
HashSet<ServiceItem> actual = ServiceHelper_Accessor.ParseServicesOutput(output);
Assert.IsTrue(expected.IsSubsetOf(actual));
Assert.IsTrue(expected.IsSupersetOf(actual));
}
public bool IsScopeSatisfied(HashSet<string> requiredScope, HashSet<string> grantedScope)
{
if (requiredScope.IsSubsetOf(grantedScope))
{
return true;
}
return false;
}
protected Expression Compare(BinaryExpression bop)
{
var e1 = this.SkipConvert(bop.Left);
var e2 = this.SkipConvert(bop.Right);
EntityExpression entity1 = e1 as EntityExpression;
EntityExpression entity2 = e2 as EntityExpression;
if (entity1 == null && e1 is OuterJoinedExpression)
{
entity1 = ((OuterJoinedExpression)e1).Expression as EntityExpression;
}
if (entity2 == null && e2 is OuterJoinedExpression)
{
entity2 = ((OuterJoinedExpression)e2).Expression as EntityExpression;
}
bool negate = bop.NodeType == ExpressionType.NotEqual;
if (entity1 != null)
{
return this.MakePredicate(e1, e2, entity1.Entity.PrimaryKeys.Select(p => p.Member), negate);
}
else if (entity2 != null)
{
return this.MakePredicate(e1, e2, entity2.Entity.PrimaryKeys.Select(p => p.Member), negate);
}
var dm1 = this.GetDefinedMembers(e1);
var dm2 = this.GetDefinedMembers(e2);
if (dm1 == null && dm2 == null)
{
// neither are constructed types
return bop;
}
if (dm1 != null && dm2 != null)
{
// both are constructed types, so they'd better have the same members declared
HashSet<string> names1 = new HashSet<string>(dm1.Select(m => m.Name), StringComparer.Ordinal);
HashSet<string> names2 = new HashSet<string>(dm2.Select(m => m.Name), StringComparer.Ordinal);
if (names1.IsSubsetOf(names2) && names2.IsSubsetOf(names1))
{
return MakePredicate(e1, e2, dm1, negate);
}
}
else if (dm1 != null)
{
return MakePredicate(e1, e2, dm1, negate);
}
else if (dm2 != null)
{
return MakePredicate(e1, e2, dm2, negate);
}
throw new InvalidOperationException(Res.InvalidOperationCompareException);
}
public void DispatchPreservesAllRouteValues(
DefaultRouteDispatcher sut,
MethodCallExpression method,
IDictionary<string, object> routeValues)
{
var actual = sut.Dispatch(method, routeValues);
var expected = new HashSet<KeyValuePair<string, object>>(routeValues);
Assert.True(expected.IsSubsetOf(actual.RouteValues));
}
static bool IsGroupTagsUnique(List<CityPack> cities, HashSet<string> tags)
{
foreach (CityPack pack in cities)
{
if (tags.IsSubsetOf(pack.cities) && !tags.IsProperSubsetOf(pack.cities))
{
return false;
}
}
return true;
}
static void Main()
{
var companyTeams =
new HashSet<string>(){ "Ferrari", "McLaren", "Mersedes" };
var traditionalTeams =
new HashSet<string>() { "Ferrari", "McLaren" };
var privateTeams =
new HashSet<string>() { "Red Bull", "Lotus", "Toro Rosso", "Force India", "Sauber" };
if (traditionalTeams.IsSubsetOf(companyTeams))
{
Console.WriteLine("tradTeam is subset of company Teams");
}
}
/// <summary>
/// Determines whether one given scope is a subset of another scope.
/// </summary>
/// <param name="requestedScope">The requested scope, which may be a subset of <paramref name="grantedScope"/>.</param>
/// <param name="grantedScope">The granted scope, the suspected superset.</param>
/// <returns>
/// <c>true</c> if all the elements that appear in <paramref name="requestedScope"/> also appear in <paramref name="grantedScope"/>;
/// <c>false</c> otherwise.
/// </returns>
public static bool IsScopeSubset(string requestedScope, string grantedScope) {
if (string.IsNullOrEmpty(requestedScope)) {
return true;
}
if (string.IsNullOrEmpty(grantedScope)) {
return false;
}
var requestedScopes = new HashSet<string>(requestedScope.Split(scopeDelimiter, StringSplitOptions.RemoveEmptyEntries));
var grantedScopes = new HashSet<string>(grantedScope.Split(scopeDelimiter, StringSplitOptions.RemoveEmptyEntries));
return requestedScopes.IsSubsetOf(grantedScopes);
}
/// <summary>
/// Gets the instance of the created command object.
/// </summary>
/// <param name="tokens">Command line arguments to initialize command with.</param>
/// <exception cref="Exception{OptionsValidationExceptionArgs}">
/// Indicates that at least one required option was not specified.
/// </exception>
internal object CreateInstance(IDictionary<string, OptionValue> tokens)
{
HashSet<string> availableOptions =
new HashSet<string>(tokens.Select(t => t.Key.ToLowerInvariant()));
OptionMetadata[] targetMetadata = null;
// Find options set that matches our tokens collection.
foreach (var usage in _metadata.Options)
{
HashSet<string> requiredOptions =
new HashSet<string>(usage.Where(o => o.Required).Select(o => o.Name.ToLowerInvariant()));
HashSet<string> allOptions =
new HashSet<string>(usage.Select(o => o.Name.ToLowerInvariant()));
if (requiredOptions.IsSubsetOf(availableOptions) &&
allOptions.IsSupersetOf(availableOptions))
{
targetMetadata = usage;
break;
}
}
if (null == targetMetadata)
{
var args = new OptionsValidationExceptionArgs("Invalid command arguments provided.");
throw new Exception<OptionsValidationExceptionArgs>(args);
}
try
{
return CreateInstanceInternal(targetMetadata, tokens);
}
catch (TargetInvocationException ex)
{
var argumentError = ex.InnerException as ArgumentException;
if (null == argumentError)
throw;
string msg = string.Format("Invalid value for option '{0}'. {1}",
argumentError.ParamName,
argumentError.Message);
var args = new OptionsValidationExceptionArgs(msg);
throw new Exception<OptionsValidationExceptionArgs>(args);
}
catch (MissingMethodException)
{
var args = new OptionsValidationExceptionArgs("Invalid command arguments provided.");
throw new Exception<OptionsValidationExceptionArgs>(args);
}
}
static void Main()
{
var companyTeams = new HashSet<string>() { "Ferrari", "McLaren", "Mercedes" };
var traditionalTeams = new HashSet<string>() { "Ferrari", "McLaren" };
var privateTeams = new HashSet<string>() { "Red Bull", "Lotus", "Toro Rosso", "Force India", "Sauber" };
if (privateTeams.Add("Williams"))
WriteLine("Williams added");
if (!companyTeams.Add("McLaren"))
WriteLine("McLaren was already in this set");
if (traditionalTeams.IsSubsetOf(companyTeams))
{
WriteLine("traditionalTeams is subset of companyTeams");
}
if (companyTeams.IsSupersetOf(traditionalTeams))
{
WriteLine("companyTeams is a superset of traditionalTeams");
}
traditionalTeams.Add("Williams");
if (privateTeams.Overlaps(traditionalTeams))
{
WriteLine("At least one team is the same with traditional and private teams");
}
var allTeams = new SortedSet<string>(companyTeams);
allTeams.UnionWith(privateTeams);
allTeams.UnionWith(traditionalTeams);
WriteLine();
WriteLine("all teams");
foreach (var team in allTeams)
{
WriteLine(team);
}
allTeams.ExceptWith(privateTeams);
WriteLine();
WriteLine("no private team left");
foreach (var team in allTeams)
{
WriteLine(team);
}
}
public void TestSubSetSuperSet ()
{
var aSet = new HashSet<int> { 1, 2 };
var bSet = new HashSet<int> { 1 };
Assert.IsTrue (aSet.IsSubsetOf (aSet));
Assert.IsTrue (bSet.IsSubsetOf (aSet));
Assert.IsTrue (bSet.IsProperSubsetOf (aSet));
Assert.IsFalse (aSet.IsProperSubsetOf (aSet));
Assert.IsTrue (aSet.IsSupersetOf (aSet));
Assert.IsTrue (aSet.IsSupersetOf (bSet));
Assert.IsTrue (aSet.IsProperSupersetOf (bSet));
Assert.IsFalse (aSet.IsProperSupersetOf (aSet));
}
protected Expression Compare(BinaryExpression bop)
{
var e1 = this.SkipConvert(bop.Left);
var e2 = this.SkipConvert(bop.Right);
EntityExpression entity1 = e1 as EntityExpression;
EntityExpression entity2 = e2 as EntityExpression;
bool negate = bop.NodeType == ExpressionType.NotEqual;
if (entity1 != null)
{
return this.MakePredicate(e1, e2, this.mapping.GetPrimaryKeyMembers(entity1.Entity), negate);
}
else if (entity2 != null)
{
return this.MakePredicate(e1, e2, this.mapping.GetPrimaryKeyMembers(entity2.Entity), negate);
}
var dm1 = this.GetDefinedMembers(e1);
var dm2 = this.GetDefinedMembers(e2);
if (dm1 == null && dm2 == null)
{
// neither are constructed types
return bop;
}
if (dm1 != null && dm2 != null)
{
// both are constructed types, so they'd better have the same members declared
HashSet<string> names1 = new HashSet<string>(dm1.Select(m => m.Name));
HashSet<string> names2 = new HashSet<string>(dm2.Select(m => m.Name));
if (names1.IsSubsetOf(names2) && names2.IsSubsetOf(names1))
{
return MakePredicate(e1, e2, dm1, negate);
}
}
else if (dm1 != null)
{
return MakePredicate(e1, e2, dm1, negate);
}
else if (dm2 != null)
{
return MakePredicate(e1, e2, dm2, negate);
}
throw new InvalidOperationException("Cannot compare two constructed types with different sets of members assigned.");
}
public bool Equals(AlternationRegExp alternationRegExp)
{
if (!base.Equals(alternationRegExp)) return false;
if (alternationRegExp.ChildExpressions.Length != ChildExpressions.Length) return false;
// The easiest way to check whether two arrays has same regular axpressions is to construct HaashSets and check
// if the sets are equal. Remember, the order is not important!
var hashSetForThis = new HashSet<RegExp>(ChildExpressions);
var hashSetForOther = new HashSet<RegExp>(alternationRegExp.ChildExpressions);
if (hashSetForOther.IsSubsetOf(hashSetForThis) && hashSetForThis.IsSubsetOf(hashSetForOther))
{
return true;
}
return false;
}
public static void Cozy()
{
Console.WriteLine("\n-----------------------------------------------");
Console.WriteLine(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.FullName);
Console.WriteLine("-----------------------------------------------");
//HashSet<T>和List<T>差不多的，但HashSet<T>只能包含不重复的元素
var hashSet = new HashSet<int>();
//Add()会返回一个bool值,添加成功返回true,集合内有相同的元素，则添加失败返回false
Console.WriteLine(hashSet.Add(1)); //output True
Console.WriteLine(hashSet.Add(1)); //output False
Console.WriteLine(hashSet.Add(2));
Console.WriteLine(hashSet.Add(3));
var array = new[] {1, 2, 3, 4, 5};
Console.WriteLine(hashSet.IsSubsetOf(array)); //output True
Console.WriteLine(hashSet.IsSupersetOf(array)); //output False
//增加array集合的元素
hashSet.UnionWith(array);
foreach (var i in hashSet)
{
Console.WriteLine(i);
}
//移除array集合的元素
hashSet.ExceptWith(array);
foreach (var i in hashSet)
{
Console.WriteLine(i);
}
}
protected void ShouldContain(ISet<ISet<Fault>> sets, params Fault[] faults)
{
foreach (var set in sets)
{
var faultSet = new HashSet<Fault>(faults);
if (set.IsSubsetOf(faultSet) && faultSet.IsSubsetOf(set))
return;
}
throw new TestException("Fault set is not contained in set.");
}
protected Expression Compare(BinaryExpression bop)
{
var e1 = this.SkipConvert(bop.Left);
var e2 = this.SkipConvert(bop.Right);
OuterJoinedExpression oj1 = e1 as OuterJoinedExpression;
OuterJoinedExpression oj2 = e2 as OuterJoinedExpression;
EntityExpression entity1 = oj1 != null ? oj1.Expression as EntityExpression : e1 as EntityExpression;
EntityExpression entity2 = oj2 != null ? oj2.Expression as EntityExpression : e2 as EntityExpression;
bool negate = bop.NodeType == ExpressionType.NotEqual;
// check for outer-joined entity comparing against null. These are special because outer joins have
// a test expression specifically desgined to be tested against null to determine if the joined side exists.
if (oj1 != null && e2.NodeType == ExpressionType.Constant && ((ConstantExpression)e2).Value == null)
{
return MakeIsNull(oj1.Test, negate);
}
else if (oj2 != null && e1.NodeType == ExpressionType.Constant && ((ConstantExpression)e1).Value == null)
{
return MakeIsNull(oj2.Test, negate);
}
// if either side is an entity construction expression then compare using its primary key members
if (entity1 != null)
{
return this.MakePredicate(e1, e2, this.mapping.GetPrimaryKeyMembers(entity1.Entity), negate);
}
else if (entity2 != null)
{
return this.MakePredicate(e1, e2, this.mapping.GetPrimaryKeyMembers(entity2.Entity), negate);
}
// check for comparison of user constructed type projections
var dm1 = this.GetDefinedMembers(e1);
var dm2 = this.GetDefinedMembers(e2);
if (dm1 == null && dm2 == null)
{
// neither are constructed types
return bop;
}
if (dm1 != null && dm2 != null)
{
// both are constructed types, so they'd better have the same members declared
HashSet<string> names1 = new HashSet<string>(dm1.Select(m => m.Name));
HashSet<string> names2 = new HashSet<string>(dm2.Select(m => m.Name));
if (names1.IsSubsetOf(names2) && names2.IsSubsetOf(names1))
{
return MakePredicate(e1, e2, dm1, negate);
}
}
else if (dm1 != null)
{
return MakePredicate(e1, e2, dm1, negate);
}
else if (dm2 != null)
{
return MakePredicate(e1, e2, dm2, negate);
}
throw new InvalidOperationException("Cannot compare two constructed types with different sets of members assigned.");
}
public bool CheckIsRefinement(ModuleDecl derived, ModuleFacadeDecl original)
{
// Check explicit refinement
// TODO syntactic analysis of export sets is not quite right
var derivedPointer = derived.Signature.ModuleDef;
while (derivedPointer != null) {
if (derivedPointer == original.OriginalSignature.ModuleDef) {
HashSet<string> exports;
if (derived is AliasModuleDecl) {
exports = new HashSet<string>(((AliasModuleDecl)derived).Exports.ConvertAll(t => t.val));
} else if (derived is ModuleFacadeDecl) {
exports = new HashSet<string>(((ModuleFacadeDecl)derived).Exports.ConvertAll(t => t.val));
} else {
reporter.Error(MessageSource.RefinementTransformer, derived, "a module ({0}) can only be refined by an alias module or a module facade", original.Name);
return false;
}
var oexports = new HashSet<string>(original.Exports.ConvertAll(t => t.val));
return oexports.IsSubsetOf(exports);
}
derivedPointer = derivedPointer.RefinementBase;
}
return false;
}
public static bool IsQualifiedSubset(QualifiedSubset subsetToTest, AccessStructure miniamlAccess)
{
foreach (var qualifiedSet in miniamlAccess.Accesses)
{
if (!(qualifiedSet is QualifiedSubset)) continue;
HashSet<int> a = new HashSet<int>(subsetToTest.Parties.Select(x => x.GetPartyId()));
var qs = (QualifiedSubset)qualifiedSet;
HashSet<int> b = new HashSet<int>(qs.Parties.Select(x => x.GetPartyId()));
if (b.IsProperSubsetOf(a) || b.IsSubsetOf(a)) return true;
}
return false;
}
public override bool IsRelationshipSource(MappingEntity entity, MemberInfo member)
{
if (IsAssociationRelationship(entity, member))
{
if (typeof(IEnumerable).IsAssignableFrom(TypeHelper.GetMemberType(member)))
{
return false;
}
// is source of relationship if relatedKeyMembers are the related entity's primary keys
MappingEntity entity2 = GetRelatedEntity(entity, member);
var relatedPKs = new HashSet<string>(this.GetPrimaryKeyMembers(entity2).Select(m => m.Name));
var relatedKeyMembers = new HashSet<string>(
this.GetAssociationRelatedKeyMembers(entity, member).Select(m => m.Name));
return relatedPKs.IsSubsetOf(relatedKeyMembers) && relatedKeyMembers.IsSubsetOf(relatedPKs);
}
return false;
}
void TestRetrieval(int offset, int length)
{
HashSet<TestTextSegment> actual = new HashSet<TestTextSegment>(tree.FindOverlappingSegments(offset, length));
HashSet<TestTextSegment> expected = new HashSet<TestTextSegment>();
foreach (TestTextSegment e in expectedSegments) {
if (e.ExpectedOffset + e.ExpectedLength < offset)
continue;
if (e.ExpectedOffset > offset + length)
continue;
expected.Add(e);
}
Assert.IsTrue(actual.IsSubsetOf(expected));
Assert.IsTrue(expected.IsSubsetOf(actual));
}
/// <summary>
/// Check if the requested scope is valid.
/// </summary>
/// <param name="requestedScope">The scope the user has requested.</param>
/// <param name="authorizedScope">The scope the user is authorized for.</param>
/// <returns><c>true</c>, if the user is authorized for the specified scope; otherwise, <c>false</c>.</returns>
private static bool RequestedScopeIsValid(HashSet<string> requestedScope, HashSet<string> authorizedScope)
{
// Check if the requested scope is a subset of the authorized scope.
// If not, that means that the user has requested at least one scope it is not authorized for
return requestedScope.IsSubsetOf(authorizedScope);
}
// insert new join closest to the aliases it depends on
private bool IsOuterDependent(bool isOuterDependent, SqlSource location, HashSet<SqlAlias> consumed, out HashSet<SqlAlias> produced)
{
if (location.NodeType == SqlNodeType.Join)
{
// walk down join tree looking for best location for join
SqlJoin join = (SqlJoin)location;
if (this.IsOuterDependent(isOuterDependent, join.Left, consumed, out produced))
return true;
HashSet<SqlAlias> rightProduced;
bool rightIsOuterDependent = join.JoinType == SqlJoinType.LeftOuter || join.JoinType == SqlJoinType.OuterApply;
if (this.IsOuterDependent(rightIsOuterDependent, join.Right, consumed, out rightProduced))
return true;
produced.UnionWith(rightProduced);
}
else
{
SqlAlias a = location as SqlAlias;
if (a != null)
{
SqlSelect s = a.Node as SqlSelect;
if (s != null && !isOuterDependent && s.From != null)
{
if (this.IsOuterDependent(false, s.From, consumed, out produced))
return true;
}
}
produced = SqlGatherProducedAliases.Gather(location);
}
// look to see if this subtree fully satisfies join condition
if (consumed.IsSubsetOf(produced))
{
return isOuterDependent;
}
return false;
}
public void AddNewFolder() {
using (var app = new VisualStudioApp()) {
var project = app.OpenProject(@"TestData\NodejsProjectData\HelloWorld.sln");
using (new NodejsOptionHolder(NodejsPackage.Instance.GeneralOptionsPage, "ShowBrowserAndNodeLabels", false)) {
var window = app.OpenSolutionExplorer();
// find server.js, send copy & paste, verify copy of file is there
var projectNode = window.WaitForItem("Solution 'HelloWorld' (1 project)", "HelloWorld");
AutomationWrapper.Select(projectNode);
var startingDirs = new HashSet<string>(Directory.GetDirectories(@"TestData\NodejsProjectData\HelloWorld"), StringComparer.OrdinalIgnoreCase);
Keyboard.PressAndRelease(Key.F10, Key.LeftCtrl, Key.LeftShift);
Keyboard.PressAndRelease(Key.D);
Keyboard.PressAndRelease(Key.Right);
Keyboard.PressAndRelease(Key.D);
Keyboard.Type("MyNewFolder");
var curDirs = new HashSet<string>(Directory.GetDirectories(@"TestData\NodejsProjectData\HelloWorld"), StringComparer.OrdinalIgnoreCase);
Assert.IsTrue(curDirs.IsSubsetOf(startingDirs) && startingDirs.IsSubsetOf(curDirs), "new directory created" + String.Join(", ", curDirs) + " vs. " + String.Join(", ", startingDirs));
Keyboard.PressAndRelease(Key.Enter);
Assert.AreNotEqual(null, window.WaitForItem("Solution 'HelloWorld' (1 project)", "HelloWorld", "MyNewFolder"));
Assert.IsTrue(Directory.Exists(@"TestData\NodejsProjectData\HelloWorld\MyNewFolder"));
}
}
}
private bool IsAuthorizationValid(HashSet<string> requestedScopes, string clientIdentifier, DateTime issuedUtc, string username) {
// If db precision exceeds token time precision (which is common), the following query would
// often disregard a token that is minted immediately after the authorization record is stored in the db.
// To compensate for this, we'll increase the timestamp on the token's issue date by 1 second.
issuedUtc += TimeSpan.FromSeconds(1);
var grantedScopeStrings = from auth in MvcApplication.DataContext.ClientAuthorizations
where
auth.Client.ClientIdentifier == clientIdentifier &&
auth.CreatedOnUtc <= issuedUtc &&
(!auth.ExpirationDateUtc.HasValue || auth.ExpirationDateUtc.Value >= DateTime.UtcNow) &&
auth.User.OpenIDClaimedIdentifier == username
select auth.Scope;
if (!grantedScopeStrings.Any()) {
// No granted authorizations prior to the issuance of this token, so it must have been revoked.
// Even if later authorizations restore this client's ability to call in, we can't allow
// access tokens issued before the re-authorization because the revoked authorization should
// effectively and permanently revoke all access and refresh tokens.
return false;
}
var grantedScopes = new HashSet<string>(OAuthUtilities.ScopeStringComparer);
foreach (string scope in grantedScopeStrings) {
grantedScopes.UnionWith(OAuthUtilities.SplitScopes(scope));
}
return requestedScopes.IsSubsetOf(grantedScopes);
}
public Episode[] GetShowEpisode(string originalShowName, int season, int episode, CancellationToken token)
{
var episodes = new List<Episode>();
var list = GetShows(token);
var showWords = FileData.GetWordset(originalShowName).ToList();
var showName = string.Join(" ", showWords);
Show exactShow = null;
if (this.CustomMappings.Contains(showName))
{
var custom = this.CustomMappings[showName];
exactShow =
list.FirstOrDefault(s => s.Title.Equals(custom.ShowName, StringComparison.CurrentCultureIgnoreCase));
}
if (exactShow == null)
{
exactShow = list.FirstOrDefault(s => s.NormalizedTitle.Equals(showName)) ??
list.FirstOrDefault(
s => s.Directory.Equals(showName, StringComparison.CurrentCultureIgnoreCase)) ??
list.FirstOrDefault(
s => s.Title.Equals(showName, StringComparison.CurrentCultureIgnoreCase));
}
if (exactShow == null)
{
var ss = new HashSet<string>(showWords);
foreach (var sh in list.Where(s => ss.IsSubsetOf(s.ExtendedWordset)))
{
Episode ep;
if (!sh.TryGetEpisode(token, season, episode, out ep))
{
ep = new Episode(sh.Title, season.ToString(CultureInfo.InvariantCulture),
episode.ToString(CultureInfo.InvariantCulture), "", false);
}
episodes.Add(ep);
}
}
else
{
Episode episodeItem;
if (exactShow.TryGetEpisode(token, season, episode, out episodeItem))
{
episodes.Add(episodeItem);
}
}
return episodes.ToArray();
}
public bool HasPermissions(params string[] permissions)
{
if (this.Permissions.Contains("*") ||
(permissions.Length == 1 && permissions[0] == "*"))
{
return true;
}
if (permissions.Length == 0 ||
(permissions.Length == 1 && string.IsNullOrEmpty(permissions[0])))
{
return false;
}
HashSet<string> perms = new HashSet<string>(permissions);
return perms.IsSubsetOf(this.Permissions);
}
private bool IsAuthorizationValid(HashSet<string> requestedScopes, string clientIdentifier, DateTime issuedUtc, string username) {
var grantedScopeStrings = from auth in Database.DataContext.ClientAuthorizations
where
auth.Client.ClientIdentifier == clientIdentifier &&
auth.CreatedOnUtc <= issuedUtc &&
(!auth.ExpirationDateUtc.HasValue || auth.ExpirationDateUtc.Value >= DateTime.UtcNow) &&
auth.User.AuthenticationTokens.Any(token => token.ClaimedIdentifier == username)
select auth.Scope;
if (!grantedScopeStrings.Any()) {
// No granted authorizations prior to the issuance of this token, so it must have been revoked.
// Even if later authorizations restore this client's ability to call in, we can't allow
// access tokens issued before the re-authorization because the revoked authorization should
// effectively and permanently revoke all access and refresh tokens.
return false;
}
var grantedScopes = new HashSet<string>(OAuthUtilities.ScopeStringComparer);
foreach (string scope in grantedScopeStrings) {
grantedScopes.UnionWith(OAuthUtilities.SplitScopes(scope));
}
return requestedScopes.IsSubsetOf(grantedScopes);
}
/// <summary>
/// Checks the supplied Commandline Arguments for valid switches
/// </summary>
/// <param name="CommandArgs">String Array of arguments</param>
public static bool ValidArgs(string[] CommandArgs)
{
HashSet<string> possibleArgs = new HashSet<string> { "-D", "-W", "-A", "-Q" };
HashSet<string> passedArgs = new HashSet<string>();
foreach (string str in CommandArgs)
{
passedArgs.Add(str);
}
bool isSubset = !passedArgs.IsSubsetOf(possibleArgs);
return true;
}
public override bool IsRelationshipTarget(MappingEntity entity, MemberInfo member)
{
if (IsAssociationRelationship(entity, member))
{
if (typeof(IEnumerable).IsAssignableFrom(TypeHelper.GetMemberType(member)))
{
return true;
}
// is target of relationship if the assoctions keys are the same as this entities primary key
var pks = new HashSet<string>(this.GetPrimaryKeyMembers(entity).Select(m => m.Name));
var keys = new HashSet<string>(this.GetAssociationKeyMembers(entity, member).Select(m => m.Name));
return keys.IsSubsetOf(pks) && pks.IsSubsetOf(keys);
}
return false;
}
/// <summary>
/// 尝试从路由值创建虚拟路径
/// </summary>
/// <param name="requestContext">当前请求上下文</param>
/// <param name="values">路由值</param>
/// <returns>虚拟路径信息</returns>
public override VirtualPathData GetVirtualPath( RequestContext requestContext, RouteValueDictionary values )
{
var cache = requestContext.HttpContext.Cache;
var _values = values.ToDictionary( pair => pair.Key, pair => pair.Value == null ? null : pair.Value.ToString(), StringComparer.OrdinalIgnoreCase );
var cacheKey = CreateCacheKey( _values );
var virtualPath = cache.Get( cacheKey ) as string;
if ( virtualPath != null )
return new VirtualPathData( this, virtualPath );
var keySet = new HashSet<string>( _values.Keys, StringComparer.OrdinalIgnoreCase );
var candidateRules = _rules
.Where( r => !r.Oneway ) //不是单向路由规则
.Where( r => keySet.IsSupersetOf( r.RouteKeys ) ) //所有路由键都必须匹配
.Where( r => keySet.IsSubsetOf( r.AllKeys ) || !r.LimitedQueries ) //所有路由键和查询字符串键必须能涵盖要设置的键。
.Where( r => r.IsMatch( _values ) ) //必须满足路由规则所定义的路由数据。
.ToArray();
if ( !candidateRules.Any() )
return null;
var bestRule = BestRule( candidateRules );
virtualPath = bestRule.CreateVirtualPath( _values );
if ( MvcCompatible )
virtualPath = virtualPath.Substring( 2 );
cache.Insert( cacheKey, virtualPath, CacheItemPriority.AboveNormal );
var data = new VirtualPathData( this, virtualPath );
foreach ( var pair in bestRule.DataTokens )
data.DataTokens.Add( pair.Key, pair.Value );
data.DataTokens["RoutingRuleName"] = bestRule.Name;
return data;
}
private void ComputeClosure(IGrammar grammar, HashSet<GeneratorStateItem> items)
{
// Continue to loop until new more elements are added to the state.
//
bool stateModified = true;
while (stateModified)
{
HashSet<GeneratorStateItem> newItems = new HashSet<GeneratorStateItem>();
// Iterate over the current elements in the state and determine (possible) new
// elements to be added.
//
foreach (GeneratorStateItem item in items)
{
LanguageElementType languageElement = item.RuleItem.DotElement;
if (languageElement != null
&& languageElement.ElementType == LanguageElementTypes.Nonterminal)
{
NonterminalType nonterminal = (NonterminalType)languageElement;
foreach (RuleType rule in nonterminal.Rules)
{
GeneratorStateItem newItem = new GeneratorStateItem(new GeneratorRuleItem(rule, 0));
newItems.Add(newItem);
}
}
}
// Exit loop if all potential new elements already exist in state. Otherwise, add new elements
// and repeat process.
//
if (newItems.IsSubsetOf(items))
{
stateModified = false;
}
else
{
items.UnionWith(newItems);
}
}
}
