github.com/Oyster-zx/tendermint@v0.34.24-fork/proto/tendermint/consensus/message.go (about)

     1  package consensus
     2  
     3  import (
     4  	"fmt"
     5  
     6  	"github.com/gogo/protobuf/proto"
     7  	"github.com/tendermint/tendermint/p2p"
     8  )
     9  
    10  var _ p2p.Wrapper = &VoteSetBits{}
    11  var _ p2p.Wrapper = &VoteSetMaj23{}
    12  var _ p2p.Wrapper = &Vote{}
    13  var _ p2p.Wrapper = &ProposalPOL{}
    14  var _ p2p.Wrapper = &Proposal{}
    15  var _ p2p.Wrapper = &NewValidBlock{}
    16  var _ p2p.Wrapper = &NewRoundStep{}
    17  var _ p2p.Wrapper = &HasVote{}
    18  var _ p2p.Wrapper = &BlockPart{}
    19  
    20  func (m *VoteSetBits) Wrap() proto.Message {
    21  	cm := &Message{}
    22  	cm.Sum = &Message_VoteSetBits{VoteSetBits: m}
    23  	return cm
    24  
    25  }
    26  
    27  func (m *VoteSetMaj23) Wrap() proto.Message {
    28  	cm := &Message{}
    29  	cm.Sum = &Message_VoteSetMaj23{VoteSetMaj23: m}
    30  	return cm
    31  }
    32  
    33  func (m *HasVote) Wrap() proto.Message {
    34  	cm := &Message{}
    35  	cm.Sum = &Message_HasVote{HasVote: m}
    36  	return cm
    37  }
    38  
    39  func (m *Vote) Wrap() proto.Message {
    40  	cm := &Message{}
    41  	cm.Sum = &Message_Vote{Vote: m}
    42  	return cm
    43  }
    44  
    45  func (m *BlockPart) Wrap() proto.Message {
    46  	cm := &Message{}
    47  	cm.Sum = &Message_BlockPart{BlockPart: m}
    48  	return cm
    49  }
    50  
    51  func (m *ProposalPOL) Wrap() proto.Message {
    52  	cm := &Message{}
    53  	cm.Sum = &Message_ProposalPol{ProposalPol: m}
    54  	return cm
    55  }
    56  
    57  func (m *Proposal) Wrap() proto.Message {
    58  	cm := &Message{}
    59  	cm.Sum = &Message_Proposal{Proposal: m}
    60  	return cm
    61  }
    62  
    63  func (m *NewValidBlock) Wrap() proto.Message {
    64  	cm := &Message{}
    65  	cm.Sum = &Message_NewValidBlock{NewValidBlock: m}
    66  	return cm
    67  }
    68  
    69  func (m *NewRoundStep) Wrap() proto.Message {
    70  	cm := &Message{}
    71  	cm.Sum = &Message_NewRoundStep{NewRoundStep: m}
    72  	return cm
    73  }
    74  
    75  // Unwrap implements the p2p Wrapper interface and unwraps a wrapped consensus
    76  // proto message.
    77  func (m *Message) Unwrap() (proto.Message, error) {
    78  	switch msg := m.Sum.(type) {
    79  	case *Message_NewRoundStep:
    80  		return m.GetNewRoundStep(), nil
    81  
    82  	case *Message_NewValidBlock:
    83  		return m.GetNewValidBlock(), nil
    84  
    85  	case *Message_Proposal:
    86  		return m.GetProposal(), nil
    87  
    88  	case *Message_ProposalPol:
    89  		return m.GetProposalPol(), nil
    90  
    91  	case *Message_BlockPart:
    92  		return m.GetBlockPart(), nil
    93  
    94  	case *Message_Vote:
    95  		return m.GetVote(), nil
    96  
    97  	case *Message_HasVote:
    98  		return m.GetHasVote(), nil
    99  
   100  	case *Message_VoteSetMaj23:
   101  		return m.GetVoteSetMaj23(), nil
   102  
   103  	case *Message_VoteSetBits:
   104  		return m.GetVoteSetBits(), nil
   105  
   106  	default:
   107  		return nil, fmt.Errorf("unknown message: %T", msg)
   108  	}
   109  }