public override void _0001(DateTime item)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
base._0001(item);
item = DescriptorIteratorMapping.ReadProperty(item, base._0001());
CalcRequest(item, WatcherComposer.Date);
}
private int InsertTest(DateTimeOffset reference)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
FlushTest();
int start_cust = 0;
m_RegistryComposer[start_cust++] = _ServiceComposer;
start_cust = DescriptorIteratorMapping.ConcatProperty(m_RegistryComposer, start_cust, (base._0001() == (FindDirection)0) ? reference.DateTime : reference.UtcDateTime, reference.Offset, DateTimeKind.Local, base._0001());
m_RegistryComposer[start_cust++] = _ServiceComposer;
return(start_cust);
}
private int MapTest(DateTime init)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
FlushTest();
int start_cust = 0;
m_RegistryComposer[start_cust++] = _ServiceComposer;
start_cust = DescriptorIteratorMapping.ConcatProperty(m_RegistryComposer, start_cust, init, null, init.Kind, base._0001());
m_RegistryComposer[start_cust++] = _ServiceComposer;
return(start_cust);
}
public static bool PostIssuer(TagTestItem res, out DateTime reg, [ConsumerBroadcasterDispatcher(false)][_0008._0012(2)] out string _0004)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
reg = default(DateTime);
_0004 = null;
if (!ChangeIssuer(res, out long?counter, out _0004) || !counter.HasValue)
{
_0004 = (_0004 ?? "Date constructor has no arguments.");
return(false);
}
if (!ChangeIssuer(res, out long?counter2, out _0004))
{
return(false);
}
if (counter2.HasValue)
{
List <long> list = new List <long>
{
counter.Value,
counter2.Value
};
while (true)
{
if (!ChangeIssuer(res, out long?counter3, out _0004))
{
return(false);
}
if (!counter3.HasValue)
{
break;
}
list.Add(counter3.Value);
}
if (list.Count > 7)
{
_0004 = "Unexpected number of arguments when reading date constructor.";
return(false);
}
while (list.Count < 7)
{
list.Add(0L);
}
reg = new DateTime((int)list[0], (int)list[1] + 1, (int)((list[2] == 0L) ? 1 : list[2]), (int)list[3], (int)list[4], (int)list[5], (int)list[6]);
}
else
{
reg = DescriptorIteratorMapping.SearchProperty(counter.Value);
}
return(true);
}
public override void _0001(DateTime last)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
GetTest(WatcherComposer.Date);
last = DescriptorIteratorMapping.ReadProperty(last, base._0001());
if (SetterTest.StartReader(base._0003()))
{
int count = MapTest(last);
m_MethodComposer.Write(m_RegistryComposer, 0, count);
}
else
{
m_MethodComposer.Write(_ServiceComposer);
m_MethodComposer.Write(last.ToString(base._0003(), base._0001()));
m_MethodComposer.Write(_ServiceComposer);
}
}
internal DateTimeOffset?ConcatError(string info)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (SetterTest.StartReader(info))
{
CancelError(WatcherComposer.Null, null, isstate: false);
return(null);
}
if (DescriptorIteratorMapping.ChangeProperty(info, setterError, this._0001(), out DateTimeOffset connection))
{
CancelError(WatcherComposer.Date, connection, isstate: false);
return(connection);
}
if (DateTimeOffset.TryParse(info, this._0001(), DateTimeStyles.RoundtripKind, out connection))
{
CancelError(WatcherComposer.Date, connection, isstate: false);
return(connection);
}
CancelError(WatcherComposer.String, info, isstate: false);
throw ContextError.CheckComposer(this, "Could not convert string to DateTimeOffset: {0}.".ListReader(CultureInfo.InvariantCulture, info));
}
internal DateTime?DeleteError(string info)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (SetterTest.StartReader(info))
{
CancelError(WatcherComposer.Null, null, isstate: false);
return(null);
}
if (DescriptorIteratorMapping.RemoveProperty(info, this._0001(), setterError, this._0001(), out DateTime res))
{
res = DescriptorIteratorMapping.ReadProperty(res, this._0001());
CancelError(WatcherComposer.Date, res, isstate: false);
return(res);
}
if (DateTime.TryParse(info, this._0001(), DateTimeStyles.RoundtripKind, out res))
{
res = DescriptorIteratorMapping.ReadProperty(res, this._0001());
CancelError(WatcherComposer.Date, res, isstate: false);
return(res);
}
throw ContextError.CheckComposer(this, "Could not convert string to DateTime: {0}.".ListReader(CultureInfo.InvariantCulture, info));
}
private void AwakeRequest(ParserFilterResolver item)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
switch (item._0001())
{
case UnicodeCategory.Object:
CustomizeError(WatcherComposer.StartObject);
break;
case UnicodeCategory.Array:
CustomizeError(WatcherComposer.StartArray);
break;
case UnicodeCategory.Constructor:
QueryError(WatcherComposer.StartConstructor, ((IndexerReaderMapper)item)._0001());
break;
case UnicodeCategory.Property:
QueryError(WatcherComposer.PropertyName, ((WatcherIssuer)item)._0001());
break;
case UnicodeCategory.Comment:
QueryError(WatcherComposer.Comment, ((PoolIssuer)item)._0001());
break;
case UnicodeCategory.Integer:
QueryError(WatcherComposer.Integer, ((PoolIssuer)item)._0001());
break;
case UnicodeCategory.Float:
QueryError(WatcherComposer.Float, ((PoolIssuer)item)._0001());
break;
case UnicodeCategory.String:
QueryError(WatcherComposer.String, ((PoolIssuer)item)._0001());
break;
case UnicodeCategory.Boolean:
QueryError(WatcherComposer.Boolean, ((PoolIssuer)item)._0001());
break;
case UnicodeCategory.Null:
QueryError(WatcherComposer.Null, ((PoolIssuer)item)._0001());
break;
case UnicodeCategory.Undefined:
QueryError(WatcherComposer.Undefined, ((PoolIssuer)item)._0001());
break;
case UnicodeCategory.Date:
{
object obj2 = ((PoolIssuer)item)._0001();
if (obj2 is DateTime)
{
DateTime param = (DateTime)obj2;
obj2 = DescriptorIteratorMapping.ReadProperty(param, base._0001());
}
QueryError(WatcherComposer.Date, obj2);
break;
}
case UnicodeCategory.Raw:
QueryError(WatcherComposer.Raw, ((PoolIssuer)item)._0001());
break;
case UnicodeCategory.Bytes:
QueryError(WatcherComposer.Bytes, ((PoolIssuer)item)._0001());
break;
case UnicodeCategory.Guid:
QueryError(WatcherComposer.String, UpdateRequest(((PoolIssuer)item)._0001()));
break;
case UnicodeCategory.Uri:
{
object obj = ((PoolIssuer)item)._0001();
Uri uri = obj as Uri;
QueryError(WatcherComposer.String, ((object)uri != null) ? uri.OriginalString : UpdateRequest(obj));
break;
}
case UnicodeCategory.TimeSpan:
QueryError(WatcherComposer.String, UpdateRequest(((PoolIssuer)item)._0001()));
break;
default:
throw CustomerListAnnotation.ConcatIssuer("Type", item._0001(), "Unexpected JTokenType.");
}
}
private void EnableIterator(SystemPropertyStruct asset)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
switch (asset._0001())
{
case (ChildRunStatus)6:
case (ChildRunStatus)10:
break;
case (ChildRunStatus)3:
{
TemplateIssuer templateIssuer = (TemplateIssuer)asset;
annotationIssuer.Write(((SystemPropertyStruct)templateIssuer)._0001());
using (IEnumerator <PageFilterResolver> enumerator2 = templateIssuer._0001())
{
while (enumerator2.MoveNext())
{
PageFilterResolver current2 = enumerator2.Current;
annotationIssuer.Write((sbyte)current2._0001()._0001());
MapIterator((string)((ValueRequestStrategy)current2._0001())._0001(), current2._0001()._0002(), null);
EnableIterator(current2._0001());
}
}
annotationIssuer.Write((byte)0);
break;
}
case (ChildRunStatus)4:
{
InitializerComposerWorker initializerComposerWorker = (InitializerComposerWorker)asset;
annotationIssuer.Write(((SystemPropertyStruct)initializerComposerWorker)._0001());
ulong num2 = 0uL;
using (IEnumerator <SystemPropertyStruct> enumerator = initializerComposerWorker._0001())
{
while (enumerator.MoveNext())
{
SystemPropertyStruct current = enumerator.Current;
annotationIssuer.Write((sbyte)current._0001());
MapIterator(num2.ToString(CultureInfo.InvariantCulture), IteratorComposerPool.ListIssuer(num2), null);
EnableIterator(current);
num2++;
}
}
annotationIssuer.Write((byte)0);
break;
}
case (ChildRunStatus)16:
{
ValueRequestStrategy valueRequestStrategy2 = (ValueRequestStrategy)asset;
annotationIssuer.Write(Convert.ToInt32(valueRequestStrategy2._0001(), CultureInfo.InvariantCulture));
break;
}
case (ChildRunStatus)18:
{
ValueRequestStrategy valueRequestStrategy3 = (ValueRequestStrategy)asset;
annotationIssuer.Write(Convert.ToInt64(valueRequestStrategy3._0001(), CultureInfo.InvariantCulture));
break;
}
case (ChildRunStatus)1:
{
ValueRequestStrategy valueRequestStrategy4 = (ValueRequestStrategy)asset;
annotationIssuer.Write(Convert.ToDouble(valueRequestStrategy4._0001(), CultureInfo.InvariantCulture));
break;
}
case (ChildRunStatus)2:
{
ParameterRequestStrategy parameterRequestStrategy = (ParameterRequestStrategy)asset;
MapIterator((string)((ValueRequestStrategy)parameterRequestStrategy)._0001(), parameterRequestStrategy._0002(), ((SystemPropertyStruct)parameterRequestStrategy)._0001() - 4);
break;
}
case (ChildRunStatus)8:
annotationIssuer.Write(asset == IdentifierPropertyStruct._ProcIssuer);
break;
case (ChildRunStatus)9:
{
ValueRequestStrategy valueRequestStrategy = (ValueRequestStrategy)asset;
long num = 0L;
object obj = valueRequestStrategy._0001();
if (obj is DateTime)
{
DateTime param = (DateTime)obj;
if (_0001() == DateTimeKind.Utc)
{
param = param.ToUniversalTime();
}
else if (_0001() == DateTimeKind.Local)
{
param = param.ToLocalTime();
}
num = DescriptorIteratorMapping.RegisterProperty(param, usecont: false);
}
else
{
DateTimeOffset dateTimeOffset = (DateTimeOffset)valueRequestStrategy._0001();
num = DescriptorIteratorMapping.ResetProperty(dateTimeOffset.UtcDateTime, dateTimeOffset.Offset);
}
annotationIssuer.Write(num);
break;
}
case (ChildRunStatus)5:
{
FilterReader filterReader = (FilterReader)asset;
byte[] array = (byte[])((ValueRequestStrategy)filterReader)._0001();
annotationIssuer.Write(array.Length);
annotationIssuer.Write((byte)filterReader._0001());
annotationIssuer.Write(array);
break;
}
case (ChildRunStatus)7:
{
byte[] buffer = (byte[])((ValueRequestStrategy)asset)._0001();
annotationIssuer.Write(buffer);
break;
}
case (ChildRunStatus)11:
{
MapperComposerPool mapperComposerPool = (MapperComposerPool)asset;
MapIterator((string)((ValueRequestStrategy)mapperComposerPool._0001())._0001(), mapperComposerPool._0001()._0002(), null);
MapIterator((string)((ValueRequestStrategy)mapperComposerPool._0002())._0001(), mapperComposerPool._0002()._0002(), null);
break;
}
default:
throw new ArgumentOutOfRangeException("t", "Unexpected token when writing BSON: {0}".ListReader(CultureInfo.InvariantCulture, asset._0001()));
}
}
private static string WriteRequest(TagTestItem init)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
switch (init._0001())
{
case WatcherComposer.String:
return(init._0001()?.ToString());
case WatcherComposer.Integer:
{
object obj = init._0001();
if (obj is BigInteger)
{
return(((BigInteger)obj).ToString(CultureInfo.InvariantCulture));
}
return(XmlConvert.ToString(Convert.ToInt64(init._0001(), CultureInfo.InvariantCulture)));
}
case WatcherComposer.Float:
{
object obj = init._0001();
if (obj is decimal)
{
decimal value3 = (decimal)obj;
return(XmlConvert.ToString(value3));
}
obj = init._0001();
if (obj is float)
{
float value4 = (float)obj;
return(XmlConvert.ToString(value4));
}
return(XmlConvert.ToString(Convert.ToDouble(init._0001(), CultureInfo.InvariantCulture)));
}
case WatcherComposer.Boolean:
return(XmlConvert.ToString(Convert.ToBoolean(init._0001(), CultureInfo.InvariantCulture)));
case WatcherComposer.Date:
{
object obj = init._0001();
if (obj is DateTimeOffset)
{
DateTimeOffset value = (DateTimeOffset)obj;
return(XmlConvert.ToString(value));
}
DateTime value2 = Convert.ToDateTime(init._0001(), CultureInfo.InvariantCulture);
return(XmlConvert.ToString(value2, DescriptorIteratorMapping.UpdateProperty(value2.Kind)));
}
case WatcherComposer.Bytes:
return(Convert.ToBase64String((byte[])init._0001()));
case WatcherComposer.Null:
return(null);
default:
throw StrategyError.PatchComposer(init, "Cannot get an XML string value from token type '{0}'.".ListReader(CultureInfo.InvariantCulture, init._0001()));
}
}
private string AddClass(RecordClassDispatcher item, object result, ProcTest temp, out bool last2)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (temp._ErrorProperty == (ParameterFilterResolver)3)
{
ProccesorClassSpec proccesorClassSpec = (ProccesorClassSpec)temp;
switch (proccesorClassSpec._0001())
{
case (SettingsSerializeAs)26:
case (SettingsSerializeAs)27:
{
DateTime token = DescriptorIteratorMapping.ReadProperty((DateTime)result, item._0001());
last2 = false;
StringWriter stringWriter2 = new StringWriter(CultureInfo.InvariantCulture);
DescriptorIteratorMapping.TestProperty(stringWriter2, token, item._0001(), item._0003(), item._0001());
return(stringWriter2.ToString());
}
case (SettingsSerializeAs)28:
case (SettingsSerializeAs)29:
{
last2 = false;
StringWriter stringWriter = new StringWriter(CultureInfo.InvariantCulture);
DescriptorIteratorMapping.AssetProperty(stringWriter, (DateTimeOffset)result, item._0001(), item._0003(), item._0001());
return(stringWriter.ToString());
}
case (SettingsSerializeAs)24:
case (SettingsSerializeAs)25:
{
double num = (double)result;
last2 = false;
return(num.ToString("R", CultureInfo.InvariantCulture));
}
case (SettingsSerializeAs)22:
case (SettingsSerializeAs)23:
{
float num2 = (float)result;
last2 = false;
return(num2.ToString("R", CultureInfo.InvariantCulture));
}
default:
{
last2 = true;
if (proccesorClassSpec._FilterProperty && InfoFilterResolver.InsertIssuer(proccesorClassSpec._InstanceProperty, result, null, out string _0005))
{
return(_0005);
}
return(Convert.ToString(result, CultureInfo.InvariantCulture));
}
}
}
if (ExcludeBroadcaster(result, result.GetType(), out string _0004))
{
last2 = true;
return(_0004);
}
last2 = true;
return(result.ToString());
}
