// TODO:
        // [Parameter( Mandatory = true,
        //             Position = 0,
        //             ValueFromPipeline = true,
        //             ParameterSetName = c_FileParamSet )]
        // [ValidateNotNullOrEmpty]
        // public string File { get; set; }


        protected override void ProcessRecord()
        {
            base.ProcessRecord();

            if (!String.IsNullOrEmpty(TypeName))
            {
                string mod, template;
                ulong  dontCare;
                DbgProvider.ParseSymbolName(TypeName, out mod, out template, out dontCare);
                if (0 != dontCare)
                {
                    throw new ArgumentException("The TypeName parameter does not look like a type name.", "TypeName");
                }

                DbgValueConversionManager.RemoveEntries(mod, template, !AllMatching);
            }
            else
            {
                Util.Fail("impossible");
            }
            // else
            // {
            //     Util.Assert( !String.IsNullOrEmpty( File ) );
            //     string fullpath = GetUnresolvedProviderPathFromPSPath( File );
            //     DbgValueConversionManager.RemoveAllEntriesFromFile( fullpath, !AllMatching );
            // }
        } // end ProcessRecord()
        } // end ProcessRecord()

        protected override void EndProcessing()
        {
            using (var pipe = GetPipelineCallback())
            {
                DbgValueConversionManager.Reload(InvokeCommand,
                                                 m_appendPaths,
                                                 m_prependPaths,
                                                 pipe);
            }
        } // end EndProcessing()
        protected override void ProcessRecord()
        {
            base.ProcessRecord();

            if (null != ForSymbol)
            {
                Util.Assert(ParameterSetName == c_SymbolParamSet);
                foreach (var converter in DbgValueConversionManager.EnumerateAllConvertersForSymbol(ForSymbol))
                {
                    WriteObject(converter);
                }
                return;
            }

            if (String.IsNullOrEmpty(ModuleName) && String.IsNullOrEmpty(TypeName))
            {
                if (ExactMatchOnly)
                {
                    // I guess this doesn't have to be terminating.
                    WriteError(new ArgumentException("You asked for exact matches only, but did not specify a type name."),
                               "InvalidParam_ExactMatchOnly",
                               ErrorCategory.InvalidArgument,
                               null);
                }

                foreach (var converter in DbgValueConversionManager.GetEntries())
                {
                    WriteObject(converter);
                }
                return;
            }

            foreach (var converter in DbgValueConversionManager.GetMatchingEntries(ModuleName,
                                                                                   TypeName,
                                                                                   ExactMatchOnly))
            {
                WriteObject(converter);
            }
        } // end ProcessRecord()
        } // end ProcessRecord()

        protected override void EndProcessing()
        {
            DbgValueConversionManager.ScrubFileList();
            base.EndProcessing();
        }