private void RevertRequest(TagTestItem instance, AttrBroadcasterFilter selection, string template, CreatorIssuer value2, XmlNamespaceManager item3)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
string dir = CustomerListAnnotation.CountIssuer(template);
InfoRequestStrategy infoRequestStrategy = FindIterator(template, selection, dir, item3);
value2._0001(infoRequestStrategy);
int num = 0;
while (instance._0001() && instance._0001() != WatcherComposer.EndArray)
{
CollectRequest(instance, selection, item3, template, infoRequestStrategy);
num++;
}
if (_0003())
{
LoginIterator(infoRequestStrategy, selection);
}
if (num == 1 && _0003())
{
foreach (CreatorIssuer item4 in ((CreatorIssuer)infoRequestStrategy)._0001())
{
InfoRequestStrategy infoRequestStrategy2 = item4 as InfoRequestStrategy;
if (infoRequestStrategy2 != null && ((CreatorIssuer)infoRequestStrategy2)._0001() == template)
{
LoginIterator(infoRequestStrategy2, selection);
break;
}
}
}
}
private void SortRequest(TagTestItem spec, AttrBroadcasterFilter connection, CreatorIssuer template, string pred2, XmlNamespaceManager connection3)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (SetterTest.StartReader(pred2))
{
throw StrategyError.PatchComposer(spec, "XmlNodeConverter cannot convert JSON with an empty property name to XML.");
}
Dictionary <string, string> token = null;
string asset = null;
if (!_0005())
{
token = (CheckIterator(spec) ? DisableIterator(spec, connection3) : null);
asset = CustomerListAnnotation.CountIssuer(pred2);
if (pred2.ExcludeReader('@'))
{
string text = pred2.Substring(1);
string reference = CustomerListAnnotation.CountIssuer(text);
PublishRequest(spec, connection, template, pred2, text, connection3, reference);
return;
}
if (pred2.ExcludeReader('$'))
{
switch (pred2)
{
case "$values":
pred2 = pred2.Substring(1);
asset = connection3.LookupPrefix("http://james.newtonking.com/projects/json");
CallRequest(spec, connection, template, pred2, connection3, asset, token);
return;
case "$id":
case "$ref":
case "$type":
case "$value":
{
string v = pred2.Substring(1);
string reference2 = connection3.LookupPrefix("http://james.newtonking.com/projects/json");
PublishRequest(spec, connection, template, pred2, v, connection3, reference2);
return;
}
}
}
}
else if (CheckIterator(spec))
{
spec.SortError();
}
CallRequest(spec, connection, template, pred2, connection3, asset, token);
}
private void CallRequest(TagTestItem def, AttrBroadcasterFilter attr, CreatorIssuer state, string pred2, XmlNamespaceManager reference3, string asset4, Dictionary <string, string> token5)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
InfoRequestStrategy infoRequestStrategy = FindIterator(pred2, attr, asset4, reference3);
state._0001(infoRequestStrategy);
if (token5 != null)
{
foreach (KeyValuePair <string, string> item in token5)
{
string text = XmlConvert.EncodeName(item.Key);
string text2 = CustomerListAnnotation.CountIssuer(item.Key);
CreatorIssuer key = (!SetterTest.StartReader(text2)) ? attr._0002(text, reference3.LookupNamespace(text2) ?? string.Empty, item.Value) : attr._0002(text, item.Value);
infoRequestStrategy._0001(key);
}
}
switch (def._0001())
{
case WatcherComposer.Null:
break;
case WatcherComposer.Integer:
case WatcherComposer.Float:
case WatcherComposer.String:
case WatcherComposer.Boolean:
case WatcherComposer.Date:
case WatcherComposer.Bytes:
{
string text3 = WriteRequest(def);
if (text3 != null)
{
((CreatorIssuer)infoRequestStrategy)._0001(attr._0002(text3));
}
break;
}
case WatcherComposer.EndObject:
reference3.RemoveNamespace(string.Empty, reference3.DefaultNamespace);
break;
default:
reference3.PushScope();
ValidateIterator(def, attr, reference3, infoRequestStrategy);
reference3.PopScope();
reference3.RemoveNamespace(string.Empty, reference3.DefaultNamespace);
break;
}
}
private object SelectRequest(TagTestItem ident)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
string text = (string)ident._0001();
if (text.Length > 0 && text[0] == '/')
{
int num = text.LastIndexOf('/');
if (num > 0)
{
string pattern = text.Substring(1, num - 1);
RegexOptions options = CustomerListAnnotation.QueryIssuer(text.Substring(num + 1));
return(new Regex(pattern, options));
}
}
throw StrategyError.PatchComposer(ident, "Regex pattern must be enclosed by slashes.");
}
public static XmlDateTimeSerializationMode UpdateProperty(DateTimeKind ident)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
switch (ident)
{
case DateTimeKind.Local:
return(XmlDateTimeSerializationMode.Local);
case DateTimeKind.Unspecified:
return(XmlDateTimeSerializationMode.Unspecified);
case DateTimeKind.Utc:
return(XmlDateTimeSerializationMode.Utc);
default:
throw CustomerListAnnotation.ConcatIssuer("kind", ident, "Unexpected DateTimeKind value.");
}
}
private WatcherComposer?IncludeRequest(ConfigurationIssuer spec)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
switch (((ParserFilterResolver)spec)._0001())
{
case UnicodeCategory.Object:
return(WatcherComposer.EndObject);
case UnicodeCategory.Array:
return(WatcherComposer.EndArray);
case UnicodeCategory.Constructor:
return(WatcherComposer.EndConstructor);
case UnicodeCategory.Property:
return(null);
default:
throw CustomerListAnnotation.ConcatIssuer("Type", ((ParserFilterResolver)spec)._0001(), "Unexpected JContainer type.");
}
}
public override void _0001(RecordClassDispatcher task, BroadcasterError[] counter)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (counter != null && counter.Length != 0 && m_InvocationIssuer != null)
{
BroadcasterError broadcasterError = PrototypeError.LogoutComposer(counter, m_InvocationIssuer.GetType());
if (broadcasterError != null && broadcasterError._0001())
{
broadcasterError._0001(task, m_InvocationIssuer, PrototypeError.FillComposer());
return;
}
}
switch (_ValIssuer)
{
case Newtonsoft.Rules.UnicodeCategory.Comment:
task._0005(m_InvocationIssuer?.ToString());
break;
case Newtonsoft.Rules.UnicodeCategory.Raw:
task._0006(m_InvocationIssuer?.ToString());
break;
case Newtonsoft.Rules.UnicodeCategory.Null:
task._0008();
break;
case Newtonsoft.Rules.UnicodeCategory.Undefined:
task._000E();
break;
case Newtonsoft.Rules.UnicodeCategory.Integer:
{
object invocationIssuer = m_InvocationIssuer;
if (invocationIssuer is int)
{
int first_Low = (int)invocationIssuer;
task._0001(first_Low);
break;
}
invocationIssuer = m_InvocationIssuer;
if (invocationIssuer is long)
{
long asset2 = (long)invocationIssuer;
task._0001(asset2);
break;
}
invocationIssuer = m_InvocationIssuer;
if (invocationIssuer is ulong)
{
ulong specID = (ulong)invocationIssuer;
task._0001(specID);
break;
}
invocationIssuer = m_InvocationIssuer;
if (invocationIssuer is BigInteger)
{
BigInteger bigInteger = (BigInteger)invocationIssuer;
task._0001(bigInteger);
}
else
{
task._0001(Convert.ToInt64(m_InvocationIssuer, CultureInfo.InvariantCulture));
}
break;
}
case Newtonsoft.Rules.UnicodeCategory.Float:
{
object invocationIssuer = m_InvocationIssuer;
if (invocationIssuer is decimal)
{
decimal asset = (decimal)invocationIssuer;
task._0001(asset);
break;
}
invocationIssuer = m_InvocationIssuer;
if (invocationIssuer is double)
{
double last = (double)invocationIssuer;
task._0001(last);
break;
}
invocationIssuer = m_InvocationIssuer;
if (invocationIssuer is float)
{
float init = (float)invocationIssuer;
task._0001(init);
}
else
{
task._0001(Convert.ToDouble(m_InvocationIssuer, CultureInfo.InvariantCulture));
}
break;
}
case Newtonsoft.Rules.UnicodeCategory.String:
task._0004(m_InvocationIssuer?.ToString());
break;
case Newtonsoft.Rules.UnicodeCategory.Boolean:
task._0001(Convert.ToBoolean(m_InvocationIssuer, CultureInfo.InvariantCulture));
break;
case Newtonsoft.Rules.UnicodeCategory.Date:
{
object invocationIssuer = m_InvocationIssuer;
if (invocationIssuer is DateTimeOffset)
{
DateTimeOffset last2 = (DateTimeOffset)invocationIssuer;
task._0001(last2);
}
else
{
task._0001(Convert.ToDateTime(m_InvocationIssuer, CultureInfo.InvariantCulture));
}
break;
}
case Newtonsoft.Rules.UnicodeCategory.Bytes:
task._0001((byte[])m_InvocationIssuer);
break;
case Newtonsoft.Rules.UnicodeCategory.Guid:
task._0001((m_InvocationIssuer != null) ? ((Guid?)m_InvocationIssuer) : null);
break;
case Newtonsoft.Rules.UnicodeCategory.TimeSpan:
task._0001((m_InvocationIssuer != null) ? ((TimeSpan?)m_InvocationIssuer) : null);
break;
case Newtonsoft.Rules.UnicodeCategory.Uri:
task._0001((Uri)m_InvocationIssuer);
break;
default:
throw CustomerListAnnotation.ConcatIssuer("Type", _ValIssuer, "Unexpected token type.");
}
}
internal static int StopRequest(Newtonsoft.Rules.UnicodeCategory key, object attr, object pool)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (attr == pool)
{
return(0);
}
if (pool == null)
{
return(1);
}
if (attr == null)
{
return(-1);
}
switch (key)
{
case Newtonsoft.Rules.UnicodeCategory.Integer:
if (attr is BigInteger)
{
BigInteger value3 = (BigInteger)attr;
return(CreateRequest(value3, pool));
}
if (pool is BigInteger)
{
BigInteger value4 = (BigInteger)pool;
return(-CreateRequest(value4, attr));
}
if (attr is ulong || pool is ulong || attr is decimal || pool is decimal)
{
return(Convert.ToDecimal(attr, CultureInfo.InvariantCulture).CompareTo(Convert.ToDecimal(pool, CultureInfo.InvariantCulture)));
}
if (attr is float || pool is float || attr is double || pool is double)
{
return(CloneRequest(attr, pool));
}
return(Convert.ToInt64(attr, CultureInfo.InvariantCulture).CompareTo(Convert.ToInt64(pool, CultureInfo.InvariantCulture)));
case Newtonsoft.Rules.UnicodeCategory.Float:
if (attr is BigInteger)
{
BigInteger value7 = (BigInteger)attr;
return(CreateRequest(value7, pool));
}
if (pool is BigInteger)
{
BigInteger value8 = (BigInteger)pool;
return(-CreateRequest(value8, attr));
}
if (attr is ulong || pool is ulong || attr is decimal || pool is decimal)
{
return(Convert.ToDecimal(attr, CultureInfo.InvariantCulture).CompareTo(Convert.ToDecimal(pool, CultureInfo.InvariantCulture)));
}
return(CloneRequest(attr, pool));
case Newtonsoft.Rules.UnicodeCategory.Comment:
case Newtonsoft.Rules.UnicodeCategory.String:
case Newtonsoft.Rules.UnicodeCategory.Raw:
{
string strA = Convert.ToString(attr, CultureInfo.InvariantCulture);
string strB = Convert.ToString(pool, CultureInfo.InvariantCulture);
return(string.CompareOrdinal(strA, strB));
}
case Newtonsoft.Rules.UnicodeCategory.Boolean:
{
bool flag = Convert.ToBoolean(attr, CultureInfo.InvariantCulture);
bool value2 = Convert.ToBoolean(pool, CultureInfo.InvariantCulture);
return(flag.CompareTo(value2));
}
case Newtonsoft.Rules.UnicodeCategory.Date:
{
if (attr is DateTime)
{
DateTime dateTime = (DateTime)attr;
DateTime value5 = (!(pool is DateTimeOffset)) ? Convert.ToDateTime(pool, CultureInfo.InvariantCulture) : ((DateTimeOffset)pool).DateTime;
return(dateTime.CompareTo(value5));
}
DateTimeOffset dateTimeOffset = (DateTimeOffset)attr;
DateTimeOffset other = (pool is DateTimeOffset) ? ((DateTimeOffset)pool) : new DateTimeOffset(Convert.ToDateTime(pool, CultureInfo.InvariantCulture));
return(dateTimeOffset.CompareTo(other));
}
case Newtonsoft.Rules.UnicodeCategory.Bytes:
{
byte[] array = pool as byte[];
if (array == null)
{
throw new ArgumentException("Object must be of type byte[].");
}
return(CustomerListAnnotation.PrintIssuer(attr as byte[], array));
}
case Newtonsoft.Rules.UnicodeCategory.Guid:
{
if (!(pool is Guid))
{
throw new ArgumentException("Object must be of type Guid.");
}
Guid guid = (Guid)attr;
Guid value6 = (Guid)pool;
return(guid.CompareTo(value6));
}
case Newtonsoft.Rules.UnicodeCategory.Uri:
{
Uri uri = pool as Uri;
if (uri == null)
{
throw new ArgumentException("Object must be of type Uri.");
}
Uri uri2 = (Uri)attr;
return(Comparer <string> .Default.Compare(uri2.ToString(), uri.ToString()));
}
case Newtonsoft.Rules.UnicodeCategory.TimeSpan:
{
if (!(pool is TimeSpan))
{
throw new ArgumentException("Object must be of type TimeSpan.");
}
TimeSpan timeSpan = (TimeSpan)attr;
TimeSpan value = (TimeSpan)pool;
return(timeSpan.CompareTo(value));
}
default:
throw CustomerListAnnotation.ConcatIssuer("valueType", key, "Unexpected value type: {0}".ListReader(CultureInfo.InvariantCulture, key));
}
}
public override ParserFilterResolver this[object item]
{
[MethodImpl(MethodImplOptions.NoInlining)]
get
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
ContextClientBridge.RunClient(item, "key");
if (!(item is int))
{
throw new ArgumentException("Accessed JArray values with invalid key value: {0}. Int32 array index expected.".ListReader(CultureInfo.InvariantCulture, CustomerListAnnotation.InvokeIssuer(item)));
}
return(((ConfigurationIssuer)this)._0001((int)item));
}
[MethodImpl(MethodImplOptions.NoInlining)]
set
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
ContextClientBridge.RunClient(def, "key");
if (!(def is int))
{
throw new ArgumentException("Set JArray values with invalid key value: {0}. Int32 array index expected.".ListReader(CultureInfo.InvariantCulture, CustomerListAnnotation.InvokeIssuer(def)));
}
_0001((int)def, value);
}
}
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 bool FillClass(object res)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (baseProperty.m_DatabaseError == (ApplicationState)1 && res == null)
{
return(false);
}
if (RevertBroadcaster(baseProperty._FactoryError, (ConnectActionCursor)1) && (res == null || CustomerListAnnotation.TestIssuer(res, ResolverErrorFilter.ReflectReader(res.GetType()))))
{
return(false);
}
return(true);
}
private void ValidateIterator(TagTestItem def, AttrBroadcasterFilter caller, XmlNamespaceManager tag, CreatorIssuer ord2)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
do
{
switch (def._0001())
{
case WatcherComposer.EndObject:
case WatcherComposer.EndArray:
return;
case WatcherComposer.PropertyName:
{
if (ord2._0001() == XmlNodeType.Document && caller._0001() != null)
{
throw StrategyError.PatchComposer(def, "JSON root object has multiple properties. The root object must have a single property in order to create a valid XML document. Consider specifying a DeserializeRootElementName.");
}
string text = def._0001().ToString();
def.SortError();
if (def._0001() == WatcherComposer.StartArray)
{
int num = 0;
while (def._0001() && def._0001() != WatcherComposer.EndArray)
{
CollectRequest(def, caller, tag, text, ord2);
num++;
}
if (num == 1 && this._0003())
{
CustomerListAnnotation.CustomizeIssuer(text, out string _0003, out string role);
string b = SetterTest.StartReader(_0003) ? tag.DefaultNamespace : tag.LookupNamespace(_0003);
foreach (CreatorIssuer item in ord2._0001())
{
InfoRequestStrategy infoRequestStrategy = item as InfoRequestStrategy;
if (infoRequestStrategy != null && ((CreatorIssuer)infoRequestStrategy)._0001() == role && infoRequestStrategy._0003() == b)
{
LoginIterator(infoRequestStrategy, caller);
break;
}
}
}
}
else
{
CollectRequest(def, caller, tag, text, ord2);
}
break;
}
case WatcherComposer.StartConstructor:
{
string reg = def._0001().ToString();
while (def._0001() && def._0001() != WatcherComposer.EndConstructor)
{
CollectRequest(def, caller, tag, reg, ord2);
}
break;
}
case WatcherComposer.Comment:
ord2._0001(caller._0001((string)def._0001()));
break;
default:
throw StrategyError.PatchComposer(def, "Unexpected JsonToken when deserializing node: " + def._0001());
}
}while (def._0001());
}
public override ParserFilterResolver this[object init]
{
[MethodImpl(MethodImplOptions.NoInlining)]
get
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
ContextClientBridge.RunClient(init, "key");
string text = init as string;
if (text == null)
{
throw new ArgumentException("Accessed JObject values with invalid key value: {0}. Object property name expected.".ListReader(CultureInfo.InvariantCulture, CustomerListAnnotation.InvokeIssuer(init)));
}
return(this[text]);
}
[MethodImpl(MethodImplOptions.NoInlining)]
set
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
ContextClientBridge.RunClient(init, "key");
string text = init as string;
if (text == null)
{
throw new ArgumentException("Set JObject values with invalid key value: {0}. Object property name expected.".ListReader(CultureInfo.InvariantCulture, CustomerListAnnotation.InvokeIssuer(init)));
}
this[text] = value;
}
}
public override ParserFilterResolver this[object def]
{
[MethodImpl(MethodImplOptions.NoInlining)]
get
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
ContextClientBridge.RunClient(def, "key");
if (def is int)
{
int lengthinit = (int)def;
return(((ConfigurationIssuer)this)._0001(lengthinit));
}
throw new ArgumentException("Accessed JConstructor values with invalid key value: {0}. Argument position index expected.".ListReader(CultureInfo.InvariantCulture, CustomerListAnnotation.InvokeIssuer(def)));
}
[MethodImpl(MethodImplOptions.NoInlining)]
set
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
ContextClientBridge.RunClient(v, "key");
if (v is int)
{
int lastY = (int)v;
_0001(lastY, value);
return;
}
throw new ArgumentException("Set JConstructor values with invalid key value: {0}. Argument position index expected.".ListReader(CultureInfo.InvariantCulture, CustomerListAnnotation.InvokeIssuer(v)));
}
}
public InfoRequestStrategy _0001(string reference, string cfg)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
return(new SerializerDicCandidate(new XElement(XName.Get(CustomerListAnnotation.AssetIssuer(reference), cfg))));
}
public CreatorIssuer _0002(string param, string col, string tag)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
return(new ProccesorIssuer(new XAttribute(XName.Get(CustomerListAnnotation.AssetIssuer(param), col), tag)));
}
private bool AssetBroadcaster(object asset, PrototypeFilterResolver cont, ProductInstanceExpression consumer)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (asset == null && WriteClient(cont, consumer) == (ApplicationState)1)
{
return(false);
}
if (RevertBroadcaster(consumer._0001().GetValueOrDefault(baseProperty._FactoryError), (ConnectActionCursor)1) && CustomerListAnnotation.TestIssuer(asset, consumer.InitClient()))
{
return(false);
}
return(true);
}
