github.com/glide-im/glide@v1.6.0/pkg/messages/message.go (about)

     1  package messages
     2  
     3  import (
     4  	"encoding/json"
     5  	"errors"
     6  	"fmt"
     7  	"reflect"
     8  )
     9  
    10  var messageVersion int64 = 1
    11  
    12  // GlideMessage common data of all message
    13  type GlideMessage struct {
    14  	Ver    int64  `json:"ver,omitempty"`
    15  	Seq    int64  `json:"seq,omitempty"`
    16  	Action string `json:"action"`
    17  	From   string `json:"from,omitempty"`
    18  	To     string `json:"to,omitempty"`
    19  	Data   *Data  `json:"data,omitempty"`
    20  	Msg    string `json:"msg,omitempty"`
    21  
    22  	Ticket string `json:"ticket,omitempty"`
    23  	Sign   string `json:"sign,omitempty"`
    24  
    25  	Extra map[string]string `json:"extra,omitempty"`
    26  }
    27  
    28  func NewMessage(seq int64, action Action, data interface{}) *GlideMessage {
    29  	return &GlideMessage{
    30  		Ver:    messageVersion,
    31  		Seq:    seq,
    32  		Action: string(action),
    33  		Data:   NewData(data),
    34  		Extra:  nil,
    35  	}
    36  }
    37  
    38  func NewEmptyMessage() *GlideMessage {
    39  	return &GlideMessage{
    40  		Ver:   messageVersion,
    41  		Data:  nil,
    42  		Extra: nil,
    43  	}
    44  }
    45  
    46  func (g *GlideMessage) GetSeq() int64 {
    47  	return g.Seq
    48  }
    49  
    50  func (g *GlideMessage) GetAction() Action {
    51  	return Action(g.Action)
    52  }
    53  
    54  func (g *GlideMessage) SetSeq(seq int64) {
    55  	g.Seq = seq
    56  }
    57  
    58  func (g *GlideMessage) String() string {
    59  	if g == nil {
    60  		return "<nil>"
    61  	}
    62  	return fmt.Sprintf("&Message{Ver:%d, Action:%s, Data:%s}", g.Ver, g.Action, g.Data)
    63  }
    64  
    65  // Data used to wrap message data.
    66  // Server received a message, the data type is []byte, it's waiting for deserialize to specified struct.
    67  // When server push a message to client, the data type is specific struct.
    68  type Data struct {
    69  	des interface{}
    70  }
    71  
    72  func NewData(d interface{}) *Data {
    73  	return &Data{
    74  		des: d,
    75  	}
    76  }
    77  
    78  func (d *Data) UnmarshalJSON(bytes []byte) error {
    79  	d.des = bytes
    80  	return nil
    81  }
    82  
    83  func (d *Data) MarshalJSON() ([]byte, error) {
    84  	bytes, ok := d.des.([]byte)
    85  	if ok {
    86  		return bytes, nil
    87  	}
    88  	return JsonCodec.Encode(d.des)
    89  }
    90  
    91  func (d *Data) GetData() interface{} {
    92  	return d.des
    93  }
    94  
    95  func (d *Data) Deserialize(i interface{}) error {
    96  	if d == nil {
    97  		return errors.New("data is nil")
    98  	}
    99  	s, ok := d.des.([]byte)
   100  	if ok {
   101  		return JsonCodec.Decode(s, i)
   102  	} else {
   103  		t1 := reflect.TypeOf(i)
   104  		t2 := reflect.TypeOf(d.des)
   105  		if t1 == t2 {
   106  			reflect.ValueOf(i).Elem().Set(reflect.ValueOf(d.des).Elem())
   107  			return nil
   108  		}
   109  	}
   110  	return errors.New("deserialize message data failed")
   111  }
   112  
   113  func (d *Data) String() string {
   114  	b, ok := d.des.([]byte)
   115  	var s interface{}
   116  	if ok {
   117  		s = string(b)
   118  	} else {
   119  		if d.des == nil {
   120  			s = "<nil>"
   121  		} else {
   122  			s, _ = json.Marshal(d.des)
   123  		}
   124  	}
   125  	return fmt.Sprintf("%s", s)
   126  }