private object NoCheckDeserialize(Stream serializationStream, HeaderHandler handler)
{
if (serializationStream == null)
{
throw new ArgumentNullException("serializationStream");
}
if (serializationStream.CanSeek && serializationStream.Length == 0L)
{
throw new SerializationException("serializationStream supports seeking, but its length is 0");
}
BinaryReader binaryReader = new BinaryReader(serializationStream);
bool flag;
this.ReadBinaryHeader(binaryReader, out flag);
BinaryElement binaryElement = (BinaryElement)binaryReader.Read();
if (binaryElement == BinaryElement.MethodCall)
{
return(MessageFormatter.ReadMethodCall(binaryElement, binaryReader, flag, handler, this));
}
if (binaryElement == BinaryElement.MethodResponse)
{
return(MessageFormatter.ReadMethodResponse(binaryElement, binaryReader, flag, handler, null, this));
}
ObjectReader objectReader = new ObjectReader(this);
object result;
Header[] headers;
objectReader.ReadObjectGraph(binaryElement, binaryReader, flag, out result, out headers);
if (handler != null)
{
handler(headers);
}
return(result);
}
[System.Security.SecurityCritical] // auto-generated
internal Object Deserialize(Stream serializationStream, HeaderHandler handler, bool fCheck, bool isCrossAppDomain, IMethodCallMessage methodCallMessage)
{
if (serializationStream == null)
{
throw new ArgumentNullException("serializationStream", ModifiedVulnerableBinaryFormatters.binary.Environment.GetResourceString("ArgumentNull_WithParamName", serializationStream));
}
Contract.EndContractBlock();
if (serializationStream.CanSeek && (serializationStream.Length == 0))
{
throw new SerializationException(Environment.GetResourceString("Serialization_Stream"));
}
SerTrace.Log(this, "Deserialize Entry");
InternalFE formatterEnums = new InternalFE();
formatterEnums.FEtypeFormat = m_typeFormat;
formatterEnums.FEserializerTypeEnum = InternalSerializerTypeE.Binary;
formatterEnums.FEassemblyFormat = m_assemblyFormat;
formatterEnums.FEsecurityLevel = m_securityLevel;
ObjectReader sor = new ObjectReader(serializationStream, m_surrogates, m_context, formatterEnums, m_binder);
sor.crossAppDomainArray = m_crossAppDomainArray;
return(sor.Deserialize(handler, new __BinaryParser(serializationStream, sor), fCheck, isCrossAppDomain, methodCallMessage));
}
public object Deserialize(Stream serializationStream, HeaderHandler handler)
{
if (serializationStream == null)
{
throw new ArgumentNullException("serializationStream");
}
if (serializationStream.CanSeek && (serializationStream.Length == 0L))
{
throw new SerializationException(SoapUtil.GetResourceString("Serialization_Stream"));
}
InternalFE formatterEnums = new InternalFE {
FEtypeFormat = this.m_typeFormat,
FEtopObject = this.m_topObject,
FEserializerTypeEnum = InternalSerializerTypeE.Soap,
FEassemblyFormat = this.m_assemblyFormat,
FEsecurityLevel = this.m_securityLevel
};
ObjectReader objectReader = new ObjectReader(serializationStream, this.m_surrogates, this.m_context, formatterEnums, this.m_binder);
if ((this.soapParser == null) || (serializationStream != this.currentStream))
{
this.soapParser = new SoapParser(serializationStream);
this.currentStream = serializationStream;
}
this.soapParser.Init(objectReader);
return(objectReader.Deserialize(handler, this.soapParser));
}
internal object Deserialize(Stream serializationStream, HeaderHandler handler, bool check)
{
if (serializationStream == null)
{
throw new ArgumentNullException(nameof(serializationStream));
}
if (serializationStream.CanSeek && (serializationStream.Length == 0))
{
throw new SerializationException(SR.Serialization_Stream);
}
var formatterEnums = new InternalFE()
{
_typeFormat = _typeFormat,
_serializerTypeEnum = InternalSerializerTypeE.Binary,
_assemblyFormat = _assemblyFormat,
_securityLevel = _securityLevel,
};
var reader = new ObjectReader(serializationStream, _surrogates, _context, formatterEnums, _binder)
{
_crossAppDomainArray = _crossAppDomainArray
};
var parser = new BinaryParser(serializationStream, reader);
return reader.Deserialize(handler, parser, check);
}
private void DrawActionUI(ActionView actionView)
{
HeaderHandler headerRects;
if (EditorApplication.isPlaying)
{
headerRects = HeaderHandler.GetHeaderRects(0);
}
else
{
headerRects = HeaderHandler.GetHeaderRects(2);
if (GUI.Button(headerRects.Next, SharedStyles.deleteTooltip, SharedStyles.BuiltIn.deleteButtonSmall))
{
GUI.changed = false;
_state.currentAIUI.RemoveSelected();
return;
}
if (GUI.Button(headerRects.Next, EditorStyling.changeTypeTooltip, SharedStyles.BuiltIn.changeButtonSmall))
{
ShowChangeTypeMenu(actionView.action, (newAction) => _state.currentAIUI.ReplaceAction(actionView.parent, newAction));
}
}
GUI.Label(headerRects.Next, string.Concat(_state.editedItem.name, " | APEX AI"), EditorStyling.Skinned.inspectorTitle);
EditorGUILayout.Separator();
DrawViewSharedUI(actionView);
EditorGUILayout.Separator();
_state.editedItem.Render(_state);
}
public StateData(HTTPMessage req, IPEndPoint d, object Tag, HeaderHandler HeaderCB)
{
this.Dest = d;
this.Request = req;
this.Tag = Tag;
this.HeaderCB = HeaderCB;
}
public StateData(HTTPMessage req, IPEndPoint d, object Tag, HeaderHandler HeaderCB)
{
this.Dest = d;
this.Request = req;
this.Tag = Tag;
this.HeaderCB = HeaderCB;
}
public Object DeserializeMethodResponse
(Stream serializationStream, HeaderHandler handler,
IMethodCallMessage methodCallMessage)
{
// TODO
return(null);
}
public Object UnsafeDeserializeMethodResponse
(Stream serializationStream, HeaderHandler handler,
IMethodCallMessage methodCallMessage)
{
return(DeserializeMethodResponse
(serializationStream, handler, methodCallMessage));
}
internal object Deserialize(Stream serializationStream, HeaderHandler handler, bool check)
{
if (serializationStream == null)
{
throw new ArgumentNullException(nameof(serializationStream));
}
if (serializationStream.CanSeek && (serializationStream.Length == 0))
{
throw new SerializationException(SR.Serialization_Stream);
}
var formatterEnums = new InternalFE()
{
_typeFormat = _typeFormat,
_serializerTypeEnum = InternalSerializerTypeE.Binary,
_assemblyFormat = _assemblyFormat,
_securityLevel = _securityLevel,
};
var reader = new ObjectReader(serializationStream, _surrogates, _context, formatterEnums, _binder)
{
_crossAppDomainArray = _crossAppDomainArray
};
var parser = new BinaryParser(serializationStream, reader);
return(reader.Deserialize(handler, parser, check));
}
private void DrawAIUI(AIUI aiui)
{
HeaderHandler headerRects;
if (EditorApplication.isPlaying)
{
headerRects = HeaderHandler.GetHeaderRects(0);
}
else
{
headerRects = HeaderHandler.GetHeaderRects(1);
if (GUI.Button(headerRects.Next, SharedStyles.deleteTooltip, SharedStyles.BuiltIn.deleteButtonSmall))
{
GUI.changed = false;
if (DisplayHelper.ConfirmDelete("AI", true))
{
AIEditorWindow.activeInstance.DeleteAI();
return;
}
}
}
GUI.Label(headerRects.Next, string.Concat(_state.currentAIUI.name, " | APEX AI"), EditorStyling.Skinned.inspectorTitle);
}
internal object Deserialize(HeaderHandler handler, BinaryParser serParser, bool fCheck)
{
if (serParser == null)
{
throw new ArgumentNullException(nameof(serParser));
}
_fullDeserialization = false;
TopObject = null;
_topId = 0;
_isSimpleAssembly = (_formatterEnums._assemblyFormat == FormatterAssemblyStyle.Simple);
_handler = handler;
if (_fullDeserialization)
{
// Reinitialize
_objectManager = new ObjectManager(_surrogates, _context, false, false);
_serObjectInfoInit = new SerObjectInfoInit();
}
// Will call back to ParseObject, ParseHeader for each object found
serParser.Run();
if (_fullDeserialization)
{
_objectManager.DoFixups();
}
if (TopObject == null)
{
throw new SerializationException(SR.Serialization_TopObject);
}
//if TopObject has a surrogate then the actual object may be changed during special fixup
//So refresh it using topID.
if (HasSurrogate(TopObject.GetType()) && _topId != 0)//Not yet resolved
{
TopObject = _objectManager.GetObject(_topId);
}
if (TopObject is IObjectReference)
{
TopObject = ((IObjectReference)TopObject).GetRealObject(_context);
}
if (_fullDeserialization)
{
_objectManager.RaiseDeserializationEvent(); // This will raise both IDeserialization and [OnDeserialized] events
}
// Return the headers if there is a handler
if (handler != null)
{
_handlerObject = handler(_headers);
}
return TopObject;
}
// [System.Security.SecurityCritical] // auto-generated
internal Object Deserialize(Stream serializationStream, HeaderHandler handler, bool fCheck)
{
#if FEATURE_REMOTING
return(Deserialize(serializationStream, handler, fCheck, null));
#else
if (serializationStream == null)
{
throw new ArgumentNullException("serializationStream", Ssz.Runtime.Serialization.Environment.GetResourceString("ArgumentNull_WithParamName", serializationStream));
}
Contract.EndContractBlock();
if (serializationStream.CanSeek && (serializationStream.Length == 0))
{
throw new SerializationException(Ssz.Runtime.Serialization.Environment.GetResourceString("Serialization_Stream"));
}
SerTrace.Log(this, "Deserialize Entry");
InternalFE formatterEnums = new InternalFE();
formatterEnums.FEtypeFormat = m_typeFormat;
formatterEnums.FEserializerTypeEnum = InternalSerializerTypeE.Binary;
formatterEnums.FEassemblyFormat = m_assemblyFormat;
formatterEnums.FEsecurityLevel = m_securityLevel;
ObjectReader sor = new ObjectReader(serializationStream, m_surrogates, m_context, formatterEnums, m_binder);
sor.crossAppDomainArray = m_crossAppDomainArray;
return(sor.Deserialize(handler, new __BinaryParser(serializationStream, sor), fCheck));
#endif
}
void ParseHeader(string header, HeaderHandler handler)
{
if (handler == null)
{
throw new ArgumentNullException("handler");
}
if (header == null)
{
return;
}
else if (header == "\r\n")
{
handler(HeaderKind.BodyDelimiter, null, null);
return;
}
header = header.TrimEnd('\r', '\n');
var colonOffset = header.IndexOf(':');
if (header.StartsWith("HTTP/") && colonOffset < 0)
{
handler(HeaderKind.Status, header, null);
return;
}
else if (colonOffset > 0)
{
handler(HeaderKind.KeyValue,
header.Substring(0, colonOffset).Trim(),
header.Substring(colonOffset + 1).Trim()
);
}
}
internal object Deserialize(HeaderHandler handler, BinaryParser serParser, bool fCheck)
{
if (serParser == null)
{
throw new ArgumentNullException(nameof(serParser));
}
_fullDeserialization = false;
TopObject = null;
_topId = 0;
_isSimpleAssembly = (_formatterEnums._assemblyFormat == FormatterAssemblyStyle.Simple);
_handler = handler;
if (_fullDeserialization)
{
// Reinitialize
_objectManager = new ObjectManager(_surrogates, _context, false, false);
_serObjectInfoInit = new SerObjectInfoInit();
}
// Will call back to ParseObject, ParseHeader for each object found
serParser.Run();
if (_fullDeserialization)
{
_objectManager.DoFixups();
}
if (TopObject == null)
{
throw new SerializationException(SR.Serialization_TopObject);
}
//if TopObject has a surrogate then the actual object may be changed during special fixup
//So refresh it using topID.
if (HasSurrogate(TopObject.GetType()) && _topId != 0)//Not yet resolved
{
TopObject = _objectManager.GetObject(_topId);
}
if (TopObject is IObjectReference)
{
TopObject = ((IObjectReference)TopObject).GetRealObject(_context);
}
if (_fullDeserialization)
{
_objectManager.RaiseDeserializationEvent(); // This will raise both IDeserialization and [OnDeserialized] events
}
// Return the headers if there is a handler
if (handler != null)
{
_handlerObject = handler(_headers);
}
return(TopObject);
}
private void DrawLinkUI(AILinkView linkView)
{
HeaderHandler headerRects;
if (EditorApplication.isPlaying)
{
headerRects = HeaderHandler.GetHeaderRects(0);
}
else
{
headerRects = HeaderHandler.GetHeaderRects(2);
if (GUI.Button(headerRects.Next, SharedStyles.deleteTooltip, SharedStyles.BuiltIn.deleteButtonSmall))
{
GUI.changed = false;
_state.currentAIUI.RemoveSelected();
return;
}
if (GUI.Button(headerRects.Next, EditorStyling.changeTypeTooltip, SharedStyles.BuiltIn.changeButtonSmall))
{
ShowChangeLinkMenu(linkView);
}
}
GUI.Label(headerRects.Next, "AI Link | APEX AI", EditorStyling.Skinned.inspectorTitle);
EditorGUILayout.Separator();
DrawViewSharedUI(linkView);
}
public object Deserialize(Stream serializationStream, HeaderHandler handler)
{
if (serializationStream == null)
{
throw new ArgumentNullException("serializationStream");
}
if (serializationStream.CanSeek && (serializationStream.Length == 0L))
{
throw new SerializationException(SoapUtil.GetResourceString("Serialization_Stream"));
}
InternalFE formatterEnums = new InternalFE {
FEtypeFormat = this.m_typeFormat,
FEtopObject = this.m_topObject,
FEserializerTypeEnum = InternalSerializerTypeE.Soap,
FEassemblyFormat = this.m_assemblyFormat,
FEsecurityLevel = this.m_securityLevel
};
ObjectReader objectReader = new ObjectReader(serializationStream, this.m_surrogates, this.m_context, formatterEnums, this.m_binder);
if ((this.soapParser == null) || (serializationStream != this.currentStream))
{
this.soapParser = new SoapParser(serializationStream);
this.currentStream = serializationStream;
}
this.soapParser.Init(objectReader);
return objectReader.Deserialize(handler, this.soapParser);
}
//
// Summary:
// Deserializes a response to a remote method call from the provided System.IO.Stream.
//
// Parameters:
// serializationStream:
// The stream from which to deserialize the object graph.
//
// handler:
// The System.Runtime.Remoting.Messaging.HeaderHandler that handles any headers
// in the serializationStream. Can be null.
//
// methodCallMessage:
// The System.Runtime.Remoting.Messaging.IMethodCallMessage that contains details
// about where the call came from.
//
// Returns:
// The deserialized response to the remote method call.
//
// Exceptions:
// System.ArgumentNullException:
// The serializationStream is null.
//
// System.Runtime.Serialization.SerializationException:
// The serializationStream supports seeking, but its length is 0.
//
// System.Security.SecurityException:
// The caller does not have the required permission.
//[ComVisible(false)]
public object UnsafeDeserializeMethodResponse(Stream serializationStream, HeaderHandler handler, IMethodCallMessage methodCallMessage)
{
Contract.Requires(serializationStream != null);
Contract.Ensures(Contract.Result <object>() != null);
return(default(object));
}
//
// Summary:
// Deserializes the specified stream into an object graph. The provided System.Runtime.Remoting.Messaging.HeaderHandler
// handles any headers in that stream.
//
// Parameters:
// serializationStream:
// The stream from which to deserialize the object graph.
//
// handler:
// The System.Runtime.Remoting.Messaging.HeaderHandler that handles any headers
// in the serializationStream. Can be null.
//
// Returns:
// The deserialized object or the top object (root) of the object graph.
//
// Exceptions:
// System.ArgumentNullException:
// The serializationStream is null.
//
// System.Runtime.Serialization.SerializationException:
// The serializationStream supports seeking, but its length is 0.
//
// System.Security.SecurityException:
// The caller does not have the required permission.
//[ComVisible(false)]
public object UnsafeDeserialize(Stream serializationStream, HeaderHandler handler)
{
Contract.Requires(serializationStream != null);
Contract.Ensures(Contract.Result <object>() != null);
return(default(object));
}
public void Init(HttpApplication application)
{
_corsHandler = new CORSHandler();
_requestHandler = new RequestHandler();
_cookieHandler = new CookieHandler();
_headerHandler = new HeaderHandler();
application.PostAuthenticateRequest += OnPostAuthenticateRequest;
application.BeginRequest += application_BeginRequest;
}
/// <summary>
/// Extends BeginInvoke so that when a state object is not needed, null does not need to be passed.
/// <example>
/// headerhandler.BeginInvoke(headers, callback);
/// </example>
/// </summary>
public static IAsyncResult BeginInvoke(this HeaderHandler headerhandler, Header[] headers, AsyncCallback callback)
{
if (headerhandler == null)
{
throw new ArgumentNullException("headerhandler");
}
return(headerhandler.BeginInvoke(headers, callback, null));
}
//
// Summary:
// Deserializes the specified stream into an object graph. The provided System.Runtime.Remoting.Messaging.HeaderHandler
// handles any headers in that stream.
//
// Parameters:
// serializationStream:
// The stream from which to deserialize the object graph.
//
// handler:
// The System.Runtime.Remoting.Messaging.HeaderHandler that handles any headers
// in the serializationStream. Can be null.
//
// Returns:
// The deserialized object or the top object (root) of the object graph.
//
// Exceptions:
// System.ArgumentNullException:
// The serializationStream is null.
//
// System.Runtime.Serialization.SerializationException:
// The serializationStream supports seeking, but its length is 0.
//
// System.Security.SecurityException:
// The caller does not have the required permission.
virtual public object Deserialize(Stream serializationStream, HeaderHandler handler)
{
Contract.Requires(serializationStream != null);
Contract.Requires(!serializationStream.CanSeek || serializationStream.Length > 0);
Contract.Ensures(Contract.Result <object>() != null);
return(default(object));
}
public ComponentSerializer()
{
_stream = new MemoryStream(0);
_selector = new ComSurrogateSelector();
_formatter = new BinaryFormatter();
_streamingCtx = new StreamingContext(StreamingContextStates.Other);
_formatter.Context = _streamingCtx;
_headerhandler = new HeaderHandler(TPHeaderHandler);
}
/* ----------------------------------------------------------------- */
///
/// Create
///
/// <summary>
/// RssClient オブジェクトを生成します。
/// </summary>
///
/* ----------------------------------------------------------------- */
private RssClient Create()
{
var asm = Assembly.GetExecutingAssembly();
var h = new HeaderHandler {
UserAgent = $"{asm.GetProduct()}/{asm.GetVersion()}"
};
return(new RssClient(h));
}
internal object Deserialize(HeaderHandler handler, __BinaryParser serParser, bool fCheck, bool isCrossAppDomain, IMethodCallMessage methodCallMessage)
{
if (serParser == null)
{
throw new ArgumentNullException("serParser", Environment.GetResourceString("ArgumentNull_WithParamName", (object)serParser));
}
this.bFullDeserialization = false;
this.TopObject = (object)null;
this.topId = 0L;
this.bMethodCall = false;
this.bMethodReturn = false;
this.bIsCrossAppDomain = isCrossAppDomain;
this.bSimpleAssembly = this.formatterEnums.FEassemblyFormat == FormatterAssemblyStyle.Simple;
if (fCheck)
{
CodeAccessPermission.Demand(PermissionType.SecuritySerialization);
}
this.handler = handler;
serParser.Run();
if (this.bFullDeserialization)
{
this.m_objectManager.DoFixups();
}
if (!this.bMethodCall && !this.bMethodReturn)
{
if (this.TopObject == null)
{
throw new SerializationException(Environment.GetResourceString("Serialization_TopObject"));
}
if (this.HasSurrogate(this.TopObject.GetType()) && this.topId != 0L)
{
this.TopObject = this.m_objectManager.GetObject(this.topId);
}
if (this.TopObject is IObjectReference)
{
this.TopObject = ((IObjectReference)this.TopObject).GetRealObject(this.m_context);
}
}
if (this.bFullDeserialization)
{
this.m_objectManager.RaiseDeserializationEvent();
}
if (handler != null)
{
this.handlerObject = handler(this.headers);
}
if (this.bMethodCall)
{
this.TopObject = (object)this.binaryMethodCall.ReadArray(this.TopObject as object[], this.handlerObject);
}
else if (this.bMethodReturn)
{
this.TopObject = (object)this.binaryMethodReturn.ReadArray(this.TopObject as object[], methodCallMessage, this.handlerObject);
}
return(this.TopObject);
}
private static async Task CookieMiddleware(HttpContext context, Func <Task> next)
{
if (context.Request.IsInteresting())
{
CookieHandler.Handle(context);
HeaderHandler.Handle(context);
}
await next();
}
/* ----------------------------------------------------------------- */
///
/// RssMonitor
///
/// <summary>
/// オブジェクトを初期化します。
/// </summary>
///
/* ----------------------------------------------------------------- */
public RssMonitor()
{
Handler = new HeaderHandler {
UseEntityTag = false
};
_http = new RssClient(Handler);
Timeout = _http.Timeout;
RetryCount = 2;
Timer.Subscribe(WhenTick);
}
internal Request(HttpListenerRequest request, ExpressConfiguration config)
{
_request = request;
if (!request.HasEntityBody)
{
return;
}
string body = StringFromStream(request.InputStream);
this.Header = new HeaderHandler(_request);
this.Body = body;
}
public object Deserialize(Stream serializationStream, HeaderHandler handler) {
object objReturn = null;
SoapReader soapReader = new SoapReader(_binder, _selector, _context);
CultureInfo savedCi = CultureInfo.CurrentCulture;
try {
Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
objReturn = soapReader.Deserialize(serializationStream, _topObject);
}
finally {
Thread.CurrentThread.CurrentCulture = savedCi;
}
return objReturn;
}
private void DrawSelectorUI(SelectorView selectorView)
{
var isRoot = selectorView.isRoot;
HeaderHandler headerRects;
if (EditorApplication.isPlaying)
{
headerRects = HeaderHandler.GetHeaderRects(0);
}
else
{
if (isRoot)
{
headerRects = HeaderHandler.GetHeaderRects(1);
}
else
{
headerRects = HeaderHandler.GetHeaderRects(3);
if (GUI.Button(headerRects.Next, SharedStyles.deleteTooltip, SharedStyles.BuiltIn.deleteButtonSmall))
{
GUI.changed = false;
_state.currentAIUI.RemoveSelected();
return;
}
if (GUI.Button(headerRects.Next, EditorStyling.setRootTooltip, EditorStyling.Skinned.setRootButtonSmall))
{
_state.currentAIUI.SetRoot(selectorView.selector);
}
}
if (GUI.Button(headerRects.Next, EditorStyling.changeTypeTooltip, SharedStyles.BuiltIn.changeButtonSmall))
{
ShowChangeTypeMenu(selectorView.selector, (newSelector) => _state.currentAIUI.ReplaceSelector(selectorView, newSelector));
}
}
GUI.Label(headerRects.Next, string.Concat(_state.editedItem.name, (isRoot ? " (ROOT) " : string.Empty), " | APEX AI"), EditorStyling.Skinned.inspectorTitle);
EditorGUILayout.Separator();
DrawViewSharedUI(selectorView);
EditorGUILayout.Separator();
_state.editedItem.Render(_state);
}
public void ThrowsExceptionForColumnNotMappedToProperty()
{
Action action = () =>
{
var normalisedPropertyNames = new[] { "a", "b", "c" };
var normalisedHeaderNames = new[] { "a", "b", "c", "d" };
var unmappedProperties = new string[0];
var optionalProperties = new string[0];
var ignoreColumnsWithoutMatchingProperties = false;
HeaderHandler.ValidateColumnNames(normalisedPropertyNames, normalisedHeaderNames, unmappedProperties,
optionalProperties, ignoreColumnsWithoutMatchingProperties);
};
action.Should().ThrowExactly <ExcelToEnumerableInvalidHeaderException>().WithMessage("Missing properties: 'd'.");
}
public object Deserialize(Stream serializationStream, HeaderHandler handler)
{
object objReturn = null;
SoapReader soapReader = new SoapReader(_binder, _selector, _context);
CultureInfo savedCi = CultureInfo.CurrentCulture;
try {
Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
objReturn = soapReader.Deserialize(serializationStream, _topObject);
}
finally {
Thread.CurrentThread.CurrentCulture = savedCi;
}
return(objReturn);
}
private void DrawQualifierUI(QualifierView qualifierView)
{
HeaderHandler headerRects;
if (EditorApplication.isPlaying || qualifierView.isDefault)
{
headerRects = HeaderHandler.GetHeaderRects(0);
}
else
{
headerRects = HeaderHandler.GetHeaderRects(2);
if (GUI.Button(headerRects.Next, SharedStyles.deleteTooltip, SharedStyles.BuiltIn.deleteButtonSmall))
{
GUI.changed = false;
_state.currentAIUI.RemoveSelected();
return;
}
if (GUI.Button(headerRects.Next, EditorStyling.changeTypeTooltip, SharedStyles.BuiltIn.changeButtonSmall))
{
ShowChangeTypeMenu(qualifierView.qualifier, (newQualifier) => _state.currentAIUI.ReplaceQualifier(qualifierView, newQualifier));
}
}
if (qualifierView.isDefault)
{
GUI.Label(headerRects.Next, string.Concat(_state.editedItem.name, " | APEX AI"), EditorStyling.Skinned.inspectorTitle);
}
else
{
var cbd = qualifierView.qualifier;
var isDisabled = !EditorGUI.ToggleLeft(headerRects.Next, string.Concat(_state.editedItem.name, " | APEX AI"), !cbd.isDisabled, EditorStyling.Skinned.inspectorTitle);
if (isDisabled != cbd.isDisabled)
{
cbd.isDisabled = isDisabled;
_state.currentAIUI.undoRedo.Do(new DisableOperation(cbd));
}
}
EditorGUILayout.Separator();
DrawViewSharedUI(qualifierView);
EditorGUILayout.Separator();
_state.editedItem.Render(_state);
}
public void EncodeAndDecode()
{
var header = new Header
{
Command = CommandType.Exit,
DataLength = 50,
Type = HeaderType.Response
};
var handler = new HeaderHandler();
var decodedHeader = handler.DecodeHeader(handler.EncodeHeader(header));
Assert.Equal(header.Command, decodedHeader.Command);
Assert.Equal(header.Type, decodedHeader.Type);
Assert.Equal(header.DataLength, decodedHeader.DataLength);
}
private object NoCheckDeserializeMethodResponse(Stream serializationStream, HeaderHandler handler, IMethodCallMessage methodCallMessage)
{
if (serializationStream == null)
{
throw new ArgumentNullException("serializationStream");
}
if (serializationStream.CanSeek && serializationStream.Length == 0L)
{
throw new SerializationException("serializationStream supports seeking, but its length is 0");
}
BinaryReader reader = new BinaryReader(serializationStream);
bool hasHeaders;
this.ReadBinaryHeader(reader, out hasHeaders);
return(MessageFormatter.ReadMethodResponse(reader, hasHeaders, handler, methodCallMessage, this));
}
public Object Deserialize(Stream serializationStream,
HeaderHandler handler)
{
// Validate the parameters.
if(serializationStream == null)
{
throw new ArgumentNullException("serializationStream");
}
// Wrap the stream in a binary reader.
using(BinaryReader reader =
new BinaryReader(serializationStream))
{
DeserializationContext context = new DeserializationContext(this, reader);
return BinaryValueReader.Deserialize(context);
}
}
internal object Deserialize(Stream serializationStream, HeaderHandler handler, bool fCheck, bool isCrossAppDomain, IMethodCallMessage methodCallMessage)
{
if (serializationStream == null)
{
throw new ArgumentNullException("serializationStream", Environment.GetResourceString("ArgumentNull_WithParamName", new object[] { serializationStream }));
}
if (serializationStream.CanSeek && (serializationStream.Length == 0L))
{
throw new SerializationException(Environment.GetResourceString("Serialization_Stream"));
}
InternalFE formatterEnums = new InternalFE {
FEtypeFormat = this.m_typeFormat,
FEserializerTypeEnum = InternalSerializerTypeE.Binary,
FEassemblyFormat = this.m_assemblyFormat,
FEsecurityLevel = this.m_securityLevel
};
ObjectReader objectReader = new ObjectReader(serializationStream, this.m_surrogates, this.m_context, formatterEnums, this.m_binder) {
crossAppDomainArray = this.m_crossAppDomainArray
};
return objectReader.Deserialize(handler, new __BinaryParser(serializationStream, objectReader), fCheck, isCrossAppDomain, methodCallMessage);
}
internal object Deserialize(Stream serializationStream, HeaderHandler handler, bool fCheck, IMethodCallMessage methodCallMessage)
{
return this.Deserialize(serializationStream, handler, fCheck, false, methodCallMessage);
}
// shared by Deserialize and UnsafeDeserialize which both involve different security checks
private object NoCheckDeserialize (Stream serializationStream, HeaderHandler handler)
{
if(serializationStream==null)
{
throw new ArgumentNullException("serializationStream");
}
if(serializationStream.CanSeek &&
serializationStream.Length==0)
{
throw new SerializationException("serializationStream supports seeking, but its length is 0");
}
BinaryReader reader = new BinaryReader (serializationStream);
bool hasHeader;
ReadBinaryHeader (reader, out hasHeader);
// Messages are read using a special static method, which does not use ObjectReader
// if it is not needed. This saves time and memory.
BinaryElement elem = (BinaryElement) reader.Read ();
if (elem == BinaryElement.MethodCall) {
return MessageFormatter.ReadMethodCall (elem, reader, hasHeader, handler, this);
}
else if (elem == BinaryElement.MethodResponse) {
return MessageFormatter.ReadMethodResponse (elem, reader, hasHeader, handler, null, this);
}
else {
ObjectReader serializer = new ObjectReader (this);
object result;
Header[] headers;
serializer.ReadObjectGraph (elem, reader, hasHeader, out result, out headers);
if (handler != null) handler(headers);
return result;
}
}
internal Object Deserialize(Stream serializationStream, HeaderHandler handler, bool fCheck, IMethodCallMessage methodCallMessage) {
return Deserialize(serializationStream, handler, fCheck, false/*isCrossAppDomain*/, methodCallMessage);
}
// Deserialize the stream into an object graph.
internal Object Deserialize(Stream serializationStream, HeaderHandler handler, bool fCheck, bool isCrossAppDomain, IMethodCallMessage methodCallMessage) {
if (serializationStream==null)
{
throw new ArgumentNullException("serializationStream", String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("ArgumentNull_WithParamName"),serializationStream));
}
if (serializationStream.CanSeek && (serializationStream.Length == 0))
throw new SerializationException(Environment.GetResourceString("Serialization_Stream"));
SerTrace.Log(this, "Deserialize Entry");
InternalFE formatterEnums = new InternalFE();
formatterEnums.FEtypeFormat = m_typeFormat;
formatterEnums.FEserializerTypeEnum = InternalSerializerTypeE.Binary;
formatterEnums.FEassemblyFormat = m_assemblyFormat;
formatterEnums.FEsecurityLevel = m_securityLevel;
ObjectReader sor = new ObjectReader(serializationStream, m_surrogates, m_context, formatterEnums, m_binder);
sor.crossAppDomainArray = m_crossAppDomainArray;
return sor.Deserialize(handler, new __BinaryParser(serializationStream, sor), fCheck, isCrossAppDomain, methodCallMessage);
}
internal object Deserialize(HeaderHandler handler, ISerParser serParser)
{
if (serParser == null)
{
throw new ArgumentNullException("serParser", string.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("ArgumentNull_WithParamName"), new object[] { serParser }));
}
this.deserializationSecurityException = null;
try
{
serializationPermission.Demand();
}
catch (Exception exception)
{
this.deserializationSecurityException = exception;
}
this.handler = handler;
this.isTopObjectSecondPass = false;
this.isHeaderHandlerCalled = false;
if (handler != null)
{
this.IsFakeTopObject = true;
}
this.m_idGenerator = new ObjectIDGenerator();
this.m_objectManager = this.GetObjectManager();
this.serObjectInfoInit = new SerObjectInfoInit();
this.objectIdTable.Clear();
this.objectIds = 0L;
serParser.Run();
if (handler != null)
{
this.m_objectManager.DoFixups();
if (this.handlerObject == null)
{
this.handlerObject = handler(this.newheaders);
}
if ((this.soapFaultId > 0L) && (this.handlerObject != null))
{
this.topStack = new SerStack("Top ParseRecords");
ParseRecord record = new ParseRecord {
PRparseTypeEnum = InternalParseTypeE.Object,
PRobjectPositionEnum = InternalObjectPositionE.Top,
PRparseStateEnum = InternalParseStateE.Object,
PRname = "Response"
};
this.topStack.Push(record);
record = new ParseRecord {
PRparseTypeEnum = InternalParseTypeE.Member,
PRobjectPositionEnum = InternalObjectPositionE.Child,
PRmemberTypeEnum = InternalMemberTypeE.Field,
PRmemberValueEnum = InternalMemberValueE.Reference,
PRparseStateEnum = InternalParseStateE.Member,
PRname = "__fault",
PRidRef = this.soapFaultId
};
this.topStack.Push(record);
record = new ParseRecord {
PRparseTypeEnum = InternalParseTypeE.ObjectEnd,
PRobjectPositionEnum = InternalObjectPositionE.Top,
PRparseStateEnum = InternalParseStateE.Object,
PRname = "Response"
};
this.topStack.Push(record);
this.isTopObjectResolved = false;
}
}
if (!this.isTopObjectResolved)
{
this.isTopObjectSecondPass = true;
this.topStack.Reverse();
int num = this.topStack.Count();
ParseRecord pr = null;
for (int i = 0; i < num; i++)
{
pr = (ParseRecord) this.topStack.Pop();
this.Parse(pr);
}
}
this.m_objectManager.DoFixups();
if (this.topObject == null)
{
throw new SerializationException(SoapUtil.GetResourceString("Serialization_TopObject"));
}
if (this.HasSurrogate(this.topObject.GetType()) && (this.topId != 0L))
{
this.topObject = this.m_objectManager.GetObject(this.topId);
}
if (this.topObject is IObjectReference)
{
this.topObject = ((IObjectReference) this.topObject).GetRealObject(this.m_context);
}
this.m_objectManager.RaiseDeserializationEvent();
if ((this.formatterEnums.FEtopObject != null) && (this.topObject is InternalSoapMessage))
{
InternalSoapMessage topObject = (InternalSoapMessage) this.topObject;
ISoapMessage fEtopObject = this.formatterEnums.FEtopObject;
fEtopObject.MethodName = topObject.methodName;
fEtopObject.XmlNameSpace = topObject.xmlNameSpace;
fEtopObject.ParamNames = topObject.paramNames;
fEtopObject.ParamValues = topObject.paramValues;
fEtopObject.Headers = this.headers;
this.topObject = fEtopObject;
this.isTopObjectResolved = true;
}
return this.topObject;
}
// Deserialize the stream into an object graph.
internal Object Deserialize(HeaderHandler handler, __BinaryParser serParser, bool fCheck, IMethodCallMessage methodCallMessage)
{
SerTrace.Log( this, "Deserialize Entry handler", handler);
BCLDebug.Assert((IsCrossAppDomain() && (crossAppDomainArray != null))
|| (!IsCrossAppDomain()),
"[System.Runtime.Serialization.Formatters.BinaryObjectReader missing crossAppDomainArray]");
bFullDeserialization = false;
bMethodCall = false;
bMethodReturn = false;
bSimpleAssembly = (formatterEnums.FEassemblyFormat == FormatterAssemblyStyle.Simple);
if (serParser == null)
throw new ArgumentNullException("serParser", String.Format(Environment.GetResourceString("ArgumentNull_WithParamName"), serParser));
if (fCheck)
{
try{
CodeAccessPermission.DemandInternal(PermissionType.SecuritySerialization);
}catch(Exception e)
{
deserializationSecurityException = e;
}
}
this.handler = handler;
if (bFullDeserialization)
{
// Reinitialize
m_objectManager = new ObjectManager(m_surrogates, m_context, false);
serObjectInfoInit = new SerObjectInfoInit();
}
// Will call back to ParseObject, ParseHeader for each object found
serParser.Run();
SerTrace.Log( this, "Deserialize Finished Parsing DoFixups");
if (bFullDeserialization)
m_objectManager.DoFixups();
if (!bMethodCall && !bMethodReturn)
{
if (topObject == null)
throw new SerializationException(Environment.GetResourceString("Serialization_TopObject"));
if (topObject is IObjectReference)
{
topObject = ((IObjectReference)topObject).GetRealObject(m_context);
}
}
SerTrace.Log( this, "Deserialize Exit ",topObject);
if (bFullDeserialization)
m_objectManager.RaiseDeserializationEvent();
// Return the headers if there is a handler
if (handler != null)
{
handlerObject = handler(headers);
}
if (bMethodCall)
{
Object[] methodCallArray = topObject as Object[];
topObject = binaryMethodCall.ReadArray(methodCallArray, handlerObject);
}
else if (bMethodReturn)
{
Object[] methodReturnArray = topObject as Object[];
topObject = binaryMethodReturn.ReadArray(methodReturnArray, methodCallMessage, handlerObject);
}
return topObject;
}
internal Object Deserialize(HeaderHandler handler, __BinaryParser serParser, bool fCheck)
{
if (serParser == null)
throw new ArgumentNullException("serParser", Environment.GetResourceString("ArgumentNull_WithParamName", serParser));
Contract.EndContractBlock();
#if _DEBUG
SerTrace.Log( this, "Deserialize Entry handler", handler);
#endif
bFullDeserialization = false;
TopObject = null;
topId = 0;
#if FEATURE_REMOTING
bMethodCall = false;
bMethodReturn = false;
bIsCrossAppDomain = isCrossAppDomain;
#endif
bSimpleAssembly = (formatterEnums.FEassemblyFormat == FormatterAssemblyStyle.Simple);
if (fCheck)
{
try{
CodeAccessPermission.Demand(PermissionType.SecuritySerialization);
}catch(Exception e)
{
deserializationSecurityException = e;
}
}
this.handler = handler;
if (bFullDeserialization)
{
// Reinitialize
#if FEATURE_REMOTING
m_objectManager = new ObjectManager(m_surrogates, m_context, false, bIsCrossAppDomain);
#else
m_objectManager = new ObjectManager(m_surrogates, m_context, false, false);
#endif
serObjectInfoInit = new SerObjectInfoInit();
}
// Will call back to ParseObject, ParseHeader for each object found
serParser.Run();
#if _DEBUG
SerTrace.Log( this, "Deserialize Finished Parsing DoFixups");
#endif
if (bFullDeserialization)
m_objectManager.DoFixups();
#if FEATURE_REMOTING
if (!bMethodCall && !bMethodReturn)
#endif
{
if (TopObject == null)
throw new SerializationException(Environment.GetResourceString("Serialization_TopObject"));
//if TopObject has a surrogate then the actual object may be changed during special fixup
//So refresh it using topID.
if (HasSurrogate(TopObject.GetType()) && topId != 0)//Not yet resolved
TopObject = m_objectManager.GetObject(topId);
if (TopObject is IObjectReference)
{
TopObject = ((IObjectReference)TopObject).GetRealObject(m_context);
}
}
SerTrace.Log( this, "Deserialize Exit ",TopObject);
if (bFullDeserialization)
{
m_objectManager.RaiseDeserializationEvent(); // This will raise both IDeserialization and [OnDeserialized] events
}
// Return the headers if there is a handler
if (handler != null)
{
handlerObject = handler(headers);
}
#if FEATURE_REMOTING
if (bMethodCall)
{
Object[] methodCallArray = TopObject as Object[];
TopObject = binaryMethodCall.ReadArray(methodCallArray, handlerObject);
}
else if (bMethodReturn)
{
Object[] methodReturnArray = TopObject as Object[];
TopObject = binaryMethodReturn.ReadArray(methodReturnArray, methodCallMessage, handlerObject);
}
#endif
return TopObject;
}
public static object ReadMethodCall (BinaryReader reader, bool hasHeaders, HeaderHandler headerHandler, BinaryFormatter formatter)
{
BinaryElement elem = (BinaryElement)reader.ReadByte(); // The element code
return ReadMethodCall (elem, reader, hasHeaders, headerHandler, formatter);
}
public object DeserializeMethodResponse (Stream serializationStream, HeaderHandler handler, IMethodCallMessage methodCallMessage)
{
return NoCheckDeserializeMethodResponse (serializationStream, handler, methodCallMessage);
}
internal object Deserialize(HeaderHandler handler, __BinaryParser serParser, bool fCheck, bool isCrossAppDomain, IMethodCallMessage methodCallMessage)
{
if (serParser == null)
{
throw new ArgumentNullException("serParser", Environment.GetResourceString("ArgumentNull_WithParamName", new object[] { serParser }));
}
this.bFullDeserialization = false;
this.TopObject = null;
this.topId = 0L;
this.bMethodCall = false;
this.bMethodReturn = false;
this.bIsCrossAppDomain = isCrossAppDomain;
this.bSimpleAssembly = this.formatterEnums.FEassemblyFormat == FormatterAssemblyStyle.Simple;
if (fCheck)
{
CodeAccessPermission.Demand(PermissionType.SecuritySerialization);
}
this.handler = handler;
if (this.bFullDeserialization)
{
this.m_objectManager = new ObjectManager(this.m_surrogates, this.m_context, false, this.bIsCrossAppDomain);
this.serObjectInfoInit = new SerObjectInfoInit();
}
serParser.Run();
if (this.bFullDeserialization)
{
this.m_objectManager.DoFixups();
}
if (!this.bMethodCall && !this.bMethodReturn)
{
if (this.TopObject == null)
{
throw new SerializationException(Environment.GetResourceString("Serialization_TopObject"));
}
if (this.HasSurrogate(this.TopObject.GetType()) && (this.topId != 0L))
{
this.TopObject = this.m_objectManager.GetObject(this.topId);
}
if (this.TopObject is IObjectReference)
{
this.TopObject = ((IObjectReference) this.TopObject).GetRealObject(this.m_context);
}
}
if (this.bFullDeserialization)
{
this.m_objectManager.RaiseDeserializationEvent();
}
if (handler != null)
{
this.handlerObject = handler(this.headers);
}
if (this.bMethodCall)
{
object[] topObject = this.TopObject as object[];
this.TopObject = this.binaryMethodCall.ReadArray(topObject, this.handlerObject);
}
else if (this.bMethodReturn)
{
object[] returnA = this.TopObject as object[];
this.TopObject = this.binaryMethodReturn.ReadArray(returnA, methodCallMessage, this.handlerObject);
}
return this.TopObject;
}
// shared by DeserializeMethodResponse and UnsafeDeserializeMethodResponse which both involve different security checks
private object NoCheckDeserializeMethodResponse (Stream serializationStream, HeaderHandler handler, IMethodCallMessage methodCallMessage)
{
if(serializationStream==null) {
throw new ArgumentNullException("serializationStream");
}
if(serializationStream.CanSeek &&
serializationStream.Length==0) {
throw new SerializationException("serializationStream supports seeking, but its length is 0");
}
BinaryReader reader = new BinaryReader (serializationStream);
bool hasHeader;
ReadBinaryHeader (reader, out hasHeader);
return MessageFormatter.ReadMethodResponse (reader, hasHeader, handler, methodCallMessage, this);
}
public object UnsafeDeserialize (Stream serializationStream, HeaderHandler handler)
{
return NoCheckDeserialize (serializationStream, handler);
}
public ComponentSerializer()
{
this._formatter.Context = this._streamingCtx;
this._headerhandler = new HeaderHandler(this.TPHeaderHandler);
}
internal object Deserialize(Stream serializationStream, HeaderHandler handler, bool fCheck)
{
return this.Deserialize(serializationStream, handler, fCheck, null);
}
public Object UnsafeDeserialize(Stream serializationStream, HeaderHandler handler) {
return Deserialize(serializationStream, handler, false, null);
}
[System.Security.SecurityCritical] // auto-generated
internal Object Deserialize(Stream serializationStream, HeaderHandler handler, bool fCheck)
{
#if FEATURE_REMOTING
return Deserialize(serializationStream, handler, fCheck, null);
#else
if (serializationStream == null)
{
throw new ArgumentNullException("serializationStream", Environment.GetResourceString("ArgumentNull_WithParamName", serializationStream));
}
Contract.EndContractBlock();
if (serializationStream.CanSeek && (serializationStream.Length == 0))
throw new SerializationException(Environment.GetResourceString("Serialization_Stream"));
SerTrace.Log(this, "Deserialize Entry");
InternalFE formatterEnums = new InternalFE();
formatterEnums.FEtypeFormat = m_typeFormat;
formatterEnums.FEserializerTypeEnum = InternalSerializerTypeE.Binary;
formatterEnums.FEassemblyFormat = m_assemblyFormat;
formatterEnums.FEsecurityLevel = m_securityLevel;
ObjectReader sor = new ObjectReader(serializationStream, m_surrogates, m_context, formatterEnums, m_binder);
sor.crossAppDomainArray = m_crossAppDomainArray;
return sor.Deserialize(handler, new __BinaryParser(serializationStream, sor), fCheck);
#endif
}
public Object UnsafeDeserializeMethodResponse(Stream serializationStream, HeaderHandler handler, IMethodCallMessage methodCallMessage) {
return Deserialize(serializationStream, handler, false, methodCallMessage);
}
internal Object Deserialize(Stream serializationStream, HeaderHandler handler, bool fCheck)
{
return Deserialize(serializationStream, null, fCheck, null);
}
void ParseHeader(string header, HeaderHandler handler)
{
if (handler == null)
throw new ArgumentNullException ("handler");
if (header == null) {
return;
} else if (header == "\r\n") {
handler (HeaderKind.BodyDelimiter, null, null);
return;
}
header = header.TrimEnd ('\r', '\n');
var colonOffset = header.IndexOf (':');
if (header.StartsWith ("HTTP/") && colonOffset < 0) {
handler (HeaderKind.Status, header, null);
return;
} else if (colonOffset > 0) {
handler (HeaderKind.KeyValue,
header.Substring (0, colonOffset).Trim (),
header.Substring (colonOffset + 1).Trim ()
);
}
}
// Deserialize the stream into an object graph.
public Object Deserialize(Stream serializationStream, HeaderHandler handler) {
return Deserialize(serializationStream, handler, true, null);
}
public static object ReadMethodCall (BinaryElement elem, BinaryReader reader, bool hasHeaders, HeaderHandler headerHandler, BinaryFormatter formatter)
{
if (elem != BinaryElement.MethodCall) throw new SerializationException("Invalid format. Expected BinaryElement.MethodCall, found " + elem);
MethodFlags flags = (MethodFlags) reader.ReadInt32();
if (((BinaryTypeCode)reader.ReadByte()) != BinaryTypeCode.String) throw new SerializationException ("Invalid format");
string methodName = reader.ReadString();
if (((BinaryTypeCode)reader.ReadByte()) != BinaryTypeCode.String) throw new SerializationException ("Invalid format");
string className = reader.ReadString();
//bool hasContextInfo = (flags & MethodFlags.IncludesLogicalCallContext) > 0;
object[] arguments = null;
object methodSignature = null;
object callContext = null;
object[] extraProperties = null;
Header[] headers = null;
#if NET_2_0
Type[] genericArguments = null;
#endif
if ((flags & MethodFlags.PrimitiveArguments) > 0)
{
uint count = reader.ReadUInt32();
arguments = new object[count];
for (int n=0; n<count; n++)
{
Type type = BinaryCommon.GetTypeFromCode (reader.ReadByte());
arguments[n] = ObjectReader.ReadPrimitiveTypeValue (reader, type);
}
}
if ((flags & MethodFlags.NeedsInfoArrayMask) > 0)
{
ObjectReader objectReader = new ObjectReader (formatter);
object result;
objectReader.ReadObjectGraph (reader, hasHeaders, out result, out headers);
object[] msgInfo = (object[]) result;
if ((flags & MethodFlags.ArgumentsInSimpleArray) > 0) {
arguments = msgInfo;
}
else
{
int n = 0;
if ((flags & MethodFlags.ArgumentsInMultiArray) > 0) {
if (msgInfo.Length > 1) arguments = (object[]) msgInfo[n++];
else arguments = new object[0];
}
#if NET_2_0
if ((flags & MethodFlags.GenericArguments) > 0)
genericArguments = (Type[]) msgInfo[n++];
#endif
if ((flags & MethodFlags.IncludesSignature) > 0)
methodSignature = msgInfo[n++];
if ((flags & MethodFlags.IncludesLogicalCallContext) > 0)
callContext = msgInfo[n++];
if (n < msgInfo.Length)
extraProperties = (object[]) msgInfo[n];
}
}
else {
reader.ReadByte (); // Reads the stream ender
}
if (arguments == null) arguments = new object[0];
string uri = null;
if (headerHandler != null)
uri = headerHandler(headers) as string;
#if NET_2_0
Header[] methodInfo = new Header[7];
#else
Header[] methodInfo = new Header[6];
#endif
methodInfo[0] = new Header("__MethodName", methodName);
methodInfo[1] = new Header("__MethodSignature", methodSignature);
methodInfo[2] = new Header("__TypeName", className);
methodInfo[3] = new Header("__Args", arguments);
methodInfo[4] = new Header("__CallContext", callContext);
methodInfo[5] = new Header("__Uri", uri);
#if NET_2_0
methodInfo[6] = new Header("__GenericArguments", genericArguments);
#endif
MethodCall call = new MethodCall (methodInfo);
if (extraProperties != null) {
foreach (DictionaryEntry entry in extraProperties)
call.Properties [(string)entry.Key] = entry.Value;
}
return call;
}
public static object ReadMethodResponse (BinaryReader reader, bool hasHeaders, HeaderHandler headerHandler, IMethodCallMessage methodCallMessage, BinaryFormatter formatter)
{
BinaryElement elem = (BinaryElement) reader.ReadByte ();
return ReadMethodResponse (elem, reader, hasHeaders, headerHandler, methodCallMessage, formatter);
}
public static object ReadMethodResponse (BinaryElement elem, BinaryReader reader, bool hasHeaders, HeaderHandler headerHandler, IMethodCallMessage methodCallMessage, BinaryFormatter formatter)
{
if (elem != BinaryElement.MethodResponse) throw new SerializationException("Invalid format. Expected BinaryElement.MethodResponse, found " + elem);
MethodFlags flags = (MethodFlags) reader.ReadByte ();
ReturnTypeTag typeTag = (ReturnTypeTag) reader.ReadByte ();
bool hasContextInfo = (flags & MethodFlags.IncludesLogicalCallContext) > 0;
// FIXME: find a meaning for those 2 bytes
reader.ReadByte();
reader.ReadByte();
object returnValue = null;
object[] outArgs = null;
LogicalCallContext callContext = null;
Exception exception = null;
object[] extraProperties = null;
Header[] headers = null;
if ((typeTag & ReturnTypeTag.PrimitiveType) > 0)
{
Type type = BinaryCommon.GetTypeFromCode (reader.ReadByte());
returnValue = ObjectReader.ReadPrimitiveTypeValue (reader, type);
}
if ((flags & MethodFlags.PrimitiveArguments) > 0)
{
uint count = reader.ReadUInt32();
outArgs = new object[count];
for (int n=0; n<count; n++) {
Type type = BinaryCommon.GetTypeFromCode (reader.ReadByte());
outArgs[n] = ObjectReader.ReadPrimitiveTypeValue (reader, type);
}
}
if (hasContextInfo || (typeTag & ReturnTypeTag.ObjectType) > 0 ||
(typeTag & ReturnTypeTag.Exception) > 0 ||
(flags & MethodFlags.ArgumentsInSimpleArray) > 0 ||
(flags & MethodFlags.ArgumentsInMultiArray) > 0)
{
// There objects that need to be deserialized using an ObjectReader
ObjectReader objectReader = new ObjectReader (formatter);
object result;
objectReader.ReadObjectGraph (reader, hasHeaders, out result, out headers);
object[] msgInfo = (object[]) result;
if ((typeTag & ReturnTypeTag.Exception) > 0) {
exception = (Exception) msgInfo[0];
if (hasContextInfo) callContext = (LogicalCallContext)msgInfo[1];
}
else if ((flags & MethodFlags.NoArguments) > 0 || (flags & MethodFlags.PrimitiveArguments) > 0) {
int n = 0;
if ((typeTag & ReturnTypeTag.ObjectType) > 0) returnValue = msgInfo [n++];
if (hasContextInfo) callContext = (LogicalCallContext)msgInfo[n++];
if (n < msgInfo.Length) extraProperties = (object[]) msgInfo[n];
}
else if ((flags & MethodFlags.ArgumentsInSimpleArray) > 0) {
outArgs = msgInfo;
}
else {
int n = 0;
outArgs = (object[]) msgInfo[n++];
if ((typeTag & ReturnTypeTag.ObjectType) > 0) returnValue = msgInfo[n++];
if (hasContextInfo) callContext = (LogicalCallContext)msgInfo[n++];
if (n < msgInfo.Length) extraProperties = (object[]) msgInfo[n];
}
}
else {
reader.ReadByte (); // Reads the stream ender
}
if (headerHandler != null)
headerHandler(headers);
if (exception != null)
return new ReturnMessage (exception, methodCallMessage);
else
{
int argCount = (outArgs!=null) ? outArgs.Length : 0;
ReturnMessage result = new ReturnMessage (returnValue, outArgs, argCount, callContext, methodCallMessage);
if (extraProperties != null) {
foreach (DictionaryEntry entry in extraProperties)
result.Properties [(string)entry.Key] = entry.Value;
}
return result;
}
}
