C++ (Cpp) message_get_state Examples

Example #1

File: message.c Project: TVilaboa/Proyecto-Parser-C

static ObjectChange *
message_apply_properties(Message *message)
{
  MessageDialog *prop_dialog;
  ObjectState *old_state;
  
  prop_dialog = properties_dialog;

  old_state = (ObjectState *)message_get_state(message);

  /* Read from dialog and put in object: */
  g_free(message->text);
  message->text = strdup(gtk_entry_get_text(prop_dialog->text));
    
  message->text_width =
      font_string_width(message->text, message_font,
			MESSAGE_FONTHEIGHT);
  
  
  if (GTK_TOGGLE_BUTTON(prop_dialog->m_call)->active) 
      message->type = MESSAGE_CALL;
  else if (GTK_TOGGLE_BUTTON( prop_dialog->m_return )->active) 
      message->type = MESSAGE_RETURN;
  else if (GTK_TOGGLE_BUTTON( prop_dialog->m_create )->active) 
      message->type = MESSAGE_CREATE;
  else if (GTK_TOGGLE_BUTTON( prop_dialog->m_destroy )->active) 
      message->type = MESSAGE_DESTROY;
  else if (GTK_TOGGLE_BUTTON( prop_dialog->m_send )->active) 
      message->type = MESSAGE_SEND;
  else if (GTK_TOGGLE_BUTTON( prop_dialog->m_simple )->active) 
      message->type = MESSAGE_SIMPLE;
  else if (GTK_TOGGLE_BUTTON( prop_dialog->m_recursive )->active) 
      message->type = MESSAGE_RECURSIVE;
  
  message_update_data(message);

  return new_object_state_change((Object *)message, old_state, 
				 (GetStateFunc)message_get_state,
				 (SetStateFunc)message_set_state);
}

Example #2

File: json_port_func.c Project: biparadox/cube-1.11-proc

int json_port_start(void * sub_proc,void * para)
{
    int ret;
    int retval;
    void * message_box;
    void * context;
    struct tcloud_connector_hub * port_hub;
    struct tcloud_connector * port_conn;
    struct tcloud_connector * recv_conn;
    struct tcloud_connector * channel_conn;
    int i;
    struct timeval conn_val;
    conn_val.tv_usec=time_val.tv_usec;

    char local_uuid[DIGEST_SIZE*2+1];
    char proc_name[DIGEST_SIZE*2+1];
    char buffer[4096];
    memset(buffer,0,4096);
    int stroffset;
	
    printf("begin json server process!\n");
    ret=proc_share_data_getvalue("uuid",local_uuid);
    if(ret<0)
        return ret;
    ret=proc_share_data_getvalue("proc_name",proc_name);

    if(ret<0)
	return ret;
    struct json_server_context * server_context;

    ret=sec_subject_getcontext(sub_proc,&context);
    server_context=sec_object_getpointer(context);

    port_hub=server_context->json_port_hub;

    port_conn=hub_get_connector(server_context->json_port_hub,"json_server");
    if(port_conn==NULL)
        return -EINVAL;

    channel_conn=NULL;
    for(i=0;i<500*1000;i++)
    {
        ret=port_hub->hub_ops->select(port_hub,&conn_val);
        usleep(conn_val.tv_usec);
	conn_val.tv_usec=time_val.tv_usec;
        if(ret>0)
        {

        	do{

           	 	recv_conn=port_hub->hub_ops->getactiveread(port_hub);
        		if(recv_conn==NULL)
                		break;
          		if(connector_get_type(recv_conn)==CONN_SERVER)
            		{

           		     channel_conn=recv_conn->conn_ops->accept(recv_conn);
         		     if(channel_conn==NULL)
                	     {
              			      printf("error: json_server connector accept error %x!\n",channel_conn);
               			      continue;
               		     }
              		     printf("create a new channel %x!\n",channel_conn);

           		     // build a server syn message with service name,uuid and proc_name
           		     channel_conn->conn_ops->write(channel_conn,
                             	  server_context->json_message,
                              	  server_context->message_len);

               		    port_hub->hub_ops->add_connector(port_hub,channel_conn,NULL);
            		}
	  		else if(connector_get_type(recv_conn)==CONN_CHANNEL)
	    		{
				char * buffer=malloc(65535);
		 		int offset=0;
		  		do {
		 			ret=recv_conn->conn_ops->read(recv_conn,buffer+offset,4096);
		   	 		if(ret<0)
				 		break;
			  		offset+=ret;
		    		}while(ret==4096);
	    	 		void * message;
	    	  		ret=json_2_message(buffer,&message);
		   		if(ret>=0)
		    		{
					if(message_get_state(message)==0)
						message_set_state(message,MSG_FLOW_INIT);
					set_message_head(message,"sender_uuid",local_uuid);
	    	    			sec_subject_sendmsg(sub_proc,message);	
		    		}
	    		}
		}while(1);
	}
	// send message to the remote
	while(sec_subject_recvmsg(sub_proc,&message_box)>=0)
	{
		if(message_box==NULL)
			break;
    		stroffset=message_2_json(message_box,buffer);
		if(channel_conn!=NULL)
		{
                	channel_conn->conn_ops->write(channel_conn,
                               buffer,stroffset);
			printf("json port send %d data !",stroffset);
		}	
	}

    }
    return 0;
}