public bool TryGet(TKey name, out TValue value)
{
if (name is null)
{
CThrowHelper.ThrowArgumentNullException(CExceptionArgument.name);
}
bool found = false;
int h = _hashingStrategy.HashCode(name);
int i = Index(h);
HeaderEntry <TKey, TValue> e = _entries[i];
value = default;
// loop until the first header was found
while (e is object)
{
if (e.Hash == h && _hashingStrategy.Equals(name, e._key))
{
value = e._value;
found = true;
}
e = e.Next;
}
return(found);
}
public void ValidateName(T name)
{
if (name is null)
{
CThrowHelper.ThrowArgumentNullException(CExceptionArgument.name);
}
}
public DefaultHeaders(IHashingStrategy <TKey> nameHashingStrategy,
IValueConverter <TValue> valueConverter, INameValidator <TKey> nameValidator, int arraySizeHint)
{
if (nameHashingStrategy is null)
{
CThrowHelper.ThrowArgumentNullException(CExceptionArgument.nameHashingStrategy);
}
if (valueConverter is null)
{
CThrowHelper.ThrowArgumentNullException(CExceptionArgument.valueConverter);
}
if (nameValidator is null)
{
CThrowHelper.ThrowArgumentNullException(CExceptionArgument.nameValidator);
}
_hashingStrategy = nameHashingStrategy;
ValueConverter = valueConverter;
_nameValidator = nameValidator;
// Enforce a bound of [2, 128] because hashMask is a byte. The max possible value of hashMask is one less
// than the length of this array, and we want the mask to be > 0.
_entries = new HeaderEntry <TKey, TValue> [FindNextPositivePowerOfTwo(Math.Max(2, Math.Min(arraySizeHint, 128)))];
_hashMask = (byte)(_entries.Length - 1);
_head = new HeaderEntry <TKey, TValue>();
}
public static DecoderResult Failure(Exception cause)
{
if (cause is null)
{
CThrowHelper.ThrowArgumentNullException(CExceptionArgument.cause);
}
return(new DecoderResult(cause));
}
protected DecoderResult(Exception cause)
{
if (cause is null)
{
CThrowHelper.ThrowArgumentNullException(CExceptionArgument.cause);
}
this.cause = cause;
}
public bool ContainsObject(TKey name, object value)
{
if (value is null)
{
CThrowHelper.ThrowArgumentNullException(CExceptionArgument.value);
}
return(Contains(name, ValueConverter.ConvertObject(value)));
}
/// <summary>
/// Create a <see cref="DatagramPacket"/> decoder using the specified <see cref="IByteBuffer"/> decoder.
/// </summary>
/// <param name="decoder">the specified <see cref="IByteBuffer"/> decoder</param>
public DatagramPacketDecoder(MessageToMessageDecoder <IByteBuffer> decoder)
{
if (decoder is null)
{
CThrowHelper.ThrowArgumentNullException(CExceptionArgument.decoder);
}
this.decoder = decoder;
}
/// <summary>
/// Create an encoder that encodes the content in <see cref="IAddressedEnvelope{T}"/> to <see cref="DatagramPacket"/> using
/// the specified message encoder.
/// </summary>
/// <param name="encoder">the specified message encoder</param>
public DatagramPacketEncoder(MessageToMessageEncoder <T> encoder)
{
if (encoder is null)
{
CThrowHelper.ThrowArgumentNullException(CExceptionArgument.encoder);
}
this.encoder = encoder;
}
/// <summary>
/// Allocate a <see cref="IByteBuffer"/> which will be used as argument of <see cref="Encode(IChannelHandlerContext, T, IByteBuffer)"/>.
/// Sub-classes may override this method to return <see cref="IByteBuffer"/> with a perfect matching <c>initialCapacity</c>.
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
protected virtual IByteBuffer AllocateBuffer(IChannelHandlerContext context)
{
if (context is null)
{
CThrowHelper.ThrowArgumentNullException(CExceptionArgument.context);
}
return(context.Allocator.Buffer());
}
/// <summary>
/// Set the <see cref="ICumulator"/> to use for cumulate the received <see cref="IByteBuffer"/>s.
/// </summary>
/// <param name="cumulator"></param>
public void SetCumulator(ICumulator cumulator)
{
if (cumulator is null)
{
CThrowHelper.ThrowArgumentNullException(CExceptionArgument.cumulator);
}
_cumulator = cumulator;
}
public virtual IHeaders <TKey, TValue> AddObject(TKey name, object value)
{
if (value is null)
{
CThrowHelper.ThrowArgumentNullException(CExceptionArgument.value);
}
return(Add(name, ValueConverter.ConvertObject(value)));
}
public virtual IHeaders <TKey, TValue> SetObject(TKey name, object value)
{
if (value is null)
{
CThrowHelper.ThrowArgumentNullException(CExceptionArgument.value);
}
TValue convertedValue = ValueConverter.ConvertObject(value);
return(Set(name, convertedValue));
}
public bool TryGetAndRemove(TKey name, out TValue value)
{
if (name is null)
{
CThrowHelper.ThrowArgumentNullException(CExceptionArgument.name);
}
int h = _hashingStrategy.HashCode(name);
return(TryRemove0(h, Index(h), name, out value));
}
/// <inheritdoc />
public override void Write(IChannelHandlerContext context, object message, IPromise promise)
{
if (context is null)
{
CThrowHelper.ThrowArgumentNullException(CExceptionArgument.context);
}
IByteBuffer buffer = null;
try
{
if (this.AcceptOutboundMessage(message))
{
var input = (T)message;
buffer = this.AllocateBuffer(context);
try
{
this.Encode(context, input, buffer);
}
finally
{
_ = ReferenceCountUtil.Release(input);
}
if (buffer.IsReadable())
{
_ = context.WriteAsync(buffer, promise);
}
else
{
_ = buffer.Release();
_ = context.WriteAsync(Unpooled.Empty, promise);
}
buffer = null;
}
else
{
_ = context.WriteAsync(message, promise);
}
}
catch (EncoderException)
{
throw;
}
catch (Exception ex)
{
CThrowHelper.ThrowEncoderException(ex);
}
finally
{
_ = (buffer?.Release());
}
}
public ValueEnumerator(DefaultHeaders <TKey, TValue> headers, TKey name)
{
if (name is null)
{
CThrowHelper.ThrowArgumentNullException(CExceptionArgument.name);
}
_hashingStrategy = headers._hashingStrategy;
_hash = _hashingStrategy.HashCode(name);
_name = name;
_node = _head = headers._entries[headers.Index(_hash)];
_current = default;
}
public virtual IHeaders <TKey, TValue> Add(TKey name, TValue value)
{
if (value == null)
{
CThrowHelper.ThrowArgumentNullException(CExceptionArgument.value);
}
_nameValidator.ValidateName(name);
int h = _hashingStrategy.HashCode(name);
int i = Index(h);
Add0(h, i, name, value);
return(this);
}
public TValue SetValue(TValue newValue)
{
if (_isReadonly)
{
CThrowHelper.ThrowNotSupportedException_Readonly();
}
if (newValue == null)
{
CThrowHelper.ThrowArgumentNullException(CExceptionArgument.newValue);
}
TValue oldValue = _value;
_value = newValue;
return(oldValue);
}
public static DateTime? ParseHttpDate(ICharSequence txt, int start, int end)
{
if (txt is null) { CThrowHelper.ThrowArgumentNullException(CExceptionArgument.txt); }
int length = end - start;
if (0u >= (uint)length)
{
return null;
}
else if (length < 0)
{
CThrowHelper.ThrowArgumentException_CannotHaveEndStart();
}
else if (length > 64)
{
CThrowHelper.ThrowArgumentException_CannotParseMoreThan64Chars();
}
return Formatter().Parse0(txt, start, end);
}
public bool Contains(TKey name, TValue value, IHashingStrategy <TValue> valueHashingStrategy)
{
if (name is null)
{
CThrowHelper.ThrowArgumentNullException(CExceptionArgument.name);
}
int h = _hashingStrategy.HashCode(name);
int i = Index(h);
HeaderEntry <TKey, TValue> e = _entries[i];
while (e is object)
{
if (e.Hash == h && _hashingStrategy.Equals(name, e._key) &&
valueHashingStrategy.Equals(value, e._value))
{
return(true);
}
e = e.Next;
}
return(false);
}
public virtual IList <TValue> GetAll(TKey name)
{
if (name is null)
{
CThrowHelper.ThrowArgumentNullException(CExceptionArgument.name);
}
var values = new List <TValue>();
int h = _hashingStrategy.HashCode(name);
int i = Index(h);
HeaderEntry <TKey, TValue> e = _entries[i];
while (e is object)
{
if (e.Hash == h && _hashingStrategy.Equals(name, e._key))
{
values.Insert(0, e._value);
}
e = e.Next;
}
return(values);
}
public virtual IHeaders <TKey, TValue> SetObject(TKey name, IEnumerable <object> values)
{
if (values is null)
{
CThrowHelper.ThrowArgumentNullException(CExceptionArgument.values);
}
_nameValidator.ValidateName(name);
int h = _hashingStrategy.HashCode(name);
int i = Index(h);
_ = TryRemove0(h, i, name, out _);
// ReSharper disable once PossibleNullReferenceException
foreach (object v in values)
{
if (v is null)
{
break;
}
Add0(h, i, name, ValueConverter.ConvertObject(v));
}
return(this);
}
/// <summary>
/// Called once data should be decoded from the given <see cref="IByteBuffer"/>. This method will call
/// <see cref="Decode(IChannelHandlerContext, IByteBuffer, List{object})"/> as long as decoding should take place.
/// </summary>
/// <param name="context"></param>
/// <param name="input"></param>
/// <param name="output"></param>
protected virtual void CallDecode(IChannelHandlerContext context, IByteBuffer input, List <object> output)
{
if (context is null)
{
CThrowHelper.ThrowArgumentNullException(CExceptionArgument.context);
}
if (input is null)
{
CThrowHelper.ThrowArgumentNullException(CExceptionArgument.input);
}
if (output is null)
{
CThrowHelper.ThrowArgumentNullException(CExceptionArgument.output);
}
try
{
while (input.IsReadable())
{
int initialOutputCount = output.Count;
if ((uint)initialOutputCount > 0u)
{
FireChannelRead(context, output, initialOutputCount);
output.Clear();
// Check if this handler was removed before continuing with decoding.
// If it was removed, it is not safe to continue to operate on the buffer.
//
// See:
// - https://github.com/netty/netty/issues/4635
if (context.IsRemoved)
{
break;
}
initialOutputCount = 0;
}
int oldInputLength = input.ReadableBytes;
DecodeRemovalReentryProtection(context, input, output);
// Check if this handler was removed before continuing the loop.
// If it was removed, it is not safe to continue to operate on the buffer.
//
// See https://github.com/netty/netty/issues/1664
if (context.IsRemoved)
{
break;
}
bool noOutgoingMessages = 0u >= (uint)(oldInputLength - input.ReadableBytes);
if (0u >= (uint)(initialOutputCount - output.Count))
{
// no outgoing messages have been produced
if (noOutgoingMessages)
{
break;
}
else
{
continue;
}
}
if (noOutgoingMessages)
{
CThrowHelper.ThrowDecoderException_ByteToMessageDecoder(GetType());
}
if (SingleDecode)
{
break;
}
}
}
catch (DecoderException)
{
throw;
}
catch (Exception cause)
{
CThrowHelper.ThrowDecoderException(cause);
}
}