public override DynamicMetaObject _0001(DynamicMetaObject res, DynamicMetaObject col)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
DynamicMetaObject dynamicMetaObject = _ConnectionComposer.Bind(res, ObserverIteratorMapping.CheckProperty <DynamicMetaObject>());
return(new DynamicMetaObject(new SchemaComposer().Visit(dynamicMetaObject.Expression), dynamicMetaObject.Restrictions));
}
public virtual byte[] _0001()
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
WatcherComposer watcherComposer = LoginComposer();
switch (watcherComposer)
{
case WatcherComposer.StartObject:
{
CountError();
byte[] array3 = this._0001();
InvokeError();
if (this._0001() != WatcherComposer.EndObject)
{
throw ContextError.CheckComposer(this, "Error reading bytes. Unexpected token: {0}.".ListReader(CultureInfo.InvariantCulture, this._0001()));
}
CancelError(WatcherComposer.Bytes, array3, isstate: false);
return(array3);
}
case WatcherComposer.String:
{
string text = (string)this._0001();
Guid connection;
byte[] array2 = (text.Length == 0) ? ObserverIteratorMapping.CheckProperty <byte>() : ((!HelperDicCandidate.VisitProperty(text, out connection)) ? Convert.FromBase64String(text) : connection.ToByteArray());
CancelError(WatcherComposer.Bytes, array2, isstate: false);
return(array2);
}
case WatcherComposer.None:
case WatcherComposer.Null:
case WatcherComposer.EndArray:
return(null);
case WatcherComposer.Bytes:
{
object obj = this._0001();
if (obj is Guid)
{
byte[] array = ((Guid)obj).ToByteArray();
CancelError(WatcherComposer.Bytes, array, isstate: false);
return(array);
}
return((byte[])this._0001());
}
case WatcherComposer.StartArray:
return(ChangeError());
default:
throw ContextError.CheckComposer(this, "Error reading bytes. Unexpected token: {0}.".ListReader(CultureInfo.InvariantCulture, watcherComposer));
}
}
public ParamClientBridge(Type asset)
{
//Discarded unreachable code: IL_0002, IL_0006
//IL_0003: Incompatible stack heights: 0 vs 1
//IL_0007: Incompatible stack heights: 0 vs 1
SingletonReader.PushGlobal();
base._002Ector(asset);
_ErrorProperty = (ParameterFilterResolver)5;
Type second;
Type util;
if (ResolverErrorFilter.FillReader(asset, typeof(IDictionary <, >), out m_AttrProperty))
{
second = m_AttrProperty.GetGenericArguments()[0];
util = m_AttrProperty.GetGenericArguments()[1];
if (ResolverErrorFilter.OrderReader(base._0002(), typeof(IDictionary <, >)))
{
_0002(typeof(Dictionary <, >).MakeGenericType(second, util));
}
else if (asset.CallReader() && asset.GetGenericTypeDefinition().FullName == "System.Collections.Concurrent.ConcurrentDictionary`2")
{
printerProperty = true;
}
}
else
{
ResolverErrorFilter.MapReader(base._0002(), out second, out util);
if (base._0002() == typeof(IDictionary))
{
_0002(typeof(Dictionary <object, object>));
}
}
if (second != null && util != null)
{
m_MappingProperty = ObserverIteratorMapping.InitTest(base._0003(), typeof(KeyValuePair <, >).MakeGenericType(second, util), typeof(IDictionary <, >).MakeGenericType(second, util));
if (!this._0003() && asset.Name == "FSharpMap`2")
{
PropertyTest.MoveIssuer(asset.RevertReader());
_ObserverProperty = PropertyTest._0001().IncludeIssuer(second, util);
}
}
if (!typeof(IDictionary).IsAssignableFrom(base._0003()))
{
printerProperty = true;
}
queueProperty = second;
m_ProxyProperty = util;
if (this._0001() != null && _0004() != null && ParamRequestStrategy.InstantiateIssuer(asset, this._0001(), _0004(), out Type _0005, out GDBD.Specifications.AdapterClassSpec <object> _0006))
{
_0002(_0005);
_ObserverProperty = _0006;
composerProperty = true;
}
}
private void PatchClass(RecordClassDispatcher i, Array result, MessageTest tag, ProductInstanceExpression connection2, InitializerTest ord3, ProductInstanceExpression asset4)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
ManageBroadcaster(i, tag, result);
wrapperProperty.Add(result);
bool num = ValidateClass(i, result, tag, connection2, ord3, asset4);
FindClass(i, result, tag, connection2, i._0002(), ObserverIteratorMapping.CheckProperty <int>());
if (num)
{
i._0011();
}
wrapperProperty.RemoveAt(wrapperProperty.Count - 1);
InitBroadcaster(i, tag, result);
}
private static Expression[] _0001()
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
return(ObserverIteratorMapping.CheckProperty <Expression>());
}
private static void RunComposer(PrototypeError last, CodeListAnnotation cfg)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (!ObserverIteratorMapping.CancelTest(cfg._0001()))
{
for (int i = 0; i < cfg._0001().Count; i++)
{
last._0001().Insert(i, cfg._0001()[i]);
}
}
if (cfg.m_ConsumerError.HasValue)
{
last._0001(cfg._0001());
}
if (cfg.m_ComparatorError.HasValue)
{
last._0001(cfg._0001());
}
if (cfg.templateError.HasValue)
{
last._0001(cfg._0001());
}
if (cfg.configError.HasValue)
{
last._0001(cfg._0001());
}
if (cfg.schemaError.HasValue)
{
last._0001(cfg._0001());
}
if (cfg.objectError.HasValue)
{
last._0001(cfg._0001());
}
if (cfg.initializerError.HasValue)
{
last._0001(cfg._0001());
}
if (cfg.connectionError.HasValue)
{
last._0001(cfg._0001());
}
if (cfg.m_ExpressionError.HasValue)
{
last._0001(cfg._0001());
}
if (cfg.threadError.HasValue)
{
last._0001(cfg._0001());
}
if (cfg.m_RefError.HasValue)
{
last._0001(cfg._0001());
}
if (cfg.m_ExporterError.HasValue)
{
last._BaseError = cfg.m_ExporterError;
}
if (cfg._0001() != null)
{
last._0001(cfg._0001());
}
if (cfg._0001() != null)
{
last._0001(cfg._0001());
}
if (cfg._0001() != null)
{
last._0001(cfg._0001()());
}
if (cfg._0001() != null)
{
last._0001(cfg._0001());
}
if (cfg._0001() != null)
{
last._0001(cfg._0001());
}
if (cfg._0001() != null)
{
last._0001(cfg._0001());
}
if (cfg.accountError.HasValue)
{
last._RuleError = cfg.accountError;
}
if (cfg.m_SingletonError.HasValue)
{
last.m_BridgeError = cfg.m_SingletonError;
}
if (cfg._ModelError.HasValue)
{
last.importerError = cfg._ModelError;
}
if (cfg._MessageError.HasValue)
{
last._ReponseError = cfg._MessageError;
}
if (cfg._ParamsError)
{
last.containerError = cfg.m_WrapperError;
last.proccesorError = cfg._ParamsError;
}
if (cfg.productError.HasValue)
{
last.m_IndexerError = cfg.productError;
}
if (cfg.m_InterceptorError.HasValue)
{
last._DecoratorError = cfg.m_InterceptorError;
}
if (cfg.m_AlgoError.HasValue)
{
last._FieldError = cfg.m_AlgoError;
}
if (cfg._AnnotationError != null)
{
last.m_ItemError = cfg._AnnotationError;
}
if (cfg._GlobalError)
{
last._RegError = cfg._VisitorError;
last.processError = cfg._GlobalError;
}
}
public MessageTest(Type instance)
{
//Discarded unreachable code: IL_0002, IL_0006
//IL_0003: Incompatible stack heights: 0 vs 1
//IL_0007: Incompatible stack heights: 0 vs 1
SingletonReader.PushGlobal();
base._002Ector(instance);
_ErrorProperty = (ParameterFilterResolver)2;
m_GlobalTest = (base._0003().IsArray || (_InstanceProperty.CallReader() && _InstanceProperty.GetGenericTypeDefinition().FullName == "System.Linq.EmptyPartition`1"));
bool forcedef;
Type _0004;
if (this._0002())
{
_ProductTest = ResolverErrorFilter.EnableReader(base._0002());
composerProperty = true;
_AlgoTest = typeof(List <>).MakeGenericType(this._0001());
forcedef = true;
m_InterceptorTest = (base._0003().IsArray&& base._0002().GetArrayRank() > 1);
}
else if (typeof(IList).IsAssignableFrom(_InstanceProperty))
{
if (ResolverErrorFilter.FillReader(_InstanceProperty, typeof(ICollection <>), out _AlgoTest))
{
_ProductTest = _AlgoTest.GetGenericArguments()[0];
}
else
{
_ProductTest = ResolverErrorFilter.EnableReader(_InstanceProperty);
}
if (_InstanceProperty == typeof(IList))
{
_0002(typeof(List <object>));
}
if (this._0001() != null)
{
_TemplateTest = ObserverIteratorMapping.ManageTest(_InstanceProperty, this._0001());
}
composerProperty = ResolverErrorFilter.RunReader(_InstanceProperty, typeof(ReadOnlyCollection <>));
forcedef = true;
}
else if (ResolverErrorFilter.FillReader(_InstanceProperty, typeof(ICollection <>), out _AlgoTest))
{
_ProductTest = _AlgoTest.GetGenericArguments()[0];
if (ResolverErrorFilter.OrderReader(_InstanceProperty, typeof(ICollection <>)) || ResolverErrorFilter.OrderReader(_InstanceProperty, typeof(IList <>)))
{
_0002(typeof(List <>).MakeGenericType(this._0001()));
}
if (ResolverErrorFilter.OrderReader(_InstanceProperty, typeof(ISet <>)))
{
_0002(typeof(HashSet <>).MakeGenericType(this._0001()));
}
_TemplateTest = ObserverIteratorMapping.ManageTest(_InstanceProperty, this._0001());
forcedef = true;
_WrapperTest = true;
}
else if (ResolverErrorFilter.FillReader(_InstanceProperty, typeof(IEnumerable <>), out _0004))
{
_ProductTest = _0004.GetGenericArguments()[0];
if (ResolverErrorFilter.OrderReader(base._0002(), typeof(IEnumerable <>)))
{
_0002(typeof(List <>).MakeGenericType(this._0001()));
}
_TemplateTest = ObserverIteratorMapping.ManageTest(_InstanceProperty, this._0001());
StartClient(_InstanceProperty);
if (_InstanceProperty.CallReader() && _InstanceProperty.GetGenericTypeDefinition() == typeof(IEnumerable <>))
{
_AlgoTest = _0004;
composerProperty = false;
_WrapperTest = false;
forcedef = true;
}
else
{
_AlgoTest = typeof(List <>).MakeGenericType(this._0001());
composerProperty = true;
_WrapperTest = true;
forcedef = _0006();
}
}
else
{
forcedef = false;
_WrapperTest = true;
}
_0001(forcedef);
if (this._0001() != null && ParamRequestStrategy.CalcIssuer(_InstanceProperty, this._0001(), out Type _00042, out GDBD.Specifications.AdapterClassSpec <object> _0005))
{
_0002(_00042);
m_ExpressionTest = _0005;
composerProperty = true;
_0001(forcedef: true);
}
}
public virtual IEnumerable <string> _0001(T asset)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
return(ObserverIteratorMapping.CheckProperty <string>());
}
