public override void _0005(string var1)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
base._0005(var1);
InstantiateRequest(PoolIssuer.LogoutRequest(var1), WatcherComposer.Comment);
}
public object _0001(object key, TypeCode col)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
ContextClientBridge.RunClient(key, "value");
PoolIssuer poolIssuer = key as PoolIssuer;
return(Convert.ChangeType((poolIssuer != null) ? poolIssuer._0001() : key, col, CultureInfo.InvariantCulture));
}
internal static bool ExcludeClass(ParserFilterResolver instance, ParserFilterResolver caller)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
PoolIssuer poolIssuer = instance as PoolIssuer;
if (poolIssuer != null)
{
if (caller == null)
{
return(((ParserFilterResolver)poolIssuer)._0001() == Newtonsoft.Rules.UnicodeCategory.Null);
}
return(poolIssuer.Equals(caller));
}
return(false);
}
public void _0003(ParserFilterResolver param)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
CustomizeClass();
ParserFilterResolver cust = param ?? PoolIssuer.VisitRequest();
if (collectionIssuer.m_ServerIssuer == null)
{
_0001(0, cust, isconsumer: false);
}
else
{
_0001(0, cust);
}
}
internal ParserFilterResolver CancelClass(ParserFilterResolver first, bool removevis)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (first == null)
{
return(PoolIssuer.VisitRequest());
}
if (removevis)
{
return(first);
}
if (first._0001() != null || first == this || (first._0001() && base._0005() == first))
{
first = first._0001();
}
return(first);
}
internal void InstantiateRequest(PoolIssuer first, WatcherComposer col)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (m_ParamIssuer != null)
{
m_ParamIssuer.Add(first);
utilsIssuer = ((ParserFilterResolver)m_ParamIssuer)._0003();
if (((ParserFilterResolver)m_ParamIssuer)._0001() == Newtonsoft.Rules.UnicodeCategory.Property)
{
m_ParamIssuer = ((ParserFilterResolver)m_ParamIssuer)._0001();
}
}
else
{
_PublisherIssuer = (first ?? PoolIssuer.VisitRequest());
utilsIssuer = _PublisherIssuer;
}
}
internal static TT SearchClass <[_0008._0012(0)] T, [_0008._0012(2)] TT>(this T init) where T : ParserFilterResolver
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (init == null)
{
return(default(TT));
}
if (init is TT)
{
TT result = init as TT;
if (typeof(TT) != typeof(IComparable) && typeof(TT) != typeof(IFormattable))
{
return(result);
}
}
PoolIssuer poolIssuer = init as PoolIssuer;
if (poolIssuer == null)
{
throw new InvalidCastException("Cannot cast {0} to {1}.".SelectReader(CultureInfo.InvariantCulture, init.GetType(), typeof(T)));
}
object obj = poolIssuer._0001();
if (obj is TT)
{
return((TT)obj);
}
Type type = typeof(TT);
if (ResolverErrorFilter.PatchReader(type))
{
if (poolIssuer._0001() == null)
{
return(default(TT));
}
type = Nullable.GetUnderlyingType(type);
}
return((TT)Convert.ChangeType(poolIssuer._0001(), type, CultureInfo.InvariantCulture));
}
internal override void _0001(TagTestItem asset, bool excludepol, bool containstag, bool extractident2)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
DatabaseDicCandidate databaseDicCandidate = asset as DatabaseDicCandidate;
if (databaseDicCandidate != null && excludepol && containstag && extractident2)
{
if (((TagTestItem)databaseDicCandidate)._0001() == WatcherComposer.None && !((TagTestItem)databaseDicCandidate)._0001())
{
return;
}
ParserFilterResolver parserFilterResolver = databaseDicCandidate._0001()._0001();
if (m_ParamIssuer != null)
{
m_ParamIssuer.Add(parserFilterResolver);
utilsIssuer = ((ParserFilterResolver)m_ParamIssuer)._0003();
if (((ParserFilterResolver)m_ParamIssuer)._0001() == Newtonsoft.Rules.UnicodeCategory.Property)
{
m_ParamIssuer = ((ParserFilterResolver)m_ParamIssuer)._0001();
GetTest(WatcherComposer.Null);
}
}
else
{
utilsIssuer = parserFilterResolver;
if (_ContextIssuer == null && _PublisherIssuer == null)
{
_ContextIssuer = (parserFilterResolver as ConfigurationIssuer);
_PublisherIssuer = (parserFilterResolver as PoolIssuer);
}
}
databaseDicCandidate.AssetError();
}
else
{
base._0001(asset, excludepol, containstag, extractident2);
}
}
internal void SortClass(TagTestItem setup, CodeIteratorMapping cust)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
ContextClientBridge.RunClient(setup, "r");
IdentifierClientBridge identifierClientBridge = setup as IdentifierClientBridge;
ConfigurationIssuer configurationIssuer = this;
do
{
WatcherIssuer watcherIssuer = configurationIssuer as WatcherIssuer;
if (watcherIssuer != null && watcherIssuer._0004() != null)
{
if (configurationIssuer == this)
{
break;
}
configurationIssuer = ((ParserFilterResolver)configurationIssuer)._0001();
}
switch (setup._0001())
{
case WatcherComposer.StartArray:
{
InstanceClassDispatcher instanceClassDispatcher = new InstanceClassDispatcher();
instanceClassDispatcher.TestClass(identifierClientBridge, cust);
configurationIssuer.Add(instanceClassDispatcher);
configurationIssuer = instanceClassDispatcher;
break;
}
case WatcherComposer.EndArray:
if (configurationIssuer == this)
{
return;
}
configurationIssuer = ((ParserFilterResolver)configurationIssuer)._0001();
break;
case WatcherComposer.StartObject:
{
DecoratorReaderMapper decoratorReaderMapper = new DecoratorReaderMapper();
decoratorReaderMapper.TestClass(identifierClientBridge, cust);
configurationIssuer.Add(decoratorReaderMapper);
configurationIssuer = decoratorReaderMapper;
break;
}
case WatcherComposer.EndObject:
if (configurationIssuer == this)
{
return;
}
configurationIssuer = ((ParserFilterResolver)configurationIssuer)._0001();
break;
case WatcherComposer.StartConstructor:
{
IndexerReaderMapper indexerReaderMapper = new IndexerReaderMapper(setup._0001().ToString());
indexerReaderMapper.TestClass(identifierClientBridge, cust);
configurationIssuer.Add(indexerReaderMapper);
configurationIssuer = indexerReaderMapper;
break;
}
case WatcherComposer.EndConstructor:
if (configurationIssuer == this)
{
return;
}
configurationIssuer = ((ParserFilterResolver)configurationIssuer)._0001();
break;
case WatcherComposer.Integer:
case WatcherComposer.Float:
case WatcherComposer.String:
case WatcherComposer.Boolean:
case WatcherComposer.Date:
case WatcherComposer.Bytes:
{
PoolIssuer poolIssuer = new PoolIssuer(setup._0001());
poolIssuer.TestClass(identifierClientBridge, cust);
configurationIssuer.Add(poolIssuer);
break;
}
case WatcherComposer.Comment:
if (cust != null && cust._0001() == (XlOLEVerb)1)
{
PoolIssuer poolIssuer = PoolIssuer.LogoutRequest(setup._0001().ToString());
poolIssuer.TestClass(identifierClientBridge, cust);
configurationIssuer.Add(poolIssuer);
}
break;
case WatcherComposer.Null:
{
PoolIssuer poolIssuer = PoolIssuer.VisitRequest();
poolIssuer.TestClass(identifierClientBridge, cust);
configurationIssuer.Add(poolIssuer);
break;
}
case WatcherComposer.Undefined:
{
PoolIssuer poolIssuer = PoolIssuer.ViewRequest();
poolIssuer.TestClass(identifierClientBridge, cust);
configurationIssuer.Add(poolIssuer);
break;
}
case WatcherComposer.PropertyName:
{
WatcherIssuer watcherIssuer2 = CallClass(setup, cust, identifierClientBridge, configurationIssuer);
if (watcherIssuer2 != null)
{
configurationIssuer = watcherIssuer2;
}
else
{
setup.AssetError();
}
break;
}
default:
throw new InvalidOperationException("The JsonReader should not be on a token of type {0}.".ListReader(CultureInfo.InvariantCulture, setup._0001()));
case WatcherComposer.None:
break;
}
}while (setup._0001());
}
