func (c *Channel) WithServerUnaryInterceptor(interceptor grpc.UnaryServerInterceptor) *Channel {
	c.unaryInterceptor = interceptor
	return c
}
WithServerUnaryInterceptor configures the in-process channel to use the given
server interceptor for unary RPCs when dispatching.
package inprocgrpc
import (
	"context"
	"fmt"
	"io"
	"reflect"
	"runtime"
	"strings"
	"sync"
	"google.golang.org/grpc"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/metadata"
	"google.golang.org/grpc/peer"
	"google.golang.org/grpc/status"
	"github.com/fullstorydev/grpchan"
	"github.com/fullstorydev/grpchan/internal"
)
type frame struct {
	data interface{}
	headers metadata.MD
	trailers metadata.MD
	err error
}
type frameKind int
const (
	kindHeaders frameKind = iota
	kindData
	kindTrailers
	kindError
	kindUnknown
)
func (m frame) kind() frameKind {
	switch {
	case m.headers != nil:
		return kindHeaders
	case m.data != nil:
		return kindData
	case m.trailers != nil:
		return kindTrailers
	case m.err != nil:
		return kindError
	default:
		return kindUnknown
	}
}
func (m frame) String() string {
	switch m.kind() {
	case kindData:
		return fmt.Sprintf("data:%v", m.data)
	case kindHeaders:
		return fmt.Sprintf("headers:%v", m.headers)
	case kindTrailers:
		return fmt.Sprintf("trailers:%v", m.trailers)
	case kindError:
		return fmt.Sprintf("error:%v", m.err)
	default:
		return "?unknown?"
	}
}
type Channel struct {
	handlers          grpchan.HandlerMap
	unaryInterceptor  grpc.UnaryServerInterceptor
	streamInterceptor grpc.StreamServerInterceptor
	cloner            Cloner
}
var _ grpc.ClientConnInterface = (*Channel)(nil)
var _ grpc.ServiceRegistrar = (*Channel)(nil)
func (c *Channel) RegisterService(desc *grpc.ServiceDesc, svr interface{}) {
	if c.handlers == nil {
		c.handlers = grpchan.HandlerMap{}
	}
	c.handlers.RegisterService(desc, svr)
}