private void SetMessageType(MESSAGE_TYPE m_type) { Span <byte> type = new Span <byte>(m_Buffer, PACKET_TYPE_START, PACKET_TYPE_LENGTH); type[0] = (byte)m_type; }
// //関数: // 説明: // messageを設定する // /// <summary> /// messageを設定する /// </summary> /// <param name="text"></param> /// <param name="type"></param> /// <param name="mode"></param> /// <param name="messageParam"></param> /// <returns></returns> public int Set(string text, MESSAGE_TYPE type, MESSAGE_MODE mode, Param messageParam) { int i; ParamPrivate paramPrivate; paramPrivate = new ParamPrivate(); paramPrivate.activated = true; paramPrivate.isPlaying = false; paramPrivate.messageState = MESSAGE_STATE.READY; paramPrivate.text = text; paramPrivate.messageStartTime = 0.0f; paramPrivate.messageMode = mode; paramPrivate.messageType = type; paramPrivate.transparency = 0.0f; if (messageList.Count == 0) { return(CreateMessageElement(0, paramPrivate, (Param)messageParam.Clone())); } for (i = 0; i < messageList.Count; i++) { if (!messageList[i].paramPrivate.activated) { break; } } return(CreateMessageElement(i, paramPrivate, (Param)messageParam.Clone())); }
// these methods translate PRSMessage <--> byte[] // based on the expected format of a message // NOTE: there is a challenge with the port field... // port is an unsigned short, but // NetworkToHostOrder() and HostToNetworkOrder() only operate on SIGNED short, so // casting between short and ushort is required in the following methods private PRSMessage(byte[] bytes) { this.msg_type = (MESSAGE_TYPE)bytes[0]; this.service_name = ASCIIEncoding.UTF8.GetString(bytes, 1, 50).TrimEnd('\0'); this.port = (ushort)IPAddress.NetworkToHostOrder(((short)BitConverter.ToInt16(bytes, 51))); this.status = (STATUS)bytes[53]; }
public async Task CreateNewMessageForUser(string userToId, string userFromId, string content, TEAM team = null, string messageTypeName = null) { USER userFrom = null; MESSAGE_TYPE messageType = null; USER userTo = await _userRepository.GetUserById(userToId); if (userFromId != null) { userFrom = await _userRepository.GetUserById(userFromId); } if (messageTypeName != null) { messageType = _messageRepository.GetMessageTypeByName(messageTypeName); } MESSAGE message = new MESSAGE(); if (userTo != null) { message.USER_TO = userTo; message.TEXT = content; message.MESSAGE_TYPE = messageType ?? _messageRepository.GetMessageTypeByName(MessageTypeNames.INFO); message.USER_FROM = userFrom; message.SEND_DATE = DateTime.Now; message.TEAM = team; _messageRepository.AddMessage(message); } }
public PRSMessage(MESSAGE_TYPE msg_type, string service_name, ushort port, STATUS status) { this.msg_type = msg_type; this.service_name = service_name; this.port = port; this.status = status; }
private void SendRequestMessage(MESSAGE_TYPE messageType, List <string> value = null) { // value is a parameters separated by $ CommunicationType cmd = new CommunicationType(messageType, "", value); switch (messageType) { case MESSAGE_TYPE.GET_MENU_REQ: socketConnection.SendAsync(Communication.Serializer.SerializeCommunicationType(cmd)); break; case MESSAGE_TYPE.GET_ACTIVE_ORDERS_REQ: socketConnection.SendAsync(Communication.Serializer.SerializeCommunicationType(cmd)); break; case MESSAGE_TYPE.GET_COMPLETED_ORDERS_REQ: socketConnection.SendAsync(Communication.Serializer.SerializeCommunicationType(cmd)); break; case MESSAGE_TYPE.GET_ACTIVE_DELIVERIES_REQ: socketConnection.SendAsync(Communication.Serializer.SerializeCommunicationType(cmd)); break; case MESSAGE_TYPE.GET_COMPLETED_DELIVERIES_REQ: socketConnection.SendAsync(Communication.Serializer.SerializeCommunicationType(cmd)); break; case MESSAGE_TYPE.GET_ALL_CLIENTS_REQ: socketConnection.SendAsync(Communication.Serializer.SerializeCommunicationType(cmd)); break; case MESSAGE_TYPE.GET_ORDER_BYID_REQ: socketConnection.SendAsync(Communication.Serializer.SerializeCommunicationType(cmd)); break; case MESSAGE_TYPE.GET_DELIVERY_BYID_REQ: socketConnection.SendAsync(Communication.Serializer.SerializeCommunicationType(cmd)); break; case MESSAGE_TYPE.CREATE_CLIENT_REQ: socketConnection.SendAsync(Communication.Serializer.SerializeCommunicationType(cmd)); break; case MESSAGE_TYPE.CREATE_DISH_REQ: socketConnection.SendAsync(Communication.Serializer.SerializeCommunicationType(cmd)); break; case MESSAGE_TYPE.CREATE_ORDER_REQ: socketConnection.SendAsync(Communication.Serializer.SerializeCommunicationType(cmd)); break; case MESSAGE_TYPE.COMPLETE_ORDER_REQ: socketConnection.SendAsync(Communication.Serializer.SerializeCommunicationType(cmd)); break; case MESSAGE_TYPE.COMPLETE_DELIVERY_REQ: socketConnection.SendAsync(Communication.Serializer.SerializeCommunicationType(cmd)); break; } }
private MESSAGE_TYPE GetMessageTypeFromOperation() { MESSAGE_TYPE message_type = MESSAGE_TYPE.MSG_OPEINS; switch (_opeType) { case OPE_TYPE.OPEINS: { message_type = MESSAGE_TYPE.MSG_OPEINS; break; } case OPE_TYPE.RECINS: { message_type = MESSAGE_TYPE.MSG_RECINS; break; } case OPE_TYPE.TARSAL: { message_type = MESSAGE_TYPE.MSG_TARSAL; break; } } return(message_type); }
/// <summary> /// This loop waits for incoming data /// </summary> public void AwaitData() { try { int i; while ((i = stream.Read(bytes, 0, bytes.Length)) != 0) { //Incoming data is stored in buffer data = System.Text.Encoding.ASCII.GetString(bytes, 0, i); //Username, message_type, and message being parsed from the data string name = data.Substring(0, data.IndexOf(':')); MESSAGE_TYPE messageType = (MESSAGE_TYPE)Enum.Parse(typeof(MESSAGE_TYPE), data.Substring(data.IndexOf("//") + 2)); string message = data.Substring(data.IndexOf(':') + 1, data.IndexOf("//") - data.IndexOf(':') - 1); //Calls an event to write to the console chatEventHandler?.Invoke(this, new MessageRecievedEventArgs(name, messageType, message)); } } catch (System.IO.IOException) { ServerHandler.DisconnectClient(this); } catch (Exception) { Console.WriteLine("Error Occurred"); ServerHandler.DisconnectClient(this); } }
private void SendRequestMessage(MESSAGE_TYPE messageType) { switch (messageType) { case MESSAGE_TYPE.GET_MENU_REQ: socketConnection.SendAsync("GET_MENU_REQ"); break; case MESSAGE_TYPE.GET_ACTIVE_ORDERS_REQ: socketConnection.SendAsync("GET_ACTIVE_ORDERS_REQ"); break; case MESSAGE_TYPE.GET_COMPLETED_ORDERS_REQ: socketConnection.SendAsync("GET_COMPLETED_ORDERS_REQ"); break; case MESSAGE_TYPE.GET_ACTIVE_DELIVERIES_REQ: socketConnection.SendAsync("GET_ACTIVE_DELIVERIES_REQ"); break; case MESSAGE_TYPE.GET_COMPLETED_DELIVERIES_REQ: socketConnection.SendAsync("GET_COMPLETED_DELIVERIES_REQ"); break; } }
public virtual void ADD_MESSAGE_LOG( String _Message_Text , MESSAGE_TYPE _Messaage_Type , MESSAGE_RESULT_TYPE _Message_Result_Type = MESSAGE_RESULT_TYPE.Succeed) { //System.Console.WriteLine(String.Format("[{0}][{1}]:[{2}]", _Messaage_Type.ToString(), _Message_Result_Type.ToString(), _Message_Text)); }
public CustomException(Exception ex, MESSAGE_TYPE type) : base(ex.Message) { if (ex.InnerException != null) { this.AdditionalMessage = ex.InnerException.Message; } }
//////////////////////////////////////////////////////////////////// /// public override void execute() { if (!_inited) { _inited = true; dbStart(); return; } if (_requestUpdateDb == null) { return; } MESSAGE_TYPE type = (MESSAGE_TYPE)_requestUpdateDb.Type; switch (type) { case MESSAGE_TYPE.CACHE_UPDATE_ADD: case MESSAGE_TYPE.CACHE_UPDATE_DELETE: case MESSAGE_TYPE.CACHE_UPDATE_EDIT: //using (var client = new HttpClient()) //{ // string url = "api/cusid"; // client.BaseAddress = new Uri(ConfigurationManager.AppSettings["webapi_uri_root"]); // client.DefaultRequestHeaders.Accept.Clear(); // client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); // var jsonRequest = JsonConvert.SerializeObject(_request); // var content = new StringContent(jsonRequest, Encoding.UTF8, "text/json"); // var response = client.PostAsync(url, content).Result; // if (response.IsSuccessStatusCode) // { // //string responseString = response.Content.ReadAsStringAsync().Result; // } //} break; case MESSAGE_TYPE.CACHE_SETUP: break; case MESSAGE_TYPE.CACHE_WEBAPI_REGISTER: break; default: break; } //SqlCommand cmd = new SqlCommand(); //foreach (var kv in this._request..Pairs) // cmd.Parameters.AddWithValue("@" + kv.Key, kv.Value); //cmd.Connection = _connect; //cmd.CommandText = _request.Message; //cmd.CommandType = CommandType.StoredProcedure; //cmd.ExecuteNonQuery(); }
public void RemoveListener(MESSAGE_TYPE msgType, MessageHandleDelegate handle) { List <MessageHandleDelegate> handleList = null; if (m_DelegateLists.TryGetValue(msgType, out handleList)) { handleList.Remove(handle); } }
public void SendMessage(Message msg) { MESSAGE_TYPE type = msg.GetMsgType(); List <MessageHandleDelegate> handleList = null; if (m_DelegateLists.TryGetValue(type, out handleList)) { ExecuteDelegate(handleList, msg); } }
/// <summary> /// Vlozenie a zabalenie spravy podla zadaneho typu /// do urcenej struktury /// </summary> /// <param name="type"> typ requestu</param> /// <param name="data"> data requestu</param> /// <return>Message</return> public Message Wrap(MESSAGE_TYPE m, SERVICE_TYPE type, string data) { string message_content = ""; if (m == MESSAGE_TYPE.REQUEST) { message_content = new Request(type, data, DataSet.Instance().loged_user).ToString(); } return(new Message(m, message_content)); }
public static void SendMessage(MESSAGE_TYPE msgType) { CommonNotify message = (CommonNotify)MessageManager.Instance.GetMsg(typeof(CommonNotify)); if (message == null) { message = new CommonNotify(); MessageManager.Instance.AddMsg(typeof(CommonNotify), message); } message.SetData(msgType); MessageManager.Instance.SendMessage(message); }
public static void SendMessage <T, U>(MESSAGE_TYPE msgType, T dataT, U dataU) { CommonNotify <T, U> message = (CommonNotify <T, U>)MessageManager.Instance.GetMsg(typeof(CommonNotify <T, U>)); if (message == null) { message = new CommonNotify <T, U>(); MessageManager.Instance.AddMsg(typeof(CommonNotify <T, U>), message); } message.SetData(msgType, dataT, dataU); MessageManager.Instance.SendMessage(message); }
public bool AddListener(MESSAGE_TYPE msgType, MessageHandleDelegate handle) { if (!m_DelegateLists.ContainsKey(msgType)) { m_DelegateLists.Add(msgType, new List <MessageHandleDelegate>()); } List <MessageHandleDelegate> handleList = m_DelegateLists[msgType]; if (handleList.Contains(handle)) { return(false); } handleList.Add(handle); return(true); }
public static string GetHeader(this MESSAGE_TYPE type) { switch (type) { case MESSAGE_TYPE.SUCCESS: return("Success"); case MESSAGE_TYPE.WARN: return("Warning"); case MESSAGE_TYPE.ERROR: return("Error"); case MESSAGE_TYPE.FATAL: return("Fatal"); default: return(""); } }
public static Message Parse(string text) { try { XElement tree = XElement.Parse(text); string type_value = tree.Attribute("type").Value; MESSAGE_TYPE t = (MESSAGE_TYPE)Enum.Parse(typeof(MESSAGE_TYPE), type_value); Message m = new Message(t, tree.Value); return(m); } catch (Exception) { return(null); } }
/// <summary> /// Schreibt die Nachricht ins Log /// </summary> public void WriteMessage(string cLogMessage, MESSAGE_TYPE eTyp) { FileStream oFileStream = null; StackFrame oStackFrame; try { lock (m_oLockFileWrite) { oStackFrame = new StackTrace().GetFrame(1); // Datei öffnen, gegebenenfalls erstellen if (!File.Exists(CURRENT_LOG_FILE)) { oFileStream = File.Create(CURRENT_LOG_FILE); oFileStream.Close(); oFileStream.Dispose(); } using (StreamWriter oLogWriter = new StreamWriter(CURRENT_LOG_FILE, true, Encoding.UTF8)) { oLogWriter.WriteLine(string.Format( "[{0:T}] => {1} <{2}>.<{3}>: {4}", DateTime.Now, eTyp.ToString().ToUpper(), oStackFrame.GetMethod().ReflectedType.Name, oStackFrame.GetMethod().Name, cLogMessage )); oLogWriter.Close(); } } } catch (Exception oEx) { throw oEx; } finally { if (oFileStream != null) { oFileStream.Close(); oFileStream.Dispose(); } } }
public void CreateMessageLocal( string _message, MESSAGE_TYPE _messageType, int? _receiverID = null ) { DebugConsole.Log( "Creating message \"" + _message + "\"" ); _message = _message.Replace( ">", "\\>" ).Replace( "<", "\\<" ); if ( Network.peerType != NetworkPeerType.Disconnected ) { if ( _messageType == MESSAGE_TYPE.PRIVATE ) { if ( _receiverID == null ) { throw new Exception( "Receiver ID required for private messages." ); } DebugConsole.Log( "Sending private message to " + _receiverID.Value ); GamePlayer receiver = GamePlayerManager.instance.GetPlayerWithID( _receiverID.Value ); BaseNetworkManager.baseInstance.SendLobbyMessage( _message, receiver.networkPlayer, _messageType ); } else if ( _messageType == MESSAGE_TYPE.TO_ALL || _messageType == MESSAGE_TYPE.TO_TEAM ) { foreach ( KeyValuePair<int, GamePlayer> pair in GamePlayerManager.instance.playerMap ) { if ( pair.Value == GamePlayerManager.instance.myPlayer ) { continue; } if ( !pair.Value.sendMessagesTo ) { DebugConsole.Log( "Ignoring player on ignore list " + pair.Key ); continue; } if ( _messageType == MESSAGE_TYPE.TO_TEAM && pair.Value.team != GamePlayerManager.instance.myPlayer.team ) { DebugConsole.Log( "Ignoring player on opposing team " + pair.Key ); continue; } DebugConsole.Log( "Sending to " + pair.Key ); BaseNetworkManager.baseInstance.SendLobbyMessage( _message, pair.Value.networkPlayer, _messageType ); } } } // Send to myself this.CreateMessageNetworked( Common.MyNetworkID(), _message, _messageType ); }
/// <summary> /// show message box according different type. /// </summary> /// <param name="message"></param> /// <param name="messageType"></param> /// <returns>Dialog Result</returns> private static DialogResult doShow(string message, MESSAGE_TYPE messageType) { DialogResult dialogResult = DialogResult.None; switch (messageType) { case MESSAGE_TYPE.SUCCESS: dialogResult = MessageBox.Show(message, "PROMPT", MessageBoxButtons.OK, MessageBoxIcon.Information); break; case MESSAGE_TYPE.FAILURE: dialogResult = MessageBox.Show(message, "PROMPT", MessageBoxButtons.OK, MessageBoxIcon.Error); break; case MESSAGE_TYPE.ADVISORY: dialogResult = MessageBox.Show(message, "PROMPT", MessageBoxButtons.YesNo, MessageBoxIcon.Warning); break; } return(dialogResult); }
/// <summary> /// Sets the error messages based on the supplied type /// </summary> /// <param name="type">Type of message that should be shown to the user</param> public static void SetMessage(MESSAGE_TYPE type) { switch (type) { case MESSAGE_TYPE.INVALID_DIGIT: ErrorMessage = "You can only use digits 1-9"; break; case MESSAGE_TYPE.BREAKS_SUDOKU_RULES: ErrorMessage = "You can not repeat the same digit in a row, column or block"; break; case MESSAGE_TYPE.NO_ERROR: ErrorMessage = ""; break; default: break; } }
public static void SendDebugString(MESSAGE_TYPE mt, string msg) { // ask permission to report this message. var rc = MessageBox.Show("Please help improve this program and report this error. The information to be sent is this: " + Environment.NewLine + Environment.NewLine + msg, "An error has been detected, will you supply permission to report?", MessageBoxButtons.YesNo); if (rc != DialogResult.Yes) { return; } UdpClient newsock = new UdpClient(); byte[] data = new byte[10000]; Encoding.ASCII.GetBytes("Eddie", 0, 5, data, 0); // encode the message data[5] = (byte)mt; string mdetails = Application.ProductName + " " + version + " "; int length = Encoding.ASCII.GetBytes(mdetails + msg, 0, mdetails.Length + msg.Length, data, 6); data[6 + length] = 0; try { // ekhtodo - sometimes these messages get long.... use TCP? newsock.Send(data, Math.Min(1200, length + 7), "debug01cloudrouter.dyndns.org", 502); } catch (SocketException) { // possibly not even connected - ignore } catch { // Socket send fails if not connected to the internet... // todo, at least log this exception to file, ready for email. } }
public static string GetString <T>(T _obj, Model.Header _head, MESSAGE_TYPE _type, string _eqpID) { try { switch (_type) { case MESSAGE_TYPE.REQUEST: return(requestObject(_obj, _head)); case MESSAGE_TYPE.RESPONSE: return(reponseMessage(_head, _eqpID)); } return(string.Empty); } catch (Exception ex) { throw new Exception(ex.ToString()); } }
public override void ADD_MESSAGE_LOG( String _Message_Text , MESSAGE_TYPE _Messaage_Type , MESSAGE_RESULT_TYPE _Message_Result_Type = MESSAGE_RESULT_TYPE.Succeed) { List <SqlParameter> sqlParaList = new List <SqlParameter>(); SqlParameter message_type = new SqlParameter("@message_type", SqlDbType.NVarChar); message_type.Value = _Messaage_Type.ToString(); sqlParaList.Add(message_type); SqlParameter message_result = new SqlParameter("@message_result", SqlDbType.NVarChar); message_result.Value = _Message_Result_Type.ToString(); sqlParaList.Add(message_result); SqlParameter message_description = new SqlParameter("@message_description", SqlDbType.NVarChar); message_description.Value = _Message_Text; sqlParaList.Add(message_description); SqlParameter[] parameters = sqlParaList.ToArray(); EXECUTE_PROCEDURE_WITH_PARAMETERS(this, "sp_ssas_automation_deploy_log_details", parameters); }
public void givePlayerFeedBack(Heros currentHero, String text, MESSAGE_TYPE messageType) { Console.WriteLine(text); displayInfo(Program.DebugMode, text, messageType.ToString()); }
public CommunicationType(MESSAGE_TYPE MsgType, string Msg, List <string> param) { MessageType = MsgType; Message = Msg; Parameters = param; }
private void OnStatus(object sender, MESSAGE_TYPE staus, byte[] msg) { string smsg = null; switch (staus) { case MESSAGE_TYPE.MT_CONNECT_READY: push.Subscribe(push.UserTopic); smsg = encoding.GetString(msg); AddInfo("CONNECT_READY:" + String.Format("{0} UserNo:{1}", smsg, push.UserNo)); SetBtnStatus(true); break; case MESSAGE_TYPE.MT_CONNECT_FAIL: smsg = encoding.GetString(msg); AddInfo("CONNECT_FAIL:" + String.Format("{0}", smsg)); break; case MESSAGE_TYPE.MT_DISCONNECTED: smsg = encoding.GetString(msg); AddInfo("DISCONNECTED:" + String.Format("{0}", smsg)); SetBtnStatus(false); break; case MESSAGE_TYPE.MT_SUBSCRIBE: smsg = encoding.GetString(msg); AddInfo("SUBSCRIBE:" + String.Format("{0}", smsg)); break; case MESSAGE_TYPE.MT_UNSUBSCRIBE: smsg = encoding.GetString(msg); AddInfo("UNSUBSCRIBE:" + String.Format("{0}", smsg)); break; case MESSAGE_TYPE.MT_ACK_REQUESTID: long RequestId = BitConverter.ToInt64(msg, 0); AddInfo("Request Id BACK: " + RequestId); break; case MESSAGE_TYPE.MT_RECOVER_DATA: smsg = encoding.GetString(msg, 1, msg.Length - 1); if (msg[0] == 0) { AddInfo(String.Format("Begin Recover Topic:{0}", smsg)); } if (msg[0] == 1) { AddInfo(String.Format("End Recover Topic:{0}", smsg)); } break; case MESSAGE_TYPE.MT_HEART_BEAT: long UTC = ((PushClient)sender).ServerTime(); double totsec = (double)UTC / (double)1000000000; DateTime st = (new DateTime(1970, 1, 1, 0, 0, 0)).AddHours(8).AddSeconds(totsec); AddInfo(String.Format("{0:yyyy/MM/dd hh:mm:ss.fff}", st)); AddInfo(String.Format("{0:yyyy/MM/dd hh:mm:ss.fff}", DateTime.Now)); // TimeSpan toNow = new TimeSpan(UTC * 10); // AddInfo(String.Format("{0:yyyy/MM/dd hh:mm:ss.fff}", gtm.Add(toNow))); break; } }
public void SendLobbyMessage( string _message, NetworkPlayer _receiver, MESSAGE_TYPE _messageType ) { this.GetComponent<NetworkView>().RPC( "OnSendLobbyMessageRPC", _receiver, Common.MyNetworkID(), _message, (int)_messageType ); }
public CustomException(string message, MESSAGE_TYPE type, object data) : base(message) { this.type = type; this.data = data; }
public Message(MESSAGE_TYPE type, string header, string msg) { Type = type; Header = header; Msg = msg; }
public void SetMessage(string message, MESSAGE_TYPE type) { Session["MESSAGE"] = new CustomException(message, type); }
public void CreateMessageNetworked( int _senderID, string _message, MESSAGE_TYPE _messageType ) { DebugConsole.Log( "Received message \"" + _senderID + "\" from " + _senderID ); GamePlayer sender = GamePlayerManager.instance.GetPlayerWithID( _senderID ); if ( !sender.receiveMessagesFrom ) { DebugConsole.Log( "Ignoring message" ); return; } Message msg = new Message(); msg.senderID = _senderID; msg.message = _message; msg.timeReceived = DateTime.Now; msg.messageType = _messageType; this.messages.Add( msg ); if ( _senderID != Common.MyNetworkID() ) { this.newMessages = true; } }
public CustomException(string message, MESSAGE_TYPE type) : base(message) { this.type = type; }
public void SetMessageType(MESSAGE_TYPE type) { this.PutByte((byte)type, 4); }
public Message(MESSAGE_TYPE type, string msg) { Type = type; Header = type.GetHeader(); Msg = msg; }
/// <summary> /// Schreibt die Nachricht ins Log /// </summary> public void WriteMessage(string cLogMessage, MESSAGE_TYPE eTyp) { FileStream oFileStream = null; StackFrame oStackFrame; try { lock (m_oLockFileWrite) { oStackFrame = new StackTrace().GetFrame(1); // Datei öffnen, gegebenenfalls erstellen if(!File.Exists(CURRENT_LOG_FILE)) { oFileStream = File.Create(CURRENT_LOG_FILE); oFileStream.Close(); oFileStream.Dispose(); } using(StreamWriter oLogWriter = new StreamWriter(CURRENT_LOG_FILE, true, Encoding.UTF8)) { oLogWriter.WriteLine(string.Format( "[{0:T}] => {1} <{2}>.<{3}>: {4}", DateTime.Now, eTyp.ToString().ToUpper(), oStackFrame.GetMethod().ReflectedType.Name, oStackFrame.GetMethod().Name, cLogMessage )); oLogWriter.Close(); } } } catch (Exception oEx) { throw oEx; } finally { if (oFileStream != null) { oFileStream.Close(); oFileStream.Dispose(); } } }