/// <summary>
 /// Initializes a new instance of the <see cref="ZpAccessException"/> class.
 /// </summary>
 /// <param name="aMessage">The AccessException message.</param>
 /// <param name="aUserID">The UserID of the access controlled user.</param>
 /// <param name="aAccessMode">The AccessMode.</param>
 /// <param name="aObject">The access controlled object.</param>
 public ZpAccessException(string aMessage, string aUserID, AccessMode aAccessMode, string aObject)
     : base(aMessage)
 {
     _userID = aUserID;
     _accessMode = aAccessMode;
     _object = aObject;
 }

 /// <summary>
 /// Constructor.
 /// </summary>
 public GXDLT645Property(ulong dataID, string name, DataType type, AccessMode access) : 
     base(name)
 {
     this.DataID = dataID;
     Type = type;
     this.AccessMode = access;
 }

		public ImageMapSegment(string name, uint size, AccessMode access) : base(size) 
		{
			if (name == null)
				throw new ArgumentNullException("name", "Segments must have names.");
			this.Name = name;
			this.Access = access;
		}

 public ImageSegment AddSegment(MemoryArea mem, string segmentName, AccessMode mode)
 {
     var segment = new ImageSegment(
             segmentName,
             mem,
             mode);
     AddSegment(segment);
     return segment;
 }

		public Task<Stream> OpenStreamAsync(string boardName, AccessMode accessMode)
		{
			// Note that we do not need any preconditions here. They are inherited from
			// the base interface.

			return Task.FromResult(new FileStream(
				Path.Combine(this.boardsDirectory.Value, boardName),
				accessMode == AccessMode.Read ? FileMode.Open : FileMode.OpenOrCreate) as Stream);
		}

 public ImageSegment(string name, Address addr, long size, AccessMode access)
 {
     if (name == null)
         throw new ArgumentNullException("name", "Segments must have names.");
     this.Name = name;
     this.Size = (uint) size;
     this.Address = addr;
     this.Access = access;
 }

		/// <summary>
		/// Checks if the caller has access to the inode 
		/// </summary>
		/// <param name="path">The resource to check permissions for.</param>
		/// <returns>True if the requested access mode combination is available to the immediate caller. If any one requested access mode is not available, the result is false.</returns>
		public static bool Access(string path, AccessMode mode)
		{
			DirectoryEntry entry = PathResolver.Resolve(rootNode, ref path, PathResolutionFlags.DoNotThrowNotFoundException);
			if (null != entry) {
				return AccessCheck.Perform(entry, mode, AccessCheckFlags.NoThrow);
			}

			return false;
		}

        public LockingObject Lock(AccessMode accessMode, bool enableSynchronize)
        {
            if (!enableSynchronize)
            {
                return null;
            }

            return this.Lock(accessMode);
        }

		public async Task<Stream> OpenStreamAsync(string boardName, AccessMode accessMode)
		{
			// Note that we do not need any preconditions here. They are inherited from
			// the base interface.

			// Get reference to requested blob and open stream
			var blob = this.container.GetBlockBlobReference(boardName);
			return accessMode == AccessMode.Read
				? await blob.OpenReadAsync().ConfigureAwait(false)
				: await blob.OpenWriteAsync().ConfigureAwait(false);
		}

	    public static String getAccessString(AccessMode access_mode) {
		    switch (access_mode) {
		    case AccessMode.ACCESS_READWRITE:
			    return "Read/Write";
            //case AccessMode.ACCESS_WRITEONLY:
			//    return "Write only";
            case AccessMode.ACCESS_READONLY:
			    return "Read only";
		    default:
			    return "unknowm Access Mode";
		    }
	    }

 async Task ChangeAccessMode(AccessMode changeAccessMode, int portNo) {
     var s3f24 = await EAP.SendAsync(new SecsMessage(3, 23, "ChangeAccessMode",
         Item.L(
             Item.A("ChangeAccess"),
             Item.A(portNo.ToString()),
             Item.L(
                 Item.L(
                     Item.A("AccessMode"),
                     Item.B((byte)changeAccessMode))))));
     byte returnCode = (byte)s3f24.SecsItem.Items[0];
     if (returnCode != 0 && returnCode != 4)
         throw new ScenarioException("Change Loadport[" + portNo + "] access mode fial: " + s3f24.SecsItem.Items[1].Items[0].Items[1].GetValue<string>());
 }

        internal DocumentStoreWrapper(
            string name, 
            AccessMode accessMode,
            Action<DocumentStoreWrapper> updateInnerStore)
        {
            name.Ensure("name").IsNotNullOrWhiteSpace();
            updateInnerStore.Ensure("updateInnerStore").IsNotNull();

            this.Name = name;
            this.AccessMode = accessMode;
            this.IsInitialized = false;
            this.UpdateInnerStore = updateInnerStore;
        }

        public LockingObject Lock(AccessMode accessMode)
        {
            if (accessMode == AccessMode.Read)
            {
                this.lastRequireReadTime = DateTime.Now;
            }
            else
            {
                this.lastRequireWriteTime = DateTime.Now;
            }

            return new LockingObject(this.readerWriterLock, accessMode);
        } 

		public Task<Stream> OpenStreamAsync(string boardName, AccessMode accessMode)
		{
			// Note that we cannot make this precondition a legacy-requires in our sample.
			Contract.Requires(boardName != null);

			// The following postcondition checks the resulting task.
			Contract.Ensures(Contract.Result<Task<Stream>>() != null);

			// The following postcondition checks the result once the Task has been completed.
			Contract.Ensures(Contract.Result<Task<Stream>>().Result != null);

			return default(Task<Stream>);
		}

        public LockingObject(ReaderWriterLock _lock, AccessMode _lockMode)
        {
            readerWriterLock = _lock;
            accessMode = _lockMode;

            if (accessMode == AccessMode.Read)
            {
                readerWriterLock.AcquireReaderLock(-1);
            }
            else
            {
                readerWriterLock.AcquireWriterLock(-1);
            }
        }

		/// <summary>
		/// Constructor.
		/// </summary>
		public VistaDBConnection()
		{
			VistaDBErrorMsgs.SetErrorFunc();
			this.connectionState = ConnectionState.Closed;
			this.accessMode      = AccessMode.Local;
			this.vistaDBSQL      = null;

			this.dataSource      = null;
			this.database        = null;
			this.cypher          = CypherType.None;
			this.password        = null;
			this.exclusive       = false;
			this.readOnly        = false;
			this.loginUser       = "";
			this.loginPassword   = "";
		}

        public LockingObject(ReaderWriterLock _lock, AccessMode _lockMode)
        {
            this.readerWriterLock = _lock;
            this.accessMode = _lockMode;

            if (this.accessMode == AccessMode.Read)
            {
                this.readerWriterLock.AcquireReaderLock(-1);
            }
            else if (this.accessMode == AccessMode.Write)
            {
                this.readerWriterLock.AcquireWriterLock(-1);
            }
            else //UpAndDowngrade
            {
                this.lockCookie = this.readerWriterLock.UpgradeToWriterLock(-1);
            }
        }

        private void TestBandwidth(Context context, Device[] devices, int start, int end, int increment, TestMode testMode, MemoryCopyKind memoryCopyKind, PrintMode printMode, AccessMode accessMode, MemoryMode memoryMode, int startDevice, int endDevice)
        {
            switch (testMode)
            {
            case TestMode.Quick:
                TestBandwidthQuick(context, devices, DefaultSize, memoryCopyKind, printMode, accessMode, memoryMode, startDevice, endDevice);
                break;

            case TestMode.Range:
                TestBandwidthRange(context, devices, start, end, increment, memoryCopyKind, printMode, accessMode, memoryMode, startDevice, endDevice);
                break;

            case TestMode.Shmoo:
                TestBandwidthShmoo(context, devices, memoryCopyKind, printMode, accessMode, memoryMode, startDevice, endDevice);
                break;

            default:
                break;
            }
        }

 /// <summary>
 /// Gets a specific access of a Specific mode for a user.
 /// </summary>
 /// <param name="aUserKey">A user key composite.</param>
 /// <param name="aFunction">A function.</param>
 /// <param name="aAccessMode">A access mode.</param>
 /// <returns></returns>
 public static bool HasModeAccess(UserKey aUserKey, string aFunction, AccessMode aAccessMode)
 {
     UserFunctionAccess vUserFunctionAccess = new UserFunctionAccess() { UsrKey = aUserKey.UsrKey };
     vUserFunctionAccess.FunctionAccess.Function = aFunction;
     Load(vUserFunctionAccess);
     bool vAccess = false;
     switch (aAccessMode)
     {
         case AccessMode.List:
             {
                 vAccess = vUserFunctionAccess.FunctionAccess.Access.List;
                 break;
             }
         case AccessMode.Read:
             {
                 vAccess = vUserFunctionAccess.FunctionAccess.Access.Read;
                 break;
             }
         case AccessMode.Create:
             {
                 vAccess = vUserFunctionAccess.FunctionAccess.Access.Create;
                 break;
             }
         case AccessMode.Update:
             {
                 vAccess = vUserFunctionAccess.FunctionAccess.Access.Update;
                 break;
             }
         case AccessMode.Delete:
             {
                 vAccess = vUserFunctionAccess.FunctionAccess.Access.Delete;
                 break;
             }
         default:
             {
                 vAccess = false;
                 break;
             }
     }
     return vAccess;
 }

        /// <summary>
        /// Retrieve a Stream for the given path (Read or Write access can be specified)
        /// Stream.Close() should be called when you are finished using the Stream.
        /// </summary>
        /// <param name="file">Heirarchical path designating stream location (uses "/" as
        /// path designator)</param>
        /// <param name="mode">Read or Write. Write will overwrite any exising path of
        /// the same name.</param>
        /// <returns>Stream that can be used to access the path (Stream.Close() must be
        /// called when you are finished using the Stream).</returns>
        public override Stream Open(string file, AccessMode mode)
        {
            // validate the path (throws an exception if it is invalid)
            ValidatePath(file);

            // convert the path to lower-case
            string pathLower = file.ToLower(CultureInfo.InvariantCulture);

            // return the approrpiate stream
            switch (mode)
            {
                case AccessMode.Read:
                    return OpenMemoryStreamForRead(pathLower);

                case AccessMode.Write:
                    return OpenMemoryStreamForWrite(pathLower);

                default:
                    Debug.Assert(false, "Invalid AccessMode");
                    return null;
            }
        }