Merge pull request #2419 from esdrubal/xmlsubclassel

[mono.git] / mcs / class / corlib / System.Security.AccessControl / ObjectSecurity_T.cs

diff --git a/mcs/class/corlib/System.Security.AccessControl/ObjectSecurity_T.cs b/mcs/class/corlib/System.Security.AccessControl/ObjectSecurity_T.cs
index 2f002577adad74761de26e2dcc8f7864eb50faab..4bed60fc3b93acbda77c62ddc51f284fc284254c 100644 (file)
--- a/mcs/class/corlib/System.Security.AccessControl/ObjectSecurity_T.cs
+++ b/mcs/class/corlib/System.Security.AccessControl/ObjectSecurity_T.cs
@@ -1,7 +1,12 @@
 //
 // System.Security.AccessControl.ObjectSecurity<T>
 //
+// Authors:
+//      ?
+//     James Bellinger  <jfb@zer7.com>
+//
 // Copyright (C) 2009 Novell, Inc (http://www.novell.com)
+// Copyright (C) 2012 James Bellinger
 //
 // Permission is hereby granted, free of charge, to any person obtaining
 // a copy of this software and associated documentation files (the
@@ -23,7 +28,6 @@
 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 //
 
-#if NET_4_0
 
 using System.Runtime.InteropServices;
 using System.Security.Principal;
@@ -32,11 +36,6 @@ namespace System.Security.AccessControl
 {
        public abstract class ObjectSecurity<T> : NativeObjectSecurity where T : struct
        {
-               internal ObjectSecurity ()
-               {
-
-               }
-               
                protected ObjectSecurity (bool isContainer,
                                          ResourceType resourceType)
                        : base (isContainer, resourceType)
@@ -87,34 +86,106 @@ namespace System.Security.AccessControl
                }
 
                public override Type AccessRightType {
-                       get {
-                               return typeof(T);
-                       }
+                       get { return typeof (T); }
                }
                
                public override Type AccessRuleType {
-                       get {
-                               return typeof (AccessRule<T>);
-                       }
+                       get { return typeof (AccessRule<T>); }
                }
                
                public override Type AuditRuleType {
-                       get {
-                               return typeof (AuditRule<T>);
-                       }
+                       get { return typeof (AuditRule<T>); }
                }
                
-               public override AccessRule AccessRuleFactory(IdentityReference identityReference, int accessMask, bool isInherited, InheritanceFlags inheritanceFlags, PropagationFlags propagationFlags, AccessControlType type)
+               public override AccessRule AccessRuleFactory(IdentityReference identityReference, int accessMask,
+                                                            bool isInherited, InheritanceFlags inheritanceFlags,
+                                                            PropagationFlags propagationFlags, AccessControlType type)
                {
                        return new AccessRule<T> (identityReference, accessMask, isInherited, inheritanceFlags, propagationFlags, type);
                }
                
-               public override AuditRule AuditRuleFactory(IdentityReference identityReference, int accessMask, bool isInherited, InheritanceFlags inheritanceFlags, PropagationFlags propagationFlags, AuditFlags flags)
+               public virtual void AddAccessRule (AccessRule<T> rule)
+               {
+                       AddAccessRule ((AccessRule)rule);
+               }
+               
+               public virtual bool RemoveAccessRule (AccessRule<T> rule)
+               {
+                       return RemoveAccessRule ((AccessRule)rule);
+               }
+               
+               public virtual void RemoveAccessRuleAll (AccessRule<T> rule)
+               {
+                       RemoveAccessRuleAll ((AccessRule)rule);
+               }
+               
+               public virtual void RemoveAccessRuleSpecific (AccessRule<T> rule)
+               {
+                       RemoveAccessRuleSpecific ((AccessRule)rule);
+               }
+               
+               public virtual void ResetAccessRule (AccessRule<T> rule)
+               {
+                       ResetAccessRule ((AccessRule)rule);
+               }
+               
+               public virtual void SetAccessRule (AccessRule<T> rule)
+               {
+                       SetAccessRule ((AccessRule)rule);
+               }
+               
+               public override AuditRule AuditRuleFactory(IdentityReference identityReference, int accessMask,
+                                                          bool isInherited, InheritanceFlags inheritanceFlags,
+                                                          PropagationFlags propagationFlags, AuditFlags flags)
                {
                        return new AuditRule<T> (identityReference, accessMask, isInherited, inheritanceFlags, propagationFlags, flags);
                }
+               
+               public virtual void AddAuditRule (AuditRule<T> rule)
+               {
+                       AddAuditRule ((AuditRule)rule);
+               }
+               
+               public virtual bool RemoveAuditRule (AuditRule<T> rule)
+               {
+                       return RemoveAuditRule((AuditRule)rule);
+               }
+               
+               public virtual void RemoveAuditRuleAll (AuditRule<T> rule)
+               {
+                       RemoveAuditRuleAll((AuditRule)rule);
+               }
+               
+               public virtual void RemoveAuditRuleSpecific (AuditRule<T> rule)
+               {
+                       RemoveAuditRuleSpecific((AuditRule)rule);
+               }
+               
+               public virtual void SetAuditRule (AuditRule<T> rule)
+               {
+                       SetAuditRule((AuditRule)rule);
+               }
+               
+               protected void Persist (SafeHandle handle)
+               {
+                       WriteLock ();
+                       try {
+                               Persist (handle, AccessControlSectionsModified);
+                       } finally {
+                               WriteUnlock ();
+                       }
+               }
+               
+               protected void Persist (string name)
+               {
+                       WriteLock ();
+                       try {
+                               Persist (name, AccessControlSectionsModified);
+                       } finally {
+                               WriteUnlock ();
+                       }
+               }
        }
 }
        
-#endif