public Header AddHeader(HeaderNames name, string val = null)
{
var header = new Header(name, val);
Add(header);
return(header);
}
protected virtual string GetMessage()
{
return(string.Format("Row {0}: The row value count ({1}) does not equal the head count ({2}).\n{3}\n{4}",
RowIndex,
CurrentValues.Count,
HeaderNames.Count,
string.Join(",", HeaderNames.ToArray()),
string.Join(",", CurrentValues.ToArray())));
}
public IEnumerable <int> FindHeaderIndexes(HeaderNames name)
{
for (int i = 0; i < Count.HeaderCount; i++)
{
if (Headers[i].HeaderName == name)
{
yield return(i);
}
}
}
private void TestRawHeaderParse(HeaderNames header, string value)
{
var name = Encoding.UTF8.GetString(header.ToUtf8Bytes());
var dfa = ParseHeader(name + ": " + value);
Assert.AreEqual(1, dfa.Count.HeaderCount);
Assert.AreEqual(name, dfa.Headers[0].Name.ToString());
Assert.AreEqual(header, dfa.Headers[0].HeaderName);
Assert.AreEqual(" " + value, dfa.Headers[0].Value.ToString());
}
public Header FindHeader(HeaderNames name)
{
for (int i = 0; i < Count.HeaderCount; i++)
{
if (Headers[i].HeaderName == name)
{
return(Headers[i]);
}
}
throw new Exception(string.Format(@"Header {0} not found", name.ToString()));
}
public void WriteDigestAuthorization(HeaderNames header, ByteArrayPart username, ByteArrayPart realm, AuthQops qop,
AuthAlgorithms algorithm, ByteArrayPart uri, ByteArrayPart nonce, int nc, int cnonce, ByteArrayPart opaque, byte[] response)
{
if (header == HeaderNames.Authorization)
{
Write(C.Authorization);
}
else if (header == HeaderNames.ProxyAuthorization)
{
Write(C.Proxy_Authorization);
}
else
{
throw new ArgumentException(@"HeaderNames");
}
Write(C.__Digest_username__);
Write(username);
Write(C.___realm__);
Write(realm);
if (qop != AuthQops.None)
{
Write(C.___qop__);
Write(qop.ToByteArrayPart());
}
else
{
Write(C.DQUOTE);
}
Write(C.__algorithm_);
Write(algorithm.ToByteArrayPart());
Write(C.__uri__);
Write(uri);
Write(C.___nonce__);
Write(nonce);
if (qop != AuthQops.None)
{
Write(C.__nc_);
Write(nc);
Write(C.__cnonce__);
WriteAsHex8(cnonce);
}
Write(C.___opaque__);
if (opaque.IsValid)
{
Write(opaque);
}
Write(C.___response__);
Write(response);
Write(C.DQUOTE);
Write(C.CRLF);
}
// find the indx in data for flight variables
public void inxFlightVar()
{
rudderInx = HeaderNames.FindIndex(a => a.Contains("rudder"));
throttleInx = HeaderNames.FindIndex(a => a.Contains("throttle"));
airspeedInx = HeaderNames.FindIndex(a => a.Contains("airspeed-kt"));
altimeterInx = HeaderNames.FindIndex(a => a.Contains("altimeter_indicated-altitude-ft"));
rollInx = HeaderNames.FindIndex(a => a.Contains("roll-deg"));
pitchInx = HeaderNames.FindIndex(a => a.Contains("pitch-deg"));
yawInx = HeaderNames.FindIndex(a => a.Contains("side-slip-deg"));
headingInx = HeaderNames.FindIndex(a => a.Contains("heading-deg"));
aileronInx = HeaderNames.FindIndex(a => a.Contains("aileron"));
elevatorInx = HeaderNames.FindIndex(a => a.Contains("elevator"));
}
/// <summary>
/// 添加头
/// </summary>
/// <param name="name"> </param>
/// <param name="values"> </param>
private void AddHeader(string name, IEnumerable <string> values)
{
Request?.OnHeaderFound(ref name, ref values);
if (values == null)
{
return;
}
foreach (var value in values)
{
HeaderNames.Add(name);
Headers.Add(new KeyValuePair <string, string>(name, value));
}
}
/// <summary>
/// Sets the header.
/// </summary>
/// <param name="name">The header name.</param>
/// <param name="val">The header value.</param>
public void SetHeader(HeaderNames name, string val = null)
{
var header = GetHeader(name);
if (header != null)
{
header.Value = val;
}
else
{
AddHeader(name, val);
}
}
static void Main(string[] args)
{
var e1 = Object.ReferenceEquals("Accept", HeaderNames.Accept);
var e2 = Object.ReferenceEquals("Accept", HeaderNames.AcceptConst);
var e3 = Object.ReferenceEquals(HeaderNames.Accept, HeaderNames.AcceptConst);
Console.WriteLine(e1);
Console.WriteLine(e2);
Console.WriteLine(e3);
Console.WriteLine(HeaderNames.IsAccept("accept"));
Console.WriteLine(HeaderNames.IsAcceptConst("accept"));
Console.WriteLine(HeaderNames.X);
}
public int CountHeaders(HeaderNames name)
{
int count = 0;
for (int i = 0; i < Count.HeaderCount; i++)
{
if (Headers[i].HeaderName == name)
{
count++;
}
}
return(count);
}
public int FindHeaderIndex(HeaderNames name, int skipCount)
{
for (int i = 0; i < Count.HeaderCount; i++)
{
if (Headers[i].HeaderName == name)
{
if (skipCount == 0)
{
return(i);
}
skipCount--;
}
}
return(-1);
}
public IBaseMessage Execute(IPipelineContext pContext, IBaseMessage pInMsg)
{
string errorMessage;
if (!Validate(out errorMessage))
{
throw new ArgumentException(errorMessage);
}
//Component will not be executed if the property is set to true
if (Disabled)
{
return(pInMsg);
}
IBaseMessageContext context = pInMsg.Context;
string[] PropertyPathList = PropertyPaths.Split(';');
string[] HeaderNamesList = HeaderNames.Split(';');
StringBuilder sb = new StringBuilder();
for (int i = 0; i < PropertyPathList.Length; i++)
{
sb.Append(HeaderNamesList[i] + ":" + (string)context.Read(new ContextProperty(PropertyPathList[i])));
if (i < PropertyPathList.Length - 1)
{
sb.Append(" ");
}
}
string HttpHeaders = sb.ToString();
if (PromoteProperty)
{
pInMsg.Context.Promote(new ContextProperty(DestinationPath), HttpHeaders);
}
else
{
pInMsg.Context.Write(new ContextProperty(DestinationPath), HttpHeaders);
}
return(pInMsg);
}
public void WriteDigestAuthorization(HeaderNames header, ByteArrayPart username, ByteArrayPart realm, AuthQops qop,
AuthAlgorithms algorithm, ByteArrayPart uri, ByteArrayPart nonce, int nc, int cnonce, ByteArrayPart opaque, byte[] response)
{
if (header == HeaderNames.Authorization)
Write(C.Authorization);
else if (header == HeaderNames.ProxyAuthorization)
Write(C.Proxy_Authorization);
else
throw new ArgumentException(@"HeaderNames");
Write(C.__Digest_username__);
Write(username);
Write(C.___realm__);
Write(realm);
if (qop != AuthQops.None)
{
Write(C.___qop__);
Write(qop.ToByteArrayPart());
}
else
Write(C.DQUOTE);
Write(C.__algorithm_);
Write(algorithm.ToByteArrayPart());
Write(C.__uri__);
Write(uri);
Write(C.___nonce__);
Write(nonce);
if (qop != AuthQops.None)
{
Write(C.__nc_);
Write(nc);
Write(C.__cnonce__);
WriteAsHex8(cnonce);
}
Write(C.___opaque__);
if (opaque.IsValid)
Write(opaque);
Write(C.___response__);
Write(response);
Write(C.DQUOTE);
Write(C.CRLF);
}
/// <summary>
/// Initializes a new instance of the <see cref="HeaderApiVersionReader"/> class.
/// </summary>
/// <param name="headerNames">An array of HTTP header names to read the service API version from.</param>
public HeaderApiVersionReader(params string[] headerNames)
{
Arg.NotNull(headerNames, nameof(headerNames));
HeaderNames.AddRange(headerNames);
}
public int FindHeaderIndex(HeaderNames name, int skipCount)
{
for (int i = 0; i < Count.HeaderCount; i++)
{
if (Headers[i].HeaderName == name)
{
if (skipCount == 0)
return i;
skipCount--;
}
}
return -1;
}
/// <summary>
/// Gets the header with the given header name.
/// </summary>
/// <param name="name">The header name.</param>
/// <returns>Header.</returns>
public Header GetHeader(HeaderNames name)
{
return(Elements <Header>().FirstOrDefault(h => h.HeaderName == name));
}
public static byte[] ToUtf8Bytes(this HeaderNames headerName)
{
return(Converters.headerNames[(int)headerName]);
}
public void WriteHeader(HeaderNames name, ByteArrayPart value)
{
Write(name.ToUtf8Bytes());
Write(C.HCOLON, C.SP, value, C.CRLF);
}
/// <summary>
/// Gets the header with the given header name.
/// </summary>
/// <param name="name">The header name.</param>
/// <returns>Header.</returns>
public Header GetHeader(HeaderNames name)
{
return(GetHeader(name.GetName()));
}
/// <summary>
/// Determines whether a header with the specified name exists.
/// </summary>
/// <param name="name">The name.</param>
/// <returns><c>true</c> if the header exists; otherwise, <c>false</c>.</returns>
public bool HasHeader(HeaderNames name)
{
return(HasHeader(name.GetName()));
}
/// <summary> /// Gets the <see cref="Header"/> with the specified name. /// </summary> /// <param name="name">The header name.</param> /// <returns>the Header.</returns> public Header this[HeaderNames name] => HasHeader(name.GetName()) ? GetHeader(name.GetName()) : AddHeader(name.GetName());
public void WriteHeader(HeaderNames name, ByteArrayPart value)
{
Write(name.ToUtf8Bytes());
Write(C.HCOLON, C.SP, value, C.CRLF);
}
public Header(HeaderNames headerName, string val) : base(Namespaces.HttpUpload, "header")
{
this.HeaderName = headerName;
this.Value = val;
}
public Header FindHeader(HeaderNames name)
{
for (int i = 0; i < Count.HeaderCount; i++)
if (Headers[i].HeaderName == name)
return Headers[i];
throw new Exception(string.Format(@"Header {0} not found", name.ToString()));
}
public void SetDefaultValue(int index)
{
this.HeaderName = HeaderNames.None;
this.Name.SetDefaultValue(index);
this.Value.SetDefaultValue(index);
}
public int CountHeaders(HeaderNames name)
{
int count = 0;
for (int i = 0; i < Count.HeaderCount; i++)
if (Headers[i].HeaderName == name)
count++;
return count;
}
/// <summary>
/// Determines whether a header with the specified name exists.
/// </summary>
/// <param name="name">The name.</param>
/// <returns><c>true</c> if the header exists; otherwise, <c>false</c>.</returns>
public bool HasHeader(HeaderNames name)
{
return(Elements <Header>().Any(h => h.HeaderName == name));
}
public override bool Synthesize()
{
ValidateSynthesizer();
audioFileNumber = -1;
WaveFileWriter writer = null;
MemoryStream writerStream = null;
var encodingTaskStack = new Stack <Task>();
var elements = ElementsToSynthesize;
for (int i = 0; i < elements.Count; i++)
{
if (FireProgress(
100 * i / elements.Count,
$"Synthesizing element {i + 1} of {elements.Count} to {AudioFileName}"))
{
return(false);
}
var elem = elements[i];
if (HeaderNames.Contains(elem.Name) || writer == null)
{
if (EncodeMp3)
{
writer?.Flush();
encodingTaskStack.Push(EncodeMp3AudioFile(writerStream, AudioFilePath));
audioFileNumber++;
writerStream = new MemoryStream();
writer = new WaveFileWriter(writerStream, AudioWaveFormat);
}
else
{
writer?.Close();
audioFileNumber++;
writer = new WaveFileWriter(AudioFilePath, AudioWaveFormat);
}
}
var ci = Utils.SelectCulture(elem);
var synth = CultureInfo.InvariantCulture.Equals(ci)
? DefaultSynthesizer
: SynthesizerSelector(ci);
synth.TextToSynthesizeDelegate = e => e.Value;
synth.SynthesizeElement(elem, writer, AudioFileName);
}
if (EncodeMp3 && writer != null)
{
writer.Flush();
encodingTaskStack.Push(EncodeMp3AudioFile(writerStream, AudioFilePath));
var taskCount = encodingTaskStack.Count;
while (encodingTaskStack.Any())
{
FireProgress(
100 * (taskCount - encodingTaskStack.Count) / taskCount,
$"Waiting for mp3 encoding to finish {encodingTaskStack.Count} left of {taskCount}");
encodingTaskStack.Pop().Wait();
}
}
else
{
writer?.Close();
}
return(true);
}
public IEnumerable<int> FindHeaderIndexes(HeaderNames name)
{
for (int i = 0; i < Count.HeaderCount; i++)
if (Headers[i].HeaderName == name)
yield return i;
}
/// <summary>
/// Initializes a new instance of the <see cref="Header"/> class.
/// </summary>
/// <param name="name">The header name.</param>
/// <param name="val">The header value.</param>
public Header(HeaderNames name, string val = null)
: this(name.GetName(), val)
{
}
public static ulong ToMask(this HeaderNames name)
{
switch (name)
{
case HeaderNames.None:
return(0uL);
case HeaderNames.Extension:
return(1uL);
case HeaderNames.ContentType:
return(2uL);
case HeaderNames.ContentEncoding:
return(4uL);
case HeaderNames.From:
return(8uL);
case HeaderNames.CallId:
return(16uL);
case HeaderNames.Supported:
return(32uL);
case HeaderNames.ContentLength:
return(64uL);
case HeaderNames.Contact:
return(128uL);
case HeaderNames.Event:
return(256uL);
case HeaderNames.Subject:
return(512uL);
case HeaderNames.To:
return(1024uL);
case HeaderNames.AllowEvents:
return(2048uL);
case HeaderNames.Via:
return(4096uL);
case HeaderNames.CSeq:
return(8192uL);
case HeaderNames.Date:
return(16384uL);
case HeaderNames.Allow:
return(32768uL);
case HeaderNames.Route:
return(65536uL);
case HeaderNames.Accept:
return(131072uL);
case HeaderNames.Server:
return(262144uL);
case HeaderNames.Expires:
return(1125899906842624uL);
case HeaderNames.Require:
return(524288uL);
case HeaderNames.Warning:
return(1048576uL);
case HeaderNames.Priority:
return(2097152uL);
case HeaderNames.ReplyTo:
return(4194304uL);
case HeaderNames.SipEtag:
return(281474976710656uL);
case HeaderNames.CallInfo:
return(8388608uL);
case HeaderNames.Timestamp:
return(16777216uL);
case HeaderNames.AlertInfo:
return(33554432uL);
case HeaderNames.ErrorInfo:
return(67108864uL);
case HeaderNames.UserAgent:
return(134217728uL);
case HeaderNames.InReplyTo:
return(268435456uL);
case HeaderNames.MinExpires:
return(536870912uL);
case HeaderNames.RetryAfter:
return(1073741824uL);
case HeaderNames.Unsupported:
return((ulong)-2147483648);
case HeaderNames.MaxForwards:
return(4294967296uL);
case HeaderNames.MimeVersion:
return(8589934592uL);
case HeaderNames.Organization:
return(17179869184uL);
case HeaderNames.RecordRoute:
return(34359738368uL);
case HeaderNames.SipIfMatch:
return(562949953421312uL);
case HeaderNames.Authorization:
return(68719476736uL);
case HeaderNames.ProxyRequire:
return(137438953472uL);
case HeaderNames.AcceptEncoding:
return(274877906944uL);
case HeaderNames.AcceptLanguage:
return(549755813888uL);
case HeaderNames.ContentLanguage:
return(1099511627776uL);
case HeaderNames.WwwAuthenticate:
return(2199023255552uL);
case HeaderNames.ProxyAuthenticate:
return(4398046511104uL);
case HeaderNames.SubscriptionState:
return(8796093022208uL);
case HeaderNames.AuthenticationInfo:
return(17592186044416uL);
case HeaderNames.ContentDisposition:
return(35184372088832uL);
case HeaderNames.ProxyAuthorization:
return(70368744177664uL);
case HeaderNames.ProxyAuthenticationInfo:
return(140737488355328uL);
default:
throw new ArgumentOutOfRangeException(name.ToString());
}
}
public static bool IsMasked(this HeaderNames name, ulong mask)
{
return((mask & name.ToMask()) > 0uL);
}
public Header AddHeader(HeaderNames name, string val = null)
{
return(AddHeader(name.GetName(), val));
}
/// <summary>
/// Initializes a new instance of the <see cref="HeaderApiVersionReader"/> class.
/// </summary>
/// <param name="headerNames">A <see cref="IEnumerable{T}">sequence</see> of HTTP header names to read the service API version from.</param>
public HeaderApiVersionReader(IEnumerable <string> headerNames)
{
Arg.NotNull(headerNames, nameof(headerNames));
HeaderNames.AddRange(headerNames);
}
/// <summary>
/// Sets the header.
/// </summary>
/// <param name="name">The header name.</param>
/// <param name="val">The header value.</param>
public void SetHeader(HeaderNames name, string val = null)
{
SetHeader(name.GetName(), val);
}
private void TestRawHeaderParse(HeaderNames header, string value)
{
var name = Encoding.UTF8.GetString(header.ToUtf8Bytes());
var dfa = ParseHeader(name + ": " + value);
Assert.AreEqual(1, dfa.Count.HeaderCount);
Assert.AreEqual(name, dfa.Headers[0].Name.ToString());
Assert.AreEqual(header, dfa.Headers[0].HeaderName);
Assert.AreEqual(" " + value, dfa.Headers[0].Value.ToString());
}
