text:
package grpc_binarylog_v1

import (
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	duration "github.com/golang/protobuf/ptypes/duration"
	timestamp "github.com/golang/protobuf/ptypes/timestamp"
	math "math"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package

// Enumerates the type of event
// Note the terminology is different from the RPC semantics
// definition, but the same meaning is expressed here.
type GrpcLogEntry_EventType int32

const (
	GrpcLogEntry_EVENT_TYPE_UNKNOWN GrpcLogEntry_EventType = 0
	// Header sent from client to server
	GrpcLogEntry_EVENT_TYPE_CLIENT_HEADER GrpcLogEntry_EventType = 1
	// Header sent from server to client
	GrpcLogEntry_EVENT_TYPE_SERVER_HEADER GrpcLogEntry_EventType = 2
	// Message sent from client to server
	GrpcLogEntry_EVENT_TYPE_CLIENT_MESSAGE GrpcLogEntry_EventType = 3
	// Message sent from server to client
	GrpcLogEntry_EVENT_TYPE_SERVER_MESSAGE GrpcLogEntry_EventType = 4
	// A signal that client is done sending
	GrpcLogEntry_EVENT_TYPE_CLIENT_HALF_CLOSE GrpcLogEntry_EventType = 5
	// Trailer indicates the end of the RPC.
	// On client side, this event means a trailer was either received
	// from the network or the gRPC library locally generated a status
	// to inform the application about a failure.
	// On server side, this event means the server application requested
	// to send a trailer. Note: EVENT_TYPE_CANCEL may still arrive after
	// this due to races on server side.
	GrpcLogEntry_EVENT_TYPE_SERVER_TRAILER GrpcLogEntry_EventType = 6
	// A signal that the RPC is cancelled. On client side, this
	// indicates the client application requests a cancellation.
	// On server side, this indicates that cancellation was detected.
	// Note: This marks the end of the RPC. Events may arrive after
	// this due to races. For example, on client side a trailer
	// may arrive even though the application requested to cancel the RPC.
	GrpcLogEntry_EVENT_TYPE_CANCEL GrpcLogEntry_EventType = 7
)

var GrpcLogEntry_EventType_name = map[int32]string{
	0: "EVENT_TYPE_UNKNOWN",
	1: "EVENT_TYPE_CLIENT_HEADER",
	2: "EVENT_TYPE_SERVER_HEADER",
	3: "EVENT_TYPE_CLIENT_MESSAGE",
	4: "EVENT_TYPE_SERVER_MESSAGE",
	5: "EVENT_TYPE_CLIENT_HALF_CLOSE",
	6: "EVENT_TYPE_SERVER_TRAILER",
	7: "EVENT_TYPE_CANCEL",
}

var GrpcLogEntry_EventType_value = map[string]int32{
	"EVENT_TYPE_UNKNOWN":           0,
	"EVENT_TYPE_CLIENT_HEADER":     1,
	"EVENT_TYPE_SERVER_HEADER":     2,
	"EVENT_TYPE_CLIENT_MESSAGE":    3,
	"EVENT_TYPE_SERVER_MESSAGE":    4,
	"EVENT_TYPE_CLIENT_HALF_CLOSE": 5,
	"EVENT_TYPE_SERVER_TRAILER":    6,
	"EVENT_TYPE_CANCEL":            7,
}

func (x GrpcLogEntry_EventType) String() string {
	return proto.EnumName(GrpcLogEntry_EventType_name, int32(x))
}

func (GrpcLogEntry_EventType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_b7972e58de45083a, []int{0, 0}
}

// Enumerates the entity that generates the log entry
type GrpcLogEntry_Logger int32

const (
	GrpcLogEntry_LOGGER_UNKNOWN GrpcLogEntry_Logger = 0
	GrpcLogEntry_LOGGER_CLIENT  GrpcLogEntry_Logger = 1
	GrpcLogEntry_LOGGER_SERVER  GrpcLogEntry_Logger = 2
)

var GrpcLogEntry_Logger_name = map[int32]string{
	0: "LOGGER_UNKNOWN",
	1: "LOGGER_CLIENT",
	2: "LOGGER_SERVER",
}

var GrpcLogEntry_Logger_value = map[string]int32{
	"LOGGER_UNKNOWN": 0,
	"LOGGER_CLIENT":  1,
	"LOGGER_SERVER":  2,
}

func (x GrpcLogEntry_Logger) String() string {
	return proto.EnumName(GrpcLogEntry_Logger_name, int32(x))
}

func (GrpcLogEntry_Logger) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_b7972e58de45083a, []int{0, 1}
}

type Address_Type int32

const (
	Address_TYPE_UNKNOWN Address_Type = 0
	// address is in 1.2.3.4 form
	Address_TYPE_IPV4 Address_Type = 1
	// address is in IPv6 canonical form (RFC5952 section 4)
	// The scope is NOT included in the address string.
	Address_TYPE_IPV6 Address_Type = 2
	// address is UDS string
	Address_TYPE_UNIX Address_Type = 3
)

var Address_Type_name = map[int32]string{
	0: "TYPE_UNKNOWN",
	1: "TYPE_IPV4",
	2: "TYPE_IPV6",
	3: "TYPE_UNIX",
}

var Address_Type_value = map[string]int32{
	"TYPE_UNKNOWN": 0,
	"TYPE_IPV4":    1,
	"TYPE_IPV6":    2,
	"TYPE_UNIX":    3,
}

func (x Address_Type) String() string {
	return proto.EnumName(Address_Type_name, int32(x))
}

func (Address_Type) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_b7972e58de45083a, []int{7, 0}
}

// Log entry we store in binary logs
type GrpcLogEntry struct {
	// The timestamp of the binary log message
	Timestamp *timestamp.Timestamp `protobuf:"bytes,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	// Uniquely identifies a call. The value must not be 0 in order to disambiguate
	// from an unset value.
	// Each call may have several log entries, they will all have the same call_id.
	// Nothing is guaranteed about their value other than they are unique across
	// different RPCs in the same gRPC process.
	CallId uint64 `protobuf:"varint,2,opt,name=call_id,json=callId,proto3" json:"call_id,omitempty"`
	// The entry sequence id for this call. The first GrpcLogEntry has a
	// value of 1, to disambiguate from an unset value. The purpose of
	// this field is to detect missing entries in environments where
	// durability or ordering is not guaranteed.
	SequenceIdWithinCall uint64                 `protobuf:"varint,3,opt,name=sequence_id_within_call,json=sequenceIdWithinCall,proto3" json:"sequence_id_within_call,omitempty"`
	Type                 GrpcLogEntry_EventType `protobuf:"varint,4,opt,name=type,proto3,enum=grpc.binarylog.v1.GrpcLogEntry_EventType" json:"type,omitempty"`
	Logger               GrpcLogEntry_Logger    `protobuf:"varint,5,opt,name=logger,proto3,enum=grpc.binarylog.v1.GrpcLogEntry_Logger" json:"logger,omitempty"`
	// The logger uses one of the following fields to record the payload,
	// according to the type of the log entry.
	//
	// Types that are valid to be assigned to Payload:
	//	*GrpcLogEntry_ClientHeader
	//	*GrpcLogEntry_ServerHeader
	//	*GrpcLogEntry_Message
	//	*GrpcLogEntry_Trailer
	Payload isGrpcLogEntry_Payload `protobuf_oneof:"payload"`
	// true if payload does not represent the full message or metadata.
	PayloadTruncated bool `protobuf:"varint,10,opt,name=payload_truncated,json=payloadTruncated,proto3" json:"payload_truncated,omitempty"`
	// Peer address information, will only be recorded on the first
	// incoming event. On client side, peer is logged on
	// EVENT_TYPE_SERVER_HEADER normally or EVENT_TYPE_SERVER_TRAILER in
	// the case of trailers-only. On server side, peer is always
	// logged on EVENT_TYPE_CLIENT_HEADER.
	Peer                 *Address `protobuf:"bytes,11,opt,name=peer,proto3" json:"peer,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GrpcLogEntry) Reset()         { *m = GrpcLogEntry{} }
func (m *GrpcLogEntry) String() string { return proto.CompactTextString(m) }
func (*GrpcLogEntry) ProtoMessage()    {}
func (*GrpcLogEntry) Descriptor() ([]byte, []int) {
	return fileDescriptor_b7972e58de45083a, []int{0}
}

func (m *GrpcLogEntry) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GrpcLogEntry.Unmarshal(m, b)
}
func (m *GrpcLogEntry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GrpcLogEntry.Marshal(b, m, deterministic)
}
func (m *GrpcLogEntry) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GrpcLogEntry.Merge(m, src)
}
func (m *GrpcLogEntry) XXX_Size() int {
	return xxx_messageInfo_GrpcLogEntry.Size(m)
}
func (m *GrpcLogEntry) XXX_DiscardUnknown() {
	xxx_messageInfo_GrpcLogEntry.DiscardUnknown(m)
}

var xxx_messageInfo_GrpcLogEntry proto.InternalMessageInfo

func (m *GrpcLogEntry) GetTimestamp() *timestamp.Timestamp {
	if m != nil {
		return m.Timestamp
	}
	return nil
}

func (m *GrpcLogEntry) GetCallId() uint64 {
	if m != nil {
		return m.CallId
	}
	return 0
}

func (m *GrpcLogEntry) GetSequenceIdWithinCall() uint64 {
	if m != nil {
		return m.SequenceIdWithinCall
	}
	return 0
}

func (m *GrpcLogEntry) GetType() GrpcLogEntry_EventType {
	if m != nil {
		return m.Type
	}
	return GrpcLogEntry_EVENT_TYPE_UNKNOWN
}

func (m *GrpcLogEntry) GetLogger() GrpcLogEntry_Logger {
	if m != nil {
		return m.Logger
	}
	return GrpcLogEntry_LOGGER_UNKNOWN
}

type isGrpcLogEntry_Payload interface {
	isGrpcLogEntry_Payload()
}

type GrpcLogEntry_ClientHeader struct {
	ClientHeader *ClientHeader `protobuf:"bytes,6,opt,name=client_header,json=clientHeader,proto3,oneof"`
}

type GrpcLogEntry_ServerHeader struct {
	ServerHeader *ServerHeader `protobuf:"bytes,7,opt,name=server_header,json=serverHeader,proto3,oneof"`
}

type GrpcLogEntry_Message struct {
	Message *Message `protobuf:"bytes,8,opt,name=message,proto3,oneof"`
}

type GrpcLogEntry_Trailer struct {
	Trailer *Trailer `protobuf:"bytes,9,opt,name=trailer,proto3,oneof"`
}

func (*GrpcLogEntry_ClientHeader) isGrpcLogEntry_Payload() {}

func (*GrpcLogEntry_ServerHeader) isGrpcLogEntry_Payload() {}

func (*GrpcLogEntry_Message) isGrpcLogEntry_Payload() {}

func (*GrpcLogEntry_Trailer) isGrpcLogEntry_Payload() {}

func (m *GrpcLogEntry) GetPayload() isGrpcLogEntry_Payload {
	if m != nil {
		return m.Payload
	}
	return nil
}

func (m *GrpcLogEntry) GetClientHeader() *ClientHeader {
	if x, ok := m.GetPayload().(*GrpcLogEntry_ClientHeader); ok {
		return x.ClientHeader
	}
	return nil
}

func (m *GrpcLogEntry) GetServerHeader() *ServerHeader {
	if x, ok := m.GetPayload().(*GrpcLogEntry_ServerHeader); ok {
		return x.ServerHeader
	}
	return nil
}

func (m *GrpcLogEntry) GetMessage() *Message {
	if x, ok := m.GetPayload().(*GrpcLogEntry_Message); ok {
		return x.Message
	}
	return nil
}

func (m *GrpcLogEntry) GetTrailer() *Trailer {
	if x, ok := m.GetPayload().(*GrpcLogEntry_Trailer); ok {
		return x.Trailer
	}
	return nil
}

func (m *GrpcLogEntry) GetPayloadTruncated() bool {
	if m != nil {
		return m.PayloadTruncated
	}
	return false
}

func (m *GrpcLogEntry) GetPeer() *Address {
	if m != nil {
		return m.Peer
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*GrpcLogEntry) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*GrpcLogEntry_ClientHeader)(nil),
		(*GrpcLogEntry_ServerHeader)(nil),
		(*GrpcLogEntry_Message)(nil),
		(*GrpcLogEntry_Trailer)(nil),
	}
}

type ClientHeader struct {
	// This contains only the metadata from the application.
	Metadata *Metadata `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"`
	// The name of the RPC method, which looks something like:
	// /<service>/<method>
	// Note the leading "/" character.
	MethodName string `protobuf:"bytes,2,opt,name=method_name,json=methodName,proto3" json:"method_name,omitempty"`
	// A single process may be used to run multiple virtual
	// servers with different identities.
	// The authority is the name of such a server identitiy.
	// It is typically a portion of the URI in the form of
	// <host> or <host>:<port> .
	Authority string `protobuf:"bytes,3,opt,name=authority,proto3" json:"authority,omitempty"`
	// the RPC timeout
	Timeout              *duration.Duration `protobuf:"bytes,4,opt,name=timeout,proto3" json:"timeout,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (m *ClientHeader) Reset()         { *m = ClientHeader{} }
func (m *ClientHeader) String() string { return proto.CompactTextString(m) }
func (*ClientHeader) ProtoMessage()    {}
func (*ClientHeader) Descriptor() ([]byte, []int) {
	return fileDescriptor_b7972e58de45083a, []int{1}
}

func (m *ClientHeader) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ClientHeader.Unmarshal(m, b)
}
func (m *ClientHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ClientHeader.Marshal(b, m, deterministic)
}
func (m *ClientHeader) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ClientHeader.Merge(m, src)
}
func (m *ClientHeader) XXX_Size() int {
	return xxx_messageInfo_ClientHeader.Size(m)
}
func (m *ClientHeader) XXX_DiscardUnknown() {
	xxx_messageInfo_ClientHeader.DiscardUnknown(m)
}

var xxx_messageInfo_ClientHeader proto.InternalMessageInfo

func (m *ClientHeader) GetMetadata() *Metadata {
	if m != nil {
		return m.Metadata
	}
	return nil
}

func (m *ClientHeader) GetMethodName() string {
	if m != nil {
		return m.MethodName
	}
	return ""
}

func (m *ClientHeader) GetAuthority() string {
	if m != nil {
		return m.Authority
	}
	return ""
}

func (m *ClientHeader) GetTimeout() *duration.Duration {
	if m != nil {
		return m.Timeout
	}
	return nil
}

type ServerHeader struct {
	// This contains only the metadata from the application.
	Metadata             *Metadata `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *ServerHeader) Reset()         { *m = ServerHeader{} }
func (m *ServerHeader) String() string { return proto.CompactTextString(m) }
func (*ServerHeader) ProtoMessage()    {}
func (*ServerHeader) Descriptor() ([]byte, []int) {
	return fileDescriptor_b7972e58de45083a, []int{2}
}

func (m *ServerHeader) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ServerHeader.Unmarshal(m, b)
}
func (m *ServerHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ServerHeader.Marshal(b, m, deterministic)
}
func (m *ServerHeader) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ServerHeader.Merge(m, src)
}
func (m *ServerHeader) XXX_Size() int {
	return xxx_messageInfo_ServerHeader.Size(m)
}
func (m *ServerHeader) XXX_DiscardUnknown() {
	xxx_messageInfo_ServerHeader.DiscardUnknown(m)
}

var xxx_messageInfo_ServerHeader proto.InternalMessageInfo

func (m *ServerHeader) GetMetadata() *Metadata {
	if m != nil {
		return m.Metadata
	}
	return nil
}

type Trailer struct {
	// This contains only the metadata from the application.
	Metadata *Metadata `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"`
	// The gRPC status code.
	StatusCode uint32 `protobuf:"varint,2,opt,name=status_code,json=statusCode,proto3" json:"status_code,omitempty"`
	// An original status message before any transport specific
	// encoding.
	StatusMessage string `protobuf:"bytes,3,opt,name=status_message,json=statusMessage,proto3" json:"status_message,omitempty"`
	// The value of the 'grpc-status-details-bin' metadata key. If
	// present, this is always an encoded 'google.rpc.Status' message.
	StatusDetails        []byte   `protobuf:"bytes,4,opt,name=status_details,json=statusDetails,proto3" json:"status_details,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Trailer) Reset()         { *m = Trailer{} }
func (m *Trailer) String() string { return proto.CompactTextString(m) }
func (*Trailer) ProtoMessage()    {}
func (*Trailer) Descriptor() ([]byte, []int) {
	return fileDescriptor_b7972e58de45083a, []int{3}
}

func (m *Trailer) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Trailer.Unmarshal(m, b)
}
func (m *Trailer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Trailer.Marshal(b, m, deterministic)
}
func (m *Trailer) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Trailer.Merge(m, src)
}
func (m *Trailer) XXX_Size() int {
	return xxx_messageInfo_Trailer.Size(m)
}
func (m *Trailer) XXX_DiscardUnknown() {
	xxx_messageInfo_Trailer.DiscardUnknown(m)
}

var xxx_messageInfo_Trailer proto.InternalMessageInfo

func (m *Trailer) GetMetadata() *Metadata {
	if m != nil {
		return m.Metadata
	}
	return nil
}

func (m *Trailer) GetStatusCode() uint32 {
	if m != nil {
		return m.StatusCode
	}
	return 0
}

func (m *Trailer) GetStatusMessage() string {
	if m != nil {
		return m.StatusMessage
	}
	return ""
}

func (m *Trailer) GetStatusDetails() []byte {
	if m != nil {
		return m.StatusDetails
	}
	return nil
}

// Message payload, used by CLIENT_MESSAGE and SERVER_MESSAGE
type Message struct {
	// Length of the message. It may not be the same as the length of the
	// data field, as the logging payload can be truncated or omitted.
	Length uint32 `protobuf:"varint,1,opt,name=length,proto3" json:"length,omitempty"`
	// May be truncated or omitted.
	Data                 []byte   `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Message) Reset()         { *m = Message{} }
func (m *Message) String() string { return proto.CompactTextString(m) }
func (*Message) ProtoMessage()    {}
func (*Message) Descriptor() ([]byte, []int) {
	return fileDescriptor_b7972e58de45083a, []int{4}
}

func (m *Message) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Message.Unmarshal(m, b)
}
func (m *Message) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Message.Marshal(b, m, deterministic)
}
func (m *Message) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Message.Merge(m, src)
}
func (m *Message) XXX_Size() int {
	return xxx_messageInfo_Message.Size(m)
}
func (m *Message) XXX_DiscardUnknown() {
	xxx_messageInfo_Message.DiscardUnknown(m)
}

var xxx_messageInfo_Message proto.InternalMessageInfo

func (m *Message) GetLength() uint32 {
	if m != nil {
		return m.Length
	}
	return 0
}

func (m *Message) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

// A list of metadata pairs, used in the payload of client header,
// server header, and server trailer.
// Implementations may omit some entries to honor the header limits
// of GRPC_BINARY_LOG_CONFIG.
//
// Header keys added by gRPC are omitted. To be more specific,
// implementations will not log the following entries, and this is
// not to be treated as a truncation:
// - entries handled by grpc that are not user visible, such as those
//   that begin with 'grpc-' (with exception of grpc-trace-bin)
//   or keys like 'lb-token'
// - transport specific entries, including but not limited to:
//   ':path', ':authority', 'content-encoding', 'user-agent', 'te', etc
// - entries added for call credentials
//
// Implementations must always log grpc-trace-bin if it is present.
// Practically speaking it will only be visible on server side because
// grpc-trace-bin is managed by low level client side mechanisms
// inaccessible from the application level. On server side, the
// header is just a normal metadata key.
// The pair will not count towards the size limit.
type Metadata struct {
	Entry                []*MetadataEntry `protobuf:"bytes,1,rep,name=entry,proto3" json:"entry,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *Metadata) Reset()         { *m = Metadata{} }
func (m *Metadata) String() string { return proto.CompactTextString(m) }
func (*Metadata) ProtoMessage()    {}
func (*Metadata) Descriptor() ([]byte, []int) {
	return fileDescriptor_b7972e58de45083a, []int{5}
}

func (m *Metadata) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Metadata.Unmarshal(m, b)
}
func (m *Metadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Metadata.Marshal(b, m, deterministic)
}
func (m *Metadata) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Metadata.Merge(m, src)
}
func (m *Metadata) XXX_Size() int {
	return xxx_messageInfo_Metadata.Size(m)
}
func (m *Metadata) XXX_DiscardUnknown() {
	xxx_messageInfo_Metadata.DiscardUnknown(m)
}

var xxx_messageInfo_Metadata proto.InternalMessageInfo

func (m *Metadata) GetEntry() []*MetadataEntry {
	if m != nil {
		return m.Entry
	}
	return nil
}

// A metadata key value pair
type MetadataEntry struct {
	Key                  string   `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Value                []byte   `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MetadataEntry) Reset()         { *m = MetadataEntry{} }
func (m *MetadataEntry) String() string { return proto.CompactTextString(m) }
func (*MetadataEntry) ProtoMessage()    {}
func (*MetadataEntry) Descriptor() ([]byte, []int) {
	return fileDescriptor_b7972e58de45083a, []int{6}
}

func (m *MetadataEntry) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MetadataEntry.Unmarshal(m, b)
}
func (m *MetadataEntry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MetadataEntry.Marshal(b, m, deterministic)
}
func (m *MetadataEntry) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MetadataEntry.Merge(m, src)
}
func (m *MetadataEntry) XXX_Size() int {
	return xxx_messageInfo_MetadataEntry.Size(m)
}
func (m *MetadataEntry) XXX_DiscardUnknown() {
	xxx_messageInfo_MetadataEntry.DiscardUnknown(m)
}

var xxx_messageInfo_MetadataEntry proto.InternalMessageInfo

func (m *MetadataEntry) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

func (m *MetadataEntry) GetValue() []byte {
	if m != nil {
		return m.Value
	}
	return nil
}

// Address information
type Address struct {
	Type    Address_Type `protobuf:"varint,1,opt,name=type,proto3,enum=grpc.binarylog.v1.Address_Type" json:"type,omitempty"`
	Address string       `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
	// only for TYPE_IPV4 and TYPE_IPV6
	IpPort               uint32   `protobuf:"varint,3,opt,name=ip_port,json=ipPort,proto3" json:"ip_port,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Address) Reset()         { *m = Address{} }
func (m *Address) String() string { return proto.CompactTextString(m) }
func (*Address) ProtoMessage()    {}
func (*Address) Descriptor() ([]byte, []int) {
	return fileDescriptor_b7972e58de45083a, []int{7}
}

func (m *Address) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Address.Unmarshal(m, b)
}
func (m *Address) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Address.Marshal(b, m, deterministic)
}
func (m *Address) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Address.Merge(m, src)
}
func (m *Address) XXX_Size() int {
	return xxx_messageInfo_Address.Size(m)
}
func (m *Address) XXX_DiscardUnknown() {
	xxx_messageInfo_Address.DiscardUnknown(m)
}

var xxx_messageInfo_Address proto.InternalMessageInfo

func (m *Address) GetType() Address_Type {
	if m != nil {
		return m.Type
	}
	return Address_TYPE_UNKNOWN
}

func (m *Address) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

func (m *Address) GetIpPort() uint32 {
	if m != nil {
		return m.IpPort
	}
	return 0
}

func init() {
	proto.RegisterEnum("grpc.binarylog.v1.GrpcLogEntry_EventType", GrpcLogEntry_EventType_name, GrpcLogEntry_EventType_value)
	proto.RegisterEnum("grpc.binarylog.v1.GrpcLogEntry_Logger", GrpcLogEntry_Logger_name, GrpcLogEntry_Logger_value)
	proto.RegisterEnum("grpc.binarylog.v1.Address_Type", Address_Type_name, Address_Type_value)
	proto.RegisterType((*GrpcLogEntry)(nil), "grpc.binarylog.v1.GrpcLogEntry")
	proto.RegisterType((*ClientHeader)(nil), "grpc.binarylog.v1.ClientHeader")
	proto.RegisterType((*ServerHeader)(nil), "grpc.binarylog.v1.ServerHeader")
	proto.RegisterType((*Trailer)(nil), "grpc.binarylog.v1.Trailer")
	proto.RegisterType((*Message)(nil), "grpc.binarylog.v1.Message")
	proto.RegisterType((*Metadata)(nil), "grpc.binarylog.v1.Metadata")
	proto.RegisterType((*MetadataEntry)(nil), "grpc.binarylog.v1.MetadataEntry")
	proto.RegisterType((*Address)(nil), "grpc.binarylog.v1.Address")
}

func init() { proto.RegisterFile("grpc/binlog/v1/binarylog.proto", fileDescriptor_b7972e58de45083a) }

var fileDescriptor_b7972e58de45083a = []byte{
	// 904 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x55, 0x51, 0x6f, 0xe3, 0x44,
	0x10, 0xae, 0xdb, 0x34, 0x6e, 0x26, 0x49, 0xe5, 0xae, 0xca, 0x9d, 0xaf, 0x94, 0x6b, 0x64, 0x09,
	0x14, 0x84, 0xe4, 0xa8, 0x29, 0xd7, 0xe3, 0x05, 0xa4, 0x24, 0xf5, 0xa5, 0x11, 0xb9, 0x34, 0xda,
	0xe4, 0x7a, 0x80, 0x90, 0xac, 0x6d, 0xbc, 0x38, 0x16, 0x8e, 0xd7, 0xac, 0x37, 0x41, 0xf9, 0x59,
	0xbc, 0x21, 0xdd, 0xef, 0xe2, 0x1d, 0x79, 0xd7, 0x4e, 0x4d, 0xd3, 0x82, 0xc4, 0xbd, 0xed, 0x7c,
	0xf3, 0xcd, 0x37, 0xbb, 0xe3, 0x99, 0x31, 0xbc, 0xf4, 0x79, 0x3c, 0x6b, 0xdd, 0x05, 0x51, 0xc8,
	0xfc, 0xd6, 0xea, 0x3c, 0x3d, 0x11, 0xbe, 0x0e, 0x99, 0x6f, 0xc7, 0x9c, 0x09, 0x86, 0x8e, 0x52,
	0xbf, 0x7d, 0x8f, 0xae, 0xce, 0x4f, 0x5e, 0xfa, 0x8c, 0xf9, 0x21, 0x6d, 0x49, 0xc2, 0xdd, 0xf2,
	0x97, 0x96, 0xb7, 0xe4, 0x44, 0x04, 0x2c, 0x52, 0x21, 0x27, 0x67, 0x0f, 0xfd, 0x22, 0x58, 0xd0,
	0x44, 0x90, 0x45, 0xac, 0x08, 0xd6, 0x07, 0x1d, 0x6a, 0x7d, 0x1e, 0xcf, 0x86, 0xcc, 0x77, 0x22,
	0xc1, 0xd7, 0xe8, 0x1b, 0xa8, 0x6c, 0x38, 0xa6, 0xd6, 0xd0, 0x9a, 0xd5, 0xf6, 0x89, 0xad, 0x54,
	0xec, 0x5c, 0xc5, 0x9e, 0xe6, 0x0c, 0x7c, 0x4f, 0x46, 0xcf, 0x41, 0x9f, 0x91, 0x30, 0x74, 0x03,
	0xcf, 0xdc, 0x6d, 0x68, 0xcd, 0x12, 0x2e, 0xa7, 0xe6, 0xc0, 0x43, 0xaf, 0xe0, 0x79, 0x42, 0x7f,
	0x5b, 0xd2, 0x68, 0x46, 0xdd, 0xc0, 0x73, 0x7f, 0x0f, 0xc4, 0x3c, 0x88, 0xdc, 0xd4, 0x69, 0xee,
	0x49, 0xe2, 0x71, 0xee, 0x1e, 0x78, 0xef, 0xa5, 0xb3, 0x47, 0xc2, 0x10, 0x7d, 0x0b, 0x25, 0xb1,
	0x8e, 0xa9, 0x59, 0x6a, 0x68, 0xcd, 0xc3, 0xf6, 0x97, 0xf6, 0xd6, 0xeb, 0xed, 0xe2, 0xc5, 0x6d,
	0x67, 0x45, 0x23, 0x31, 0x5d, 0xc7, 0x14, 0xcb, 0x30, 0xf4, 0x1d, 0x94, 0x43, 0xe6, 0xfb, 0x94,
	0x9b, 0xfb, 0x52, 0xe0, 0x8b, 0xff, 0x12, 0x18, 0x4a, 0x36, 0xce, 0xa2, 0xd0, 0x1b, 0xa8, 0xcf,
	0xc2, 0x80, 0x46, 0xc2, 0x9d, 0x53, 0xe2, 0x51, 0x6e, 0x96, 0x65, 0x31, 0xce, 0x1e, 0x91, 0xe9,
	0x49, 0xde, 0xb5, 0xa4, 0x5d, 0xef, 0xe0, 0xda, 0xac, 0x60, 0xa7, 0x3a, 0x09, 0xe5, 0x2b, 0xca,
	0x73, 0x1d, 0xfd, 0x49, 0x9d, 0x89, 0xe4, 0xdd, 0xeb, 0x24, 0x05, 0x1b, 0x5d, 0x82, 0xbe, 0xa0,
	0x49, 0x42, 0x7c, 0x6a, 0x1e, 0xe4, 0x9f, 0x65, 0x4b, 0xe1, 0xad, 0x62, 0x5c, 0xef, 0xe0, 0x9c,
	0x9c, 0xc6, 0x09, 0x4e, 0x82, 0x90, 0x72, 0xb3, 0xf2, 0x64, 0xdc, 0x54, 0x31, 0xd2, 0xb8, 0x8c,
	0x8c, 0xbe, 0x82, 0xa3, 0x98, 0xac, 0x43, 0x46, 0x3c, 0x57, 0xf0, 0x65, 0x34, 0x23, 0x82, 0x7a,
	0x26, 0x34, 0xb4, 0xe6, 0x01, 0x36, 0x32, 0xc7, 0x34, 0xc7, 0x91, 0x0d, 0xa5, 0x98, 0x52, 0x6e,
	0x56, 0x9f, 0xcc, 0xd0, 0xf1, 0x3c, 0x4e, 0x93, 0x04, 0x4b, 0x9e, 0xf5, 0x97, 0x06, 0x95, 0xcd,
	0x07, 0x43, 0xcf, 0x00, 0x39, 0xb7, 0xce, 0x68, 0xea, 0x4e, 0x7f, 0x1c, 0x3b, 0xee, 0xbb, 0xd1,
	0xf7, 0xa3, 0x9b, 0xf7, 0x23, 0x63, 0x07, 0x9d, 0x82, 0x59, 0xc0, 0x7b, 0xc3, 0x41, 0x7a, 0xbe,
	0x76, 0x3a, 0x57, 0x0e, 0x36, 0xb4, 0x07, 0xde, 0x89, 0x83, 0x6f, 0x1d, 0x9c, 0x7b, 0x77, 0xd1,
	0x67, 0xf0, 0x62, 0x3b, 0xf6, 0xad, 0x33, 0x99, 0x74, 0xfa, 0x8e, 0xb1, 0xf7, 0xc0, 0x9d, 0x05,
	0xe7, 0xee, 0x12, 0x6a, 0xc0, 0xe9, 0x23, 0x99, 0x3b, 0xc3, 0x37, 0x6e, 0x6f, 0x78, 0x33, 0x71,
	0x8c, 0xfd, 0xc7, 0x05, 0xa6, 0xb8, 0x33, 0x18, 0x3a, 0xd8, 0x28, 0xa3, 0x4f, 0xe0, 0xa8, 0x28,
	0xd0, 0x19, 0xf5, 0x9c, 0xa1, 0xa1, 0x5b, 0x5d, 0x28, 0xab, 0x36, 0x43, 0x08, 0x0e, 0x87, 0x37,
	0xfd, 0xbe, 0x83, 0x0b, 0xef, 0x3d, 0x82, 0x7a, 0x86, 0xa9, 0x8c, 0x86, 0x56, 0x80, 0x54, 0x0a,
	0x63, 0xb7, 0x5b, 0x01, 0x3d, 0xab, 0xbf, 0xf5, 0x41, 0x83, 0x5a, 0xb1, 0xf9, 0xd0, 0x6b, 0x38,
	0x58, 0x50, 0x41, 0x3c, 0x22, 0x48, 0x36, 0xbc, 0x9f, 0x3e, 0xda, 0x25, 0x8a, 0x82, 0x37, 0x64,
	0x74, 0x06, 0xd5, 0x05, 0x15, 0x73, 0xe6, 0xb9, 0x11, 0x59, 0x50, 0x39, 0xc0, 0x15, 0x0c, 0x0a,
	0x1a, 0x91, 0x05, 0x45, 0xa7, 0x50, 0x21, 0x4b, 0x31, 0x67, 0x3c, 0x10, 0x6b, 0x39, 0xb6, 0x15,
	0x7c, 0x0f, 0xa0, 0x0b, 0xd0, 0xd3, 0x45, 0xc0, 0x96, 0x42, 0x8e, 0x6b, 0xb5, 0xfd, 0x62, 0x6b,
	0x67, 0x5c, 0x65, 0x9b, 0x09, 0xe7, 0x4c, 0xab, 0x0f, 0xb5, 0x62, 0xc7, 0xff, 0xef, 0xcb, 0x5b,
	0x7f, 0x68, 0xa0, 0x67, 0x1d, 0xfc, 0x51, 0x15, 0x48, 0x04, 0x11, 0xcb, 0xc4, 0x9d, 0x31, 0x4f,
	0x55, 0xa0, 0x8e, 0x41, 0x41, 0x3d, 0xe6, 0x51, 0xf4, 0x39, 0x1c, 0x66, 0x84, 0x7c, 0x0e, 0x55,
	0x19, 0xea, 0x0a, 0xcd, 0x46, 0xaf, 0x40, 0xf3, 0xa8, 0x20, 0x41, 0x98, 0xc8, 0x8a, 0xd4, 0x72,
	0xda, 0x95, 0x02, 0xad, 0x57, 0xa0, 0xe7, 0x11, 0xcf, 0xa0, 0x1c, 0xd2, 0xc8, 0x17, 0x73, 0x79,
	0xe1, 0x3a, 0xce, 0x2c, 0x84, 0xa0, 0x24, 0x9f, 0xb1, 0x2b, 0xe3, 0xe5, 0xd9, 0xea, 0xc2, 0x41,
	0x7e, 0x77, 0x74, 0x09, 0xfb, 0x34, 0xdd, 0x5c, 0xa6, 0xd6, 0xd8, 0x6b, 0x56, 0xdb, 0x8d, 0x7f,
	0x79, 0xa7, 0xdc, 0x70, 0x58, 0xd1, 0xad, 0xd7, 0x50, 0xff, 0x07, 0x8e, 0x0c, 0xd8, 0xfb, 0x95,
	0xae, 0x65, 0xf6, 0x0a, 0x4e, 0x8f, 0xe8, 0x18, 0xf6, 0x57, 0x24, 0x5c, 0xd2, 0x2c, 0xb7, 0x32,
	0xac, 0x3f, 0x35, 0xd0, 0xb3, 0x39, 0x46, 0x17, 0xd9, 0x76, 0xd6, 0xe4, 0x72, 0x3d, 0x7b, 0x7a,
	0xe2, 0xed, 0xc2, 0x4e, 0x36, 0x41, 0x27, 0x0a, 0xcd, 0x3a, 0x2c, 0x37, 0xd3, 0x9f, 0x47, 0x10,
	0xbb, 0x31, 0xe3, 0x42, 0x56, 0xb5, 0x8e, 0xcb, 0x41, 0x3c, 0x66, 0x5c, 0x58, 0x0e, 0x94, 0xe4,
	0x8e, 0x30, 0xa0, 0xf6, 0x60, 0x3b, 0xd4, 0xa1, 0x22, 0x91, 0xc1, 0xf8, 0xf6, 0x6b, 0x43, 0x2b,
	0x9a, 0x97, 0xc6, 0xee, 0xc6, 0x7c, 0x37, 0x1a, 0xfc, 0x60, 0xec, 0x75, 0x7f, 0x86, 0xe3, 0x80,
	0x6d, 0x5f, 0xb2, 0x7b, 0xd8, 0x95, 0xd6, 0x90, 0xf9, 0xe3, 0xb4, 0x51, 0xc7, 0xda, 0x4f, 0xed,
	0xac, 0x71, 0x7d, 0x16, 0x92, 0xc8, 0xb7, 0x19, 0xf7, 0x5b, 0xf9, 0x7f, 0x59, 0x85, 0x49, 0xd3,
	0xdd, 0x98, 0xee, 0xea, 0xfc, 0xae, 0x2c, 0xbb, 0xfc, 0xe2, 0xef, 0x00, 0x00, 0x00, 0xff, 0xff,
	0x10, 0x93, 0x68, 0x41, 0xc2, 0x07, 0x00, 0x00,
}


text:
namespace OpenLiveWriter.PostEditor.Tables
{

    public partial class TablePropertiesForm
    {
        private System.Windows.Forms.Button buttonOK;
        private System.Windows.Forms.Button buttonCancel;
        private System.Windows.Forms.GroupBox groupBoxSize;
        private System.Windows.Forms.Label labelRows;
        private System.Windows.Forms.Label labelColumns;
        private System.Windows.Forms.Panel panelRowsAndColumns;
        private System.Windows.Forms.Label label1;
        private OpenLiveWriter.PostEditor.Tables.ColumnWidthControl columnWidthControl;
        /// <summary>
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.Container components = null;
        private System.Windows.Forms.GroupBox groupBoxAppearance;
        private OpenLiveWriter.Controls.NumericTextBox numericTextBoxBorder;
        private OpenLiveWriter.Controls.NumericTextBox numericTextBoxColumns;
        private OpenLiveWriter.Controls.NumericTextBox numericTextBoxRows;
        private OpenLiveWriter.Controls.NumericTextBox numericTextBoxCellPadding;
        private OpenLiveWriter.Controls.NumericTextBox numericTextBoxCellSpacing;
        private System.Windows.Forms.CheckBox checkBoxShowBorder;
        private System.Windows.Forms.Label labelSpacingPixels;
        private System.Windows.Forms.Label labelPaddingPixels;
        private System.Windows.Forms.Label labelBorderPixels;
        private System.Windows.Forms.Label label3;

        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (components != null)
                {
                    components.Dispose();
                }
            }
            base.Dispose(disposing);
        }

        #region Windows Form Designer generated code
        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            this.buttonOK = new System.Windows.Forms.Button();
            this.buttonCancel = new System.Windows.Forms.Button();
            this.groupBoxSize = new System.Windows.Forms.GroupBox();
            this.columnWidthControl = new OpenLiveWriter.PostEditor.Tables.ColumnWidthControl();
            this.panelRowsAndColumns = new System.Windows.Forms.Panel();
            this.numericTextBoxColumns = new OpenLiveWriter.Controls.NumericTextBox();
            this.numericTextBoxRows = new OpenLiveWriter.Controls.NumericTextBox();
            this.labelRows = new System.Windows.Forms.Label();
            this.labelColumns = new System.Windows.Forms.Label();
            this.groupBoxAppearance = new System.Windows.Forms.GroupBox();
            this.labelSpacingPixels = new System.Windows.Forms.Label();
            this.labelPaddingPixels = new System.Windows.Forms.Label();
            this.labelBorderPixels = new System.Windows.Forms.Label();
            this.checkBoxShowBorder = new System.Windows.Forms.CheckBox();
            this.numericTextBoxCellSpacing = new OpenLiveWriter.Controls.NumericTextBox();
            this.label3 = new System.Windows.Forms.Label();
            this.numericTextBoxBorder = new OpenLiveWriter.Controls.NumericTextBox();
            this.numericTextBoxCellPadding = new OpenLiveWriter.Controls.NumericTextBox();
            this.label1 = new System.Windows.Forms.Label();
            this.groupBoxSize.SuspendLayout();
            this.panelRowsAndColumns.SuspendLayout();
            this.groupBoxAppearance.SuspendLayout();
            this.SuspendLayout();
            //
            // buttonOK
            //
            this.buttonOK.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
            this.buttonOK.FlatStyle = System.Windows.Forms.FlatStyle.System;
            this.buttonOK.Location = new System.Drawing.Point(139, 247);
            this.buttonOK.Name = "buttonOK";
            this.buttonOK.Size = new System.Drawing.Size(75, 23);
            this.buttonOK.TabIndex = 2;
            this.buttonOK.Text = "OK";
            this.buttonOK.Click += new System.EventHandler(this.buttonOK_Click);
            //
            // buttonCancel
            //
            this.buttonCancel.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
            this.buttonCancel.DialogResult = System.Windows.Forms.DialogResult.Cancel;
            this.buttonCancel.FlatStyle = System.Windows.Forms.FlatStyle.System;
            this.buttonCancel.Location = new System.Drawing.Point(221, 247);
            this.buttonCancel.Name = "buttonCancel";
            this.buttonCancel.Size = new System.Drawing.Size(75, 23);
            this.buttonCancel.TabIndex = 3;
            this.buttonCancel.Text = "Cancel";
            //
            // groupBoxSize
            //
            this.groupBoxSize.Controls.Add(this.columnWidthControl);
            this.groupBoxSize.Controls.Add(this.panelRowsAndColumns);
            this.groupBoxSize.FlatStyle = System.Windows.Forms.FlatStyle.System;
            this.groupBoxSize.Location = new System.Drawing.Point(9, 8);
            this.groupBoxSize.Name = "groupBoxSize";
            this.groupBoxSize.Size = new System.Drawing.Size(287, 97);
            this.groupBoxSize.TabIndex = 0;
            this.groupBoxSize.TabStop = false;
            this.groupBoxSize.Text = "Size";
            //
            // columnWidthControl
            //
            this.columnWidthControl.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
                        | System.Windows.Forms.AnchorStyles.Right)));
            this.columnWidthControl.ColumnWidth = new PixelPercent();
            this.columnWidthControl.ImeMode = System.Windows.Forms.ImeMode.Off;
            this.columnWidthControl.Location = new System.Drawing.Point(16, 55);
            this.columnWidthControl.Name = "columnWidthControl";
            this.columnWidthControl.Size = new System.Drawing.Size(254, 23);
            this.columnWidthControl.TabIndex = 1;
            //
            // panelRowsAndColumns
            //
            this.panelRowsAndColumns.Controls.Add(this.numericTextBoxColumns);
            this.panelRowsAndColumns.Controls.Add(this.numericTextBoxRows);
            this.panelRowsAndColumns.Controls.Add(this.labelRows);
            this.panelRowsAndColumns.Controls.Add(this.labelColumns);
            this.panelRowsAndColumns.Location = new System.Drawing.Point(16, 24);
            this.panelRowsAndColumns.Name = "panelRowsAndColumns";
            this.panelRowsAndColumns.Size = new System.Drawing.Size(227, 23);
            this.panelRowsAndColumns.TabIndex = 0;
            //
            // numericTextBoxColumns
            //
            this.numericTextBoxColumns.ImeMode = System.Windows.Forms.ImeMode.Off;
            this.numericTextBoxColumns.Location = new System.Drawing.Point(155, 0);
            this.numericTextBoxColumns.MaxLength = 9;
            this.numericTextBoxColumns.Name = "numericTextBoxColumns";
            this.numericTextBoxColumns.Size = new System.Drawing.Size(46, 21);
            this.numericTextBoxColumns.TabIndex = 3;
            //
            // numericTextBoxRows
            //
            this.numericTextBoxRows.ImeMode = System.Windows.Forms.ImeMode.Off;
            this.numericTextBoxRows.Location = new System.Drawing.Point(43, 0);
            this.numericTextBoxRows.MaxLength = 9;
            this.numericTextBoxRows.Name = "numericTextBoxRows";
            this.numericTextBoxRows.Size = new System.Drawing.Size(46, 21);
            this.numericTextBoxRows.TabIndex = 1;
            //
            // labelRows
            //
            this.labelRows.FlatStyle = System.Windows.Forms.FlatStyle.System;
            this.labelRows.Location = new System.Drawing.Point(0, 3);
            this.labelRows.Name = "labelRows";
            this.labelRows.Size = new System.Drawing.Size(37, 15);
            this.labelRows.TabIndex = 0;
            this.labelRows.Text = "&Rows:";
            //
            // labelColumns
            //
            this.labelColumns.FlatStyle = System.Windows.Forms.FlatStyle.System;
            this.labelColumns.Location = new System.Drawing.Point(104, 3);
            this.labelColumns.Name = "labelColumns";
            this.labelColumns.Size = new System.Drawing.Size(49, 15);
            this.labelColumns.TabIndex = 2;
            this.labelColumns.Text = "&Columns:";
            //
            // groupBoxAppearance
            //
            this.groupBoxAppearance.Controls.Add(this.labelSpacingPixels);
            this.groupBoxAppearance.Controls.Add(this.labelPaddingPixels);
            this.groupBoxAppearance.Controls.Add(this.labelBorderPixels);
            this.groupBoxAppearance.Controls.Add(this.checkBoxShowBorder);
            this.groupBoxAppearance.Controls.Add(this.numericTextBoxCellSpacing);
            this.groupBoxAppearance.Controls.Add(this.label3);
            this.groupBoxAppearance.Controls.Add(this.numericTextBoxBorder);
            this.groupBoxAppearance.Controls.Add(this.numericTextBoxCellPadding);
            this.groupBoxAppearance.Controls.Add(this.label1);
            this.groupBoxAppearance.FlatStyle = System.Windows.Forms.FlatStyle.System;
            this.groupBoxAppearance.Location = new System.Drawing.Point(9, 108);
            this.groupBoxAppearance.Name = "groupBoxAppearance";
            this.groupBoxAppearance.Size = new System.Drawing.Size(287, 132);
            this.groupBoxAppearance.TabIndex = 1;
            this.groupBoxAppearance.TabStop = false;
            this.groupBoxAppearance.Text = "Appearance";
            //
            // labelSpacingPixels
            //
            this.labelSpacingPixels.FlatStyle = System.Windows.Forms.FlatStyle.System;
            this.labelSpacingPixels.Location = new System.Drawing.Point(206, 94);
            this.labelSpacingPixels.Name = "labelSpacingPixels";
            this.labelSpacingPixels.Size = new System.Drawing.Size(64, 15);
            this.labelSpacingPixels.TabIndex = 9;
            this.labelSpacingPixels.Text = "pixels";
            //
            // labelPaddingPixels
            //
            this.labelPaddingPixels.FlatStyle = System.Windows.Forms.FlatStyle.System;
            this.labelPaddingPixels.Location = new System.Drawing.Point(206, 65);
            this.labelPaddingPixels.Name = "labelPaddingPixels";
            this.labelPaddingPixels.Size = new System.Drawing.Size(64, 15);
            this.labelPaddingPixels.TabIndex = 8;
            this.labelPaddingPixels.Text = "pixels";
            //
            // labelBorderPixels
            //
            this.labelBorderPixels.FlatStyle = System.Windows.Forms.FlatStyle.System;
            this.labelBorderPixels.Location = new System.Drawing.Point(206, 29);
            this.labelBorderPixels.Name = "labelBorderPixels";
            this.labelBorderPixels.Size = new System.Drawing.Size(64, 16);
            this.labelBorderPixels.TabIndex = 7;
            this.labelBorderPixels.Text = "pixels";
            //
            // checkBoxShowBorder
            //
            this.checkBoxShowBorder.FlatStyle = System.Windows.Forms.FlatStyle.System;
            this.checkBoxShowBorder.Location = new System.Drawing.Point(16, 24);
            this.checkBoxShowBorder.Name = "checkBoxShowBorder";
            this.checkBoxShowBorder.Size = new System.Drawing.Size(141, 24);
            this.checkBoxShowBorder.TabIndex = 0;
            this.checkBoxShowBorder.Text = "Show table &border:";
            this.checkBoxShowBorder.CheckedChanged += new System.EventHandler(this.checkBoxShowBorder_CheckedChanged);
            //
            // numericTextBoxCellSpacing
            //
            this.numericTextBoxCellSpacing.ImeMode = System.Windows.Forms.ImeMode.Off;
            this.numericTextBoxCellSpacing.Location = new System.Drawing.Point(166, 91);
            this.numericTextBoxCellSpacing.MaxLength = 9;
            this.numericTextBoxCellSpacing.Name = "numericTextBoxCellSpacing";
            this.numericTextBoxCellSpacing.Size = new System.Drawing.Size(35, 21);
            this.numericTextBoxCellSpacing.TabIndex = 6;
            //
            // label3
            //
            this.label3.FlatStyle = System.Windows.Forms.FlatStyle.System;
            this.label3.Location = new System.Drawing.Point(16, 94);
            this.label3.Name = "label3";
            this.label3.Size = new System.Drawing.Size(139, 15);
            this.label3.TabIndex = 5;
            this.label3.Text = "&Space between cells:";
            //
            // numericTextBoxBorder
            //
            this.numericTextBoxBorder.ImeMode = System.Windows.Forms.ImeMode.Off;
            this.numericTextBoxBorder.Location = new System.Drawing.Point(166, 26);
            this.numericTextBoxBorder.MaxLength = 9;
            this.numericTextBoxBorder.Name = "numericTextBoxBorder";
            this.numericTextBoxBorder.Size = new System.Drawing.Size(35, 21);
            this.numericTextBoxBorder.TabIndex = 2;
            //
            // numericTextBoxCellPadding
            //
            this.numericTextBoxCellPadding.ImeMode = System.Windows.Forms.ImeMode.Off;
            this.numericTextBoxCellPadding.Location = new System.Drawing.Point(166, 61);
            this.numericTextBoxCellPadding.MaxLength = 9;
            this.numericTextBoxCellPadding.Name = "numericTextBoxCellPadding";
            this.numericTextBoxCellPadding.Size = new System.Drawing.Size(35, 21);
            this.numericTextBoxCellPadding.TabIndex = 4;
            //
            // label1
            //
            this.label1.FlatStyle = System.Windows.Forms.FlatStyle.System;
            this.label1.Location = new System.Drawing.Point(16, 65);
            this.label1.Name = "label1";
            this.label1.Size = new System.Drawing.Size(140, 15);
            this.label1.TabIndex = 3;
            this.label1.Text = "&Pad cell contents:";
            //
            // TablePropertiesForm
            //
            this.AcceptButton = this.buttonOK;
            this.CancelButton = this.buttonCancel;
            this.ClientSize = new System.Drawing.Size(305, 277);
            this.Controls.Add(this.groupBoxAppearance);
            this.Controls.Add(this.groupBoxSize);
            this.Controls.Add(this.buttonCancel);
            this.Controls.Add(this.buttonOK);
            this.MaximizeBox = false;
            this.MinimizeBox = false;
            this.Name = "TablePropertiesForm";
            this.Text = "Insert Table";
            this.groupBoxSize.ResumeLayout(false);
            this.panelRowsAndColumns.ResumeLayout(false);
            this.panelRowsAndColumns.PerformLayout();
            this.groupBoxAppearance.ResumeLayout(false);
            this.groupBoxAppearance.PerformLayout();
            this.ResumeLayout(false);

        }
        #endregion

    }
}

redpajama_set_name: RedPajamaGithub


text:
package org.carrot2.core.test.assertions;

import static org.carrot2.core.test.assertions.Carrot2CoreAssertions.assertThatClusters;
import static org.carrot2.core.test.assertions.Carrot2CoreAssertions.assertThatDocuments;
import static org.fest.assertions.Assertions.assertThat;

import org.carrot2.core.Cluster;
import org.fest.assertions.AssertExtension;
import org.fest.assertions.GenericAssert;

/**
 * Assertions on {@link Cluster}s.
 */
public class ClusterAssertion
    extends GenericAssert<ClusterAssertion, Cluster>
    implements AssertExtension
{
    ClusterAssertion(Cluster actual)
    {
        super(ClusterAssertion.class, actual);
    }

    /** Description of the assertion */
    private String description;

    /**
     * Asserts that the cluster is equivalent to the provided cluster. Two clusters are
     * equivalent if their {@link Cluster#getPhrases()} and
     * {@link Cluster#getAttributes()} are equal, and their
     * {@link Cluster#getSubclusters()} and {@link Cluster#getDocuments()} are equivalent
     *
     * @see DocumentAssertion#isEquivalentTo(org.carrot2.core.Document)
     * @param expectedCluster the expected cluster
     * @return this assertion for convenience
     */
    public ClusterAssertion isEquivalentTo(Cluster expectedCluster)
    {
        return isEquivalentTo(expectedCluster, true);
    }

    /**
     * Asserts that the cluster is equivalent to the provided cluster. Two clusters are
     * equivalent if their {@link Cluster#getPhrases()} and
     * {@link Cluster#getAttributes()} are equal, and their
     * {@link Cluster#getSubclusters()} and {@link Cluster#getDocuments()} are equivalent
     *
     * @see DocumentAssertion#isEquivalentTo(org.carrot2.core.Document)
     * @param expectedCluster the expected cluster
     * @param checkDocuments if false, cluster's document references will not
     *            be checked
     * @return this assertion for convenience
     */
    public ClusterAssertion isEquivalentTo(Cluster expectedCluster, boolean checkDocuments)
    {
        assertThat(actual.getPhrases()).isEqualTo(expectedCluster.getPhrases());
        if (checkDocuments)
        {
            assertThatDocuments(actual.getDocuments()).as(
                description + ": " + "cluster: " + actual.getLabel()).isEquivalentTo(
                expectedCluster.getDocuments());
        }
        assertThat(actual.getAttributes()).isEqualTo(expectedCluster.getAttributes());
        assertThatClusters(actual.getSubclusters()).isEquivalentTo(
            expectedCluster.getSubclusters(), checkDocuments);

        return this;
    }

    /**
     * Asserts that the cluster's Other Topics flag is set to the required state.
     */
    public ClusterAssertion isOtherTopics(boolean isOtherTopics, String otherTopicsLabel)
    {
        assertThat(actual.isOtherTopics()).isEqualTo(isOtherTopics);
        if (isOtherTopics)
        {
            assertThat(actual.getPhrases()).contains(otherTopicsLabel);
        }
        else
        {
            assertThat(actual.getPhrases()).excludes(otherTopicsLabel);
        }
        return this;
    }

    /**
     * Asserts that the cluster's Other Topics flag is set to the required state.
     */
    public ClusterAssertion isOtherTopics(boolean isOtherTopics)
    {
        return isOtherTopics(isOtherTopics, "Other Topics");
    }

    /**
     * Assert that the cluster's label is equal to expectedLabel.
     */
    public ClusterAssertion hasLabel(String expectedLabel)
    {
        assertThat(actual.getLabel()).isEqualTo(expectedLabel);
        return this;
    }

    /**
     * Assert that the number of unique documents in the cluster and its subclusters is
     * equal to expectedClusterSize.
     */
    public ClusterAssertion hasSize(int expectedClusterSize)
    {
        assertThat(actual.getAllDocuments().size()).isEqualTo(expectedClusterSize);
        return this;
    }
}


text:
namespace kmldom {

// Verify proper behavior for good KML.  The XML is valid and all elements
// are known and contained by proper parents.
TEST(ParserTest, TestValidKml) {
  string errors;
  ElementPtr root = Parse("<kml>"
                          "<Placemark>"
                          "<name>a good Placemark</name>"
                          "<Point>"
                          "<coordinates>1,2,3</coordinates>"
                          "</Point>"
                          "</Placemark>"
                          "</kml>",
                          &errors);
  // KML is valid so there are no errors and the root is <kml>.
  ASSERT_TRUE(errors.empty());
  ASSERT_TRUE(root != 0);

  const KmlPtr kml = AsKml(root);
  ASSERT_TRUE(kml != 0);

  errors.clear();
  // Assigning to root releases storage allocated in Parse above.
  root = Parse(" <kml/>", &errors);  // Note leading space.
  ASSERT_TRUE(errors.empty());
  ASSERT_TRUE(root != 0);

  ASSERT_TRUE(AsKml(root) != 0);

  // ElementPtr root going out of scope releases storage allocated in 2nd
  // Parse.
}

TEST(ParserTest, TestJunkInput) {
  // Parse a garbage string.
  string errors;
  ElementPtr root = Parse("This is not even xml", &errors);
  // Since the parse failed there will be an error string and NULL is returned.
  ASSERT_FALSE(errors.empty());
  ASSERT_FALSE(root);

  // An unescaped ampersand is a basic XML parse error.
  root = Parse("<Document><name>&</name></Document>", &errors);
  ASSERT_FALSE(errors.empty());
  ASSERT_FALSE(root);
}

TEST(ParserTest, TestFullyUnknownXml) {
  // Parse perfectly valid, but fully unknown XML.  "Fully unknown" means
  // the root element is not known.  When Parse returns NULL an error string
  // is set.  The error string is considered human readable and not
  // examined further by this test.
  string errors;
  ElementPtr root;

  // These test some subtle variations of the inner workings of expat.
  root = Parse("<gml/>", &errors);
  ASSERT_FALSE(root);
  ASSERT_FALSE(errors.empty());

  errors.clear();
  root = Parse("<gml></gml>", &errors);
  ASSERT_FALSE(root);
  ASSERT_FALSE(errors.empty());

  errors.clear();
  root = Parse("<gml/>\n", &errors);
  ASSERT_FALSE(root);
  ASSERT_FALSE(errors.empty());

  errors.clear();
  root = Parse("<gml></gml>\n", &errors);
  ASSERT_FALSE(root);
  ASSERT_FALSE(errors.empty());

  errors.clear();
  root = Parse("<gml><this>is not<kml/></this>is also not</gml>", &errors);
  ASSERT_FALSE(root);
  ASSERT_FALSE(errors.empty());

  errors.clear();
  root = Parse("<gml>"
               "<Placemark><name>still not kml</name></Placemark>"
               "</gml>",
               &errors);
  ASSERT_FALSE(root);
  ASSERT_FALSE(errors.empty());
}

TEST(ParserTest, TestPartlyValidKml) {
  // This pushes several elements onto the stack within the parser to
  // excercise the destructor which frees them all.
  string errors;
  ElementPtr root = Parse("<kml>"
                          "<Folder>"
                          "<Document>"
                          "<Placemark>"
                          "<name>a good Placemark</name>"
                          "<MultiGeometry>"
                          "<MultiGeometry>"
                          "<Point>"
                          "<coordinates>",
                          &errors);
  ASSERT_FALSE(root);
  ASSERT_FALSE(errors.empty());
}

TEST(ParserTest, TestKmlWithUnknownEmptyFields) {
  // Note that the unknown element handling logic still engages expat handlers
  // hence nil elements (<c/>) are turned into <c></c>.  Note also the newline
  // added by the unknown element handler.
  const string kUnknownXml("b<c></c>\n");
  const string kKml(
      string("<kml>") + kUnknownXml + "</kml>");
  ElementPtr root = Parse(kKml, NULL);
  ASSERT_TRUE(root != 0);
  ASSERT_EQ(static_cast<size_t>(1), root->get_unknown_elements_array_size());
  ASSERT_EQ(kUnknownXml, root->get_unknown_elements_array_at(0));
}

TEST(ParserTest, TestParseAtomOnJunk) {
  ASSERT_FALSE(ParseAtom("junk", NULL));
}

TEST(ParserTest, TestBasicParseAtomError) {
  string errors;
  ElementPtr root = ParseAtom("<feed xmlns='http://www.w3.org/2005/Atom'>",
                              &errors);
  ASSERT_FALSE(root.get());
  ASSERT_FALSE(errors.empty());
}

TEST(ParserTest, TestBasicParseAtom) {
  string errors;
  ElementPtr root = ParseAtom("<feed xmlns='http://www.w3.org/2005/Atom'/>",
                              &errors);
  ASSERT_TRUE(errors.empty());
  ASSERT_TRUE(root.get());
  ASSERT_TRUE(AsAtomFeed(root) != 0);
  ASSERT_EQ(kmlbase::XMLNS_ATOM, root->get_xmlns());
}

TEST(ParserTest, TestBasicParseAtomWithKml) {
  ElementPtr root = ParseAtom(
    "<atom:content xmlns:atom='http://www.w3.org/2005/Atom'>"
    " xmlns='http://www.opengis.net/kml/2.2'>"
    "<Placemark id='pm0'/>"
    "</atom:content>", NULL);
  ASSERT_TRUE(root.get());
  kmldom::AtomContentPtr content = kmldom::AsAtomContent(root);
  ASSERT_TRUE(content.get());
  ASSERT_EQ(static_cast<size_t>(1),
            content->get_misplaced_elements_array_size());
  kmldom::PlacemarkPtr placemark =
      kmldom::AsPlacemark(content->get_misplaced_elements_array_at(0));
  ASSERT_EQ(string("pm0"), placemark->get_id());
}

}  // end namespace kmldom


text:
#include "leds_sw.h"
#include <cust_leds.h>
#include <cust_leds_def.h>

#define AAAAAAAAAAAAAAAAAAAA
/****************************************************************************
 * LED HAL functions
 ***************************************************************************/
extern void mt_leds_wake_lock_init(void);
extern unsigned int mt_get_bl_brightness(void);
extern unsigned int mt_get_bl_duty(void);
extern unsigned int mt_get_bl_div(void);
extern unsigned int mt_get_bl_frequency(void);
extern unsigned int *mt_get_div_array(void);
extern void mt_set_bl_duty(unsigned int level);
extern void mt_set_bl_div(unsigned int div);
extern void mt_set_bl_frequency(unsigned int freq);
extern void mt_led_pwm_disable(int pwm_num);
extern int mt_brightness_set_pmic_duty_store(u32 level, u32 div);
extern void mt_backlight_set_pwm_duty(int pwm_num, u32 level, u32 div, struct PWM_config *config_data);
extern void mt_backlight_set_pwm_div(int pwm_num, u32 level, u32 div, struct PWM_config *config_data);
extern void mt_backlight_get_pwm_fsel(unsigned int bl_div, unsigned int *bl_frequency);
extern void mt_store_pwm_register(unsigned int addr, unsigned int value);
extern unsigned int mt_show_pwm_register(unsigned int addr);
extern int mt_led_set_pwm(int pwm_num, struct nled_setting* led);
extern int mt_led_blink_pmic(enum mt65xx_led_pmic pmic_type, struct nled_setting* led);
extern int mt_backlight_set_pwm(int pwm_num, u32 level, u32 div, struct PWM_config *config_data);
extern int mt_brightness_set_pmic(enum mt65xx_led_pmic pmic_type, u32 level, u32 div);
extern int mt_mt65xx_led_set_cust(struct cust_mt65xx_led *cust, int level);
extern void mt_mt65xx_led_work(struct work_struct *work);
extern void mt_mt65xx_led_set(struct led_classdev *led_cdev, enum led_brightness level);
extern int  mt_mt65xx_blink_set(struct led_classdev *led_cdev,
			     unsigned long *delay_on,
			     unsigned long *delay_off);

struct cust_mt65xx_led* mt_get_cust_led_list(void);


text:
import baseGet from './_baseGet.js';
import baseSet from './_baseSet.js';

/**
 * The base implementation of `_.update`.
 *
 * @private
 * @param {Object} object The object to modify.
 * @param {Array|string} path The path of the property to update.
 * @param {Function} updater The function to produce the updated value.
 * @param {Function} [customizer] The function to customize path creation.
 * @returns {Object} Returns `object`.
 */
function baseUpdate(object, path, updater, customizer) {
  return baseSet(object, path, updater(baseGet(object, path)), customizer);
}

export default baseUpdate;


text:
module Graphics.Efl.Widgets.Window (
   createWindow, Window(..), getWindowCanvas
) where

import Graphics.Efl.Widgets.Reactive
import qualified Graphics.Efl.Window as Peer
import qualified Graphics.Efl.Canvas as Peer

data Window = Window {
   windowPeer :: Peer.Window,
   windowSize :: Property (Int,Int),
   windowPosition :: Property (Int,Int),
   windowTitle :: Property String,
   windowVisible :: Property Bool,
   windowFocus :: Property Bool
}

createWindow :: Maybe String -> Int -> Int -> Int -> Int -> Maybe String -> IO Window
createWindow engine x y w h options = do
   peer <- Peer.createWindow engine x y w h options

   win <- Window peer
      <$> newProperty (`Peer.resizeWindow` peer) (Peer.getWindowSize peer)
      <*> newProperty (`Peer.moveWindow` peer) (Peer.getWindowPosition peer)
      <*> newProperty (`Peer.setWindowTitle` peer) (Peer.getWindowTitle peer)
      <*> newProperty (`Peer.setWindowVisible` peer) (Peer.getWindowVisible peer)
      <*> newProperty (`Peer.setWindowFocus` peer) (Peer.getWindowFocus peer)

   Peer.onWindowResize peer $ do
      triggerPropertyEvent (windowSize win)
      triggerPropertyEvent (windowPosition win)
   Peer.onWindowMove peer (triggerPropertyEvent (windowPosition win))
   Peer.onWindowHide peer (triggerPropertyEvent (windowVisible win))
   Peer.onWindowShow peer (triggerPropertyEvent (windowVisible win))
   Peer.onWindowFocusIn peer (triggerPropertyEvent (windowFocus win))
   Peer.onWindowFocusOut peer (triggerPropertyEvent (windowFocus win))

   return win

getWindowCanvas :: Window -> IO Peer.Canvas
getWindowCanvas = Peer.getWindowCanvas . windowPeer


text:
package org.elasticsearch.search.profile.aggregation;

import org.elasticsearch.common.io.stream.StreamInput;
import org.elasticsearch.common.io.stream.StreamOutput;
import org.elasticsearch.common.io.stream.Writeable;
import org.elasticsearch.common.xcontent.ToXContent;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.search.profile.ProfileResult;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * A container class to hold the profile results for a single shard in the request.
 * Contains a list of query profiles, a collector tree and a total rewrite tree.
 */
public final class AggregationProfileShardResult implements Writeable, ToXContent {

    private final List<ProfileResult> aggProfileResults;

    public AggregationProfileShardResult(List<ProfileResult> aggProfileResults) {
        this.aggProfileResults = aggProfileResults;
    }

    /**
     * Read from a stream.
     */
    public AggregationProfileShardResult(StreamInput in) throws IOException {
        int profileSize = in.readVInt();
        aggProfileResults = new ArrayList<>(profileSize);
        for (int j = 0; j < profileSize; j++) {
            aggProfileResults.add(new ProfileResult(in));
        }
    }

    @Override
    public void writeTo(StreamOutput out) throws IOException {
        out.writeVInt(aggProfileResults.size());
        for (ProfileResult p : aggProfileResults) {
            p.writeTo(out);
        }
    }

    public List<ProfileResult> getProfileResults() {
        return Collections.unmodifiableList(aggProfileResults);
    }

    @Override
    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
        builder.startArray("aggregations");
        for (ProfileResult p : aggProfileResults) {
            p.toXContent(builder, params);
        }
        builder.endArray();
        return builder;
    }
}


text:
#ifdef AWS_MULTI_FRAMEWORK
#import <AWSRuntime/AmazonServiceRequest.h>
#else
#import "AmazonServiceRequest.h"
#endif

#import "EC2Request.h"
#import "EC2ModifyReservedInstancesRequest.h"
#import "EC2ReservedInstancesConfiguration.h"
#import "EC2ReservedInstancesConfiguration.h"

/**
 * Modify Reserved Instances Request Marshaller
 */
@interface EC2ModifyReservedInstancesRequestMarshaller:NSObject {
}

+(AmazonServiceRequest *)createRequest:(EC2ModifyReservedInstancesRequest *)modifyReservedInstancesRequest;

@end


text:
package com.library.other;

import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.graphics.Color;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import com.litesuits.android.log.Log;

import java.util.ArrayList;

/**
 * @author MaTianyu
 * @date 2014-11-19
 */
public class NotificationUtil {
    private static int LedID = 0;
    private static final String TAG = NotificationUtil.class.getSimpleName();

    public static void notification(Context context, Uri uri,
                                    int icon, String ticker, String title, String msg) {
        Log.i(TAG, "notiry uri :" + uri);
        // 设置通知的事件消息
        Intent intent = new Intent();
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.DONUT) {
            intent.setPackage(context.getPackageName());
        }
        intent.setData(uri);
        notification(context, intent, 0, icon, ticker, title, msg);
    }

    public static void notification(Context context, String activityClass, Bundle bundle,
                                    int icon, String ticker, String title, String msg) {
        // 设置通知的事件消息
        Intent intent = new Intent();
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.DONUT) {
            intent.setPackage(context.getPackageName());
        }
        intent.putExtras(bundle);
        intent.setComponent(new ComponentName(context.getPackageName(), activityClass));
        notification(context, intent, 0, icon, ticker, title, msg);
    }

    public static void notification(Context context, Intent intent, int id,
                                    int icon, String ticker, String title, String msg) {
        PendingIntent pendingIntent = PendingIntent.getActivity(context, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT);
        notification(context, pendingIntent, id, icon, ticker, title, msg);
    }

    public static void notification(Context context, PendingIntent pendingIntent, int id,
                                    int icon, String ticker, String title, String msg) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
            Notification.Builder builder = new Notification.Builder(context);
            builder.setSmallIcon(icon);

            builder.setContentTitle(title);
            builder.setTicker(ticker);
            builder.setContentText(msg);

            builder.setDefaults(Notification.DEFAULT_SOUND);
            builder.setLights(0xFFFFFF00, 0, 2000);
            builder.setVibrate(new long[]{0, 100, 300});
            builder.setAutoCancel(true);
            builder.setContentIntent(pendingIntent);
            Notification baseNF;
            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN) {
                baseNF = builder.getNotification();
            } else {
                baseNF = builder.build();
            }
            //发出状态栏通知
            NotificationManager nm = (NotificationManager) context.getSystemService(context.NOTIFICATION_SERVICE);
            nm.notify(id, baseNF);
        } else {
            // 创建一个NotificationManager的引用
            NotificationManager notificationManager = (NotificationManager) context
                    .getSystemService(Context.NOTIFICATION_SERVICE);
            // 定义Notification的各种属性
            Notification notification = new Notification(icon, ticker, System.currentTimeMillis());
            notification.flags |= Notification.FLAG_ONGOING_EVENT | Notification.FLAG_SHOW_LIGHTS;
            notification.defaults = Notification.DEFAULT_ALL;
            notification.ledARGB = Color.GREEN;
            notification.ledOnMS = 5000; //闪光时间,毫秒

            notification.tickerText = ticker;
            //notification.setLatestEventInfo(context, title, msg, pendingIntent);
            // 把Notification传递给NotificationManager
            notificationManager.notify(id, notification);
        }
    }

    public static void lightLed(Context context, int colorOx, int durationMS) {
        lightLed(context, colorOx, 0, durationMS);
    }

    public static void lightLed(Context context, int colorOx, int startOffMS, int durationMS) {
        NotificationManager nm = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
        Notification notification = new Notification();
        notification.ledARGB = colorOx;
        notification.ledOffMS = startOffMS;
        notification.ledOnMS = durationMS;
        notification.flags = Notification.FLAG_SHOW_LIGHTS;
        LedID++;
        nm.notify(LedID, notification);
        nm.cancel(LedID);
    }

    public static void lightLed(final Context context, final int colorOx, final int startOffMS, final int durationMS,
                                int repeat) {
        if (repeat < 1) {
            repeat = 1;
        }
        Handler handler = new Handler(Looper.getMainLooper());
        for (int i = 0; i < repeat; i++) {
            handler.postDelayed(new Runnable() {
                @Override
                public void run() {
                    lightLed(context, colorOx, startOffMS, durationMS);
                }
            }, (startOffMS + durationMS) * i);
        }
    }

    public static void lightLed(Context context, ArrayList<LightPattern> patterns) {
        if (patterns == null) {
            return;
        }
        for (LightPattern lp : patterns) {
            lightLed(context, lp.argb, lp.startOffMS, lp.durationMS);
        }
    }

    public static class LightPattern {
        public int argb = 0;
        public int startOffMS = 0;
        public int durationMS = 0;

        public LightPattern(int argb, int startOffMS, int durationMS) {
            this.argb = argb;
            this.startOffMS = startOffMS;
            this.durationMS = durationMS;
        }
    }

}


text:
/**
 * Provides a set of "lightweight" (all-Java language) components
 * that, to the maximum degree possible, work the same on all platforms. For a
 * programmer's guide to using these components, see
 * Creating a GUI with JFC/Swing, a trail in
 * The Java Tutorial. For other resources, see
 * Related Documentation.
 *
 *
Swing's Threading Policy

 * In general Swing is not thread safe. All Swing components and related
 * classes, unless otherwise documented, must be accessed on the event
 * dispatching thread.
 *

 * Typical Swing applications do processing in response to an event generated
 * from a user gesture. For example, clicking on a {@code JButton} notifies all
 * {@code ActionListeners} added to the {@code JButton}. As all events generated
 * from a user gesture are dispatched on the event dispatching thread, most
 * developers are not impacted by the restriction.
 *

 * Where the impact lies, however, is in constructing and showing a Swing
 * application. Calls to an application's {@code main} method, or methods in
 * {@code Applet}, are not invoked on the event dispatching thread. As such,
 * care must be taken to transfer control to the event dispatching thread when
 * constructing and showing an application or applet. The preferred way to
 * transfer control and begin working with Swing is to use {@code invokeLater}.
 * The {@code invokeLater} method schedules a {@code Runnable} to be processed
 * on the event dispatching thread. The following two examples work equally well
 * for transferring control and starting up a Swing application:
 *

 * import javax.swing.SwingUtilities;
 *
 * public class MyApp implements Runnable {
 *     public void run() {
 *         // Invoked on the event dispatching thread.
 *         // Construct and show GUI.
 *     }
 *
 *     public static void main(String[] args) {
 *         SwingUtilities.invokeLater(new MyApp());
 *     }
 * }

 * Or:

 * import javax.swing.SwingUtilities;
 *
 * public class MyApp {
 *     MyApp(String[] args) {
 *         // Invoked on the event dispatching thread.
 *         // Do any initialization here.
 *     }
 *
 *     public void show() {
 *         // Show the UI.
 *     }
 *
 *     public static void main(final String[] args) {
 *         // Schedule a job for the event-dispatching thread:
 *         // creating and showing this application's GUI.
 *         SwingUtilities.invokeLater(new Runnable() {
 *             public void run() {
 *                 new MyApp(args).show();
 *             }
 *         });
 *     }
 * }

 * This restriction also applies to models attached to Swing components. For
 * example, if a {@code TableModel} is attached to a {@code JTable}, the
 * {@code TableModel} should only be modified on the event dispatching thread.
 * If you modify the model on a separate thread you run the risk of exceptions
 * and possible display corruption.
 *

 * Although it is generally safe to make updates to the UI immediately,
 * when executing on the event dispatch thread, there is an exception :
 * if a model listener tries to further change the UI before the UI has been
 * updated to reflect a pending change then the UI may render incorrectly.
 *
 * This can happen if an application installed listener needs to update the UI
 * in response to an event which will cause a change in the model structure.
 * It is important to first allow component installed listeners to process this
 * change, since there is no guarantee of the order in which listeners may be
 * called.
 *
 * The solution is for the application listener to make the change using
 * {@link javax.swing.SwingUtilities#invokeLater(Runnable)} so that any changes
 * to  UI rendering will be done post processing all the model listeners
 * installed by the component.
 *

 *

 *
 * As all events are delivered on the event dispatching thread, care must be
 * taken in event processing. In particular, a long running task, such as
 * network io or computational intensive processing, executed on the event
 * dispatching thread blocks the event dispatching thread from dispatching any
 * other events. While the event dispatching thread is blocked the application
 * is completely unresponsive to user input. Refer to
 * {@link javax.swing.SwingWorker} for the preferred way to do such processing
 * when working with Swing.
 *

 * More information on this topic can be found in the
 * Swing tutorial,
 * in particular the section on
 *
 * Concurrency in Swing.
 *
 *
Related Documentation

 * For overviews, tutorials, examples, guides, and other documentation,
 * please see:
 *

 *
The Swing Connection

 *
The Java Tutorial

 *
Online Training
 *     at the Java Developer Connection SM

 *
Java Foundation Classes (JFC) home page

 *

 *
 * @serial exclude
 */
package javax.swing;


text:
#ifndef EGGBACKPOINTER_H
#define EGGBACKPOINTER_H

#include "pandatoolbase.h"

#include "typedObject.h"

/**
 * This stores a pointer from an EggJointData or EggSliderData object back to
 * the referencing data in an egg file.  One of these objects corresponds to
 * each model appearing in an egg file, and may reference either a single
 * node, or a table, or a slew of vertices and primitives, depending on the
 * type of data stored.
 *
 * This is just an abstract base class.  The actual details are stored in the
 * various subclasses.
 */
class EggBackPointer : public TypedObject {
public:
  EggBackPointer();

  virtual double get_frame_rate() const;
  virtual int get_num_frames() const=0;
  virtual void extend_to(int num_frames);
  virtual bool has_vertices() const;

  virtual void set_name(const std::string &name);

public:
  static TypeHandle get_class_type() {
    return _type_handle;
  }
  static void init_type() {
    TypedObject::init_type();
    register_type(_type_handle, "EggBackPointer",
                  TypedObject::get_class_type());
  }
  virtual TypeHandle get_type() const {
    return get_class_type();
  }
  virtual TypeHandle force_init_type() {init_type(); return get_class_type();}

private:
  static TypeHandle _type_handle;
};

#endif


text:
package com.github.mq.consumer.models;

import com.github.mq.consumer.parms.ArgumentExtractors;
import com.github.mq.consumer.parms.WithArgumentExtractor;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Created by wangziqing on 17/7/17.
 */
@WithArgumentExtractor(ArgumentExtractors.FastJsonExtractor.class)
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.PARAMETER})
public @interface FastJson {
}


text:
/**
 * @fileOverview Defines the {@link CKFinder.lang} object, for the Slovak
 *		language. This is the base file for all translations.
*/

/**
 * Constains the dictionary of language entries.
 * @namespace
 */
CKFinder.lang['sk'] =
{
	appTitle : 'CKFinder', // MISSING

	// Common messages and labels.
	common :
	{
		// Put the voice-only part of the label in the span.
		unavailable		: '%1, unavailable', // MISSING
		confirmCancel	: 'Some of the options have been changed. Are you sure to close the dialog?', // MISSING
		ok				: 'OK', // MISSING
		cancel			: 'Cancel', // MISSING
		confirmationTitle	: 'Confirmation', // MISSING
		messageTitle	: 'Information', // MISSING
		inputTitle		: 'Question', // MISSING
		undo			: 'Undo', // MISSING
		redo			: 'Redo', // MISSING
		skip			: 'Skip', // MISSING
		skipAll			: 'Skip all', // MISSING
		makeDecision	: 'What action should be taken?', // MISSING
		rememberDecision: 'Remember my decision' // MISSING
	},

	dir : 'ltr', // MISSING
	HelpLang : 'en',
	LangCode : 'sk',

	// Date Format
	//		d    : Day
	//		dd   : Day (padding zero)
	//		m    : Month
	//		mm   : Month (padding zero)
	//		yy   : Year (two digits)
	//		yyyy : Year (four digits)
	//		h    : Hour (12 hour clock)
	//		hh   : Hour (12 hour clock, padding zero)
	//		H    : Hour (24 hour clock)
	//		HH   : Hour (24 hour clock, padding zero)
	//		M    : Minute
	//		MM   : Minute (padding zero)
	//		a    : Firt char of AM/PM
	//		aa   : AM/PM
	DateTime : 'mm/dd/yyyy HH:MM',
	DateAmPm : ['AM', 'PM'],

	// Folders
	FoldersTitle	: 'Adresáre',
	FolderLoading	: 'Nahrávam...',
	FolderNew		: 'Zadajte prosím meno nového adresára: ',
	FolderRename	: 'Zadajte prosím meno nového adresára: ',
	FolderDelete	: 'Skutočne zmazať adresár "%1" ?',
	FolderRenaming	: ' (Prebieha premenovanie adresára...)',
	FolderDeleting	: ' (Prebieha zmazanie adresára...)',

	// Files
	FileRename		: 'Zadajte prosím meno nového súboru: ',
	FileRenameExt	: 'Skutočne chcete zmeniť príponu súboru? Upozornenie: zmenou prípony sa súbor môže stať nepoužiteľným, pokiaľ prípona nie je podporovaná.',
	FileRenaming	: 'Prebieha premenovanie súboru...',
	FileDelete		: 'Skutočne chcete odstrániť súbor "%1"?',
	FilesLoading	: 'Loading...', // MISSING
	FilesEmpty		: 'Empty folder', // MISSING
	FilesMoved		: 'File %1 moved into %2:%3', // MISSING
	FilesCopied		: 'File %1 copied into %2:%3', // MISSING

	// Basket
	BasketFolder		: 'Basket', // MISSING
	BasketClear			: 'Clear Basket', // MISSING
	BasketRemove		: 'Remove from basket', // MISSING
	BasketOpenFolder	: 'Open parent folder', // MISSING
	BasketTruncateConfirm : 'Do you really want to remove all files from the basket?', // MISSING
	BasketRemoveConfirm	: 'Do you really want to remove the file "%1" from the basket?', // MISSING
	BasketEmpty			: 'No files in the basket, drag\'n\'drop some.', // MISSING
	BasketCopyFilesHere	: 'Copy Files from Basket', // MISSING
	BasketMoveFilesHere	: 'Move Files from Basket', // MISSING

	BasketPasteErrorOther	: 'File %s error: %e', // MISSING
	BasketPasteMoveSuccess	: 'The following files were moved: %s', // MISSING
	BasketPasteCopySuccess	: 'The following files were copied: %s', // MISSING

	// Toolbar Buttons (some used elsewhere)
	Upload		: 'Prekopírovať na server (Upload)',
	UploadTip	: 'Prekopírovať nový súbor',
	Refresh		: 'Znovunačítať (Refresh)',
	Settings	: 'Nastavenia',
	Help		: 'Pomoc',
	HelpTip		: 'Pomoc',

	// Context Menus
	Select			: 'Vybrať',
	SelectThumbnail : 'Select Thumbnail', // MISSING
	View			: 'Náhľad',
	Download		: 'Stiahnuť',

	NewSubFolder	: 'Nový podadresár',
	Rename			: 'Premenovať',
	Delete			: 'Zmazať',

	CopyDragDrop	: 'Copy file here', // MISSING
	MoveDragDrop	: 'Move file here', // MISSING

	// Dialogs
	RenameDlgTitle		: 'Rename', // MISSING
	NewNameDlgTitle		: 'New name', // MISSING
	FileExistsDlgTitle	: 'File already exists', // MISSING
	SysErrorDlgTitle : 'System error', // MISSING

	FileOverwrite	: 'Overwrite', // MISSING
	FileAutorename	: 'Auto-rename', // MISSING

	// Generic
	OkBtn		: 'OK',
	CancelBtn	: 'Zrušiť',
	CloseBtn	: 'Zatvoriť',

	// Upload Panel
	UploadTitle			: 'Nahrať nový súbor',
	UploadSelectLbl		: 'Vyberte súbor, ktorý chcete prekopírovať na server',
	UploadProgressLbl	: '(Prebieha kopírovanie, čakajte prosím...)',
	UploadBtn			: 'Prekopírovať vybratý súbor',
	UploadBtnCancel		: 'Cancel', // MISSING

	UploadNoFileMsg		: 'Vyberte prosím súbor na Vašom počítači!',
	UploadNoFolder		: 'Please select folder before uploading.', // MISSING
	UploadNoPerms		: 'File upload not allowed.', // MISSING
	UploadUnknError		: 'Error sending the file.', // MISSING
	UploadExtIncorrect	: 'File extension not allowed in this folder.', // MISSING

	// Settings Panel
	SetTitle		: 'Nastavenia',
	SetView			: 'Náhľad:',
	SetViewThumb	: 'Miniobrázky',
	SetViewList		: 'Zoznam',
	SetDisplay		: 'Zobraziť:',
	SetDisplayName	: 'Názov súboru',
	SetDisplayDate	: 'Dátum',
	SetDisplaySize	: 'Veľkosť súboru',
	SetSort			: 'Zoradenie:',
	SetSortName		: 'podľa názvu súboru',
	SetSortDate		: 'podľa dátumu',
	SetSortSize		: 'podľa veľkosti',

	// Status Bar
	FilesCountEmpty : '<Prázdny adresár>',
	FilesCountOne	: '1 súbor',
	FilesCountMany	: '%1 súborov',

	// Size and Speed
	Kb				: '%1 kB',
	KbPerSecond		: '%1 kB/s',

	// Connector Error Messages.
	ErrorUnknown	: 'Server nemohol dokončiť spracovanie požiadavky. (Chyba %1)',
	Errors :
	{
	 10 : 'Neplatný príkaz.',
	 11 : 'V požiadavke nebol špecifikovaný typ súboru.',
	 12 : 'Nepodporovaný typ súboru.',
	102 : 'Neplatný názov súboru alebo adresára.',
	103 : 'Nebolo možné dokončiť spracovanie požiadavky kvôli nepostačujúcej úrovni oprávnení.',
	104 : 'Nebolo možné dokončiť spracovanie požiadavky kvôli obmedzeniam v prístupových právach ku súborom.',
	105 : 'Neplatná prípona súboru.',
	109 : 'Neplatná požiadavka.',
	110 : 'Neidentifikovaná chyba.',
	115 : 'Zadaný súbor alebo adresár už existuje.',
	116 : 'Adresár nebol nájdený. Aktualizujte obsah adresára (Znovunačítať) a skúste znovu.',
	117 : 'Súbor nebol nájdený. Aktualizujte obsah adresára (Znovunačítať) a skúste znovu.',
	118 : 'Source and target paths are equal.', // MISSING
	201 : 'Súbor so zadaným názvom už existuje. Prekopírovaný súbor bol premenovaný na "%1"',
	202 : 'Neplatný súbor',
	203 : 'Neplatný súbor - súbor presahuje maximálnu povolenú veľkosť.',
	204 : 'Kopírovaný súbor je poškodený.',
	205 : 'Server nemá špecifikovaný dočasný adresár pre kopírované súbory.',
	206 : 'Kopírovanie prerušené kvôli nedostatočnému zabezpečeniu. Súbor obsahuje HTML data.',
	207 : 'Prekopírovaný súbor bol premenovaný na "%1"',
	300 : 'Moving file(s) failed.', // MISSING
	301 : 'Copying file(s) failed.', // MISSING
	500 : 'Prehliadanie súborov je zakázané kvôli bezpečnosti. Kontaktujte prosím administrátora a overte nastavenia v konfiguračnom súbore pre CKFinder.',
	501 : 'Momentálne nie je zapnutá podpora pre generáciu miniobrázkov.'
	},

	// Other Error Messages.
	ErrorMsg :
	{
		FileEmpty		: 'Názov súbor nesmie prázdny',
		FileExists		: 'File %s already exists', // MISSING
		FolderEmpty		: 'Názov adresára nesmie byť prázdny',

		FileInvChar		: 'Súbor nesmie obsahovať žiadny z nasledujúcich znakov: \n\\ / : * ? " < > |',
		FolderInvChar	: 'Adresár nesmie obsahovať žiadny z nasledujúcich znakov: \n\\ / : * ? " < > |',

		PopupBlockView	: 'Nebolo možné otvoriť súbor v novom okne. Overte nastavenia Vášho prehliadača a zakážte všetky blokovače popup okien pre túto webstránku.'
	},

	// Imageresize plugin
	Imageresize :
	{
		dialogTitle		: 'Resize %s', // MISSING
		sizeTooBig		: 'Cannot set image height or width to a value bigger than the original size (%size).', // MISSING
		resizeSuccess	: 'Image resized successfully.', // MISSING
		thumbnailNew	: 'Create new thumbnail', // MISSING
		thumbnailSmall	: 'Small (%s)', // MISSING
		thumbnailMedium	: 'Medium (%s)', // MISSING
		thumbnailLarge	: 'Large (%s)', // MISSING
		newSize			: 'Set new size', // MISSING
		width			: 'Width', // MISSING
		height			: 'Height', // MISSING
		invalidHeight	: 'Invalid height.', // MISSING
		invalidWidth	: 'Invalid width.', // MISSING
		invalidName		: 'Invalid file name.', // MISSING
		newImage		: 'Create new image', // MISSING
		noExtensionChange : 'The file extension cannot be changed.', // MISSING
		imageSmall		: 'Source image is too small', // MISSING
		contextMenuName	: 'Resize' // MISSING
	},

	// Fileeditor plugin
	Fileeditor :
	{
		save			: 'Save', // MISSING
		fileOpenError	: 'Unable to open file.', // MISSING
		fileSaveSuccess	: 'File saved successfully.', // MISSING
		contextMenuName	: 'Edit', // MISSING
		loadingFile		: 'Loading file, please wait...' // MISSING
	}
};


text:
local _princess = ...
local core = _princess.core

function string.startsWith(str, prefix)
    local lpre = #prefix
    if str:sub(1, lpre) == prefix then
        return true, str:sub(lpre + 1, #str)
    else
        return false
    end
end

function string.endsWith(str, suffix)
    local lstr, lsuf = #str, #suffix
    if str:sub(lstr - lsuf + 1, lstr) == suffix then
        return true, str:sub(1, lstr - lsuf)
    else
        return false
    end
end

string.trim = core.trimString
string.split = core.splitString


text:
require 'puppet'
require 'fileutils'
require 'tempfile'

SEPARATOR = [Regexp.escape(File::SEPARATOR.to_s), Regexp.escape(File::ALT_SEPARATOR.to_s)].join

Puppet::Reports.register_report(:store) do
  desc "Store the yaml report on disk.  Each host sends its report as a YAML dump
    and this just stores the file on disk, in the `reportdir` directory.

    These files collect quickly -- one every half hour -- so it is a good idea
    to perform some maintenance on them if you use this report (it's the only
    default report)."

  def process
    validate_host(host)

    dir = File.join(Puppet[:reportdir], host)

    if ! FileTest.exists?(dir)
      FileUtils.mkdir_p(dir)
      FileUtils.chmod_R(0750, dir)
    end

    # Now store the report.
    now = Time.now.gmtime
    name = %w{year month day hour min}.collect do |method|
      # Make sure we're at least two digits everywhere
      "%02d" % now.send(method).to_s
    end.join("") + ".yaml"

    file = File.join(dir, name)

    f = Tempfile.new(name, dir)
    begin
      begin
        f.chmod(0640)
        f.print to_yaml
      ensure
        f.close
      end
      FileUtils.mv(f.path, file)
    rescue => detail
      Puppet.log_exception(detail, "Could not write report for #{host} at #{file}: #{detail}")
    end

    # Only testing cares about the return value
    file
  end

  # removes all reports for a given host?
  def self.destroy(host)
    validate_host(host)

    dir = File.join(Puppet[:reportdir], host)

    if File.exists?(dir)
      Dir.entries(dir).each do |file|
        next if ['.','..'].include?(file)
        file = File.join(dir, file)
        File.unlink(file) if File.file?(file)
      end
      Dir.rmdir(dir)
    end
  end

  def validate_host(host)
    if host =~ Regexp.union(/[#{SEPARATOR}]/, /\A\.\.?\Z/)
      raise ArgumentError, "Invalid node name #{host.inspect}"
    end
  end
  module_function :validate_host
end


text:
package com.cjburkey.monopoly.util;

import java.util.Calendar;

public class Logger {

	private String format;
	private String owner;

	public Logger(String owner) { this.owner = owner; }
	public Logger(String owner, String format) {
		this.format = format;
		this.owner = owner;
	}

	public void lineBreak() { System.out.println(); }

	public void log(String msg) {
		log(msg, false);
	}

	public void log(String msg, boolean error) {
		String out = "[" + owner + "] " + format.replaceAll("%second%", Calendar.getInstance().get(Calendar.SECOND) + "")
				.replaceAll("%minute%", Calendar.getInstance().get(Calendar.MINUTE) + "")
				.replaceAll("%hour%", Calendar.getInstance().get(Calendar.HOUR) + "")
				.replaceAll("%msg%", msg);
		if(error) System.err.println(out); else System.out.println(out);
	}

}


text:
<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8">
    <title></title>
    <script>
      var sendMessage = `require('electron').ipcRenderer.send('answer', 'extension loaded')`
      window.chrome.devtools.inspectedWindow.eval(sendMessage, function () {})
    </script>
  </head>
  <body>
    a custom devtools extension
  </body>
</html>


text:
function summarize(object)

for n=1:numel(object.Group)
    name=object.Group(n).Label;
    if ischar(name)
        name={name};
    end
    fprintf('%s\n',name{:});
    disp(object.Group(n).Table);
end

end


text:
using namespace BeatBuilder::Audio;
using namespace std;
using namespace Windows::Foundation;
using namespace Windows::Foundation::Diagnostics;
using namespace Windows::System::Threading;
using namespace Platform;

Metronome::Metronome(int tempo, TickResolution tickResolution)
	: m_tickInMs(0)
{
	double beatsPerSecond = tempo / 60.0;
	int millisecondsPerBeat = (int) (1000 / beatsPerSecond);
	m_tickInMs = millisecondsPerBeat / static_cast<int>(tickResolution);
}

Metronome::~Metronome(void)
{
}

void Metronome::AddTickListener(TickHandler^ callback)
{
	m_tickHandlers.push_back(callback);
}

void Metronome::Start()
{
	TimeSpan span;
	span.Duration = m_tickInMs * 10000;

	m_timer = ThreadPoolTimer::CreatePeriodicTimer(ref new TimerElapsedHandler([this](ThreadPoolTimer^ timer) {
		HRESULT hr = Windows::Foundation::Initialize(RO_INIT_MULTITHREADED);
		if (SUCCEEDED(hr))
		{
			for (auto it = this->m_tickHandlers.begin(); it != this->m_tickHandlers.end(); ++it)
			{
				(*it)();
			}
		}
	}), span);
}

void Metronome::Stop()
{
	m_timer->Cancel();
}


text:
package pebbler.pdfgen.graphics;

import pebbler.constants.GoColor;

// TODO: Finish this class
public class Triangle implements Graphic {

  private int x;
  private int y;
  private GoColor color;

  public Triangle(int x, int y, GoColor color) {
    this.x = x;
    this.y = y;
    this.color = color;
  }

  // TODO: Add this
  public StringBuilder streamOut() {
    return new StringBuilder();
  }
}


text:
// Copyright 2022 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

/**
 * TargetedSize.java
 *
 * This file was auto-generated from WSDL
 * by the Apache Axis 1.4 Mar 02, 2009 (07:08:06 PST) WSDL2Java emitter.
 */

package com.google.api.ads.admanager.axis.v202208;

public class TargetedSize  implements java.io.Serializable {
    private com.google.api.ads.admanager.axis.v202208.Size size;

    public TargetedSize() {
    }

    public TargetedSize(
           com.google.api.ads.admanager.axis.v202208.Size size) {
           this.size = size;
    }

    @Override
    public String toString() {
        return com.google.common.base.MoreObjects.toStringHelper(this.getClass())
            .omitNullValues()
            .add("size", getSize())
            .toString();
    }

    /**
     * Gets the size value for this TargetedSize.
     *
     * @return size
     */
    public com.google.api.ads.admanager.axis.v202208.Size getSize() {
        return size;
    }

    /**
     * Sets the size value for this TargetedSize.
     *
     * @param size
     */
    public void setSize(com.google.api.ads.admanager.axis.v202208.Size size) {
        this.size = size;
    }

    private java.lang.Object __equalsCalc = null;
    public synchronized boolean equals(java.lang.Object obj) {
        if (!(obj instanceof TargetedSize)) return false;
        TargetedSize other = (TargetedSize) obj;
        if (obj == null) return false;
        if (this == obj) return true;
        if (__equalsCalc != null) {
            return (__equalsCalc == obj);
        }
        __equalsCalc = obj;
        boolean _equals;
        _equals = true &&
            ((this.size==null && other.getSize()==null) ||
             (this.size!=null &&
              this.size.equals(other.getSize())));
        __equalsCalc = null;
        return _equals;
    }

    private boolean __hashCodeCalc = false;
    public synchronized int hashCode() {
        if (__hashCodeCalc) {
            return 0;
        }
        __hashCodeCalc = true;
        int _hashCode = 1;
        if (getSize() != null) {
            _hashCode += getSize().hashCode();
        }
        __hashCodeCalc = false;
        return _hashCode;
    }

    // Type metadata
    private static org.apache.axis.description.TypeDesc typeDesc =
        new org.apache.axis.description.TypeDesc(TargetedSize.class, true);

    static {
        typeDesc.setXmlType(new javax.xml.namespace.QName("https://www.google.com/apis/ads/publisher/v202208", "TargetedSize"));
        org.apache.axis.description.ElementDesc elemField = new org.apache.axis.description.ElementDesc();
        elemField.setFieldName("size");
        elemField.setXmlName(new javax.xml.namespace.QName("https://www.google.com/apis/ads/publisher/v202208", "size"));
        elemField.setXmlType(new javax.xml.namespace.QName("https://www.google.com/apis/ads/publisher/v202208", "Size"));
        elemField.setMinOccurs(0);
        elemField.setNillable(false);
        typeDesc.addFieldDesc(elemField);
    }

    /**
     * Return type metadata object
     */
    public static org.apache.axis.description.TypeDesc getTypeDesc() {
        return typeDesc;
    }

    /**
     * Get Custom Serializer
     */
    public static org.apache.axis.encoding.Serializer getSerializer(
           java.lang.String mechType,
           java.lang.Class _javaType,
           javax.xml.namespace.QName _xmlType) {
        return
          new  org.apache.axis.encoding.ser.BeanSerializer(
            _javaType, _xmlType, typeDesc);
    }

    /**
     * Get Custom Deserializer
     */
    public static org.apache.axis.encoding.Deserializer getDeserializer(
           java.lang.String mechType,
           java.lang.Class _javaType,
           javax.xml.namespace.QName _xmlType) {
        return
          new  org.apache.axis.encoding.ser.BeanDeserializer(
            _javaType, _xmlType, typeDesc);
    }

}


text:
package com.freetymekiyan.algorithms.level.medium;

/**
 * 75. Sort Colors
 *

 * Given an array with n objects colored red, white or blue, sort them so that objects of the same color are adjacent,
 * with the colors in the order red, white and blue.
 *

 * Here, we will use the integers 0, 1, and 2 to represent the color red, white, and blue respectively.
 *

 * Note:
 * You are not suppose to use the library's sort function for this problem.
 *

 * Follow up:
 * A rather straight forward solution is a two-pass algorithm using counting sort.
 * First, iterate the array counting number of 0's, 1's, and 2's, then overwrite array with total number of 0's, then
 * 1's and followed by 2's.
 *

 * Could you come up with an one-pass algorithm using only constant space?
 *

 * Company Tags: Pocket Gems, Microsoft, Facebook
 * Tags: Array, Two Pointers, Sort
 * Similar Problems: (M) Sort List, (M) Wiggle Sort, (M) Wiggle Sort II
 */
public class SortColors {

  private static final int RED = 0;
  private static final int WHITE = 1;
  private static final int BLUE = 2;

  /**
   * Two pointers. One-pass.
   * Similar to find minimum and second minimum.
   * Remember the count of red, and count of red + white.
   * Loop through the array.
   * For each color, we get its value, and overwrite it with blue.
   * Then check if it's red,
   * Note:
   * Why do we update WHITE first?
   * Since whiteEnd and redEnd can be at the same position.
   * what ought to be RED can be overrode by WHITE.
   */
  public void sortColors(int[] nums) {
    int redEnd = -1; // Ending index of red
    int whiteEnd = -1; // Ending index of white

    for (int i = 0; i < nums.length; i++) {
      int v = nums[i];
      nums[i] = BLUE;
      if (v == RED) {
        nums[++whiteEnd] = WHITE; // Update white first
        nums[++redEnd] = RED; // If there is no white yet, will overwrite white.
      } else if (v == WHITE) {
        nums[++whiteEnd] = WHITE;
      }
    }
  }

  /**
   * 3-way Partitioning. Two pointers. One-pass.
   * One pointer redEnd for the end of red.
   * The other blueStart for the start of blue from the end.
   * If its blue, swap with the end.
   * If its red, swap with the start.
   * All whites will remain in the middle.
   *

   * Implementation:
   * redEnd = 0, blueStart = n-1
   * For each i from 0 to blueStart:
   * | While nums[i] is blue and i < blueStart:
   * |   Swap i with blueStart.
   * |   Update blueStart to blueStart - 1.
   * | While nums[i] is red and i > redEnd:
   * |   Swap i with redEnd.
   * |   Update redEnd to redEnd + 1.
   * Note:
   * Why swap BLUE first not RED? If swap RED first what would happen?
   * If we swap RED first, when we swap with BLUE, the element resulting at i can be 0, 1, 2, anything.
   * We must take care of 0's further.
   * If we swap with BLUE first, 0's are taken care of when we swap with RED later.
   * The elements before i are already in order, so they are either 0 or 1. There won't be a 2 to further swap.
   */
  public void sortColors2(int nums[]) {
    int redEnd = 0, blueStart = nums.length - 1;
    for (int i = 0; i <= blueStart; i++) {
      while (nums[i] == BLUE && i < blueStart) { // Move all BLUEs to the end.
        swap(nums, i, blueStart--);
      }
      while (nums[i] == RED && i > redEnd) { // Move all REDs to the front.
        swap(nums, i, redEnd++);
      }
    }
  }

  /**
   * 3-way partitioning. Standard.
   * Move red to the front, blue to the end. Keep white in the middle.
   * One pointer to the end of red, redEnd, starting from 0.
   * Another pointer to the start of blue, blueStart, starting from n-1, go backwards.
   * For i = 0 to blueStart:
   * | If nums[i] is RED:
   * |   Swap nums[i] with nums[redEnd].
   * |   Move redEnd.
   * |   Can move i too because the color swapped to i won't be red or blue.
   * | If nums[i] is BLUE:
   * |   Swap nums[i] with nums[blueStart].
   * |   Move blueStart.
   * |   No need to move i since the color swapped to i can be blue or red.
   * | If nums[i] is WHITE:
   * |   i++, just skip.
   */
  public void sortColors3(int[] nums) {
    int redEnd = 0;
    int blueStart = nums.length - 1;
    int i = 0;
    while (i <= blueStart) { // i stops at blueStart, no blueStart - 1.
      if (nums[i] == RED) {
        swap(nums, i++, redEnd++);
      } else if (nums[i] == BLUE) {
        swap(nums, i, blueStart--);
      } else {
        i++;
      }
    }
  }

  private void swap(int[] nums, int i1, int i2) {
    int temp = nums[i1];
    nums[i1] = nums[i2];
    nums[i2] = temp;
  }

  /**
   * Counting sort. Two-pass.
   * First iterate through the array to find each color's count.
   * Then iterate again and write colors to array.
   */
  public void sortColors4(int[] nums) {
    int red = 0;
    int white = 0;

    for (int i = 0; i < nums.length; i++) {
      if (nums[i] == RED) {
        red++;
      } else if (nums[i] == WHITE) {
        white++;
      }
    }
    for (int i = 0; i < nums.length; i++) {
      if (i < red) {
        nums[i] = RED;
      } else if (i < red + white) {
        nums[i] = WHITE;
      } else {
        nums[i] = BLUE;
      }
    }
  }
}