Example #1
0
            internal object DeserialiseResponseArgs(out object[] outArgs,
                                                    CdrInputStream sourceStream)
            {
                // demarshal first the return value;
                object retValue = null;

                if (m_returnValue.IsNonVoidReturn())
                {
                    retValue = m_returnValue.Deserialize(sourceStream);
                }

                // ... then the outargs
                outArgs = new object[m_arguments.Length];
                bool outArgFound = false;

                for (int actualParamNr = 0; actualParamNr < m_arguments.Length; actualParamNr++)
                {
                    ArgumentMapping paramInfo = m_arguments[actualParamNr];
                    if (paramInfo.IsOutArg() || paramInfo.IsRefArg())
                    {
                        outArgs[actualParamNr] = paramInfo.Deserialize(sourceStream);
                        outArgFound            = true;
                    } // else: for an in param null must be added to out-args
                }

                // prepare the result
                // need to return empty array, if no out-arg is present, because otherwise async calls fail
                if (!outArgFound)
                {
                    outArgs = new object[0];
                }
                return(retValue);
            }
Example #2
0
 internal object[] DeserialiseRequestArgs(CdrInputStream sourceStream,
                                          out IDictionary contextElements,
                                          Serializer contextElementSer)
 {
     object[] result = new object[m_arguments.Length];
     for (int actualParamNr = 0; actualParamNr < m_arguments.Length; actualParamNr++)
     {
         ArgumentMapping paramInfo = m_arguments[actualParamNr];
         if (paramInfo.IsInArg() || paramInfo.IsRefArg())
         {
             result[actualParamNr] = paramInfo.Deserialize(sourceStream);
         } // else: null for an out parameter
     }
     contextElements = DeserializeContextElements(sourceStream, contextElementSer);
     return(result);
 }
Example #3
0
 internal void SerializeRequestArgs(object[] arguments, CdrOutputStream targetStream,
                                    LogicalCallContext context, Serializer contextElementSer)
 {
     for (int actualParamNr = 0; actualParamNr < arguments.Length; actualParamNr++)
     {
         ArgumentMapping paramInfo = m_arguments[actualParamNr];
         // iterate through the parameters, nonOut and nonRetval params are serialised for a request
         if (paramInfo.IsInArg() || paramInfo.IsRefArg())
         {
             paramInfo.Serialize(targetStream, arguments[actualParamNr]);
         }
         // move to next parameter
         // out-args are also part of the arguments array -> move to next for those whithout doing something
     }
     SerializeContextElements(targetStream, context, contextElementSer);
 }
Example #4
0
            internal void SerializeResponseArgs(object result, object[] outArgs,
                                                CdrOutputStream targetStream)
            {
                // first serialise the return value,
                if (m_returnValue.IsNonVoidReturn())
                {
                    m_returnValue.Serialize(targetStream, result);
                }
                // ... then the out/ref args
                int outParamNr = 0;

                for (int actualParamNr = 0; actualParamNr < m_arguments.Length; actualParamNr++)
                {
                    ArgumentMapping paramInfo = m_arguments[actualParamNr];
                    // iterate through the parameters, out/ref parameters are serialised
                    if (paramInfo.IsOutArg() || paramInfo.IsRefArg())
                    {
                        paramInfo.Serialize(targetStream, outArgs[outParamNr]);
                        outParamNr++;
                    }
                }
            }