C# TProtocol.WriteMessageBegin方法代码示例

        private void Fail( TProtocol oprot, TMessage message, TApplicationException.ExceptionType extype, string etxt)
        {
            TApplicationException appex = new TApplicationException( extype, etxt);

            TMessage newMessage = new TMessage(message.Name, TMessageType.Exception, message.SeqID);

            oprot.WriteMessageBegin(newMessage);
            appex.Write( oprot);
            oprot.WriteMessageEnd();
            oprot.Transport.Flush();
        }

 public void describe_splits_ex_Process(int seqid, TProtocol iprot, TProtocol oprot)
 {
   describe_splits_ex_args args = new describe_splits_ex_args();
   args.Read(iprot);
   iprot.ReadMessageEnd();
   describe_splits_ex_result result = new describe_splits_ex_result();
   try {
     result.Success = iface_.describe_splits_ex(args.CfName, args.Start_token, args.End_token, args.Keys_per_split);
   } catch (InvalidRequestException ire) {
     result.Ire = ire;
   }
   oprot.WriteMessageBegin(new TMessage("describe_splits_ex", TMessageType.Reply, seqid)); 
   result.Write(oprot);
   oprot.WriteMessageEnd();
   oprot.Transport.Flush();
 }

 public void trace_next_query_Process(int seqid, TProtocol iprot, TProtocol oprot)
 {
   trace_next_query_args args = new trace_next_query_args();
   args.Read(iprot);
   iprot.ReadMessageEnd();
   trace_next_query_result result = new trace_next_query_result();
   result.Success = iface_.trace_next_query();
   oprot.WriteMessageBegin(new TMessage("trace_next_query", TMessageType.Reply, seqid)); 
   result.Write(oprot);
   oprot.WriteMessageEnd();
   oprot.Transport.Flush();
 }

 public void describe_keyspace_Process(int seqid, TProtocol iprot, TProtocol oprot)
 {
   describe_keyspace_args args = new describe_keyspace_args();
   args.Read(iprot);
   iprot.ReadMessageEnd();
   describe_keyspace_result result = new describe_keyspace_result();
   try {
     result.Success = iface_.describe_keyspace(args.Keyspace);
   } catch (NotFoundException nfe) {
     result.Nfe = nfe;
   } catch (InvalidRequestException ire) {
     result.Ire = ire;
   }
   oprot.WriteMessageBegin(new TMessage("describe_keyspace", TMessageType.Reply, seqid)); 
   result.Write(oprot);
   oprot.WriteMessageEnd();
   oprot.Transport.Flush();
 }

 public void describe_snitch_Process(int seqid, TProtocol iprot, TProtocol oprot)
 {
   describe_snitch_args args = new describe_snitch_args();
   args.Read(iprot);
   iprot.ReadMessageEnd();
   describe_snitch_result result = new describe_snitch_result();
   result.Success = iface_.describe_snitch();
   oprot.WriteMessageBegin(new TMessage("describe_snitch", TMessageType.Reply, seqid)); 
   result.Write(oprot);
   oprot.WriteMessageEnd();
   oprot.Transport.Flush();
 }

 public void describe_schema_versions_Process(int seqid, TProtocol iprot, TProtocol oprot)
 {
   describe_schema_versions_args args = new describe_schema_versions_args();
   args.Read(iprot);
   iprot.ReadMessageEnd();
   describe_schema_versions_result result = new describe_schema_versions_result();
   try {
     result.Success = iface_.describe_schema_versions();
   } catch (InvalidRequestException ire) {
     result.Ire = ire;
   }
   oprot.WriteMessageBegin(new TMessage("describe_schema_versions", TMessageType.Reply, seqid)); 
   result.Write(oprot);
   oprot.WriteMessageEnd();
   oprot.Transport.Flush();
 }

 public bool Process(TProtocol iprot, TProtocol oprot)
 {
   try
   {
     TMessage msg = iprot.ReadMessageBegin();
     ProcessFunction fn;
     processMap_.TryGetValue(msg.Name, out fn);
     if (fn == null) {
       TProtocolUtil.Skip(iprot, TType.Struct);
       iprot.ReadMessageEnd();
       TApplicationException x = new TApplicationException (TApplicationException.ExceptionType.UnknownMethod, "Invalid method name: '" + msg.Name + "'");
       oprot.WriteMessageBegin(new TMessage(msg.Name, TMessageType.Exception, msg.SeqID));
       x.Write(oprot);
       oprot.WriteMessageEnd();
       oprot.Transport.Flush();
       return true;
     }
     fn(msg.SeqID, iprot, oprot);
   }
   catch (IOException)
   {
     return false;
   }
   return true;
 }

 public void execute_prepared_cql3_query_Process(int seqid, TProtocol iprot, TProtocol oprot)
 {
   execute_prepared_cql3_query_args args = new execute_prepared_cql3_query_args();
   args.Read(iprot);
   iprot.ReadMessageEnd();
   execute_prepared_cql3_query_result result = new execute_prepared_cql3_query_result();
   try {
     result.Success = iface_.execute_prepared_cql3_query(args.ItemId, args.Values, args.Consistency);
   } catch (InvalidRequestException ire) {
     result.Ire = ire;
   } catch (UnavailableException ue) {
     result.Ue = ue;
   } catch (TimedOutException te) {
     result.Te = te;
   } catch (SchemaDisagreementException sde) {
     result.Sde = sde;
   }
   oprot.WriteMessageBegin(new TMessage("execute_prepared_cql3_query", TMessageType.Reply, seqid)); 
   result.Write(oprot);
   oprot.WriteMessageEnd();
   oprot.Transport.Flush();
 }

 public void remove_counter_Process(int seqid, TProtocol iprot, TProtocol oprot)
 {
   remove_counter_args args = new remove_counter_args();
   args.Read(iprot);
   iprot.ReadMessageEnd();
   remove_counter_result result = new remove_counter_result();
   try {
     iface_.remove_counter(args.Key, args.Path, args.Consistency_level);
   } catch (InvalidRequestException ire) {
     result.Ire = ire;
   } catch (UnavailableException ue) {
     result.Ue = ue;
   } catch (TimedOutException te) {
     result.Te = te;
   }
   oprot.WriteMessageBegin(new TMessage("remove_counter", TMessageType.Reply, seqid)); 
   result.Write(oprot);
   oprot.WriteMessageEnd();
   oprot.Transport.Flush();
 }

 public void cas_Process(int seqid, TProtocol iprot, TProtocol oprot)
 {
   cas_args args = new cas_args();
   args.Read(iprot);
   iprot.ReadMessageEnd();
   cas_result result = new cas_result();
   try {
     result.Success = iface_.cas(args.Key, args.Column_family, args.Expected, args.Updates, args.Serial_consistency_level, args.Commit_consistency_level);
   } catch (InvalidRequestException ire) {
     result.Ire = ire;
   } catch (UnavailableException ue) {
     result.Ue = ue;
   } catch (TimedOutException te) {
     result.Te = te;
   }
   oprot.WriteMessageBegin(new TMessage("cas", TMessageType.Reply, seqid)); 
   result.Write(oprot);
   oprot.WriteMessageEnd();
   oprot.Transport.Flush();
 }

 public void insert_Process(int seqid, TProtocol iprot, TProtocol oprot)
 {
   insert_args args = new insert_args();
   args.Read(iprot);
   iprot.ReadMessageEnd();
   insert_result result = new insert_result();
   try {
     iface_.insert(args.Key, args.Column_parent, args.Column, args.Consistency_level);
   } catch (InvalidRequestException ire) {
     result.Ire = ire;
   } catch (UnavailableException ue) {
     result.Ue = ue;
   } catch (TimedOutException te) {
     result.Te = te;
   }
   oprot.WriteMessageBegin(new TMessage("insert", TMessageType.Reply, seqid)); 
   result.Write(oprot);
   oprot.WriteMessageEnd();
   oprot.Transport.Flush();
 }

 public void get_indexed_slices_Process(int seqid, TProtocol iprot, TProtocol oprot)
 {
   get_indexed_slices_args args = new get_indexed_slices_args();
   args.Read(iprot);
   iprot.ReadMessageEnd();
   get_indexed_slices_result result = new get_indexed_slices_result();
   try {
     result.Success = iface_.get_indexed_slices(args.Column_parent, args.Index_clause, args.Column_predicate, args.Consistency_level);
   } catch (InvalidRequestException ire) {
     result.Ire = ire;
   } catch (UnavailableException ue) {
     result.Ue = ue;
   } catch (TimedOutException te) {
     result.Te = te;
   }
   oprot.WriteMessageBegin(new TMessage("get_indexed_slices", TMessageType.Reply, seqid)); 
   result.Write(oprot);
   oprot.WriteMessageEnd();
   oprot.Transport.Flush();
 }

 public void get_Process(int seqid, TProtocol iprot, TProtocol oprot)
 {
   get_args args = new get_args();
   args.Read(iprot);
   iprot.ReadMessageEnd();
   get_result result = new get_result();
   try {
     result.Success = iface_.get(args.Key, args.Column_path, args.Consistency_level);
   } catch (InvalidRequestException ire) {
     result.Ire = ire;
   } catch (NotFoundException nfe) {
     result.Nfe = nfe;
   } catch (UnavailableException ue) {
     result.Ue = ue;
   } catch (TimedOutException te) {
     result.Te = te;
   }
   oprot.WriteMessageBegin(new TMessage("get", TMessageType.Reply, seqid)); 
   result.Write(oprot);
   oprot.WriteMessageEnd();
   oprot.Transport.Flush();
 }

 public void login_Process(int seqid, TProtocol iprot, TProtocol oprot)
 {
   login_args args = new login_args();
   args.Read(iprot);
   iprot.ReadMessageEnd();
   login_result result = new login_result();
   try {
     iface_.login(args.Auth_request);
   } catch (AuthenticationException authnx) {
     result.Authnx = authnx;
   } catch (AuthorizationException authzx) {
     result.Authzx = authzx;
   }
   oprot.WriteMessageBegin(new TMessage("login", TMessageType.Reply, seqid)); 
   result.Write(oprot);
   oprot.WriteMessageEnd();
   oprot.Transport.Flush();
 }

 public void system_update_column_family_Process(int seqid, TProtocol iprot, TProtocol oprot)
 {
   system_update_column_family_args args = new system_update_column_family_args();
   args.Read(iprot);
   iprot.ReadMessageEnd();
   system_update_column_family_result result = new system_update_column_family_result();
   try {
     result.Success = iface_.system_update_column_family(args.Cf_def);
   } catch (InvalidRequestException ire) {
     result.Ire = ire;
   } catch (SchemaDisagreementException sde) {
     result.Sde = sde;
   }
   oprot.WriteMessageBegin(new TMessage("system_update_column_family", TMessageType.Reply, seqid)); 
   result.Write(oprot);
   oprot.WriteMessageEnd();
   oprot.Transport.Flush();
 }