hercules/internal/pb/pb.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: pb.proto

/*
Package pb is a generated protocol buffer package.

It is generated from these files:
	pb.proto

It has these top-level messages:
	Metadata
	BurndownSparseMatrixRow
	BurndownSparseMatrix
	BurndownAnalysisResults
	CompressedSparseRowMatrix
	Couples
	TouchedFiles
	CouplesAnalysisResults
	UASTChange
	UASTChangesSaverResults
	ShotnessRecord
	ShotnessAnalysisResults
	FileHistory
	FileHistoryResultMessage
	LineStats
	DevDay
	DayDevs
	DevsAnalysisResults
	Sentiment
	CommentSentimentResults
	AnalysisResults
*/
package pb

import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import 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.GoGoProtoPackageIsVersion2 // please upgrade the proto package

type Metadata struct {
	// this format is versioned
	Version int32 `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
	// git hash of the revision from which Hercules is built
	Hash string `protobuf:"bytes,2,opt,name=hash,proto3" json:"hash,omitempty"`
	// repository's name
	Repository string `protobuf:"bytes,3,opt,name=repository,proto3" json:"repository,omitempty"`
	// UNIX timestamp of the first analysed commit
	BeginUnixTime int64 `protobuf:"varint,4,opt,name=begin_unix_time,json=beginUnixTime,proto3" json:"begin_unix_time,omitempty"`
	// UNIX timestamp of the last analysed commit
	EndUnixTime int64 `protobuf:"varint,5,opt,name=end_unix_time,json=endUnixTime,proto3" json:"end_unix_time,omitempty"`
	// number of processed commits
	Commits int32 `protobuf:"varint,6,opt,name=commits,proto3" json:"commits,omitempty"`
	// duration of the analysis in milliseconds
	RunTime int64 `protobuf:"varint,7,opt,name=run_time,json=runTime,proto3" json:"run_time,omitempty"`
	// time taken by each pipeline item in seconds
	RunTimePerItem map[string]float64 `protobuf:"bytes,8,rep,name=run_time_per_item,json=runTimePerItem" json:"run_time_per_item,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"`
}

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

func (m *Metadata) GetVersion() int32 {
	if m != nil {
		return m.Version
	}
	return 0
}

func (m *Metadata) GetHash() string {
	if m != nil {
		return m.Hash
	}
	return ""
}

func (m *Metadata) GetRepository() string {
	if m != nil {
		return m.Repository
	}
	return ""
}

func (m *Metadata) GetBeginUnixTime() int64 {
	if m != nil {
		return m.BeginUnixTime
	}
	return 0
}

func (m *Metadata) GetEndUnixTime() int64 {
	if m != nil {
		return m.EndUnixTime
	}
	return 0
}

func (m *Metadata) GetCommits() int32 {
	if m != nil {
		return m.Commits
	}
	return 0
}

func (m *Metadata) GetRunTime() int64 {
	if m != nil {
		return m.RunTime
	}
	return 0
}

func (m *Metadata) GetRunTimePerItem() map[string]float64 {
	if m != nil {
		return m.RunTimePerItem
	}
	return nil
}

type BurndownSparseMatrixRow struct {
	// the first `len(column)` elements are stored,
	// the rest `number_of_columns - len(column)` values are zeros
	Columns []uint32 `protobuf:"varint,1,rep,packed,name=columns" json:"columns,omitempty"`
}

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

func (m *BurndownSparseMatrixRow) GetColumns() []uint32 {
	if m != nil {
		return m.Columns
	}
	return nil
}

type BurndownSparseMatrix struct {
	Name            string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	NumberOfRows    int32  `protobuf:"varint,2,opt,name=number_of_rows,json=numberOfRows,proto3" json:"number_of_rows,omitempty"`
	NumberOfColumns int32  `protobuf:"varint,3,opt,name=number_of_columns,json=numberOfColumns,proto3" json:"number_of_columns,omitempty"`
	// `len(row)` matches `number_of_rows`
	Rows []*BurndownSparseMatrixRow `protobuf:"bytes,4,rep,name=rows" json:"rows,omitempty"`
}

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

func (m *BurndownSparseMatrix) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *BurndownSparseMatrix) GetNumberOfRows() int32 {
	if m != nil {
		return m.NumberOfRows
	}
	return 0
}

func (m *BurndownSparseMatrix) GetNumberOfColumns() int32 {
	if m != nil {
		return m.NumberOfColumns
	}
	return 0
}

func (m *BurndownSparseMatrix) GetRows() []*BurndownSparseMatrixRow {
	if m != nil {
		return m.Rows
	}
	return nil
}

type BurndownAnalysisResults struct {
	// how many days are in each band [burndown_project, burndown_file, burndown_developer]
	Granularity int32 `protobuf:"varint,1,opt,name=granularity,proto3" json:"granularity,omitempty"`
	// how frequently we measure the state of each band [burndown_project, burndown_file, burndown_developer]
	Sampling int32 `protobuf:"varint,2,opt,name=sampling,proto3" json:"sampling,omitempty"`
	// always exists
	Project *BurndownSparseMatrix `protobuf:"bytes,3,opt,name=project" json:"project,omitempty"`
	// this is included if `-burndown-files` was specified
	Files []*BurndownSparseMatrix `protobuf:"bytes,4,rep,name=files" json:"files,omitempty"`
	// these two are included if `-burndown-people` was specified
	People []*BurndownSparseMatrix `protobuf:"bytes,5,rep,name=people" json:"people,omitempty"`
	// rows and cols order correspond to `burndown_developer`
	PeopleInteraction *CompressedSparseRowMatrix `protobuf:"bytes,6,opt,name=people_interaction,json=peopleInteraction" json:"people_interaction,omitempty"`
}

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

func (m *BurndownAnalysisResults) GetGranularity() int32 {
	if m != nil {
		return m.Granularity
	}
	return 0
}

func (m *BurndownAnalysisResults) GetSampling() int32 {
	if m != nil {
		return m.Sampling
	}
	return 0
}

func (m *BurndownAnalysisResults) GetProject() *BurndownSparseMatrix {
	if m != nil {
		return m.Project
	}
	return nil
}

func (m *BurndownAnalysisResults) GetFiles() []*BurndownSparseMatrix {
	if m != nil {
		return m.Files
	}
	return nil
}

func (m *BurndownAnalysisResults) GetPeople() []*BurndownSparseMatrix {
	if m != nil {
		return m.People
	}
	return nil
}

func (m *BurndownAnalysisResults) GetPeopleInteraction() *CompressedSparseRowMatrix {
	if m != nil {
		return m.PeopleInteraction
	}
	return nil
}

type CompressedSparseRowMatrix struct {
	NumberOfRows    int32 `protobuf:"varint,1,opt,name=number_of_rows,json=numberOfRows,proto3" json:"number_of_rows,omitempty"`
	NumberOfColumns int32 `protobuf:"varint,2,opt,name=number_of_columns,json=numberOfColumns,proto3" json:"number_of_columns,omitempty"`
	// https://en.wikipedia.org/wiki/Sparse_matrix#Compressed_sparse_row_.28CSR.2C_CRS_or_Yale_format.29
	Data    []int64 `protobuf:"varint,3,rep,packed,name=data" json:"data,omitempty"`
	Indices []int32 `protobuf:"varint,4,rep,packed,name=indices" json:"indices,omitempty"`
	Indptr  []int64 `protobuf:"varint,5,rep,packed,name=indptr" json:"indptr,omitempty"`
}

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

func (m *CompressedSparseRowMatrix) GetNumberOfRows() int32 {
	if m != nil {
		return m.NumberOfRows
	}
	return 0
}

func (m *CompressedSparseRowMatrix) GetNumberOfColumns() int32 {
	if m != nil {
		return m.NumberOfColumns
	}
	return 0
}

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

func (m *CompressedSparseRowMatrix) GetIndices() []int32 {
	if m != nil {
		return m.Indices
	}
	return nil
}

func (m *CompressedSparseRowMatrix) GetIndptr() []int64 {
	if m != nil {
		return m.Indptr
	}
	return nil
}

type Couples struct {
	// name of each `matrix`'s row and column
	Index []string `protobuf:"bytes,1,rep,name=index" json:"index,omitempty"`
	// is always square
	Matrix *CompressedSparseRowMatrix `protobuf:"bytes,2,opt,name=matrix" json:"matrix,omitempty"`
}

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

func (m *Couples) GetIndex() []string {
	if m != nil {
		return m.Index
	}
	return nil
}

func (m *Couples) GetMatrix() *CompressedSparseRowMatrix {
	if m != nil {
		return m.Matrix
	}
	return nil
}

type TouchedFiles struct {
	Files []int32 `protobuf:"varint,1,rep,packed,name=files" json:"files,omitempty"`
}

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

func (m *TouchedFiles) GetFiles() []int32 {
	if m != nil {
		return m.Files
	}
	return nil
}

type CouplesAnalysisResults struct {
	FileCouples   *Couples `protobuf:"bytes,6,opt,name=file_couples,json=fileCouples" json:"file_couples,omitempty"`
	PeopleCouples *Couples `protobuf:"bytes,7,opt,name=people_couples,json=peopleCouples" json:"people_couples,omitempty"`
	// order corresponds to `people_couples::index`
	PeopleFiles []*TouchedFiles `protobuf:"bytes,8,rep,name=people_files,json=peopleFiles" json:"people_files,omitempty"`
}

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

func (m *CouplesAnalysisResults) GetFileCouples() *Couples {
	if m != nil {
		return m.FileCouples
	}
	return nil
}

func (m *CouplesAnalysisResults) GetPeopleCouples() *Couples {
	if m != nil {
		return m.PeopleCouples
	}
	return nil
}

func (m *CouplesAnalysisResults) GetPeopleFiles() []*TouchedFiles {
	if m != nil {
		return m.PeopleFiles
	}
	return nil
}

type UASTChange struct {
	FileName   string `protobuf:"bytes,1,opt,name=file_name,json=fileName,proto3" json:"file_name,omitempty"`
	SrcBefore  string `protobuf:"bytes,2,opt,name=src_before,json=srcBefore,proto3" json:"src_before,omitempty"`
	SrcAfter   string `protobuf:"bytes,3,opt,name=src_after,json=srcAfter,proto3" json:"src_after,omitempty"`
	UastBefore string `protobuf:"bytes,4,opt,name=uast_before,json=uastBefore,proto3" json:"uast_before,omitempty"`
	UastAfter  string `protobuf:"bytes,5,opt,name=uast_after,json=uastAfter,proto3" json:"uast_after,omitempty"`
}

func (m *UASTChange) Reset()                    { *m = UASTChange{} }
func (m *UASTChange) String() string            { return proto.CompactTextString(m) }
func (*UASTChange) ProtoMessage()               {}
func (*UASTChange) Descriptor() ([]byte, []int) { return fileDescriptorPb, []int{8} }

func (m *UASTChange) GetFileName() string {
	if m != nil {
		return m.FileName
	}
	return ""
}

func (m *UASTChange) GetSrcBefore() string {
	if m != nil {
		return m.SrcBefore
	}
	return ""
}

func (m *UASTChange) GetSrcAfter() string {
	if m != nil {
		return m.SrcAfter
	}
	return ""
}

func (m *UASTChange) GetUastBefore() string {
	if m != nil {
		return m.UastBefore
	}
	return ""
}

func (m *UASTChange) GetUastAfter() string {
	if m != nil {
		return m.UastAfter
	}
	return ""
}

type UASTChangesSaverResults struct {
	Changes []*UASTChange `protobuf:"bytes,1,rep,name=changes" json:"changes,omitempty"`
}

func (m *UASTChangesSaverResults) Reset()                    { *m = UASTChangesSaverResults{} }
func (m *UASTChangesSaverResults) String() string            { return proto.CompactTextString(m) }
func (*UASTChangesSaverResults) ProtoMessage()               {}
func (*UASTChangesSaverResults) Descriptor() ([]byte, []int) { return fileDescriptorPb, []int{9} }

func (m *UASTChangesSaverResults) GetChanges() []*UASTChange {
	if m != nil {
		return m.Changes
	}
	return nil
}

type ShotnessRecord struct {
	Type     string          `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
	Name     string          `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	File     string          `protobuf:"bytes,3,opt,name=file,proto3" json:"file,omitempty"`
	Counters map[int32]int32 `protobuf:"bytes,4,rep,name=counters" json:"counters,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
}

func (m *ShotnessRecord) Reset()                    { *m = ShotnessRecord{} }
func (m *ShotnessRecord) String() string            { return proto.CompactTextString(m) }
func (*ShotnessRecord) ProtoMessage()               {}
func (*ShotnessRecord) Descriptor() ([]byte, []int) { return fileDescriptorPb, []int{10} }

func (m *ShotnessRecord) GetType() string {
	if m != nil {
		return m.Type
	}
	return ""
}

func (m *ShotnessRecord) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *ShotnessRecord) GetFile() string {
	if m != nil {
		return m.File
	}
	return ""
}

func (m *ShotnessRecord) GetCounters() map[int32]int32 {
	if m != nil {
		return m.Counters
	}
	return nil
}

type ShotnessAnalysisResults struct {
	Records []*ShotnessRecord `protobuf:"bytes,1,rep,name=records" json:"records,omitempty"`
}

func (m *ShotnessAnalysisResults) Reset()                    { *m = ShotnessAnalysisResults{} }
func (m *ShotnessAnalysisResults) String() string            { return proto.CompactTextString(m) }
func (*ShotnessAnalysisResults) ProtoMessage()               {}
func (*ShotnessAnalysisResults) Descriptor() ([]byte, []int) { return fileDescriptorPb, []int{11} }

func (m *ShotnessAnalysisResults) GetRecords() []*ShotnessRecord {
	if m != nil {
		return m.Records
	}
	return nil
}

type FileHistory struct {
	Commits []string `protobuf:"bytes,1,rep,name=commits" json:"commits,omitempty"`
}

func (m *FileHistory) Reset()                    { *m = FileHistory{} }
func (m *FileHistory) String() string            { return proto.CompactTextString(m) }
func (*FileHistory) ProtoMessage()               {}
func (*FileHistory) Descriptor() ([]byte, []int) { return fileDescriptorPb, []int{12} }

func (m *FileHistory) GetCommits() []string {
	if m != nil {
		return m.Commits
	}
	return nil
}

type FileHistoryResultMessage struct {
	Files map[string]*FileHistory `protobuf:"bytes,1,rep,name=files" json:"files,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"`
}

func (m *FileHistoryResultMessage) Reset()                    { *m = FileHistoryResultMessage{} }
func (m *FileHistoryResultMessage) String() string            { return proto.CompactTextString(m) }
func (*FileHistoryResultMessage) ProtoMessage()               {}
func (*FileHistoryResultMessage) Descriptor() ([]byte, []int) { return fileDescriptorPb, []int{13} }

func (m *FileHistoryResultMessage) GetFiles() map[string]*FileHistory {
	if m != nil {
		return m.Files
	}
	return nil
}

type LineStats struct {
	Added   int32 `protobuf:"varint,1,opt,name=added,proto3" json:"added,omitempty"`
	Removed int32 `protobuf:"varint,2,opt,name=removed,proto3" json:"removed,omitempty"`
	Changed int32 `protobuf:"varint,3,opt,name=changed,proto3" json:"changed,omitempty"`
}

func (m *LineStats) Reset()                    { *m = LineStats{} }
func (m *LineStats) String() string            { return proto.CompactTextString(m) }
func (*LineStats) ProtoMessage()               {}
func (*LineStats) Descriptor() ([]byte, []int) { return fileDescriptorPb, []int{14} }

func (m *LineStats) GetAdded() int32 {
	if m != nil {
		return m.Added
	}
	return 0
}

func (m *LineStats) GetRemoved() int32 {
	if m != nil {
		return m.Removed
	}
	return 0
}

func (m *LineStats) GetChanged() int32 {
	if m != nil {
		return m.Changed
	}
	return 0
}

type DevDay struct {
	Commits   int32                 `protobuf:"varint,1,opt,name=commits,proto3" json:"commits,omitempty"`
	Stats     *LineStats            `protobuf:"bytes,2,opt,name=stats" json:"stats,omitempty"`
	Languages map[string]*LineStats `protobuf:"bytes,3,rep,name=languages" json:"languages,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"`
}

func (m *DevDay) Reset()                    { *m = DevDay{} }
func (m *DevDay) String() string            { return proto.CompactTextString(m) }
func (*DevDay) ProtoMessage()               {}
func (*DevDay) Descriptor() ([]byte, []int) { return fileDescriptorPb, []int{15} }

func (m *DevDay) GetCommits() int32 {
	if m != nil {
		return m.Commits
	}
	return 0
}

func (m *DevDay) GetStats() *LineStats {
	if m != nil {
		return m.Stats
	}
	return nil
}

func (m *DevDay) GetLanguages() map[string]*LineStats {
	if m != nil {
		return m.Languages
	}
	return nil
}

type DayDevs struct {
	Devs map[int32]*DevDay `protobuf:"bytes,1,rep,name=devs" json:"devs,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"`
}

func (m *DayDevs) Reset()                    { *m = DayDevs{} }
func (m *DayDevs) String() string            { return proto.CompactTextString(m) }
func (*DayDevs) ProtoMessage()               {}
func (*DayDevs) Descriptor() ([]byte, []int) { return fileDescriptorPb, []int{16} }

func (m *DayDevs) GetDevs() map[int32]*DevDay {
	if m != nil {
		return m.Devs
	}
	return nil
}

type DevsAnalysisResults struct {
	Days     map[int32]*DayDevs `protobuf:"bytes,1,rep,name=days" json:"days,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"`
	DevIndex []string           `protobuf:"bytes,2,rep,name=dev_index,json=devIndex" json:"dev_index,omitempty"`
}

func (m *DevsAnalysisResults) Reset()                    { *m = DevsAnalysisResults{} }
func (m *DevsAnalysisResults) String() string            { return proto.CompactTextString(m) }
func (*DevsAnalysisResults) ProtoMessage()               {}
func (*DevsAnalysisResults) Descriptor() ([]byte, []int) { return fileDescriptorPb, []int{17} }

func (m *DevsAnalysisResults) GetDays() map[int32]*DayDevs {
	if m != nil {
		return m.Days
	}
	return nil
}

func (m *DevsAnalysisResults) GetDevIndex() []string {
	if m != nil {
		return m.DevIndex
	}
	return nil
}

type Sentiment struct {
	Value    float32  `protobuf:"fixed32,1,opt,name=value,proto3" json:"value,omitempty"`
	Comments []string `protobuf:"bytes,2,rep,name=comments" json:"comments,omitempty"`
	Commits  []string `protobuf:"bytes,3,rep,name=commits" json:"commits,omitempty"`
}

func (m *Sentiment) Reset()                    { *m = Sentiment{} }
func (m *Sentiment) String() string            { return proto.CompactTextString(m) }
func (*Sentiment) ProtoMessage()               {}
func (*Sentiment) Descriptor() ([]byte, []int) { return fileDescriptorPb, []int{18} }

func (m *Sentiment) GetValue() float32 {
	if m != nil {
		return m.Value
	}
	return 0
}

func (m *Sentiment) GetComments() []string {
	if m != nil {
		return m.Comments
	}
	return nil
}

func (m *Sentiment) GetCommits() []string {
	if m != nil {
		return m.Commits
	}
	return nil
}

type CommentSentimentResults struct {
	SentimentByDay map[int32]*Sentiment `protobuf:"bytes,1,rep,name=sentiment_by_day,json=sentimentByDay" json:"sentiment_by_day,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"`
}

func (m *CommentSentimentResults) Reset()                    { *m = CommentSentimentResults{} }
func (m *CommentSentimentResults) String() string            { return proto.CompactTextString(m) }
func (*CommentSentimentResults) ProtoMessage()               {}
func (*CommentSentimentResults) Descriptor() ([]byte, []int) { return fileDescriptorPb, []int{19} }

func (m *CommentSentimentResults) GetSentimentByDay() map[int32]*Sentiment {
	if m != nil {
		return m.SentimentByDay
	}
	return nil
}

type AnalysisResults struct {
	Header *Metadata `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
	// the mapped values are dynamic messages which require the second parsing pass.
	Contents map[string][]byte `protobuf:"bytes,2,rep,name=contents" json:"contents,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

func (m *AnalysisResults) Reset()                    { *m = AnalysisResults{} }
func (m *AnalysisResults) String() string            { return proto.CompactTextString(m) }
func (*AnalysisResults) ProtoMessage()               {}
func (*AnalysisResults) Descriptor() ([]byte, []int) { return fileDescriptorPb, []int{20} }

func (m *AnalysisResults) GetHeader() *Metadata {
	if m != nil {
		return m.Header
	}
	return nil
}

func (m *AnalysisResults) GetContents() map[string][]byte {
	if m != nil {
		return m.Contents
	}
	return nil
}

func init() {
	proto.RegisterType((*Metadata)(nil), "Metadata")
	proto.RegisterType((*BurndownSparseMatrixRow)(nil), "BurndownSparseMatrixRow")
	proto.RegisterType((*BurndownSparseMatrix)(nil), "BurndownSparseMatrix")
	proto.RegisterType((*BurndownAnalysisResults)(nil), "BurndownAnalysisResults")
	proto.RegisterType((*CompressedSparseRowMatrix)(nil), "CompressedSparseRowMatrix")
	proto.RegisterType((*Couples)(nil), "Couples")
	proto.RegisterType((*TouchedFiles)(nil), "TouchedFiles")
	proto.RegisterType((*CouplesAnalysisResults)(nil), "CouplesAnalysisResults")
	proto.RegisterType((*UASTChange)(nil), "UASTChange")
	proto.RegisterType((*UASTChangesSaverResults)(nil), "UASTChangesSaverResults")
	proto.RegisterType((*ShotnessRecord)(nil), "ShotnessRecord")
	proto.RegisterType((*ShotnessAnalysisResults)(nil), "ShotnessAnalysisResults")
	proto.RegisterType((*FileHistory)(nil), "FileHistory")
	proto.RegisterType((*FileHistoryResultMessage)(nil), "FileHistoryResultMessage")
	proto.RegisterType((*LineStats)(nil), "LineStats")
	proto.RegisterType((*DevDay)(nil), "DevDay")
	proto.RegisterType((*DayDevs)(nil), "DayDevs")
	proto.RegisterType((*DevsAnalysisResults)(nil), "DevsAnalysisResults")
	proto.RegisterType((*Sentiment)(nil), "Sentiment")
	proto.RegisterType((*CommentSentimentResults)(nil), "CommentSentimentResults")
	proto.RegisterType((*AnalysisResults)(nil), "AnalysisResults")
}

func init() { proto.RegisterFile("pb.proto", fileDescriptorPb) }

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