public override IPermission Intersect(IPermission target)
{
StorePermission dp = Cast(target);
if (dp == null)
{
return(null);
}
if (this.IsUnrestricted() && dp.IsUnrestricted())
{
return(new StorePermission(PermissionState.Unrestricted));
}
if (this.IsUnrestricted())
{
return(dp.Copy());
}
if (dp.IsUnrestricted())
{
return(this.Copy());
}
StorePermissionFlags spf = _flags & dp._flags;
if (spf == StorePermissionFlags.NoFlags)
{
return(null);
}
return(new StorePermission(spf));
}
internal static void VerifyFlags(StorePermissionFlags flags)
{
if ((flags & ~StorePermissionFlags.AllFlags) != StorePermissionFlags.NoFlags)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, SR.GetString("Arg_EnumIllegalVal"), new object[] { (int)flags }));
}
}
public override void FromXml(SecurityElement securityElement)
{
if (securityElement == null)
{
throw new ArgumentNullException("securityElement");
}
string str = securityElement.Attribute("class");
if ((str == null) || (str.IndexOf(base.GetType().FullName, StringComparison.Ordinal) == -1))
{
throw new ArgumentException(SR.GetString("Argument_InvalidClassAttribute"), "securityElement");
}
string strA = securityElement.Attribute("Unrestricted");
if ((strA != null) && (string.Compare(strA, "true", StringComparison.OrdinalIgnoreCase) == 0))
{
this.m_flags = StorePermissionFlags.AllFlags;
}
else
{
this.m_flags = StorePermissionFlags.NoFlags;
string str3 = securityElement.Attribute("Flags");
if (str3 != null)
{
StorePermissionFlags flags = (StorePermissionFlags) Enum.Parse(typeof(StorePermissionFlags), str3);
VerifyFlags(flags);
this.m_flags = flags;
}
}
}
public StorePermission (PermissionState state)
{
if (PermissionHelper.CheckPermissionState (state, true) == PermissionState.Unrestricted)
_flags = StorePermissionFlags.AllFlags;
else
_flags = StorePermissionFlags.NoFlags;
}
internal static void VerifyFlags(StorePermissionFlags flags)
{
if ((flags & ~StorePermissionFlags.AllFlags) != 0)
{
throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, SR.GetString(SR.Arg_EnumIllegalVal), (int)flags));
}
}
public override void FromXml(SecurityElement securityElement)
{
if (securityElement == null)
{
throw new ArgumentNullException("securityElement");
}
string className = securityElement.Attribute("class");
if (className == null || className.IndexOf(this.GetType().FullName, StringComparison.Ordinal) == -1)
{
throw new ArgumentException(SR.GetString(SR.Argument_InvalidClassAttribute), "securityElement");
}
string unrestricted = securityElement.Attribute("Unrestricted");
if (unrestricted != null && String.Compare(unrestricted, "true", StringComparison.OrdinalIgnoreCase) == 0)
{
m_flags = StorePermissionFlags.AllFlags;
return;
}
m_flags = StorePermissionFlags.NoFlags;
String strFlags = securityElement.Attribute("Flags");
if (strFlags != null)
{
StorePermissionFlags flags = (StorePermissionFlags)Enum.Parse(typeof(StorePermissionFlags), strFlags);
VerifyFlags(flags);
m_flags = flags;
}
}
public override void FromXml(SecurityElement securityElement)
{
if (securityElement == null)
{
throw new ArgumentNullException("securityElement");
}
string str = securityElement.Attribute("class");
if ((str == null) || (str.IndexOf(base.GetType().FullName, StringComparison.Ordinal) == -1))
{
throw new ArgumentException(SR.GetString("Argument_InvalidClassAttribute"), "securityElement");
}
string strA = securityElement.Attribute("Unrestricted");
if ((strA != null) && (string.Compare(strA, "true", StringComparison.OrdinalIgnoreCase) == 0))
{
this.m_flags = StorePermissionFlags.AllFlags;
}
else
{
this.m_flags = StorePermissionFlags.NoFlags;
string str3 = securityElement.Attribute("Flags");
if (str3 != null)
{
StorePermissionFlags flags = (StorePermissionFlags)Enum.Parse(typeof(StorePermissionFlags), str3);
VerifyFlags(flags);
this.m_flags = flags;
}
}
}
public StorePermission (PermissionState state) {
if (state == PermissionState.Unrestricted)
m_flags = StorePermissionFlags.AllFlags;
else if (state == PermissionState.None)
m_flags = StorePermissionFlags.NoFlags;
else
throw new ArgumentException(SR.GetString(SR.Argument_InvalidPermissionState));
}
public StorePermission(PermissionState state)
{
if (PermissionHelper.CheckPermissionState(state, true) == PermissionState.Unrestricted)
{
_flags = StorePermissionFlags.AllFlags;
}
else
{
_flags = StorePermissionFlags.NoFlags;
}
}
public StorePermission(PermissionState state)
{
if (state == PermissionState.Unrestricted)
{
this.m_flags = StorePermissionFlags.AllFlags;
}
else
{
if (state != PermissionState.None)
{
throw new ArgumentException(SR.GetString("Argument_InvalidPermissionState"));
}
this.m_flags = StorePermissionFlags.NoFlags;
}
}
public StorePermission(PermissionState state)
{
if (state == PermissionState.Unrestricted)
{
m_flags = StorePermissionFlags.AllFlags;
}
else if (state == PermissionState.None)
{
m_flags = StorePermissionFlags.NoFlags;
}
else
{
throw new ArgumentException(SR.GetString(SR.Argument_InvalidPermissionState));
}
}
public override bool IsSubsetOf(IPermission target)
{
if (target == null)
{
return(m_flags == StorePermissionFlags.NoFlags);
}
try {
StorePermission operand = (StorePermission)target;
StorePermissionFlags sourceFlag = this.m_flags;
StorePermissionFlags targetFlag = operand.m_flags;
return((sourceFlag & targetFlag) == sourceFlag);
}
catch (InvalidCastException) {
throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, SR.GetString(SR.Argument_WrongType), this.GetType().FullName));
}
}
public override void FromXml(SecurityElement e)
{
// General validation in CodeAccessPermission
PermissionHelper.CheckSecurityElement(e, "e", version, version);
// Note: we do not (yet) care about the return value
// as we only accept version 1 (min/max values)
string s = e.Attribute("Flags");
if (s == null)
{
_flags = StorePermissionFlags.NoFlags;
}
else
{
_flags = (StorePermissionFlags)Enum.Parse(typeof(StorePermissionFlags), s);
}
}
public override bool IsSubsetOf(IPermission target)
{
bool flag;
if (target == null)
{
return(this.m_flags == StorePermissionFlags.NoFlags);
}
try
{
StorePermission permission = (StorePermission)target;
StorePermissionFlags flags = this.m_flags;
StorePermissionFlags flags2 = permission.m_flags;
flag = (flags & flags2) == flags;
}
catch (InvalidCastException)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, SR.GetString("Argument_WrongType"), new object[] { base.GetType().FullName }));
}
return(flag);
}
public override IPermission Union(IPermission target)
{
StorePermission dp = Cast(target);
if (dp == null)
{
return(this.Copy()); // will return null for NoFlags
}
if (this.IsUnrestricted() || dp.IsUnrestricted())
{
return(new StorePermission(PermissionState.Unrestricted));
}
StorePermissionFlags spf = _flags | dp._flags;
if (spf == StorePermissionFlags.NoFlags)
{
return(null);
}
return(new StorePermission(spf));
}
//
// IPermission implementation
//
public override IPermission Union(IPermission target)
{
if (target == null)
{
return(this.Copy());
}
try {
StorePermission operand = (StorePermission)target;
StorePermissionFlags flag_union = m_flags | operand.m_flags;
if (flag_union == StorePermissionFlags.NoFlags)
{
return(null);
}
else
{
return(new StorePermission(flag_union));
}
}
catch (InvalidCastException) {
throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, SR.GetString(SR.Argument_WrongType), this.GetType().FullName));
}
}
public override IPermission Intersect(IPermission target)
{
IPermission permission2;
if (target == null)
{
return(null);
}
try
{
StorePermission permission = (StorePermission)target;
StorePermissionFlags flag = permission.m_flags & this.m_flags;
if (flag == StorePermissionFlags.NoFlags)
{
return(null);
}
permission2 = new StorePermission(flag);
}
catch (InvalidCastException)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, SR.GetString("Argument_WrongType"), new object[] { base.GetType().FullName }));
}
return(permission2);
}
public StorePermission(StorePermissionFlags flags)
{
// reuse validation by the Flags property
Flags = flags;
}
public StorePermission (StorePermissionFlags flag) {
VerifyFlags(flag);
m_flags = flag;
}
public StorePermission(StorePermissionFlags flag)
{
VerifyFlags(flag);
m_flags = flag;
}
public StorePermission(StorePermissionFlags flag)
{
throw new NotImplementedException();
}
public StorePermission (StorePermissionFlags flags)
{
// reuse validation by the Flags property
Flags = flags;
}
internal static void VerifyFlags(StorePermissionFlags flags)
{
if ((flags & ~StorePermissionFlags.AllFlags) != StorePermissionFlags.NoFlags)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, SR.GetString("Arg_EnumIllegalVal"), new object[] { (int) flags }));
}
}
public override void FromXml (SecurityElement e)
{
// General validation in CodeAccessPermission
PermissionHelper.CheckSecurityElement (e, "e", version, version);
// Note: we do not (yet) care about the return value
// as we only accept version 1 (min/max values)
string s = e.Attribute ("Flags");
if (s == null)
_flags = StorePermissionFlags.NoFlags;
else
_flags = (StorePermissionFlags) Enum.Parse (typeof (StorePermissionFlags), s);
}
public override void FromXml (SecurityElement securityElement) {
if (securityElement == null)
throw new ArgumentNullException("securityElement");
string className = securityElement.Attribute("class");
if (className == null || className.IndexOf(this.GetType().FullName, StringComparison.Ordinal) == -1)
throw new ArgumentException(SR.GetString(SR.Argument_InvalidClassAttribute), "securityElement");
string unrestricted = securityElement.Attribute("Unrestricted");
if (unrestricted != null && String.Compare(unrestricted, "true", StringComparison.OrdinalIgnoreCase) == 0) {
m_flags = StorePermissionFlags.AllFlags;
return;
}
m_flags = StorePermissionFlags.NoFlags;
String strFlags = securityElement.Attribute("Flags");
if (strFlags != null) {
StorePermissionFlags flags = (StorePermissionFlags) Enum.Parse(typeof(StorePermissionFlags), strFlags);
VerifyFlags(flags);
m_flags = flags;
}
}
public StorePermissionAttribute(SecurityAction action)
: base(action)
{
_flags = StorePermissionFlags.NoFlags;
}
public StorePermission(StorePermissionFlags flag)
{
}
public void StorePermissionFlags_BadEight()
{
StorePermissionFlags spf = (StorePermissionFlags)8; // unassigned
StorePermission sp = new StorePermission(spf);
}
public void StorePermissionFlags_Bad()
{
StorePermissionFlags spf = (StorePermissionFlags)Int32.MinValue;
StorePermission sp = new StorePermission(spf);
}
public StorePermission(StorePermissionFlags flag)
{
}
public StorePermissionAttribute (SecurityAction action)
: base (action)
{
_flags = StorePermissionFlags.NoFlags;
}
internal static void VerifyFlags (StorePermissionFlags flags) {
if ((flags & ~StorePermissionFlags.AllFlags) != 0)
throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, SR.GetString(SR.Arg_EnumIllegalVal), (int)flags));
}
