Task<IAccessToken> INonCachingAccessTokenProvider.ProvisionAccessTokenAsync(
			ClaimSet claimSet,	
			IEnumerable<Scope> scopes
		) {
			var @this = this as INonCachingAccessTokenProvider;
			return @this.ProvisionAccessTokenAsync( claimSet.ToClaims(), scopes );
		}

 public override IAuthorizationPolicy CreatePolicy(ClaimSet issuer, SamlSecurityTokenAuthenticator samlAuthenticator)
 {
     if (issuer == null)
     {
         throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("issuer");
     }
     if (this.policy == null)
     {
         List<ClaimSet> list = new List<ClaimSet>();
         ClaimSet item = this.subject.ExtractSubjectKeyClaimSet(samlAuthenticator);
         if (item != null)
         {
             list.Add(item);
         }
         List<Claim> claims = new List<Claim>();
         ReadOnlyCollection<Claim> onlys = this.subject.ExtractClaims();
         for (int i = 0; i < onlys.Count; i++)
         {
             claims.Add(onlys[i]);
         }
         this.AddClaimsToList(claims);
         list.Add(new DefaultClaimSet(issuer, claims));
         this.policy = new UnconditionalPolicy(this.subject.Identity, list.AsReadOnly(), System.IdentityModel.SecurityUtils.MaxUtcDateTime);
     }
     return this.policy;
 }

        bool IClaimSetPrincipal.HasRequiredClaims(ClaimSet requiredClaims)
        {
            // if issuer is null, just check claims from anyone
            // if not, check issuer of claims as well

            return true;
        }

        public UnconditionalPolicy(ClaimSet issuance, DateTime expirationTime)
        {
            if (issuance == null)
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("issuance");

            Initialize(ClaimSet.System, issuance, null, expirationTime);
        }

 protected PeerSecurityTraceRecord(string meshId, string remoteAddress, ClaimSet claimSet, Exception exception)
 {
     this.meshId = meshId;
     this.remoteAddress = remoteAddress;
     this.claimSet = claimSet;
     this.exception = exception;
 }

        public override IAuthorizationPolicy CreatePolicy(ClaimSet issuer, SamlSecurityTokenAuthenticator samlAuthenticator)
        {
            if (issuer == null)
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("issuer");

            // SupportingTokenAuthenticator collection can be null when the Subject does not
            // contain a key.

            if (this.policy == null)
            {
                List<ClaimSet> claimSets = new List<ClaimSet>();
                ClaimSet subjectKeyClaimset = this.subject.ExtractSubjectKeyClaimSet(samlAuthenticator);
                if (subjectKeyClaimset != null)
                    claimSets.Add(subjectKeyClaimset);

                List<Claim> claims = new List<Claim>();
                ReadOnlyCollection<Claim> subjectClaims = this.subject.ExtractClaims();
                for (int i = 0; i < subjectClaims.Count; ++i)
                {
                    claims.Add(subjectClaims[i]);
                }

                AddClaimsToList(claims);
                claimSets.Add(new DefaultClaimSet(issuer, claims));
                this.policy = new UnconditionalPolicy(this.subject.Identity, claimSets.AsReadOnly(), SecurityUtils.MaxUtcDateTime);
            }

            return this.policy;
        }

        private void Initialize(ClaimSet issuer, ClaimSet issuance, ReadOnlyCollection<ClaimSet> issuances, DateTime expirationTime)
        {
            _issuer = issuer;
            _issuance = issuance;
            _issuances = issuances;
            _expirationTime = expirationTime;

            // We don't yet support WindowsClaimSet
            //if (issuance != null)
            //{
            //    _disposable = issuance is WindowsClaimSet;
            //}
            //else
            //{
            //    for (int i = 0; i < issuances.Count; ++i)
            //    {
            //        if (issuances[i] is WindowsClaimSet)
            //        {
            //            this.disposable = true;
            //            break;
            //        }
            //    }
            //}

            _disposable = false;
        }

        /// <summary>
        /// Has required claims
        /// </summary>
        /// <param name="requiredClaims">Required claim set</param>
        /// <returns><value>True</value> if the issuer has the required claims <value>false</value> if it doesn't</returns>
        public bool HasRequiredClaims(ClaimSet requiredClaims)
        {
            bool hasClaims = true;
           
            // Make sure we have claims to check
            if (this.Claims == null)
            {
                // Token contained no claims, do we need any?
                if (requiredClaims == null || requiredClaims.Count == 0)
                {
                    return true;
                }
                // Deny access
                return false;
            }

            // check issuer
            bool issuerMatch = requiredClaims.Issuer.Any(c => this.Claims.Issuer.ContainsClaim(c));
            
            // check required claims
            if (issuerMatch)
            {
                hasClaims = requiredClaims.All(c => this.Claims.ContainsClaim(c));
            }

            return issuerMatch && hasClaims;
        }

		async Task<IAccessToken> IAccessTokenProvider.ProvisionAccessTokenAsync(
			ClaimSet claimSet,
			IEnumerable<Scope> scopes,
			ICache cache
    ) {
			var @this = this as IAccessTokenProvider;
			return await @this.ProvisionAccessTokenAsync( claimSet.ToClaims(), scopes, cache ).SafeAsync();
		}

 public CreditCardTokenAuthorizationPolicy(ClaimSet issuedClaims)
 {
     if (issuedClaims == null)
         throw new ArgumentNullException("issuedClaims");
     this.issuer = issuedClaims.Issuer;
     this.issuedClaimSets = new ClaimSet[] { issuedClaims };
     this.id = Guid.NewGuid().ToString();
 }

        public CustomAuthorizationPolicy()
        {
            m_id = Guid.NewGuid();

            Claim c = Claim.CreateNameClaim("http://www.thatindigogirl.com/samples/2006/07/issuer");
            Claim[] claims = new Claim[1];
            claims[0] = c;
            m_issuer = new DefaultClaimSet(claims);
        }

        internal SecurityTokenAuthorizationPolicy( ClaimSet issuedClaims )
        {
            if ( issuedClaims == null )
                throw new ArgumentNullException( "issuedClaims" );

            _issuer = issuedClaims.Issuer;
            _issuedClaimSets = new[] { issuedClaims };
            _id = Guid.NewGuid().ToString();
        }

        public override void AddClaimSet(IAuthorizationPolicy policy, ClaimSet claimSet)
        {
            if (claimSet == null)
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("claimSet");

            if (_claimSets == null)
                _claimSets = new List<ClaimSet>();

            _claimSets.Add(claimSet);
            ++_generation;
        }

 bool TryGetStringClaimValue(ClaimSet claimSet, string claimType, out string claimValue)
 {
     claimValue = null;
     IEnumerable<Claim> matchingClaims = claimSet.FindClaims(claimType, Rights.PossessProperty);
     if (matchingClaims == null)
         return false;
     IEnumerator<Claim> enumerator = matchingClaims.GetEnumerator();
     enumerator.MoveNext();
     claimValue = (enumerator.Current.Resource == null) ? null : enumerator.Current.Resource.ToString();
     return true;
 }

        public UnconditionalPolicy(ClaimSet issuer, ClaimSet issuance, DateTime expirationTime, IList<IIdentity> identities)
        {
            if (issuer == null)
                throw new ArgumentNullException("issuer");
            if (issuance == null)
                throw new ArgumentNullException("issuance");

            this.issuer = issuer;
            this.issuance = issuance;
            this.identities = identities;
            this.expirationTime = expirationTime;
        }

 protected void Initialize(ClaimSet issuer, IList<Claim> claims)
 {
     if (issuer == null)
     {
         throw System.IdentityModel.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("issuer");
     }
     if (claims == null)
     {
         throw System.IdentityModel.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("claims");
     }
     this.issuer = issuer;
     this.claims = claims;
 }

 public override void AddClaimSet(IAuthorizationPolicy policy, ClaimSet claimSet)
 {
     if (claimSet == null)
     {
         throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("claimSet");
     }
     if (this.claimSets == null)
     {
         this.claimSets = new List<ClaimSet>();
     }
     this.claimSets.Add(claimSet);
     this.generation++;
 }

        protected override void LoadClaims(out ClaimSet issuer, out IList<Claim> claims)
        {
            issuer = _issuer;

            claims = new List<Claim>()
            {
                CreateCustomerClaimId(),
                CreateCustomerClaimProp(),
                CreatePurchaseLimitClaim(),
                CreateLastActivityClaim(),
                CreateStatusClaim(),
            };
        }

		public async Task ProvisionAccessTokenAsync_LegacyClaimSetOverload_DoesRightThing() {
			var claimSet = new ClaimSet(
				issuer: TestData.ISSUER,
				tenantId: TestData.TENANT_ID,
				user: TestData.USER
			);

			await m_accessTokenProvider
				.ProvisionAccessTokenAsync( claimSet, new Scope[] { } )
				.SafeAsync();

			AssertClaimEquals( m_actualAssertion, Constants.Claims.ISSUER, TestData.ISSUER );
			AssertClaimEquals( m_actualAssertion, Constants.Claims.TENANT_ID, TestData.TENANT_ID.ToString() );
			AssertClaimEquals( m_actualAssertion, Constants.Claims.USER_ID, TestData.USER );
		}

 private UnconditionalPolicy(UnconditionalPolicy from)
 {
     _disposable = from._disposable;
     _primaryIdentity = from._disposable ? SecurityUtils.CloneIdentityIfNecessary(from._primaryIdentity) : from._primaryIdentity;
     if (from._issuance != null)
     {
         _issuance = from._disposable ? SecurityUtils.CloneClaimSetIfNecessary(from._issuance) : from._issuance;
     }
     else
     {
         _issuances = from._disposable ? SecurityUtils.CloneClaimSetsIfNecessary(from._issuances) : from._issuances;
     }
     _issuer = from._issuer;
     _expirationTime = from._expirationTime;
 }