// Interface to plug in external Dictionaries. The external
        // dictionary should already be populated with all strings 
        // required by this assembly.
        public void PopulateDictionary(IXmlDictionary dictionary)
        {
            if (dictionary == null)
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("dictionary");

            this.dictionaryManager = new DictionaryManager(dictionary);
        }

        public string GetValue(IXmlDictionary staticDictionary, XmlBinaryReaderSession readerSession)
        {
            int id = this.DictionaryId / 2;
            XmlDictionaryString dicString = XmlDictionaryString.Empty;
            bool found;
            if (this.IsSession)
            {
                if (readerSession == null)
                {
                    return null;
                }

                found = readerSession.TryLookup(id, out dicString);
            }
            else
            {
                if (staticDictionary == null)
                {
                    return null;
                }

                found = staticDictionary.TryLookup(id, out dicString);
            }

            if (found)
            {
                return dicString.Value;
            }
            else
            {
                throw new ArgumentException("Cannot find value for dictionary string with ID = " + this.DictionaryId);
            }
        }

 public ExclusiveC14NDictionary(IXmlDictionary dictionary)
 {
     this.Namespace = this.LookupDictionaryString(dictionary, "http://www.w3.org/2001/10/xml-exc-c14n#");
     this.PrefixList = this.LookupDictionaryString(dictionary, "PrefixList");
     this.InclusiveNamespaces = this.LookupDictionaryString(dictionary, "InclusiveNamespaces");
     this.Prefix = this.LookupDictionaryString(dictionary, "ec");
 }

 public XmlSignatureDictionary(IXmlDictionary dictionary)
 {
     this.Algorithm = this.LookupDictionaryString(dictionary, "Algorithm");
     this.URI = this.LookupDictionaryString(dictionary, "URI");
     this.Reference = this.LookupDictionaryString(dictionary, "Reference");
     this.Transforms = this.LookupDictionaryString(dictionary, "Transforms");
     this.Transform = this.LookupDictionaryString(dictionary, "Transform");
     this.DigestMethod = this.LookupDictionaryString(dictionary, "DigestMethod");
     this.DigestValue = this.LookupDictionaryString(dictionary, "DigestValue");
     this.Namespace = this.LookupDictionaryString(dictionary, "http://www.w3.org/2000/09/xmldsig#");
     this.EnvelopedSignature = this.LookupDictionaryString(dictionary, "http://www.w3.org/2000/09/xmldsig#enveloped-signature");
     this.KeyInfo = this.LookupDictionaryString(dictionary, "KeyInfo");
     this.Signature = this.LookupDictionaryString(dictionary, "Signature");
     this.SignedInfo = this.LookupDictionaryString(dictionary, "SignedInfo");
     this.CanonicalizationMethod = this.LookupDictionaryString(dictionary, "CanonicalizationMethod");
     this.SignatureMethod = this.LookupDictionaryString(dictionary, "SignatureMethod");
     this.SignatureValue = this.LookupDictionaryString(dictionary, "SignatureValue");
     this.KeyName = this.LookupDictionaryString(dictionary, "KeyName");
     this.Type = this.LookupDictionaryString(dictionary, "Type");
     this.MgmtData = this.LookupDictionaryString(dictionary, "MgmtData");
     this.Prefix = this.LookupDictionaryString(dictionary, "");
     this.KeyValue = this.LookupDictionaryString(dictionary, "KeyValue");
     this.RsaKeyValue = this.LookupDictionaryString(dictionary, "RSAKeyValue");
     this.Modulus = this.LookupDictionaryString(dictionary, "Modulus");
     this.Exponent = this.LookupDictionaryString(dictionary, "Exponent");
     this.X509Data = this.LookupDictionaryString(dictionary, "X509Data");
     this.X509IssuerSerial = this.LookupDictionaryString(dictionary, "X509IssuerSerial");
     this.X509IssuerName = this.LookupDictionaryString(dictionary, "X509IssuerName");
     this.X509SerialNumber = this.LookupDictionaryString(dictionary, "X509SerialNumber");
     this.X509Certificate = this.LookupDictionaryString(dictionary, "X509Certificate");
 }

		public static XmlDictionaryWriter CreateBinaryWriter (
			Stream stream, IXmlDictionary dictionary,
			XmlBinaryWriterSession session, bool ownsStream)
		{
			return new XmlBinaryDictionaryWriter (stream,
				dictionary, session, ownsStream);
		}

 public SecurityAlgorithmDictionary(IXmlDictionary dictionary)
 {
     this.Aes128Encryption = this.LookupDictionaryString(dictionary, "http://www.w3.org/2001/04/xmlenc#aes128-cbc");
     this.Aes128KeyWrap = this.LookupDictionaryString(dictionary, "http://www.w3.org/2001/04/xmlenc#kw-aes128");
     this.Aes192Encryption = this.LookupDictionaryString(dictionary, "http://www.w3.org/2001/04/xmlenc#aes192-cbc");
     this.Aes192KeyWrap = this.LookupDictionaryString(dictionary, "http://www.w3.org/2001/04/xmlenc#kw-aes192");
     this.Aes256Encryption = this.LookupDictionaryString(dictionary, "http://www.w3.org/2001/04/xmlenc#aes256-cbc");
     this.Aes256KeyWrap = this.LookupDictionaryString(dictionary, "http://www.w3.org/2001/04/xmlenc#kw-aes256");
     this.DesEncryption = this.LookupDictionaryString(dictionary, "http://www.w3.org/2001/04/xmlenc#des-cbc");
     this.DsaSha1Signature = this.LookupDictionaryString(dictionary, "http://www.w3.org/2000/09/xmldsig#dsa-sha1");
     this.ExclusiveC14n = this.LookupDictionaryString(dictionary, "http://www.w3.org/2001/10/xml-exc-c14n#");
     this.ExclusiveC14nWithComments = this.LookupDictionaryString(dictionary, "http://www.w3.org/2001/10/xml-exc-c14n#WithComments");
     this.HmacSha1Signature = this.LookupDictionaryString(dictionary, "http://www.w3.org/2000/09/xmldsig#hmac-sha1");
     this.HmacSha256Signature = this.LookupDictionaryString(dictionary, "http://www.w3.org/2001/04/xmldsig-more#hmac-sha256");
     this.Psha1KeyDerivation = this.LookupDictionaryString(dictionary, "http://schemas.xmlsoap.org/ws/2005/02/sc/dk/p_sha1");
     this.Ripemd160Digest = this.LookupDictionaryString(dictionary, "http://www.w3.org/2001/04/xmlenc#ripemd160");
     this.RsaOaepKeyWrap = this.LookupDictionaryString(dictionary, "http://www.w3.org/2001/04/xmlenc#rsa-oaep-mgf1p");
     this.RsaSha1Signature = this.LookupDictionaryString(dictionary, "http://www.w3.org/2000/09/xmldsig#rsa-sha1");
     this.RsaSha256Signature = this.LookupDictionaryString(dictionary, "http://www.w3.org/2001/04/xmldsig-more#rsa-sha256");
     this.RsaV15KeyWrap = this.LookupDictionaryString(dictionary, "http://www.w3.org/2001/04/xmlenc#rsa-1_5");
     this.Sha1Digest = this.LookupDictionaryString(dictionary, "http://www.w3.org/2000/09/xmldsig#sha1");
     this.Sha256Digest = this.LookupDictionaryString(dictionary, "http://www.w3.org/2001/04/xmlenc#sha256");
     this.Sha512Digest = this.LookupDictionaryString(dictionary, "http://www.w3.org/2001/04/xmlenc#sha512");
     this.TripleDesEncryption = this.LookupDictionaryString(dictionary, "http://www.w3.org/2001/04/xmlenc#tripledes-cbc");
     this.TripleDesKeyWrap = this.LookupDictionaryString(dictionary, "http://www.w3.org/2001/04/xmlenc#kw-tripledes");
     this.TlsSspiKeyWrap = this.LookupDictionaryString(dictionary, "http://schemas.xmlsoap.org/2005/02/trust/tlsnego#TLS_Wrap");
     this.WindowsSspiKeyWrap = this.LookupDictionaryString(dictionary, "http://schemas.xmlsoap.org/2005/02/trust/spnego#GSS_Wrap");
 }

        public SamlDelegatingWriter(XmlDictionaryWriter innerWriter, Stream canonicalStream, ICanonicalWriterEndRootElementCallback callback, IXmlDictionary dictionary)
        {
            if (innerWriter == null)
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("innerWriter");

            if (canonicalStream == null)
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("canonicalStream");

            if (callback == null)
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("callback");

            if (dictionary == null)
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("dictionary");

            this.innerWriter = innerWriter;
            this.canonicalStream = canonicalStream;
            this.callback = callback;
            this.dictionary = dictionary;
            this.elementCount = 0;

            this.startFragment = new MemoryStream();
            this.signatureFragment = new MemoryStream();
            this.endFragment = new MemoryStream();
            this.writerStream = new MemoryStream();

            this.effectiveWriter = XmlDictionaryWriter.CreateBinaryWriter(this.writerStream, this.dictionary);
            this.effectiveWriter.StartCanonicalization(this.canonicalStream, false, null);
            ((IFragmentCapableXmlDictionaryWriter)this.effectiveWriter).StartFragment(this.startFragment, false);
        }

 private XmlDictionaryString LookupDictionaryString(IXmlDictionary dictionary, string value)
 {
     XmlDictionaryString str;
     if (!dictionary.TryLookup(value, out str))
     {
         throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(System.IdentityModel.SR.GetString("XDCannotFindValueInDictionaryString", new object[] { value }));
     }
     return str;
 }

 public UtilityDictionary(IXmlDictionary dictionary)
 {
     this.IdAttribute = this.LookupDictionaryString(dictionary, "Id");
     this.Namespace = this.LookupDictionaryString(dictionary, "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd");
     this.Timestamp = this.LookupDictionaryString(dictionary, "Timestamp");
     this.CreatedElement = this.LookupDictionaryString(dictionary, "Created");
     this.ExpiresElement = this.LookupDictionaryString(dictionary, "Expires");
     this.Prefix = this.LookupDictionaryString(dictionary, "u");
 }

 public DictionaryManager(IXmlDictionary parentDictionary)
 {
     this.samlDictionary = new System.IdentityModel.SamlDictionary(parentDictionary);
     this.sigantureDictionary = new System.IdentityModel.XmlSignatureDictionary(parentDictionary);
     this.utilityDictionary = new System.IdentityModel.UtilityDictionary(parentDictionary);
     this.exclusiveC14NDictionary = new System.IdentityModel.ExclusiveC14NDictionary(parentDictionary);
     this.securityAlgorithmDictionary = new System.IdentityModel.SecurityAlgorithmDictionary(parentDictionary);
     this.parentDictionary = parentDictionary;
 }

 public void SetBuffer(Stream stream, IXmlDictionary dictionary, XmlBinaryReaderSession session)
 {
     if (streamBuffer == null)
     {
         streamBuffer = new byte[128];
     }
     SetBuffer(stream, streamBuffer, 0, 0, dictionary, session);
     this.windowOffset = 0;
     this.windowOffsetMax = streamBuffer.Length;
 }

 public static XmlDictionaryReader CreateBinaryReader(byte[] buffer, int offset, int count,
                                                      IXmlDictionary dictionary,
                                                      XmlDictionaryReaderQuotas quotas,
                                                      XmlBinaryReaderSession session,
                                                      OnXmlDictionaryReaderClose onClose)
 {
     XmlBinaryReader reader = new XmlBinaryReader();
     reader.SetInput(buffer, offset, count, dictionary, quotas, session, onClose);
     return reader;
 }

 public void SetOutput(Stream stream, IXmlDictionary dictionary, XmlBinaryWriterSession session, bool ownsStream)
 {
     this.dictionary = dictionary;
     this.session = session;
     this.inAttribute = false;
     this.inList = false;
     this.attributeValue.Clear();
     this.textNodeOffset = -1;
     base.SetOutput(stream, ownsStream, null);
 }

 public void SetOutput(Stream stream, IXmlDictionary dictionary, XmlBinaryWriterSession session, bool ownsStream)
 {
     _dictionary = dictionary;
     _session = session;
     _inAttribute = false;
     _inList = false;
     _attributeValue.Clear();
     _textNodeOffset = -1;
     SetOutput(stream, ownsStream, null);
 }

 public void SetInput(Stream stream,
                      IXmlDictionary dictionary,
                     XmlDictionaryReaderQuotas quotas,
                     XmlBinaryReaderSession session)
 {
     if (stream == null)
         throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("stream");
     MoveToInitial(quotas, session, null);
     BufferReader.SetBuffer(stream, dictionary, session);
     _buffered = false;
 }

 public XmlDictionaryString(IXmlDictionary dictionary, string value, int key)
 {
     if (dictionary == null)
         throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException(nameof(dictionary)));
     if (value == null)
         throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException(nameof(value)));
     if (key < MinKey || key > MaxKey)
         throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException(nameof(key), SR.Format(SR.ValueMustBeInRange, MinKey, MaxKey)));
     _dictionary = dictionary;
     _value = value;
     _key = key;
 }

 public XmlDictionaryString(IXmlDictionary dictionary, string value, int key)
 {
     if (dictionary == null)
         throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("dictionary"));
     if (value == null)
         throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("value"));
     if (key < MinKey || key > MaxKey)
         throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("key", SR.GetString(SR.ValueMustBeInRange, MinKey, MaxKey)));
     this.dictionary = dictionary;
     this.value = value;
     this.key = key;
 }

 public void SetOutput(Stream stream, IXmlDictionary dictionary, XmlBinaryWriterSession session, bool ownsStream)
 {
     if (stream == null)
     {
         throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("stream"));
     }
     if (this.writer == null)
     {
         this.writer = new XmlBinaryNodeWriter();
     }
     this.writer.SetOutput(stream, dictionary, session, ownsStream);
     base.SetOutput(this.writer);
 }

		public XmlDictionaryString (IXmlDictionary dictionary,
			string value, int key)
		{
			if (dictionary == null)
				throw new ArgumentNullException ("dictionary");
			if (value == null)
				throw new ArgumentNullException ("value");
			if (key < 0 || key > (int.MaxValue/4))
				throw new ArgumentOutOfRangeException ("key");
			this.dict = dictionary;
			this.value = value;
			this.key = key;
		}

 public XmlDictionaryString(IXmlDictionary dictionary, string value, int key)
 {
     if (dictionary == null)
     {
         throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("dictionary"));
     }
     if (value == null)
     {
         throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("value"));
     }
     if ((key < 0) || (key > 0x1fffffff))
     {
         throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("key", System.Runtime.Serialization.SR.GetString("ValueMustBeInRange", new object[] { 0, 0x1fffffff })));
     }
     this.dictionary = dictionary;
     this.value = value;
     this.key = key;
 }