public VirtualDiskPSDriveInfo(PSDriveInfo toCopy, string root, VirtualDisk disk)
     : base(toCopy.Name, toCopy.Provider, root, toCopy.Description, toCopy.Credential)
 {
     _disk = disk;
     _volMgr = new VolumeManager(_disk);
     _fsCache = new Dictionary<string, DiscFileSystem>();
 }

 protected override void ProcessRecord()
 {
     var provider = SessionState.Provider.GetOne(PSProvider);
     var driveInfo = new PSDriveInfo(Name, provider, Root, Description, Credential);
     var realDrive = SessionState.Drive.New(driveInfo, Scope ?? "local", ProviderRuntime);
     WriteObject(realDrive);
 }

        protected override PSDriveInfo NewDrive(PSDriveInfo drive)
        {
            if (drive == null)
            {
                WriteError(new ErrorRecord(
                           new ArgumentNullException("drive"),
                           "NullDrive",
                           ErrorCategory.InvalidArgument,
                           null));

                return null;
            }
            SFGAO attributes;
            SFGAO isContainerQuery = SFGAO.Browsable | SFGAO.Folder;
            IdList pidl = GetPidlFromPath(drive.Root, isContainerQuery, out attributes);
            if ((attributes & isContainerQuery) == SFGAO.None)
            {
                WriteError(new ErrorRecord(
                           new ArgumentException("drive.Root"),
                           "NotAContainer",
                           ErrorCategory.InvalidArgument,
                           null));
                return null;
            }

            return new ShellPSDriveInfo((ShellFolder)ShellItem.GetShellItem(pidl, new ShellItem.ShellItemKnownInfo()
            {
                LoadedAttributes = isContainerQuery,
                Attributes = attributes
            }), drive);
        }

 internal ProviderInfo(SessionState sessionState, Type implementingType, string name, string description, string home, string helpFile, PSSnapInInfo psSnapIn)
 {
     this.helpFile = "";
     if (sessionState == null)
     {
         throw PSTraceSource.NewArgumentNullException("sessionState");
     }
     if (implementingType == null)
     {
         throw PSTraceSource.NewArgumentNullException("implementingType");
     }
     if (string.IsNullOrEmpty(name))
     {
         throw PSTraceSource.NewArgumentException("name");
     }
     if (string.IsNullOrEmpty(name))
     {
         throw PSTraceSource.NewArgumentException("name");
     }
     this.sessionState = sessionState;
     this.name = name;
     this.description = description;
     this.home = home;
     this.implementingType = implementingType;
     this.helpFile = helpFile;
     this.pssnapin = psSnapIn;
     this.hiddenDrive = new PSDriveInfo(this.FullName, this, "", "", null);
     this.hiddenDrive.Hidden = true;
 }

 protected override Collection<PSDriveInfo> InitializeDefaultDrives()
 {
     PSDriveInfo item = new PSDriveInfo("Env", ProviderInfo, string.Empty, string.Empty, null);
     Collection<PSDriveInfo> collection = new Collection<PSDriveInfo>();
     collection.Add(item);
     return collection;
 }

 internal UpdatableHelpSystemDrive(PSCmdlet cmdlet, string path, PSCredential credential)
 {
     for (int i = 0; i < 6; i++)
     {
         this._driveName = Path.GetFileNameWithoutExtension(Path.GetRandomFileName());
         this._cmdlet = cmdlet;
         if (path.EndsWith(@"\", StringComparison.OrdinalIgnoreCase) || path.EndsWith("/", StringComparison.OrdinalIgnoreCase))
         {
             path = path.Remove(path.Length - 1);
         }
         PSDriveInfo atScope = cmdlet.SessionState.Drive.GetAtScope(this._driveName, "local");
         if (atScope != null)
         {
             if (atScope.Root.Equals(path))
             {
                 return;
             }
             if (i < 5)
             {
                 continue;
             }
             cmdlet.SessionState.Drive.Remove(this._driveName, true, "local");
         }
         atScope = new PSDriveInfo(this._driveName, cmdlet.SessionState.Internal.GetSingleProvider("FileSystem"), path, string.Empty, credential);
         cmdlet.SessionState.Drive.New(atScope, "local");
         return;
     }
 }

 protected virtual PSDriveInfo RemoveDrive(PSDriveInfo drive)
 {
     using (PSTransactionManager.GetEngineProtectionScope())
     {
         return drive;
     }
 }

 public DriveInfo(PSDriveInfo driveInfo, NewDriveParameters parameters)
     : base(driveInfo)
 {
     if (parameters != null)
         Directory = parameters.Directory;
     EnsureDescription();
 }

 internal PathInfo(PSDriveInfo drive, ProviderInfo provider, Path path, SessionState sessionState)
 {
     Drive = drive;
     Provider = provider;
     _path = path;
     _sessionState = sessionState;
 }

        /// <summary>
        /// Initializes the specified VFS drive.
        /// </summary>
        /// <param name="drive">The drive to initialize.</param>
        /// <returns>The <see cref="VfsDriveInfo"/> object which represents the initialized drive.</returns>
        protected override VfsDriveInfo InitializeNewDrive(PSDriveInfo drive)
        {
            if (drive is OrchardDriveInfo)
            {
                return (VfsDriveInfo)drive;
            }

            var driveParameters = (OrchardDriveParameters)DynamicParameters;
            if (driveParameters == null)
            {
                return null;
            }

            if (!OrchardPsSnapIn.VerifyOrchardDirectory(driveParameters.OrchardRoot))
            {
                this.WriteError(
                    ThrowHelper.InvalidRootPathException(driveParameters.OrchardRoot),
                    ErrorIds.InvalidRootDirectory,
                    ErrorCategory.InvalidArgument,
                    drive);

                return null;
            }

            VfsDriveInfo orchardDrive = null;
            this.TryCritical(
                () => orchardDrive = this.InitializeOrchardDrive(drive, driveParameters),
                ErrorIds.OrchardInitFailed,
                ErrorCategory.OpenError);

            return orchardDrive;
        }

		// NewDrive

		/// <summary>
		/// 	Removes a drive from the provider.
		/// </summary>
		/// <param name = "drive">The drive to remove.</param>
		/// <returns>The drive removed.</returns>
		protected override PSDriveInfo RemoveDrive(PSDriveInfo drive)
		{
			// check if drive object is null
			if (drive == null)
			{
				WriteError(new ErrorRecord(
				           	new ArgumentNullException("drive"),
				           	"NullDrive",
				           	ErrorCategory.InvalidArgument,
				           	drive)
					);

				return null;
			}

			// dispose database on drive
			var ravenDBPSDriveInfo = drive as RavenDBPSDriveInfo;

			if (ravenDBPSDriveInfo == null)
			{
				return null;
			}

			ravenDBPSDriveInfo.Database.Dispose();

			return ravenDBPSDriveInfo;
		}

 public int CompareTo(PSDriveInfo drive)
 {
     if (drive == null)
     {
         throw PSTraceSource.NewArgumentNullException("drive");
     }
     return string.Compare(this.Name, drive.Name, true, CultureInfo.CurrentCulture);
 }

 protected override Collection<PSDriveInfo> InitializeDefaultDrives()
 {
     PSDriveInfo drive = new PSDriveInfo("Objects", this.ProviderInfo, @"\", "Object Manager Root Directory", null);
     PSDriveInfo session = new PSDriveInfo("SessionObjects", this.ProviderInfo, 
         String.Format(@"\Sessions\{0}\BaseNamedObjects", Process.GetCurrentProcess().SessionId), "Current Session Objects", null);
     Collection<PSDriveInfo> drives = new Collection<PSDriveInfo>() { drive, session };
     return drives;
 }

        protected override PSDriveInfo NewDrive(PSDriveInfo drive)
        {
            if( drive is DTEDrive )
            {
                return drive;
            }

            return new DTEDrive( drive, DTE2 );
        }

 internal PSDriveInfo NewDrive(PSDriveInfo drive, CmdletProviderContext context)
 {
     base.Context = context;
     if (((drive.Credential != null) && (drive.Credential != PSCredential.Empty)) && !CmdletProviderManagementIntrinsics.CheckProviderCapabilities(ProviderCapabilities.Credentials, base.ProviderInfo))
     {
         throw PSTraceSource.NewNotSupportedException("SessionStateStrings", "NewDriveCredentials_NotSupported", new object[0]);
     }
     return this.NewDrive(drive);
 }

 protected PSDriveInfo(PSDriveInfo driveInfo)
 {
     Name = driveInfo.Name;
     Provider = driveInfo.Provider;
     Root = driveInfo.Root;
     Description = driveInfo.Description;
     Credential = driveInfo.Credential;
     CurrentLocation = driveInfo.CurrentLocation;
 }

 public static string MakePath(string path, PSDriveInfo drive)
 {
     string format = "{0}:" + '\\' + "{1}";
     if (path.StartsWith("\\"))
     {
         format = "{0}:{1}";
     }
     return string.Format(format, new object[] { drive.Name, path });
 }

 protected override PSDriveInfo NewDrive(PSDriveInfo drive)
 {
     var sqlServerPsDriveInfo = new SqlServerPsDriveInfo(drive);
     if (!sqlServerPsDriveInfo.ItemExists(drive.Root))
     {
         ThrowTerminatingError(new ErrorRecord(null, "BadServer", ErrorCategory.InvalidArgument, drive.Root));
     }
     return sqlServerPsDriveInfo;
 }

        protected override PSDriveInfo NewDrive(PSDriveInfo drive)
        {
            if (drive is GenericEntityContextDrive)
            {
                return drive;
            }

            var p = this.DynamicParameters as GenericEntityContextDrive.NewParams;
            return new GenericEntityContextDrive( p.ContextType, drive );
        }

 protected override PSDriveInfo RemoveDrive(PSDriveInfo drive)
 {
     var testdrive = drive as TestDrive;
     if (testdrive == null)
     {
         throw new InvalidOperationException("Drive is not a TestDrive!");
     }
     testdrive.IsRemoved = true;
     return testdrive;
 }