// NewRawPressure returns a new RawPressure
164557
func NewRawPressure(TIME_USEC uint64, PRESS_ABS int16, PRESS_DIFF1 int16, PRESS_DIFF2 int16, TEMPERATURE int16) *RawPressure {
	m := RawPressure{}
	m.TIME_USEC = TIME_USEC
	m.PRESS_ABS = PRESS_ABS
	m.PRESS_DIFF1 = PRESS_DIFF1
	m.PRESS_DIFF2 = PRESS_DIFF2
	m.TEMPERATURE = TEMPERATURE
	return &m
}
1331518
func MarkdownRaw(c *context.APIContext) {
	body, err := c.Req.Body().Bytes()
	if err != nil {
		c.Error(422, "", err)
		return
	}
	c.Write(markup.RawMarkdown(body, ""))
}
666962
func NewRawFeatureVector(bits ...FeatureBit) *RawFeatureVector {
	fv := &RawFeatureVector{features: make(map[FeatureBit]bool)}
	for _, bit := range bits {
		fv.Set(bit)
	}
	return fv
}
38938
func (s *GCMMessage) SetRawContent(v string) *GCMMessage {
	s.RawContent = &v
	return s
}
745463
func (m Match) RawHandler() HandlerType {
	switch v := m.Handler.(type) {
	case netHTTPHandlerWrap:
		return v.Handler
	case handlerFuncWrap:
		return v.fn
	case netHTTPHandlerFuncWrap:
		return v.fn
	default:
		return v
	}
}
1013953
func (w *bufferedWriter) createNewWriter(file *os.File) io.Writer {
	w.buf = bufio.NewWriterSize(file, w.bufSize)
	return w.buf
}
1171270
func NewRawAsciiClient(shard int, channel io.ReadWriter) ClientShard {
	return &RawAsciiClient{
		shard:      shard,
		channel:    channel,
		validState: true,
		writer:     bufio.NewWriter(channel),
		reader:     bufio.NewReader(channel),
	}
}
134986
func newCompressed(namespace string, src io.ReadCloser) io.ReadCloser {
	pr, pw := io.Pipe()
	go func() {
		// Memory is cheap, we never want this pipeline to stall.
		const outBufSize = 1024 * 1024
		// We write into a buffer so that the Reader can read larger chunks of
		// compressed data out of the compressor instead of being constrained to
		// compressed(4096 bytes) each read.
		bufWriter := bufio.NewWriterSize(pw, outBufSize)
		// The compressor itself is not thread safe.
		compressor, err := isolated.GetCompressor(namespace, bufWriter)
		if err != nil {
			pw.CloseWithError(err)
			return
		}
		// Make this 3x bigger than the output buffer since it is uncompressed.
		buf := make([]byte, outBufSize*3)
		if _, err := io.CopyBuffer(compressor, src, buf); err != nil {
			compressor.Close()
			pw.CloseWithError(err)
			return
		}
		// compressor needs to be closed first to flush the rest of the data
		// into the bufio.Writer
		if err := compressor.Close(); err != nil {
			pw.CloseWithError(err)
			return
		}
		pw.CloseWithError(bufWriter.Flush())
	}()

	return &compressed{pr, src}
}
814552
func New(codes ...Code) *Renderer {
	return &Renderer{
		begin: []byte(Begin(codes...)),
		end:   []byte(End()),
	}
}
660159
func New(rawData ...interface{}) *Notifier {
	config := Config.clone()
	for i, datum := range rawData {
		if c, ok := datum.(Configuration); ok {
			config.update(&c)
			rawData[i] = nil
		}
	}

	return &Notifier{
		Config:  config,
		RawData: rawData,
	}
}
1146457
func (s *EndpointSendConfiguration) SetRawContent(v string) *EndpointSendConfiguration {
	s.RawContent = &v
	return s
}
825985
func newRawDefaultConsumer(config *Config) (*rawDefaultConsumer, error) {
	c := &rawDefaultConsumer{
		dopplerAddr:    config.DopplerAddr,
		token:          config.Token,
		subscriptionID: config.SubscriptionID,
		insecure:       config.Insecure,
		debugPrinter:   config.DebugPrinter,
		logger:         config.Logger,
		idleTimeout:    config.IdleTimeout,
		retryCount:     config.RetryCount,
		tokenRefresher: config.tokenFetcher,
	}

	if err := c.validate(); err != nil {
		return nil, err
	}

	return c, nil

}
92304
func NewMockRawPublishableConnector(ctrl *gomock.Controller) *MockRawPublishableConnector {
	mock := &MockRawPublishableConnector{ctrl: ctrl}
	mock.recorder = &MockRawPublishableConnectorMockRecorder{mock}
	return mock
}
298576
func NewRefPaperDoc(DocId string) *RefPaperDoc {
	s := new(RefPaperDoc)
	s.DocId = DocId
	return s
}
184171
func NewCompressWriter(w io.Writer) *compressWriter {
	p := &compressWriter{writer: w}
	p.data = make([]byte, BlockMaxSize, BlockMaxSize)

	zlen := lz4.CompressBound(BlockMaxSize) + HeaderSize
	p.zdata = make([]byte, zlen, zlen)
	return p
}
281124
func New(url string) *Renderer {
	return &Renderer{
		client: rhttp.DefaultClient,
		url:    url,
	}
}
274920
func New(opts Opts) Handler {
	if len(opts.RetryableCodes) == 0 {
		opts.RetryableCodes = DefaultRetryableCodes
	}
	return &impl{opts: opts}
}