internal IsolatedStoragePermission
					(IsolatedStoragePermissionAttribute copyFrom)
			{
				this.state = PermissionState.None;
				this.userQuota = copyFrom.userQuota;
				this.usageAllowed = copyFrom.usageAllowed;
			}

	public RegistryPermission(RegistryPermissionAccess flag, String pathList)
			{
				if(pathList == null)
				{
					throw new ArgumentNullException("pathList");
				}
				if((flag & ~(RegistryPermissionAccess.AllAccess)) != 0)
				{
					throw new ArgumentException(_("Arg_RegistryAccess"));
				}
				this.state = PermissionState.None;
				String[] split = EnvironmentPermission.SplitPath(pathList);
				if((flag & RegistryPermissionAccess.Read) != 0)
				{
					readList = split;
				}
				if((flag & RegistryPermissionAccess.Write) != 0)
				{
					writeList = split;
				}
				if((flag & RegistryPermissionAccess.Create) != 0)
				{
					createList = split;
				}
			}

	public PerformanceCounterPermission(PermissionState state)
			: base(state)
			{
				PermissionAccessType =
					typeof(PerformanceCounterPermissionAccess);
				TagNames = new String [] {"Machine", "Category"};
			}

		// Constructors

		public UIPermission (PermissionState state) 
		{
			if (CheckPermissionState (state, true) == PermissionState.Unrestricted) {
				_clipboard = UIPermissionClipboard.AllClipboard;
				_window = UIPermissionWindow.AllWindows;
			}
		}

		public IsolatedStoragePermission (PermissionState state)
#endif
		{
			if (CheckPermissionState (state, true) == PermissionState.Unrestricted) {
				UsageAllowed = IsolatedStorageContainment.UnrestrictedIsolatedStorage;
			}
		}

		public ZoneIdentityPermission (PermissionState state)
		{
			// false == do not allow Unrestricted for Identity Permissions
			CheckPermissionState (state, false);
			// default values
			zone = SecurityZone.NoZone;
		}

	// Convert an XML value into a permissions value.
	public override void FromXml(SecurityElement esd)
			{
				String value;
				if(esd == null)
				{
					throw new ArgumentNullException("esd");
				}
				if(esd.Attribute("version") != "1")
				{
					throw new ArgumentException(S._("Arg_PermissionVersion"));
				}
				value = esd.Attribute("Unrestricted");
				if(value != null && Boolean.Parse(value))
				{
					state = PermissionState.Unrestricted;
				}
				else
				{
					state = PermissionState.None;
				}
				value = esd.Attribute("Level");
				if(value != null)
				{
					level = (PrintingPermissionLevel)
						Enum.Parse(typeof(PrintingPermissionLevel), value);
				}
				else
				{
					level = PrintingPermissionLevel.NoPrinting;
				}
			}

	public FileIOPermission(FileIOPermissionAccess flag, String pathList)
			{
				if(pathList == null)
				{
					throw new ArgumentNullException("pathList");
				}
				if((flag & ~(FileIOPermissionAccess.AllAccess)) != 0)
				{
					throw new ArgumentException(_("Arg_FileIOAccess"));
				}
				this.state = PermissionState.None;
				String[] split = EnvironmentPermission.SplitPath(pathList);
				if((flag & FileIOPermissionAccess.Read) != 0)
				{
					readList = split;
				}
				if((flag & FileIOPermissionAccess.Write) != 0)
				{
					writeList = split;
				}
				if((flag & FileIOPermissionAccess.Append) != 0)
				{
					appendList = split;
				}
				if((flag & FileIOPermissionAccess.PathDiscovery) != 0)
				{
					discoveryList = split;
				}
				allLocalFiles = FileIOPermissionAccess.NoAccess;
				allFiles = FileIOPermissionAccess.NoAccess;
			}

	internal EnvironmentPermission(PermissionState state, String[] readList,
								   String[] writeList)
			{
				this.state = state;
				this.readList = readList;
				this.writeList = writeList;
			}

        /// <summary>
        /// Creates a new instance of IngresPermission.
        /// </summary>
        /// <param name="state">
        /// PermissionState for access to all or no resources.</param>
        /// <param name="allowBlankPassword"></param>
        public IngresPermission(
				PermissionState state,
				bool allowBlankPassword)
            : base(state)
        {
            this.AllowBlankPassword = allowBlankPassword;
        }

		public StorePermission (PermissionState state)
		{
			if (PermissionHelper.CheckPermissionState (state, true) == PermissionState.Unrestricted)
				_flags = StorePermissionFlags.AllFlags;
			else
				_flags = StorePermissionFlags.NoFlags;
		}

		// constructors

		public SecurityPermission (PermissionState state)
		{
			if (CheckPermissionState (state, true) == PermissionState.Unrestricted)
				flags = SecurityPermissionFlag.AllFlags;
			else
				flags = SecurityPermissionFlag.NoFlags;
		}

	// Convert an XML value into a permissions value.
	public override void FromXml(SecurityElement esd)
			{
				String value;
				if(esd == null)
				{
					throw new ArgumentNullException("esd");
				}
				if(esd.Attribute("version") != "1")
				{
					throw new ArgumentException(_("Arg_PermissionVersion"));
				}
				value = esd.Attribute("Unrestricted");
				if(value != null && Boolean.Parse(value))
				{
					state = PermissionState.Unrestricted;
				}
				else
				{
					state = PermissionState.None;
				}
				value = esd.Attribute("Access");
				if(value != null)
				{
					flags = (FileDialogPermissionAccess)
						Enum.Parse(typeof(FileDialogPermissionAccess), value);
				}
				else
				{
					flags = FileDialogPermissionAccess.None;
				}
			}

		public ReflectionPermission (PermissionState state)
		{
			if (CheckPermissionState (state, true) == PermissionState.Unrestricted)
				flags = ReflectionPermissionFlag.AllFlags;
			else
				flags = ReflectionPermissionFlag.NoFlags;
		}

//		private AccessControlActions _control;
#endif
		// Constructors

		public RegistryPermission (PermissionState state)
		{
			_state = CheckPermissionState (state, true);
			createList = new ArrayList ();
			readList = new ArrayList ();
			writeList = new ArrayList ();
		}

		public SybasePermission (PermissionState state, bool allowBlankPassword) 
#if NET_2_0
			: base (PermissionState.None)
#endif
		{ 
			throw new NotImplementedException ();
		}

 /// <include file='doc\MessageQueuePermission.uex' path='docs/doc[@for="MessageQueuePermission.MessageQueuePermission1"]/*' />
 /// <devdoc>
 ///    <para>[To be supplied.]</para>
 /// </devdoc>
 public MessageQueuePermission(PermissionState state)
 {
     if (state == PermissionState.Unrestricted)
         this.isUnrestricted = true;
     else
         this.isUnrestricted = false;
 }

        //------------------------------------------------------
        // 
        // PUBLIC CONSTRUCTORS
        // 
        //----------------------------------------------------- 

        public GacIdentityPermission(PermissionState state) 
        {
            if (state != PermissionState.Unrestricted && state != PermissionState.None)
            {
                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidPermissionState")); 
            }
        } 

		public DataProtectionPermission (PermissionState state)
		{
			if (PermissionHelper.CheckPermissionState (state, true) == PermissionState.Unrestricted)
				_flags = DataProtectionPermissionFlags.AllFlags;
			else
				_flags = DataProtectionPermissionFlags.NoFlags;
		}

		// Constructors

		public FileDialogPermission (PermissionState state)
		{
			if (CheckPermissionState (state, true) == PermissionState.Unrestricted)
				_access = FileDialogPermissionAccess.OpenSave;
			else
				_access = FileDialogPermissionAccess.None;
		}