/// <summary>
/// 输出一行具有高亮标注出特定词语、字、句子的字符串
/// </summary>
/// <param name="value">值</param>
/// <param name="delay">输出间隔（值越大输出速度越慢）</param>
/// <param name="line">换行值</param>
/// <param name="color">文字颜色</param>
/// <param name="keyColor">标注颜色</param>
/// <param name="keyWord">关键词组</param>
public static void PrintKeyWord(object value, int delay, int line, ConsoleColor color, ConsoleColor keyColor, params string[] keyWord)
{
char[] flag = new char[] { ',', ' ', '\t', '\n', '.', '?', '!', '\"', '。', '，', '！', '？', '”', '“' };
string[] valueWord = STRING.InputSplit(value.ToString(), flag);
//逆向拆卸
string[] pun = STRING.InputSplit(value.ToString(), STRING.ToCharArray(keyWord)); // 将文字剔除，留下标点符号
for (int i = 0, a = 0; i < valueWord.Length; i++, a++)
{
Console.ForegroundColor = color;
for (int j = 0; j < keyWord.Length; j++)
{
if (valueWord[i] == keyWord[j])
{
Console.ForegroundColor = keyColor;
}
}
Console.Write(valueWord[i]);
//for (int k = 0; k < pun.Length; k++)
//{
// Console.Write(pun[k]);
//}
}
}
private static IEnumerable <KeyValuePair <string, string> > ParseHeaders(STRING input)
{
if (string.IsNullOrEmpty(input))
{
return(null);
}
var headerTokens = input.Split('|');
return((from header in headerTokens
let n = header.IndexOf(':')
where n != -1
select new KeyValuePair <string, string>(
header.Substring(0, n).Trim(),
header.Substring(n + 1).Trim())
).ToList());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldCloseAllInstantiated()
public virtual void ShouldCloseAllInstantiated()
{
// given
System.Func <IndexSlot, string> factory = SlotToStringFunction();
LazyInstanceSelector <string> selector = new LazyInstanceSelector <string>(factory);
selector.Select(NUMBER);
selector.Select(STRING);
// when
System.Action <string> consumer = mock(typeof(System.Action));
selector.Close(consumer);
// then
verify(consumer, times(1)).accept(NUMBER.ToString());
verify(consumer, times(1)).accept(STRING.ToString());
verifyNoMoreInteractions(consumer);
}
/// <summary>
/// Gets a standard set of converters to be used with ConvertText. After getting back the dictionary,
/// you can manipulate the converters, or add your own using:
/// <code>
/// var DEF = GetDefaultConverters;
/// DEF[typeof (bool)] = (STRING => STRING.ToUpper() == "YES"); // new bool converter
/// DEF.Add(typeof(TimeSpan),STRING => ... ); // Add a converter for a time span
/// // etc.
/// </code>
/// </summary>
/// <returns>A set of data converters you use to in the Conver</returns>
public static Dictionary <Type, Func <String, object> > GetDefaultConverters()
{
Dictionary <Type, Func <String, object> > CONVERTERS = new Dictionary <Type, Func <string, object> >();
CONVERTERS.Add(typeof(string), STRING => STRING);
CONVERTERS.Add(typeof(short), STRING => Convert.ToInt16(STRING));
CONVERTERS.Add(typeof(int), STRING => Convert.ToInt32(STRING));
CONVERTERS.Add(typeof(long), STRING => Convert.ToInt64(STRING));
CONVERTERS.Add(typeof(float), STRING => Convert.ToSingle(STRING));
CONVERTERS.Add(typeof(decimal), STRING => Convert.ToDecimal(STRING));
CONVERTERS.Add(typeof(double), STRING => Convert.ToDouble(STRING));
// YYYYMMDD
CONVERTERS.Add(typeof(DateTime), STRING => new DateTime(Convert.ToInt32(STRING.Substring(0, 4)), Convert.ToInt32(STRING.Substring(4, 2)), Convert.ToInt32(STRING.Substring(6, 2))));
// TRUE/FALSE
CONVERTERS.Add(typeof(bool), STRING => STRING.ToUpper() == "TRUE");
return(CONVERTERS);
}
public void TestIsNumeric()
{
// Define variables and constants
Number number = 3;
const string STRING = "Hi";
const bool BOOL = true;
object @object = new object();
const decimal DECIMAL = 12m;
// Set up context
// Execute
// Assert outcome
Assert.IsTrue(Number.IsNumeric(number));
Assert.IsFalse(Number.IsNumeric(STRING));
Assert.IsFalse(Number.IsNumeric(BOOL));
Assert.IsFalse(Number.IsNumeric(@object));
Assert.IsTrue(Number.IsNumeric(DECIMAL));
Assert.IsTrue(Number.IsNumericType(number.GetType()));
Assert.IsFalse(Number.IsNumericType(STRING.GetType()));
Assert.IsFalse(Number.IsNumericType(BOOL.GetType()));
Assert.IsFalse(Number.IsNumericType(@object.GetType()));
Assert.IsTrue(Number.IsNumericType(DECIMAL.GetType()));
foreach (Number num in allNumbers)
{
Assert.IsTrue(Number.IsNumeric(num.ActualValue));
Assert.IsTrue(Number.IsNumericType(num.ActualValue.GetType()));
Assert.IsTrue(Number.IsNumericType(num.GetTypeCode()));
Assert.IsTrue(Number.IsNumericType(num.GetTypeCode().ToType()));
}
}
private void HandleFormation(ref Formation formation, string[] data)
{
LookUpTables lookUp = new LookUpTables();
int i = 0;
int a = 0;
int b = 0;
foreach (string STRING in data)
{
if (i < 2)
{
formation.FormationTight[i] = STRING.Trim().UniversalParse();
}
else if (a < 2)
{
formation.FormationSparse[a] = STRING.Trim().UniversalParse();
a++;
}
else if (b < 1)
{
formation.FormationRanks = Convert.ToInt32(STRING.Trim());
b++;
}
dynamic ft = lookUp.LookUpKey <FormationTypes>(STRING.Trim());
if (ft != null)
{
formation.FormationFlags |= ft;
}
i++;
}
}
/// <summary>
/// Extracting the data from the stream
/// </summary>
public override void extractData()
{
BiffHeader bh, latestbiff;
BOF firstBOF = null;
//try
//{
while (this.StreamReader.BaseStream.Position < this.StreamReader.BaseStream.Length)
{
bh.id = (RecordType)this.StreamReader.ReadUInt16();
bh.length = this.StreamReader.ReadUInt16();
// TraceLogger.DebugInternal("BIFF {0}\t{1}\t", bh.id, bh.length);
Console.WriteLine("WORKSHEET-BIFF {0}\t{1}\t", bh.id, bh.length);
switch (bh.id)
{
case RecordType.EOF:
{
this.StreamReader.BaseStream.Seek(0, SeekOrigin.End);
}
break;
case RecordType.BOF:
{
var bof = new BOF(this.StreamReader, bh.id, bh.length);
switch (bof.docType)
{
case BOF.DocumentType.WorkbookGlobals:
case BOF.DocumentType.Worksheet:
firstBOF = bof;
break;
case BOF.DocumentType.Chart:
// parse chart
break;
default:
this.readUnknownFile();
break;
}
}
break;
case RecordType.LabelSst:
{
var labelsst = new LabelSst(this.StreamReader, bh.id, bh.length);
this.bsd.addLabelSST(labelsst);
}
break;
case RecordType.MulRk:
{
var mulrk = new MulRk(this.StreamReader, bh.id, bh.length);
this.bsd.addMULRK(mulrk);
}
break;
case RecordType.Number:
{
var number = new Number(this.StreamReader, bh.id, bh.length);
this.bsd.addNUMBER(number);
}
break;
case RecordType.RK:
{
var rk = new RK(this.StreamReader, bh.id, bh.length);
this.bsd.addRK(rk);
}
break;
case RecordType.MergeCells:
{
var mergecells = new MergeCells(this.StreamReader, bh.id, bh.length);
this.bsd.MERGECELLSData = mergecells;
}
break;
case RecordType.Blank:
{
var blankcell = new Blank(this.StreamReader, bh.id, bh.length);
this.bsd.addBLANK(blankcell);
} break;
case RecordType.MulBlank:
{
var mulblank = new MulBlank(this.StreamReader, bh.id, bh.length);
this.bsd.addMULBLANK(mulblank);
}
break;
case RecordType.Formula:
{
var formula = new Formula(this.StreamReader, bh.id, bh.length);
this.bsd.addFORMULA(formula);
TraceLogger.DebugInternal(formula.ToString());
}
break;
case RecordType.Array:
{
var array = new ARRAY(this.StreamReader, bh.id, bh.length);
this.bsd.addARRAY(array);
}
break;
case RecordType.ShrFmla:
{
var shrfmla = new ShrFmla(this.StreamReader, bh.id, bh.length);
this.bsd.addSharedFormula(shrfmla);
}
break;
case RecordType.String:
{
var formulaString = new STRING(this.StreamReader, bh.id, bh.length);
this.bsd.addFormulaString(formulaString.value);
}
break;
case RecordType.Row:
{
var row = new Row(this.StreamReader, bh.id, bh.length);
this.bsd.addRowData(row);
}
break;
case RecordType.ColInfo:
{
var colinfo = new ColInfo(this.StreamReader, bh.id, bh.length);
this.bsd.addColData(colinfo);
}
break;
case RecordType.DefColWidth:
{
var defcolwidth = new DefColWidth(this.StreamReader, bh.id, bh.length);
this.bsd.addDefaultColWidth(defcolwidth.cchdefColWidth);
}
break;
case RecordType.DefaultRowHeight:
{
var defrowheigth = new DefaultRowHeight(this.StreamReader, bh.id, bh.length);
this.bsd.addDefaultRowData(defrowheigth);
}
break;
case RecordType.LeftMargin:
{
var leftm = new LeftMargin(this.StreamReader, bh.id, bh.length);
this.bsd.leftMargin = leftm.value;
}
break;
case RecordType.RightMargin:
{
var rightm = new RightMargin(this.StreamReader, bh.id, bh.length);
this.bsd.rightMargin = rightm.value;
}
break;
case RecordType.TopMargin:
{
var topm = new TopMargin(this.StreamReader, bh.id, bh.length);
this.bsd.topMargin = topm.value;
}
break;
case RecordType.BottomMargin:
{
var bottomm = new BottomMargin(this.StreamReader, bh.id, bh.length);
this.bsd.bottomMargin = bottomm.value;
}
break;
case RecordType.Setup:
{
var setup = new Setup(this.StreamReader, bh.id, bh.length);
this.bsd.addSetupData(setup);
}
break;
case RecordType.HLink:
{
long oldStreamPos = this.StreamReader.BaseStream.Position;
try
{
var hlink = new HLink(this.StreamReader, bh.id, bh.length);
this.bsd.addHyperLinkData(hlink);
}
catch (Exception ex)
{
this.StreamReader.BaseStream.Seek(oldStreamPos, System.IO.SeekOrigin.Begin);
this.StreamReader.BaseStream.Seek(bh.length, System.IO.SeekOrigin.Current);
TraceLogger.Debug("Link parse error");
TraceLogger.Error(ex.StackTrace);
}
}
break;
case RecordType.MsoDrawing:
{
// Record header has already been read. Reset position to record beginning.
this.StreamReader.BaseStream.Position -= 2 * sizeof(ushort);
this.bsd.ObjectsSequence = new ObjectsSequence(this.StreamReader);
}
break;
default:
{
// this else statement is used to read BiffRecords which aren't implemented
var buffer = new byte[bh.length];
buffer = this.StreamReader.ReadBytes(bh.length);
}
break;
}
latestbiff = bh;
}
//}
//catch (Exception ex)
//{
// TraceLogger.Error(ex.Message);
// TraceLogger.Error(ex.StackTrace);
// TraceLogger.Debug(ex.ToString());
//}
}
public override string ToString()
{
StringBuilder __sb = new StringBuilder("LogicalType(");
bool __first = true;
if (STRING != null && __isset.@STRING)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("STRING: ");
__sb.Append(STRING == null ? "<null>" : STRING.ToString());
}
if (MAP != null && __isset.MAP)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("MAP: ");
__sb.Append(MAP == null ? "<null>" : MAP.ToString());
}
if (LIST != null && __isset.LIST)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("LIST: ");
__sb.Append(LIST == null ? "<null>" : LIST.ToString());
}
if (ENUM != null && __isset.@ENUM)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("ENUM: ");
__sb.Append(ENUM == null ? "<null>" : ENUM.ToString());
}
if (DECIMAL != null && __isset.@DECIMAL)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("DECIMAL: ");
__sb.Append(DECIMAL == null ? "<null>" : DECIMAL.ToString());
}
if (DATE != null && __isset.DATE)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("DATE: ");
__sb.Append(DATE == null ? "<null>" : DATE.ToString());
}
if (TIME != null && __isset.TIME)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("TIME: ");
__sb.Append(TIME == null ? "<null>" : TIME.ToString());
}
if (TIMESTAMP != null && __isset.TIMESTAMP)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("TIMESTAMP: ");
__sb.Append(TIMESTAMP == null ? "<null>" : TIMESTAMP.ToString());
}
if (INTEGER != null && __isset.INTEGER)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("INTEGER: ");
__sb.Append(INTEGER == null ? "<null>" : INTEGER.ToString());
}
if (UNKNOWN != null && __isset.UNKNOWN)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("UNKNOWN: ");
__sb.Append(UNKNOWN == null ? "<null>" : UNKNOWN.ToString());
}
if (JSON != null && __isset.JSON)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("JSON: ");
__sb.Append(JSON == null ? "<null>" : JSON.ToString());
}
if (BSON != null && __isset.BSON)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("BSON: ");
__sb.Append(BSON == null ? "<null>" : BSON.ToString());
}
if (UUID != null && __isset.UUID)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("UUID: ");
__sb.Append(UUID == null ? "<null>" : UUID.ToString());
}
__sb.Append(")");
return(__sb.ToString());
}
public void Write(TProtocol oprot)
{
oprot.IncrementRecursionDepth();
try
{
TStruct struc = new TStruct("LogicalType");
oprot.WriteStructBegin(struc);
TField field = new TField();
if (STRING != null && __isset.@STRING)
{
field.Name = "STRING";
field.Type = TType.Struct;
field.ID = 1;
oprot.WriteFieldBegin(field);
STRING.Write(oprot);
oprot.WriteFieldEnd();
}
if (MAP != null && __isset.MAP)
{
field.Name = "MAP";
field.Type = TType.Struct;
field.ID = 2;
oprot.WriteFieldBegin(field);
MAP.Write(oprot);
oprot.WriteFieldEnd();
}
if (LIST != null && __isset.LIST)
{
field.Name = "LIST";
field.Type = TType.Struct;
field.ID = 3;
oprot.WriteFieldBegin(field);
LIST.Write(oprot);
oprot.WriteFieldEnd();
}
if (ENUM != null && __isset.@ENUM)
{
field.Name = "ENUM";
field.Type = TType.Struct;
field.ID = 4;
oprot.WriteFieldBegin(field);
ENUM.Write(oprot);
oprot.WriteFieldEnd();
}
if (DECIMAL != null && __isset.@DECIMAL)
{
field.Name = "DECIMAL";
field.Type = TType.Struct;
field.ID = 5;
oprot.WriteFieldBegin(field);
DECIMAL.Write(oprot);
oprot.WriteFieldEnd();
}
if (DATE != null && __isset.DATE)
{
field.Name = "DATE";
field.Type = TType.Struct;
field.ID = 6;
oprot.WriteFieldBegin(field);
DATE.Write(oprot);
oprot.WriteFieldEnd();
}
if (TIME != null && __isset.TIME)
{
field.Name = "TIME";
field.Type = TType.Struct;
field.ID = 7;
oprot.WriteFieldBegin(field);
TIME.Write(oprot);
oprot.WriteFieldEnd();
}
if (TIMESTAMP != null && __isset.TIMESTAMP)
{
field.Name = "TIMESTAMP";
field.Type = TType.Struct;
field.ID = 8;
oprot.WriteFieldBegin(field);
TIMESTAMP.Write(oprot);
oprot.WriteFieldEnd();
}
if (INTEGER != null && __isset.INTEGER)
{
field.Name = "INTEGER";
field.Type = TType.Struct;
field.ID = 10;
oprot.WriteFieldBegin(field);
INTEGER.Write(oprot);
oprot.WriteFieldEnd();
}
if (UNKNOWN != null && __isset.UNKNOWN)
{
field.Name = "UNKNOWN";
field.Type = TType.Struct;
field.ID = 11;
oprot.WriteFieldBegin(field);
UNKNOWN.Write(oprot);
oprot.WriteFieldEnd();
}
if (JSON != null && __isset.JSON)
{
field.Name = "JSON";
field.Type = TType.Struct;
field.ID = 12;
oprot.WriteFieldBegin(field);
JSON.Write(oprot);
oprot.WriteFieldEnd();
}
if (BSON != null && __isset.BSON)
{
field.Name = "BSON";
field.Type = TType.Struct;
field.ID = 13;
oprot.WriteFieldBegin(field);
BSON.Write(oprot);
oprot.WriteFieldEnd();
}
if (UUID != null && __isset.UUID)
{
field.Name = "UUID";
field.Type = TType.Struct;
field.ID = 14;
oprot.WriteFieldBegin(field);
UUID.Write(oprot);
oprot.WriteFieldEnd();
}
oprot.WriteFieldStop();
oprot.WriteStructEnd();
}
finally
{
oprot.DecrementRecursionDepth();
}
}
public static object ParseExcelType(string str, string type)
{
if (INT.Equals(type))
{
if (string.IsNullOrEmpty(str))
{
return(0);
}
return(int.Parse(str));
}
else if (NUMBER.Equals(type))
{
if (string.IsNullOrEmpty(str))
{
return(0);
}
return(LockStepConst.ParseInLevelInt(str));
}
else if (FLOAT.Equals(type))
{
if (string.IsNullOrEmpty(str))
{
return(0);
}
return(float.Parse(str));
}
else if (STRING.Equals(type))
{
return(str);
}
else if (BOOL.Equals(type))
{
return("true".Equals(str.ToLower()));
}
else if (LINT.Equals(type))
{
string[] p = str.SplitStringBySplits();
List <int> result = new List <int>(p.Length);
for (int i = 0; i < p.Length; i++)
{
if (string.IsNullOrEmpty(str))
{
result.Add(0);
}
else
{
result.Add(int.Parse(p[i]));
}
}
return(result);
}
else if (LNUMBER.Equals(type))
{
string[] p = str.SplitStringBySplits();
List <int> result = new List <int>(p.Length);
for (int i = 0; i < p.Length; i++)
{
if (string.IsNullOrEmpty(str))
{
result.Add(0);
}
else
{
result.Add(LockStepConst.ParseInLevelInt(p[i]));
}
}
return(result);
}
else if (LFLOAT.Equals(type))
{
string[] p = str.SplitStringBySplits();
List <float> result = new List <float>(p.Length);
for (int i = 0; i < p.Length; i++)
{
if (string.IsNullOrEmpty(str))
{
result.Add(0);
}
else
{
result.Add(float.Parse(p[i]));
}
}
return(result);
}
else if (LSTRING.Equals(type))
{
string[] p = str.SplitStringBySplits();
List <string> result = new List <string>(p.Length);
for (int i = 0; i < p.Length; i++)
{
result.Add(p[i]);
}
return(result);
}
else if (LBOOL.Equals(type))
{
string[] p = str.SplitStringBySplits();
List <bool> result = new List <bool>(p.Length);
for (int i = 0; i < p.Length; i++)
{
result.Add("true".Equals(str));
}
return(result);
}
return(null);
}
public async Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
{
oprot.IncrementRecursionDepth();
try
{
var struc = new TStruct("LogicalType");
await oprot.WriteStructBeginAsync(struc, cancellationToken);
var field = new TField();
if (STRING != null && __isset.@STRING)
{
field.Name = "STRING";
field.Type = TType.Struct;
field.ID = 1;
await oprot.WriteFieldBeginAsync(field, cancellationToken);
await STRING.WriteAsync(oprot, cancellationToken);
await oprot.WriteFieldEndAsync(cancellationToken);
}
if (MAP != null && __isset.MAP)
{
field.Name = "MAP";
field.Type = TType.Struct;
field.ID = 2;
await oprot.WriteFieldBeginAsync(field, cancellationToken);
await MAP.WriteAsync(oprot, cancellationToken);
await oprot.WriteFieldEndAsync(cancellationToken);
}
if (LIST != null && __isset.LIST)
{
field.Name = "LIST";
field.Type = TType.Struct;
field.ID = 3;
await oprot.WriteFieldBeginAsync(field, cancellationToken);
await LIST.WriteAsync(oprot, cancellationToken);
await oprot.WriteFieldEndAsync(cancellationToken);
}
if (ENUM != null && __isset.@ENUM)
{
field.Name = "ENUM";
field.Type = TType.Struct;
field.ID = 4;
await oprot.WriteFieldBeginAsync(field, cancellationToken);
await ENUM.WriteAsync(oprot, cancellationToken);
await oprot.WriteFieldEndAsync(cancellationToken);
}
if (DECIMAL != null && __isset.@DECIMAL)
{
field.Name = "DECIMAL";
field.Type = TType.Struct;
field.ID = 5;
await oprot.WriteFieldBeginAsync(field, cancellationToken);
await DECIMAL.WriteAsync(oprot, cancellationToken);
await oprot.WriteFieldEndAsync(cancellationToken);
}
if (DATE != null && __isset.DATE)
{
field.Name = "DATE";
field.Type = TType.Struct;
field.ID = 6;
await oprot.WriteFieldBeginAsync(field, cancellationToken);
await DATE.WriteAsync(oprot, cancellationToken);
await oprot.WriteFieldEndAsync(cancellationToken);
}
if (TIME != null && __isset.TIME)
{
field.Name = "TIME";
field.Type = TType.Struct;
field.ID = 7;
await oprot.WriteFieldBeginAsync(field, cancellationToken);
await TIME.WriteAsync(oprot, cancellationToken);
await oprot.WriteFieldEndAsync(cancellationToken);
}
if (TIMESTAMP != null && __isset.TIMESTAMP)
{
field.Name = "TIMESTAMP";
field.Type = TType.Struct;
field.ID = 8;
await oprot.WriteFieldBeginAsync(field, cancellationToken);
await TIMESTAMP.WriteAsync(oprot, cancellationToken);
await oprot.WriteFieldEndAsync(cancellationToken);
}
if (INTEGER != null && __isset.INTEGER)
{
field.Name = "INTEGER";
field.Type = TType.Struct;
field.ID = 10;
await oprot.WriteFieldBeginAsync(field, cancellationToken);
await INTEGER.WriteAsync(oprot, cancellationToken);
await oprot.WriteFieldEndAsync(cancellationToken);
}
if (UNKNOWN != null && __isset.UNKNOWN)
{
field.Name = "UNKNOWN";
field.Type = TType.Struct;
field.ID = 11;
await oprot.WriteFieldBeginAsync(field, cancellationToken);
await UNKNOWN.WriteAsync(oprot, cancellationToken);
await oprot.WriteFieldEndAsync(cancellationToken);
}
if (JSON != null && __isset.JSON)
{
field.Name = "JSON";
field.Type = TType.Struct;
field.ID = 12;
await oprot.WriteFieldBeginAsync(field, cancellationToken);
await JSON.WriteAsync(oprot, cancellationToken);
await oprot.WriteFieldEndAsync(cancellationToken);
}
if (BSON != null && __isset.BSON)
{
field.Name = "BSON";
field.Type = TType.Struct;
field.ID = 13;
await oprot.WriteFieldBeginAsync(field, cancellationToken);
await BSON.WriteAsync(oprot, cancellationToken);
await oprot.WriteFieldEndAsync(cancellationToken);
}
await oprot.WriteFieldStopAsync(cancellationToken);
await oprot.WriteStructEndAsync(cancellationToken);
}
finally
{
oprot.DecrementRecursionDepth();
}
}
public INTEGER SendPost(STRING url, STRING headers, STRING content)
{
return(MakeRequest(() => _httpsClient.Post(url, ParseHeaders(headers), content.NullIfEmpty())));
}
public INTEGER SendGet(STRING url, STRING headers)
{
return(MakeRequest(() => _httpsClient.Get(url, ParseHeaders(headers))));
}
public STRING SendDelete(STRING url, STRING headers, STRING content)
{
return(MakeRequest(() => _httpsClient.Delete(url, ParseHeaders(headers), content.NullIfEmpty())));
}
