text:
package genericmanager

import (
	context "context"
	fmt "fmt"
	proto "github.com/gogo/protobuf/proto"
	types "github.com/gogo/protobuf/types"
	grpc "google.golang.org/grpc"
	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 UpdateResult_Operation int32

const (
	UpdateResult_UNSPECIFIED UpdateResult_Operation = 0
	UpdateResult_CREATE      UpdateResult_Operation = 1
	UpdateResult_UPDATE      UpdateResult_Operation = 2
	UpdateResult_DELETE      UpdateResult_Operation = 3
)

var UpdateResult_Operation_name = map[int32]string{
	0: "UNSPECIFIED",
	1: "CREATE",
	2: "UPDATE",
	3: "DELETE",
}

var UpdateResult_Operation_value = map[string]int32{
	"UNSPECIFIED": 0,
	"CREATE":      1,
	"UPDATE":      2,
	"DELETE":      3,
}

func (x UpdateResult_Operation) String() string {
	return proto.EnumName(UpdateResult_Operation_name, int32(x))
}

func (UpdateResult_Operation) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_436b82698a12e5e3, []int{10, 0}
}

// Model represents a model description to for recognizing
// different item types.
type Model struct {
	// Module describes group of the model.
	Module string `protobuf:"bytes,1,opt,name=module,proto3" json:"module,omitempty"`
	// Version describes concrete version of the model schema.
	Version string `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"`
	// Type describes name of type described by this model.
	Type                 string   `protobuf:"bytes,3,opt,name=type,proto3" json:"type,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Model) Reset()         { *m = Model{} }
func (m *Model) String() string { return proto.CompactTextString(m) }
func (*Model) ProtoMessage()    {}
func (*Model) Descriptor() ([]byte, []int) {
	return fileDescriptor_436b82698a12e5e3, []int{0}
}
func (m *Model) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Model.Unmarshal(m, b)
}
func (m *Model) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Model.Marshal(b, m, deterministic)
}
func (m *Model) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Model.Merge(m, src)
}
func (m *Model) XXX_Size() int {
	return xxx_messageInfo_Model.Size(m)
}
func (m *Model) XXX_DiscardUnknown() {
	xxx_messageInfo_Model.DiscardUnknown(m)
}

var xxx_messageInfo_Model proto.InternalMessageInfo

func (m *Model) GetModule() string {
	if m != nil {
		return m.Module
	}
	return ""
}

func (m *Model) GetVersion() string {
	if m != nil {
		return m.Version
	}
	return ""
}

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

// Item represents single instance described by the Model.
type Item struct {
	Id                   *Item_ID `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Data                 *Data    `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Item) Reset()         { *m = Item{} }
func (m *Item) String() string { return proto.CompactTextString(m) }
func (*Item) ProtoMessage()    {}
func (*Item) Descriptor() ([]byte, []int) {
	return fileDescriptor_436b82698a12e5e3, []int{1}
}
func (m *Item) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Item.Unmarshal(m, b)
}
func (m *Item) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Item.Marshal(b, m, deterministic)
}
func (m *Item) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Item.Merge(m, src)
}
func (m *Item) XXX_Size() int {
	return xxx_messageInfo_Item.Size(m)
}
func (m *Item) XXX_DiscardUnknown() {
	xxx_messageInfo_Item.DiscardUnknown(m)
}

var xxx_messageInfo_Item proto.InternalMessageInfo

func (m *Item) GetId() *Item_ID {
	if m != nil {
		return m.Id
	}
	return nil
}

func (m *Item) GetData() *Data {
	if m != nil {
		return m.Data
	}
	return nil
}

// ID represents identifier for distinguishing items.
type Item_ID struct {
	Model                *Model   `protobuf:"bytes,1,opt,name=model,proto3" json:"model,omitempty"`
	Name                 string   `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Item_ID) Reset()         { *m = Item_ID{} }
func (m *Item_ID) String() string { return proto.CompactTextString(m) }
func (*Item_ID) ProtoMessage()    {}
func (*Item_ID) Descriptor() ([]byte, []int) {
	return fileDescriptor_436b82698a12e5e3, []int{1, 0}
}
func (m *Item_ID) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Item_ID.Unmarshal(m, b)
}
func (m *Item_ID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Item_ID.Marshal(b, m, deterministic)
}
func (m *Item_ID) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Item_ID.Merge(m, src)
}
func (m *Item_ID) XXX_Size() int {
	return xxx_messageInfo_Item_ID.Size(m)
}
func (m *Item_ID) XXX_DiscardUnknown() {
	xxx_messageInfo_Item_ID.DiscardUnknown(m)
}

var xxx_messageInfo_Item_ID proto.InternalMessageInfo

func (m *Item_ID) GetModel() *Model {
	if m != nil {
		return m.Model
	}
	return nil
}

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

// Data represents encoded data for an item.
type Data struct {
	Any                  *types.Any `protobuf:"bytes,1,opt,name=any,proto3" json:"any,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *Data) Reset()         { *m = Data{} }
func (m *Data) String() string { return proto.CompactTextString(m) }
func (*Data) ProtoMessage()    {}
func (*Data) Descriptor() ([]byte, []int) {
	return fileDescriptor_436b82698a12e5e3, []int{2}
}
func (m *Data) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Data.Unmarshal(m, b)
}
func (m *Data) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Data.Marshal(b, m, deterministic)
}
func (m *Data) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Data.Merge(m, src)
}
func (m *Data) XXX_Size() int {
	return xxx_messageInfo_Data.Size(m)
}
func (m *Data) XXX_DiscardUnknown() {
	xxx_messageInfo_Data.DiscardUnknown(m)
}

var xxx_messageInfo_Data proto.InternalMessageInfo

func (m *Data) GetAny() *types.Any {
	if m != nil {
		return m.Any
	}
	return nil
}

// Item status describes status of an item.
type ItemStatus struct {
	Status               string   `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	Message              string   `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ItemStatus) Reset()         { *m = ItemStatus{} }
func (m *ItemStatus) String() string { return proto.CompactTextString(m) }
func (*ItemStatus) ProtoMessage()    {}
func (*ItemStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_436b82698a12e5e3, []int{3}
}
func (m *ItemStatus) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ItemStatus.Unmarshal(m, b)
}
func (m *ItemStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ItemStatus.Marshal(b, m, deterministic)
}
func (m *ItemStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ItemStatus.Merge(m, src)
}
func (m *ItemStatus) XXX_Size() int {
	return xxx_messageInfo_ItemStatus.Size(m)
}
func (m *ItemStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_ItemStatus.DiscardUnknown(m)
}

var xxx_messageInfo_ItemStatus proto.InternalMessageInfo

func (m *ItemStatus) GetStatus() string {
	if m != nil {
		return m.Status
	}
	return ""
}

func (m *ItemStatus) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

type CapabilitiesRequest struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CapabilitiesRequest) Reset()         { *m = CapabilitiesRequest{} }
func (m *CapabilitiesRequest) String() string { return proto.CompactTextString(m) }
func (*CapabilitiesRequest) ProtoMessage()    {}
func (*CapabilitiesRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_436b82698a12e5e3, []int{4}
}
func (m *CapabilitiesRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CapabilitiesRequest.Unmarshal(m, b)
}
func (m *CapabilitiesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CapabilitiesRequest.Marshal(b, m, deterministic)
}
func (m *CapabilitiesRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CapabilitiesRequest.Merge(m, src)
}
func (m *CapabilitiesRequest) XXX_Size() int {
	return xxx_messageInfo_CapabilitiesRequest.Size(m)
}
func (m *CapabilitiesRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_CapabilitiesRequest.DiscardUnknown(m)
}

var xxx_messageInfo_CapabilitiesRequest proto.InternalMessageInfo

type CapabilitiesResponse struct {
	KnownModels          []*ModelInfo `protobuf:"bytes,1,rep,name=known_models,json=knownModels,proto3" json:"known_models,omitempty"`
	ActiveModules        []string     `protobuf:"bytes,2,rep,name=active_modules,json=activeModules,proto3" json:"active_modules,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *CapabilitiesResponse) Reset()         { *m = CapabilitiesResponse{} }
func (m *CapabilitiesResponse) String() string { return proto.CompactTextString(m) }
func (*CapabilitiesResponse) ProtoMessage()    {}
func (*CapabilitiesResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_436b82698a12e5e3, []int{5}
}
func (m *CapabilitiesResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CapabilitiesResponse.Unmarshal(m, b)
}
func (m *CapabilitiesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CapabilitiesResponse.Marshal(b, m, deterministic)
}
func (m *CapabilitiesResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CapabilitiesResponse.Merge(m, src)
}
func (m *CapabilitiesResponse) XXX_Size() int {
	return xxx_messageInfo_CapabilitiesResponse.Size(m)
}
func (m *CapabilitiesResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CapabilitiesResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CapabilitiesResponse proto.InternalMessageInfo

func (m *CapabilitiesResponse) GetKnownModels() []*ModelInfo {
	if m != nil {
		return m.KnownModels
	}
	return nil
}

func (m *CapabilitiesResponse) GetActiveModules() []string {
	if m != nil {
		return m.ActiveModules
	}
	return nil
}

type ModelInfo struct {
	Model                *Model            `protobuf:"bytes,1,opt,name=model,proto3" json:"model,omitempty"`
	Info                 map[string]string `protobuf:"bytes,2,rep,name=info,proto3" json:"info,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *ModelInfo) Reset()         { *m = ModelInfo{} }
func (m *ModelInfo) String() string { return proto.CompactTextString(m) }
func (*ModelInfo) ProtoMessage()    {}
func (*ModelInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_436b82698a12e5e3, []int{6}
}
func (m *ModelInfo) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ModelInfo.Unmarshal(m, b)
}
func (m *ModelInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ModelInfo.Marshal(b, m, deterministic)
}
func (m *ModelInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ModelInfo.Merge(m, src)
}
func (m *ModelInfo) XXX_Size() int {
	return xxx_messageInfo_ModelInfo.Size(m)
}
func (m *ModelInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_ModelInfo.DiscardUnknown(m)
}

var xxx_messageInfo_ModelInfo proto.InternalMessageInfo

func (m *ModelInfo) GetModel() *Model {
	if m != nil {
		return m.Model
	}
	return nil
}

func (m *ModelInfo) GetInfo() map[string]string {
	if m != nil {
		return m.Info
	}
	return nil
}

type SetConfigRequest struct {
	Updates []*UpdateItem `protobuf:"bytes,1,rep,name=updates,proto3" json:"updates,omitempty"`
	// The overwrite_all can be set to true to overwrite all other configuration
	// (this is also known as Full Resync)
	OverwriteAll         bool     `protobuf:"varint,2,opt,name=overwrite_all,json=overwriteAll,proto3" json:"overwrite_all,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SetConfigRequest) Reset()         { *m = SetConfigRequest{} }
func (m *SetConfigRequest) String() string { return proto.CompactTextString(m) }
func (*SetConfigRequest) ProtoMessage()    {}
func (*SetConfigRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_436b82698a12e5e3, []int{7}
}
func (m *SetConfigRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SetConfigRequest.Unmarshal(m, b)
}
func (m *SetConfigRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SetConfigRequest.Marshal(b, m, deterministic)
}
func (m *SetConfigRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SetConfigRequest.Merge(m, src)
}
func (m *SetConfigRequest) XXX_Size() int {
	return xxx_messageInfo_SetConfigRequest.Size(m)
}
func (m *SetConfigRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_SetConfigRequest.DiscardUnknown(m)
}

var xxx_messageInfo_SetConfigRequest proto.InternalMessageInfo

func (m *SetConfigRequest) GetUpdates() []*UpdateItem {
	if m != nil {
		return m.Updates
	}
	return nil
}

func (m *SetConfigRequest) GetOverwriteAll() bool {
	if m != nil {
		return m.OverwriteAll
	}
	return false
}

type SetConfigResponse struct {
	Results              []*UpdateResult `protobuf:"bytes,1,rep,name=results,proto3" json:"results,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *SetConfigResponse) Reset()         { *m = SetConfigResponse{} }
func (m *SetConfigResponse) String() string { return proto.CompactTextString(m) }
func (*SetConfigResponse) ProtoMessage()    {}
func (*SetConfigResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_436b82698a12e5e3, []int{8}
}
func (m *SetConfigResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SetConfigResponse.Unmarshal(m, b)
}
func (m *SetConfigResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SetConfigResponse.Marshal(b, m, deterministic)
}
func (m *SetConfigResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SetConfigResponse.Merge(m, src)
}
func (m *SetConfigResponse) XXX_Size() int {
	return xxx_messageInfo_SetConfigResponse.Size(m)
}
func (m *SetConfigResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_SetConfigResponse.DiscardUnknown(m)
}

var xxx_messageInfo_SetConfigResponse proto.InternalMessageInfo

func (m *SetConfigResponse) GetResults() []*UpdateResult {
	if m != nil {
		return m.Results
	}
	return nil
}

type UpdateItem struct {
	// The item describes item to be updated.
	// For a delete operation set fields item.Data to nil.
	Item *Item `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// The labels can be used to define user-defined labels for item.
	Labels               map[string]string `protobuf:"bytes,2,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *UpdateItem) Reset()         { *m = UpdateItem{} }
func (m *UpdateItem) String() string { return proto.CompactTextString(m) }
func (*UpdateItem) ProtoMessage()    {}
func (*UpdateItem) Descriptor() ([]byte, []int) {
	return fileDescriptor_436b82698a12e5e3, []int{9}
}
func (m *UpdateItem) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_UpdateItem.Unmarshal(m, b)
}
func (m *UpdateItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_UpdateItem.Marshal(b, m, deterministic)
}
func (m *UpdateItem) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UpdateItem.Merge(m, src)
}
func (m *UpdateItem) XXX_Size() int {
	return xxx_messageInfo_UpdateItem.Size(m)
}
func (m *UpdateItem) XXX_DiscardUnknown() {
	xxx_messageInfo_UpdateItem.DiscardUnknown(m)
}

var xxx_messageInfo_UpdateItem proto.InternalMessageInfo

func (m *UpdateItem) GetItem() *Item {
	if m != nil {
		return m.Item
	}
	return nil
}

func (m *UpdateItem) GetLabels() map[string]string {
	if m != nil {
		return m.Labels
	}
	return nil
}

type UpdateResult struct {
	Id                   *Item_ID               `protobuf:"bytes,4,opt,name=id,proto3" json:"id,omitempty"`
	Key                  string                 `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Op                   UpdateResult_Operation `protobuf:"varint,2,opt,name=op,proto3,enum=genericmanager.UpdateResult_Operation" json:"op,omitempty"`
	Status               *ItemStatus            `protobuf:"bytes,3,opt,name=status,proto3" json:"status,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (m *UpdateResult) Reset()         { *m = UpdateResult{} }
func (m *UpdateResult) String() string { return proto.CompactTextString(m) }
func (*UpdateResult) ProtoMessage()    {}
func (*UpdateResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_436b82698a12e5e3, []int{10}
}
func (m *UpdateResult) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_UpdateResult.Unmarshal(m, b)
}
func (m *UpdateResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_UpdateResult.Marshal(b, m, deterministic)
}
func (m *UpdateResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UpdateResult.Merge(m, src)
}
func (m *UpdateResult) XXX_Size() int {
	return xxx_messageInfo_UpdateResult.Size(m)
}
func (m *UpdateResult) XXX_DiscardUnknown() {
	xxx_messageInfo_UpdateResult.DiscardUnknown(m)
}

var xxx_messageInfo_UpdateResult proto.InternalMessageInfo

func (m *UpdateResult) GetId() *Item_ID {
	if m != nil {
		return m.Id
	}
	return nil
}

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

func (m *UpdateResult) GetOp() UpdateResult_Operation {
	if m != nil {
		return m.Op
	}
	return UpdateResult_UNSPECIFIED
}

func (m *UpdateResult) GetStatus() *ItemStatus {
	if m != nil {
		return m.Status
	}
	return nil
}

type GetConfigRequest struct {
	Ids                  []*Item_ID `protobuf:"bytes,1,rep,name=ids,proto3" json:"ids,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *GetConfigRequest) Reset()         { *m = GetConfigRequest{} }
func (m *GetConfigRequest) String() string { return proto.CompactTextString(m) }
func (*GetConfigRequest) ProtoMessage()    {}
func (*GetConfigRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_436b82698a12e5e3, []int{11}
}
func (m *GetConfigRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetConfigRequest.Unmarshal(m, b)
}
func (m *GetConfigRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetConfigRequest.Marshal(b, m, deterministic)
}
func (m *GetConfigRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetConfigRequest.Merge(m, src)
}
func (m *GetConfigRequest) XXX_Size() int {
	return xxx_messageInfo_GetConfigRequest.Size(m)
}
func (m *GetConfigRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetConfigRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetConfigRequest proto.InternalMessageInfo

func (m *GetConfigRequest) GetIds() []*Item_ID {
	if m != nil {
		return m.Ids
	}
	return nil
}

type GetConfigResponse struct {
	Items                []*ConfigItem `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (m *GetConfigResponse) Reset()         { *m = GetConfigResponse{} }
func (m *GetConfigResponse) String() string { return proto.CompactTextString(m) }
func (*GetConfigResponse) ProtoMessage()    {}
func (*GetConfigResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_436b82698a12e5e3, []int{12}
}
func (m *GetConfigResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetConfigResponse.Unmarshal(m, b)
}
func (m *GetConfigResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetConfigResponse.Marshal(b, m, deterministic)
}
func (m *GetConfigResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetConfigResponse.Merge(m, src)
}
func (m *GetConfigResponse) XXX_Size() int {
	return xxx_messageInfo_GetConfigResponse.Size(m)
}
func (m *GetConfigResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetConfigResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetConfigResponse proto.InternalMessageInfo

func (m *GetConfigResponse) GetItems() []*ConfigItem {
	if m != nil {
		return m.Items
	}
	return nil
}

type ConfigItem struct {
	Item                 *Item             `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	Status               *ItemStatus       `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	Labels               map[string]string `protobuf:"bytes,3,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *ConfigItem) Reset()         { *m = ConfigItem{} }
func (m *ConfigItem) String() string { return proto.CompactTextString(m) }
func (*ConfigItem) ProtoMessage()    {}
func (*ConfigItem) Descriptor() ([]byte, []int) {
	return fileDescriptor_436b82698a12e5e3, []int{13}
}
func (m *ConfigItem) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ConfigItem.Unmarshal(m, b)
}
func (m *ConfigItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ConfigItem.Marshal(b, m, deterministic)
}
func (m *ConfigItem) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ConfigItem.Merge(m, src)
}
func (m *ConfigItem) XXX_Size() int {
	return xxx_messageInfo_ConfigItem.Size(m)
}
func (m *ConfigItem) XXX_DiscardUnknown() {
	xxx_messageInfo_ConfigItem.DiscardUnknown(m)
}

var xxx_messageInfo_ConfigItem proto.InternalMessageInfo

func (m *ConfigItem) GetItem() *Item {
	if m != nil {
		return m.Item
	}
	return nil
}

func (m *ConfigItem) GetStatus() *ItemStatus {
	if m != nil {
		return m.Status
	}
	return nil
}

func (m *ConfigItem) GetLabels() map[string]string {
	if m != nil {
		return m.Labels
	}
	return nil
}

type DumpStateRequest struct {
	Ids                  []*Item_ID `protobuf:"bytes,1,rep,name=ids,proto3" json:"ids,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *DumpStateRequest) Reset()         { *m = DumpStateRequest{} }
func (m *DumpStateRequest) String() string { return proto.CompactTextString(m) }
func (*DumpStateRequest) ProtoMessage()    {}
func (*DumpStateRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_436b82698a12e5e3, []int{14}
}
func (m *DumpStateRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DumpStateRequest.Unmarshal(m, b)
}
func (m *DumpStateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DumpStateRequest.Marshal(b, m, deterministic)
}
func (m *DumpStateRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DumpStateRequest.Merge(m, src)
}
func (m *DumpStateRequest) XXX_Size() int {
	return xxx_messageInfo_DumpStateRequest.Size(m)
}
func (m *DumpStateRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_DumpStateRequest.DiscardUnknown(m)
}

var xxx_messageInfo_DumpStateRequest proto.InternalMessageInfo

func (m *DumpStateRequest) GetIds() []*Item_ID {
	if m != nil {
		return m.Ids
	}
	return nil
}

type DumpStateResponse struct {
	Items                []*StateItem `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *DumpStateResponse) Reset()         { *m = DumpStateResponse{} }
func (m *DumpStateResponse) String() string { return proto.CompactTextString(m) }
func (*DumpStateResponse) ProtoMessage()    {}
func (*DumpStateResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_436b82698a12e5e3, []int{15}
}
func (m *DumpStateResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DumpStateResponse.Unmarshal(m, b)
}
func (m *DumpStateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DumpStateResponse.Marshal(b, m, deterministic)
}
func (m *DumpStateResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DumpStateResponse.Merge(m, src)
}
func (m *DumpStateResponse) XXX_Size() int {
	return xxx_messageInfo_DumpStateResponse.Size(m)
}
func (m *DumpStateResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_DumpStateResponse.DiscardUnknown(m)
}

var xxx_messageInfo_DumpStateResponse proto.InternalMessageInfo

func (m *DumpStateResponse) GetItems() []*StateItem {
	if m != nil {
		return m.Items
	}
	return nil
}

type StateItem struct {
	Item                 *Item             `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	Metadata             map[string]string `protobuf:"bytes,2,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *StateItem) Reset()         { *m = StateItem{} }
func (m *StateItem) String() string { return proto.CompactTextString(m) }
func (*StateItem) ProtoMessage()    {}
func (*StateItem) Descriptor() ([]byte, []int) {
	return fileDescriptor_436b82698a12e5e3, []int{16}
}
func (m *StateItem) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StateItem.Unmarshal(m, b)
}
func (m *StateItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StateItem.Marshal(b, m, deterministic)
}
func (m *StateItem) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StateItem.Merge(m, src)
}
func (m *StateItem) XXX_Size() int {
	return xxx_messageInfo_StateItem.Size(m)
}
func (m *StateItem) XXX_DiscardUnknown() {
	xxx_messageInfo_StateItem.DiscardUnknown(m)
}

var xxx_messageInfo_StateItem proto.InternalMessageInfo

func (m *StateItem) GetItem() *Item {
	if m != nil {
		return m.Item
	}
	return nil
}

func (m *StateItem) GetMetadata() map[string]string {
	if m != nil {
		return m.Metadata
	}
	return nil
}

type SubscribeRequest struct {
	Subscriptions        []*Subscription `protobuf:"bytes,1,rep,name=subscriptions,proto3" json:"subscriptions,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *SubscribeRequest) Reset()         { *m = SubscribeRequest{} }
func (m *SubscribeRequest) String() string { return proto.CompactTextString(m) }
func (*SubscribeRequest) ProtoMessage()    {}
func (*SubscribeRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_436b82698a12e5e3, []int{17}
}
func (m *SubscribeRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SubscribeRequest.Unmarshal(m, b)
}
func (m *SubscribeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SubscribeRequest.Marshal(b, m, deterministic)
}
func (m *SubscribeRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SubscribeRequest.Merge(m, src)
}
func (m *SubscribeRequest) XXX_Size() int {
	return xxx_messageInfo_SubscribeRequest.Size(m)
}
func (m *SubscribeRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_SubscribeRequest.DiscardUnknown(m)
}

var xxx_messageInfo_SubscribeRequest proto.InternalMessageInfo

func (m *SubscribeRequest) GetSubscriptions() []*Subscription {
	if m != nil {
		return m.Subscriptions
	}
	return nil
}

type SubscribeResponse struct {
	Notifications        []*Notification `protobuf:"bytes,1,rep,name=notifications,proto3" json:"notifications,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *SubscribeResponse) Reset()         { *m = SubscribeResponse{} }
func (m *SubscribeResponse) String() string { return proto.CompactTextString(m) }
func (*SubscribeResponse) ProtoMessage()    {}
func (*SubscribeResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_436b82698a12e5e3, []int{18}
}
func (m *SubscribeResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SubscribeResponse.Unmarshal(m, b)
}
func (m *SubscribeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SubscribeResponse.Marshal(b, m, deterministic)
}
func (m *SubscribeResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SubscribeResponse.Merge(m, src)
}
func (m *SubscribeResponse) XXX_Size() int {
	return xxx_messageInfo_SubscribeResponse.Size(m)
}
func (m *SubscribeResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_SubscribeResponse.DiscardUnknown(m)
}

var xxx_messageInfo_SubscribeResponse proto.InternalMessageInfo

func (m *SubscribeResponse) GetNotifications() []*Notification {
	if m != nil {
		return m.Notifications
	}
	return nil
}

type Subscription struct {
	Id                   *Item_ID `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Subscription) Reset()         { *m = Subscription{} }
func (m *Subscription) String() string { return proto.CompactTextString(m) }
func (*Subscription) ProtoMessage()    {}
func (*Subscription) Descriptor() ([]byte, []int) {
	return fileDescriptor_436b82698a12e5e3, []int{19}
}
func (m *Subscription) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Subscription.Unmarshal(m, b)
}
func (m *Subscription) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Subscription.Marshal(b, m, deterministic)
}
func (m *Subscription) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Subscription.Merge(m, src)
}
func (m *Subscription) XXX_Size() int {
	return xxx_messageInfo_Subscription.Size(m)
}
func (m *Subscription) XXX_DiscardUnknown() {
	xxx_messageInfo_Subscription.DiscardUnknown(m)
}

var xxx_messageInfo_Subscription proto.InternalMessageInfo

func (m *Subscription) GetId() *Item_ID {
	if m != nil {
		return m.Id
	}
	return nil
}

type Notification struct {
	Item                 *Item       `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	Status               *ItemStatus `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *Notification) Reset()         { *m = Notification{} }
func (m *Notification) String() string { return proto.CompactTextString(m) }
func (*Notification) ProtoMessage()    {}
func (*Notification) Descriptor() ([]byte, []int) {
	return fileDescriptor_436b82698a12e5e3, []int{20}
}
func (m *Notification) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Notification.Unmarshal(m, b)
}
func (m *Notification) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Notification.Marshal(b, m, deterministic)
}
func (m *Notification) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Notification.Merge(m, src)
}
func (m *Notification) XXX_Size() int {
	return xxx_messageInfo_Notification.Size(m)
}
func (m *Notification) XXX_DiscardUnknown() {
	xxx_messageInfo_Notification.DiscardUnknown(m)
}

var xxx_messageInfo_Notification proto.InternalMessageInfo

func (m *Notification) GetItem() *Item {
	if m != nil {
		return m.Item
	}
	return nil
}

func (m *Notification) GetStatus() *ItemStatus {
	if m != nil {
		return m.Status
	}
	return nil
}

func init() {
	proto.RegisterEnum("genericmanager.UpdateResult_Operation", UpdateResult_Operation_name, UpdateResult_Operation_value)
	proto.RegisterType((*Model)(nil), "genericmanager.Model")
	proto.RegisterType((*Item)(nil), "genericmanager.Item")
	proto.RegisterType((*Item_ID)(nil), "genericmanager.Item.ID")
	proto.RegisterType((*Data)(nil), "genericmanager.Data")
	proto.RegisterType((*ItemStatus)(nil), "genericmanager.ItemStatus")
	proto.RegisterType((*CapabilitiesRequest)(nil), "genericmanager.CapabilitiesRequest")
	proto.RegisterType((*CapabilitiesResponse)(nil), "genericmanager.CapabilitiesResponse")
	proto.RegisterType((*ModelInfo)(nil), "genericmanager.ModelInfo")
	proto.RegisterMapType((map[string]string)(nil), "genericmanager.ModelInfo.InfoEntry")
	proto.RegisterType((*SetConfigRequest)(nil), "genericmanager.SetConfigRequest")
	proto.RegisterType((*SetConfigResponse)(nil), "genericmanager.SetConfigResponse")
	proto.RegisterType((*UpdateItem)(nil), "genericmanager.UpdateItem")
	proto.RegisterMapType((map[string]string)(nil), "genericmanager.UpdateItem.LabelsEntry")
	proto.RegisterType((*UpdateResult)(nil), "genericmanager.UpdateResult")
	proto.RegisterType((*GetConfigRequest)(nil), "genericmanager.GetConfigRequest")
	proto.RegisterType((*GetConfigResponse)(nil), "genericmanager.GetConfigResponse")
	proto.RegisterType((*ConfigItem)(nil), "genericmanager.ConfigItem")
	proto.RegisterMapType((map[string]string)(nil), "genericmanager.ConfigItem.LabelsEntry")
	proto.RegisterType((*DumpStateRequest)(nil), "genericmanager.DumpStateRequest")
	proto.RegisterType((*DumpStateResponse)(nil), "genericmanager.DumpStateResponse")
	proto.RegisterType((*StateItem)(nil), "genericmanager.StateItem")
	proto.RegisterMapType((map[string]string)(nil), "genericmanager.StateItem.MetadataEntry")
	proto.RegisterType((*SubscribeRequest)(nil), "genericmanager.SubscribeRequest")
	proto.RegisterType((*SubscribeResponse)(nil), "genericmanager.SubscribeResponse")
	proto.RegisterType((*Subscription)(nil), "genericmanager.Subscription")
	proto.RegisterType((*Notification)(nil), "genericmanager.Notification")
}

func init() {
	proto.RegisterFile("genericmanager/genericmanager.proto", fileDescriptor_436b82698a12e5e3)
}

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

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// GenericManagerClient is the client API for GenericManager service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type GenericManagerClient interface {
	// Capabilities returns information about service capabilities
	// including list of models supported by the server.
	Capabilities(ctx context.Context, in *CapabilitiesRequest, opts ...grpc.CallOption) (*CapabilitiesResponse, error)
	// SetConfig is used to update desired configuration.
	SetConfig(ctx context.Context, in *SetConfigRequest, opts ...grpc.CallOption) (*SetConfigResponse, error)
	// GetConfig is used to read the desired configuration.
	GetConfig(ctx context.Context, in *GetConfigRequest, opts ...grpc.CallOption) (*GetConfigResponse, error)
	// DumpState is used to retrieve the actual running state.
	DumpState(ctx context.Context, in *DumpStateRequest, opts ...grpc.CallOption) (*DumpStateResponse, error)
	// Subscribe is used for subscribing to events.
	// Notifications are returned by streaming updates.
	Subscribe(ctx context.Context, in *SubscribeRequest, opts ...grpc.CallOption) (GenericManager_SubscribeClient, error)
}

type genericManagerClient struct {
	cc *grpc.ClientConn
}

func NewGenericManagerClient(cc *grpc.ClientConn) GenericManagerClient {
	return &genericManagerClient{cc}
}

func (c *genericManagerClient) Capabilities(ctx context.Context, in *CapabilitiesRequest, opts ...grpc.CallOption) (*CapabilitiesResponse, error) {
	out := new(CapabilitiesResponse)
	err := c.cc.Invoke(ctx, "/genericmanager.GenericManager/Capabilities", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *genericManagerClient) SetConfig(ctx context.Context, in *SetConfigRequest, opts ...grpc.CallOption) (*SetConfigResponse, error) {
	out := new(SetConfigResponse)
	err := c.cc.Invoke(ctx, "/genericmanager.GenericManager/SetConfig", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *genericManagerClient) GetConfig(ctx context.Context, in *GetConfigRequest, opts ...grpc.CallOption) (*GetConfigResponse, error) {
	out := new(GetConfigResponse)
	err := c.cc.Invoke(ctx, "/genericmanager.GenericManager/GetConfig", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *genericManagerClient) DumpState(ctx context.Context, in *DumpStateRequest, opts ...grpc.CallOption) (*DumpStateResponse, error) {
	out := new(DumpStateResponse)
	err := c.cc.Invoke(ctx, "/genericmanager.GenericManager/DumpState", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *genericManagerClient) Subscribe(ctx context.Context, in *SubscribeRequest, opts ...grpc.CallOption) (GenericManager_SubscribeClient, error) {
	stream, err := c.cc.NewStream(ctx, &_GenericManager_serviceDesc.Streams[0], "/genericmanager.GenericManager/Subscribe", opts...)
	if err != nil {
		return nil, err
	}
	x := &genericManagerSubscribeClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type GenericManager_SubscribeClient interface {
	Recv() (*SubscribeResponse, error)
	grpc.ClientStream
}

type genericManagerSubscribeClient struct {
	grpc.ClientStream
}

func (x *genericManagerSubscribeClient) Recv() (*SubscribeResponse, error) {
	m := new(SubscribeResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// GenericManagerServer is the server API for GenericManager service.
type GenericManagerServer interface {
	// Capabilities returns information about service capabilities
	// including list of models supported by the server.
	Capabilities(context.Context, *CapabilitiesRequest) (*CapabilitiesResponse, error)
	// SetConfig is used to update desired configuration.
	SetConfig(context.Context, *SetConfigRequest) (*SetConfigResponse, error)
	// GetConfig is used to read the desired configuration.
	GetConfig(context.Context, *GetConfigRequest) (*GetConfigResponse, error)
	// DumpState is used to retrieve the actual running state.
	DumpState(context.Context, *DumpStateRequest) (*DumpStateResponse, error)
	// Subscribe is used for subscribing to events.
	// Notifications are returned by streaming updates.
	Subscribe(*SubscribeRequest, GenericManager_SubscribeServer) error
}

func RegisterGenericManagerServer(s *grpc.Server, srv GenericManagerServer) {
	s.RegisterService(&_GenericManager_serviceDesc, srv)
}

func _GenericManager_Capabilities_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CapabilitiesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GenericManagerServer).Capabilities(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/genericmanager.GenericManager/Capabilities",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GenericManagerServer).Capabilities(ctx, req.(*CapabilitiesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GenericManager_SetConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GenericManagerServer).SetConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/genericmanager.GenericManager/SetConfig",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GenericManagerServer).SetConfig(ctx, req.(*SetConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GenericManager_GetConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GenericManagerServer).GetConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/genericmanager.GenericManager/GetConfig",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GenericManagerServer).GetConfig(ctx, req.(*GetConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GenericManager_DumpState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DumpStateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GenericManagerServer).DumpState(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/genericmanager.GenericManager/DumpState",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GenericManagerServer).DumpState(ctx, req.(*DumpStateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GenericManager_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SubscribeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GenericManagerServer).Subscribe(m, &genericManagerSubscribeServer{stream})
}

type GenericManager_SubscribeServer interface {
	Send(*SubscribeResponse) error
	grpc.ServerStream
}

type genericManagerSubscribeServer struct {
	grpc.ServerStream
}

func (x *genericManagerSubscribeServer) Send(m *SubscribeResponse) error {
	return x.ServerStream.SendMsg(m)
}

var _GenericManager_serviceDesc = grpc.ServiceDesc{
	ServiceName: "genericmanager.GenericManager",
	HandlerType: (*GenericManagerServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Capabilities",
			Handler:    _GenericManager_Capabilities_Handler,
		},
		{
			MethodName: "SetConfig",
			Handler:    _GenericManager_SetConfig_Handler,
		},
		{
			MethodName: "GetConfig",
			Handler:    _GenericManager_GetConfig_Handler,
		},
		{
			MethodName: "DumpState",
			Handler:    _GenericManager_DumpState_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Subscribe",
			Handler:       _GenericManager_Subscribe_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "genericmanager/genericmanager.proto",
}


text:
// Imports
if (typeof window === 'undefined') {
    var Class = require('./Class');
}

/**
  * {Logger} Minimal logging interface.
  */
var Logger = Class(function(name) {
    this._logName = name;

}, {

    log: function() {

        var msg = Array.prototype.slice.call(arguments, 0);
        msg.unshift('[' + this._logName + ' ' + this + ']:');
        console.log.apply(console, msg);

    }

});

// Exports
if (typeof window === 'undefined') {
    module.exports = Logger;
}

redpajama_set_name: RedPajamaGithub


text:
export default class GraphicDrawer {

	constructor(node) {

		this.injectionNode = node;
		this.body = null;

	}

	setStyle(node, style) {

		for (let i in style) {

			node.style[ i ] = style[ i ];

		}

	}

	draw(type, data, size, minMax) {

		this.injectionNode.innerHTML = '';
		this.svg = this.injectionNode;

		switch (type) {

			case 'xy':

				this.drawXY(data, size, minMax);

		}

		this.svg.innerHTML = this.svg.innerHTML;

	}

	createBody(size) {

		this.svg = document.createElement('svg');
		this.svg.setAttribute('width', size.x);
		this.svg.setAttribute('height', size.y);
		this.setStyle(this.svg, { width: `${size.x}px`, height: `${size.y}px`, display: 'block' });
		this.svg.setAttribute('viewBox', `0 0 ${size.x} ${size.y}`);

	}

	createLine(p1, p2, style) {

		const line = document.createElement('line');

		if (style) {

			if (style.strokeWidth) {
				line.setAttribute('stroke-width', style.strokeWidth);
			}
			if (style.stroke) {
				line.setAttribute('stroke', style.stroke);
			}

		}

		line.setAttribute('x1', p1.x);
		line.setAttribute('y1', p1.y);
		line.setAttribute('x2', p2.x);
		line.setAttribute('y2', p2.y);

		return line;

	}

	createText(p, content, style) {

		const text = document.createElement('text');

		if (style && style.inline) {
			text.setAttribute('style', style.inline);
		}

		text.setAttribute('x', p.x);
		text.setAttribute('y', p.y);
		text.innerHTML = content;

		return text;

	}

	createPolyline(data, style) {

		const polyline = document.createElement('polyline');
		let points = '';
		data.map(p => {
			points += `${p.x},${p.y} `;
		});

		if (style) {

			if (style.strokeWidth) {
				polyline.setAttribute('stroke-width', style.strokeWidth);
			}
			if (style.fill) {
				polyline.setAttribute('fill', style.fill);
			}
			if (style.stroke) {
				polyline.setAttribute('stroke', style.stroke);
			}

		}

		polyline.setAttribute('points', points);

		return polyline;

	}

	drawXY(data, size, { min, max }) {

		if (typeof min === 'undefined' || typeof max === 'undefined') {
			if (typeof min === 'undefined') min = data[0][0];
			if (typeof max === 'undefined') max = data[0][0];

			data.map(lines => {
				lines.map(i => {
					if (i < min) {
						min = i;
					}
					if (i > max) {
						max = i;
					}
				});
			});
		}

		const margin = 20;

		const kX = (size.x - margin * 2) / data.length;
		const kY = (size.y - margin * 2) / Math.abs(max - min);

		const baseStyles = {
			stroke: 'black',
			strokeWidth: '1'
		};

		const baseY = min < 0 ? size.y + min - margin : size.y - margin;

		// append base lines
		this.svg.appendChild(this.createLine({ x: margin, y: margin }, { x: margin, y: baseY }, baseStyles));
		this.svg.appendChild(this.createLine({ x: margin, y: baseY }, { x: size.x - margin, y: baseY }, baseStyles));

		// append text
		this.svg.appendChild(this.createText({ x: size.x - margin - 10, y: baseY + 15 }, 'x'));
		this.svg.appendChild(this.createText({ x: 0, y: margin + 10 }, 'y'));
		this.svg.appendChild(this.createText({ x: 0, y: baseY + 15 }, '0'));

		// draw data
		data.map((d) => {
			const _d = d.map((i, key) => {
				console.log(i);
				return { x: key * kX, y: size.x - i * kY - margin * 2 };
			});
			this.svg.appendChild(this.createPolyline(_d, { fill: 'none', stroke: 'black', strokeWidth: '1' }));
		});

	}

}


text:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>

	<!-- Standard Factory bean (extends coldspring.beans.factory.FactoryBean) -->
	<bean id="beanEight.factory" class="coldspring.tests.BeanEightFactory" lazy-init="false"/>

	<!-- Test Bean for Collection Factories -->
	<bean id="beanFour" class="coldspring.tests.beanFour" lazy-init="false">
		<property name="myList">
			<ref bean="list.factory"/>
		</property>
		<property name="myMap">
			<ref bean="map.factory"/>
		</property>
	</bean>

	<!--  factories for the above bean -->
	<bean id="list.factory" class="coldspring.beans.factory.config.ListFactoryBean">
		<property name="sourceList">
			<list>
				<value>one</value>
				<value>two</value>
				<value>three</value>
			</list>
		</property>
	</bean>
	<bean id="map.factory" class="coldspring.beans.factory.config.MapFactoryBean">
		<property name="sourceMap">
			<map>
				<entry key="one"><value>hello</value></entry>
				<entry key="two"><value>there</value></entry>
			</map>
		</property>
	</bean>

	<!-- Session Service -->
	<bean id="sessionService" class="net.litepost.component.session.SessionService"/>

	<!-- Security Service -->
	<bean id="securityService" class="net.litepost.component.security.SecurityService">
		<property name="sessionService">
			<ref bean="sessionService"/>
		</property>
	</bean>

	 <!-- set up the security advice -->
    <bean id="securityAdvice" class="net.litepost.aspects.securityAdvice">
        <property name="securityService">
            <ref bean="securityService" />
        </property>
    </bean>

	<bean id="securityAdvisor" class="coldspring.aop.support.NamedMethodPointcutAdvisor">
		<property name="advice">
			<ref bean="loggingAdvice" />
		</property>
		<property name="mappedNames">
			<value>save</value>
		</property>
	</bean>

	<!-- logging service, with cflog -->
	<bean id="loggingService" class="net.litepost.component.logging.LoggingService">
		<property name="filename">
			<value>LitePost</value>
		</property>
	</bean>

	<!-- set up the logging advice -->
	<bean id="loggingAdvice" class="net.litepost.aspects.loggingAdvice">
		<property name="loggingService">
			<ref bean="loggingService" />
         </property>
	</bean>

	<bean id="loggingAdvisor" class="coldspring.aop.support.NamedMethodPointcutAdvisor">
		<property name="advice">
			<ref bean="loggingAdvice" />
		</property>
		<property name="mappedNames">
			<value>*</value>
		</property>
	</bean>

	<!-- caching service -->
	<bean id="cachingService" class="net.litepost.component.caching.CachingService">
		<property name="loggingService">
			<ref bean="loggingService" />
         </property>
	</bean>

	<!-- set up the caching advisors -->
	<bean id="cachingAdvice" class="net.litepost.aspects.cachingAdvice">
		<property name="cachingService">
			<ref bean="cachingService" />
         </property>
	</bean>

	<bean id="cachingAdvisor" class="coldspring.aop.support.RegexMethodPointcutAdvisor">
		<property name="advice">
			<ref bean="cachingAdvice" />
		</property>
		<property name="pattern">
			<value>^((?!set).)*$</value>
		</property>
	</bean>

	<!-- User Service -->
	<bean id="userService" class="net.litepost.component.user.UserService">
		<property name="userDAO">
			<bean class="net.litepost.component.user.UserDAO">
         		<property name="dsn">
					<value>litepost</value>
				 </property>
			</bean>
         </property>
		<property name="userGateway">
			<bean class="net.litepost.component.user.UserGateway">
         		<property name="dsn">
					<value>litepost</value>
				 </property>
			</bean>
         </property>
		<property name="sessionService">
			<ref bean="sessionService"/>
		</property>
	</bean>

	<!-- Blog Entry Service -->
	<bean id="entryServiceTarget" class="net.litepost.component.entry.EntryService">
		<property name="entryDAO">
			<bean class="net.litepost.component.entry.EntryDAO">
         		<property name="dsn">
					<value>litepost</value>
				 </property>
			</bean>
         </property>
		<property name="entryGateway">
			<bean class="net.litepost.component.entry.EntryGateway">
         		<property name="dsn">
					<value>litepost</value>
				 </property>
			</bean>
         </property>
		<property name="commentService">
			<ref bean="commentService"/>
		</property>
		<property name="sessionService">
			<ref bean="sessionService" />
		</property>
	</bean>

	<bean id="entryService" class="coldspring.aop.framework.ProxyFactoryBean">
		<property name="target">
			<ref bean="entryServiceTarget" />
		</property>
		<property name="interceptorNames">
			<list>
				<value>loggingAdvisor</value>
				<value>securityAdvisor</value>
				<value>cachingAdvisor</value>
			</list>
		</property>
	</bean>

	<!-- Comments Service -->
	<bean id="commentServiceTarget" class="net.litepost.component.comment.CommentService">
		<property name="commentDAO">
			<bean class="net.litepost.component.comment.CommentDAO">
         		<property name="dsn">
					<value>litepost</value>
				 </property>
			</bean>
		</property>
		<property name="commentGateway">
			<bean class="net.litepost.component.comment.CommentGateway">
         		<property name="dsn">
					<value>litepost</value>
				 </property>
			</bean>
		</property>
	</bean>

	<bean id="commentService" class="coldspring.aop.framework.ProxyFactoryBean">
		<property name="target">
			<ref bean="commentServiceTarget" />
		</property>
		<property name="interceptorNames">
			<list>
				<value>loggingAdvisor</value>
			</list>
		</property>
	</bean>

	<!-- Category Service -->
	<bean id="categoryServiceTarget" class="net.litepost.component.category.CategoryService"
			lazy-init="false">
		<property name="categoryDAO">
			<bean class="net.litepost.component.category.CategoryDAO">
         		<property name="dsn">
					<value>litepost</value>
				 </property>
			</bean>
		</property>
		<property name="categoryGateway">
			<bean class="net.litepost.component.category.CategoryGateway">
         		<property name="dsn">
					<value>litepost</value>
				 </property>
			</bean>
		</property>
		<property name="entryService">
			<ref bean="entryService" />
		</property>
	</bean>

	<bean id="categoryService" class="coldspring.aop.framework.ProxyFactoryBean">
		<property name="target">
			<ref bean="categoryServiceTarget" />
		</property>
		<property name="interceptorNames">
			<list>
				<value>loggingAdvisor</value>
				<value>securityAdvisor</value>
				<value>cachingAdvisor</value>
			</list>
		</property>
	</bean>

	<!-- Bookmark Service -->
	<bean id="bookmarkServiceTarget" class="net.litepost.component.bookmark.BookmarkService">
		<property name="bookmarkDAO">
			<bean class="net.litepost.component.bookmark.BookmarkDAO">
         		<property name="dsn">
					<value>litepost</value>
				 </property>
			</bean>
		</property>
		<property name="bookmarkGateway">
			<bean class="net.litepost.component.bookmark.BookmarkGateway">
         		<property name="dsn">
					<value>litepost</value>
				 </property>
			</bean>
		</property>
	</bean>

	<bean id="bookmarkService" parent="secureCachedService">
		<property name="target">
			<ref bean="bookmarkServiceTarget" />
		</property>
	</bean>

	<!--
	<bean id="bookmarkService" class="coldspring.aop.framework.ProxyFactoryBean">
		<property name="target">
			<ref bean="bookmarkServiceTarget" />
		</property>
		<property name="interceptorNames">
			<list>
				<value>loggingAdvisor</value>
				<value>securityAdvisor</value>
				<value>cachingAdvisor</value>
			</list>
		</property>
	</bean> -->

	<!-- RSS Service -->
	<bean id="rssService" class="net.litepost.component.rss.RSSService">
		<property name="entryService">
			<ref bean="entryService" />
		</property>
	</bean>

	<!-- abstract service bean -->

	<bean id="secureCachedService" class="coldspring.aop.framework.ProxyFactoryBean" abstract="true">
		<property name="interceptorNames">
			<list>
				<value>loggingAdvisor</value>
				<value>securityAdvisor</value>
				<value>cachingAdvisor</value>
			</list>
		</property>
	</bean>
</beans>


text:
// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.

namespace Microsoft.CodeAnalysis
{
    /// <summary>
    /// Indicates whether a type has checksum or not
    /// </summary>
    internal interface IChecksummedObject
    {
        Checksum Checksum { get; }
    }
}


text:
namespace {

constexpr int kIconSize = 32;
constexpr int kSpacingBetweenImages = 8;

// Custom layout that sets host_size to be same as the child view's size.
class ImageCarouselLayoutManager : public views::LayoutManagerBase {
 public:
  ImageCarouselLayoutManager() = default;
  ~ImageCarouselLayoutManager() override = default;

 protected:
  // LayoutManagerBase:
  views::ProposedLayout CalculateProposedLayout(
      const views::SizeBounds& size_bounds) const override {
    views::ProposedLayout layout;
    views::View* const inner_container = host_view()->children().front();

    const gfx::Size item_size(inner_container->GetPreferredSize());

    layout.child_layouts.push_back({inner_container, true,
                                    gfx::Rect(gfx::Point(0, 0), item_size),
                                    views::SizeBounds(item_size)});

    layout.host_size = item_size;
    return layout;
  }
};

class ImageCarouselView : public views::View {
 public:
  explicit ImageCarouselView(const std::vector<SkBitmap>& screenshots)
      : screenshots_(screenshots) {
    DCHECK(screenshots.size());

    // Use a fill layout to draw the buttons container on
    // top of the image carousel.
    SetUseDefaultFillLayout(true);

    // Screenshots are sanitized by `InstallableManager::OnScreenshotFetched`
    // and should all have the same aspect ratio.
#if DCHECK_IS_ON()
    for (const auto& screenshot : screenshots) {
      DCHECK(screenshot.width() * screenshots_[0].height() ==
             screenshot.height() * screenshots_[0].width());
    }
#endif

    image_padding_ = ChromeLayoutProvider::Get()->GetDistanceMetric(
        views::DISTANCE_RELATED_BUTTON_HORIZONTAL);
    image_container_ = AddChildView(std::make_unique<views::View>());

    image_inner_container_ = image_container_->AddChildView(
        std::make_unique<views::BoxLayoutView>());
    image_inner_container_->SetBetweenChildSpacing(image_padding_);

    for (size_t i = 0; i < screenshots_.size(); i++) {
      image_views_.push_back(image_inner_container_->AddChildView(
          std::make_unique<views::ImageView>()));
    }

    image_container_->SetLayoutManager(
        std::make_unique<ImageCarouselLayoutManager>());

    bounds_animator_ =
        std::make_unique<views::BoundsAnimator>(image_container_, false);
    bounds_animator_->SetAnimationDuration(base::Seconds(0.5));

    auto leading_button_container = std::make_unique<views::BoxLayoutView>();

    leading_button_container->SetCrossAxisAlignment(
        views::BoxLayout::CrossAxisAlignment::kCenter);
    leading_button_ = leading_button_container->AddChildView(CreateScrollButton(
        ButtonType::LEADING,
        base::BindRepeating(&ImageCarouselView::OnScrollButtonClicked,
                            base::Unretained(this), ButtonType::LEADING)));
    leading_button_container_ =
        AddChildView(std::move(leading_button_container));
    leading_button_->SetVisible(false);

    auto trailing_button_container = std::make_unique<views::BoxLayoutView>();
    trailing_button_container->SetCrossAxisAlignment(
        views::BoxLayout::CrossAxisAlignment::kCenter);

    trailing_button_ =
        trailing_button_container->AddChildView(CreateScrollButton(
            ButtonType::TRAILING,
            base::BindRepeating(&ImageCarouselView::OnScrollButtonClicked,
                                base::Unretained(this), ButtonType::TRAILING)));
    trailing_button_container_ =
        AddChildView(std::move(trailing_button_container));
  }

  void AddedToWidget() override {
    const display::Screen* const screen = display::Screen::GetScreen();

    float current_scale =
        screen->GetDisplayNearestView(GetWidget()->GetNativeView())
            .device_scale_factor();
    for (size_t i = 0; i < screenshots_.size(); i++) {
      image_views_[i]->SetImage(ui::ImageModel::FromImageSkia(
          gfx::ImageSkia::CreateFromBitmap(screenshots_[i], current_scale)));
    }
  }

  void Layout() override {
    // Use a fixed height that guarantees to fit the screenshot with max ratio
    // and still show a clip for the next screenshot.
    const int fixed_height = base::checked_cast<int>(
        base::checked_cast<float>(width() - image_padding_ * 2) /
        webapps::kMaximumScreenshotRatio);
    image_container_->SetBounds(0, 0, width(), height());

    // Only setup the initial visibility and screenshots size once based on
    // container width & max screenshot ratio, the visibility is later updated
    // by `OnScrollButtonClicked` based on image carousel animation.
    if (!trailing_button_visibility_set_up_) {
      for (size_t i = 0; i < screenshots_.size(); i++) {
        const int item_width = base::checked_cast<int>(
            screenshots_[i].width() * (base::checked_cast<float>(fixed_height) /
                                       screenshots_[i].height()));
        image_views_[i]->SetImageSize({item_width, fixed_height});
      }
      image_carousel_full_width_ =
          image_inner_container_->GetPreferredSize().width();
      trailing_button_->SetVisible(image_carousel_full_width_ > width());
      trailing_button_visibility_set_up_ = true;
    }

    leading_button_container_->SetBounds(kSpacingBetweenImages, 0, kIconSize,
                                         fixed_height);

    trailing_button_container_->SetBounds(
        width() - kSpacingBetweenImages - kIconSize, 0, kIconSize,
        fixed_height);
  }

 private:
  enum class ButtonType { LEADING, TRAILING };

  void OnScrollButtonClicked(ButtonType button_type) {
    DCHECK(image_inner_container_->children().size());

    int image_width =
        image_inner_container_->children().front()->bounds().width() +
        image_padding_;
    int container_width = image_container_->bounds().width();

    // Scroll past all the fully visible images
    int delta = image_width * (container_width / image_width);

    if (button_type == ButtonType::TRAILING)
      delta = -delta;

    const gfx::Rect& bounds = image_inner_container_->bounds();
    int x = bounds.x() + delta;

    // Bound the position so there is no empty space drawn before the first
    // image or after last image.
    x = std::min(x, 0);
    x = std::max(x, (container_width - image_carousel_full_width_));

    leading_button_->SetVisible(x < 0);

    trailing_button_->SetVisible(x + image_carousel_full_width_ >
                                 container_width);

    bounds_animator_->AnimateViewTo(
        image_inner_container_,
        gfx::Rect(x, bounds.y(), bounds.width(), bounds.height()));
  }

  std::unique_ptr<views::ImageButton> CreateScrollButton(
      ButtonType button_type,
      views::Button::PressedCallback callback) {
    auto scroll_button = views::CreateVectorImageButton(std::move(callback));
    scroll_button->SetBackground(views::CreateThemedRoundedRectBackground(
        kColorPwaScrollButtonBackground, kIconSize));
    scroll_button->SetPreferredSize(gfx::Size(kIconSize, kIconSize));
    views::HighlightPathGenerator::Install(
        scroll_button.get(),
        std::make_unique<views::CircleHighlightPathGenerator>(gfx::Insets()));

    scroll_button->SetAccessibleName(l10n_util::GetStringUTF16(
        button_type == ButtonType::LEADING
            ? IDS_ACCNAME_WEB_APP_DETAILED_INSTALL_DIALOG_LEADING_SCROLL_BUTTON
            : IDS_ACCNAME_WEB_APP_DETAILED_INSTALL_DIALOG_TRAILING_SCROLL_BUTTON));

    scroll_button->SetImageModel(
        views::Button::ButtonState::STATE_NORMAL,
        button_type == ButtonType::LEADING
            ? ui::ImageModel::FromVectorIcon(kLeadingScrollIcon, ui::kColorIcon)
            : ui::ImageModel::FromVectorIcon(kTrailingScrollIcon,
                                             ui::kColorIcon));

    views::InkDrop::Get(scroll_button.get())
        ->SetBaseColorCallback(base::BindRepeating(
            [](views::ImageButton* host) {
              return host->GetColorProvider()->GetColor(
                  kColorPwaScrollButtonBackground);
            },
            scroll_button.get()));
    views::InkDrop::Get(scroll_button.get())->SetVisibleOpacity(1);
    views::InkDrop::Get(scroll_button.get())->SetHighlightOpacity(1);
    scroll_button->SetFocusBehavior(FocusBehavior::ALWAYS);
    return scroll_button;
  }

  const std::vector<SkBitmap>& screenshots_;
  std::unique_ptr<views::BoundsAnimator> bounds_animator_;
  views::View* image_container_ = nullptr;
  views::BoxLayoutView* image_inner_container_ = nullptr;
  std::vector<views::ImageView*> image_views_;
  views::View* leading_button_ = nullptr;
  views::View* trailing_button_ = nullptr;
  views::View* leading_button_container_ = nullptr;
  views::View* trailing_button_container_ = nullptr;
  int image_carousel_full_width_ = 0;
  int image_padding_ = 0;
  bool trailing_button_visibility_set_up_ = false;
};

}  // namespace

namespace chrome {

void ShowWebAppDetailedInstallDialog(
    content::WebContents* web_contents,
    std::unique_ptr<WebAppInstallInfo> install_info,
    chrome::AppInstallationAcceptanceCallback callback,
    const std::vector<SkBitmap>& screenshots,
    chrome::PwaInProductHelpState iph_state) {
  content::BrowserContext* browser_context = web_contents->GetBrowserContext();
  PrefService* const prefs =
      Profile::FromBrowserContext(browser_context)->GetPrefs();

  feature_engagement::Tracker* const tracker =
      feature_engagement::TrackerFactory::GetForBrowserContext(browser_context);

  gfx::ImageSkia icon_image(std::make_unique<WebAppInfoImageSource>(
                                kIconSize, install_info->icon_bitmaps.any),
                            gfx::Size(kIconSize, kIconSize));

  auto title = install_info->title;
  auto start_url_host = install_info->start_url.host();
  const std::u16string description = gfx::TruncateString(
      install_info->description, webapps::kMaximumDescriptionLength,
      gfx::CHARACTER_BREAK);

  auto delegate =
      std::make_unique<web_app::WebAppDetailedInstallDialogDelegate>(
          web_contents, std::move(install_info), std::move(callback),
          std::move(iph_state), prefs, tracker);
  auto* delegate_ptr = delegate.get();
  auto dialog_model =
      ui::DialogModel::Builder(std::move(delegate))
          .SetIcon(ui::ImageModel::FromImageSkia(icon_image))
          .SetTitle(title)
          .SetSubtitle(base::UTF8ToUTF16(start_url_host))
          .AddParagraph(
              ui::DialogModelLabel(description).set_is_secondary(),
              l10n_util::GetStringUTF16(
                  IDS_WEB_APP_DETAILED_INSTALL_DIALOG_DESCRIPTION_TITLE))
          .AddOkButton(
              base::BindOnce(
                  &web_app::WebAppDetailedInstallDialogDelegate::OnAccept,
                  base::Unretained(delegate_ptr)),
              l10n_util::GetStringUTF16(IDS_INSTALL))
          .AddCancelButton(base::BindOnce(
              &web_app::WebAppDetailedInstallDialogDelegate::OnCancel,
              base::Unretained(delegate_ptr)))
          .AddCustomField(
              std::make_unique<views::BubbleDialogModelHost::CustomView>(
                  std::make_unique<ImageCarouselView>(screenshots),
                  views::BubbleDialogModelHost::FieldType::kControl))
          .SetDialogDestroyingCallback(base::BindOnce(
              [](web_app::WebAppDetailedInstallDialogDelegate* delegate) {
                delegate->OnCancel();
              },
              base::Unretained(delegate_ptr)))
          .Build();

  auto dialog = views::BubbleDialogModelHost::CreateModal(
      std::move(dialog_model), ui::MODAL_TYPE_CHILD);

  constrained_window::ShowWebModalDialogViews(dialog.release(), web_contents);
  base::RecordAction(base::UserMetricsAction("WebAppDetailedInstallShown"));
}

}  // namespace chrome

namespace web_app {

WebAppDetailedInstallDialogDelegate::WebAppDetailedInstallDialogDelegate(
    content::WebContents* web_contents,
    std::unique_ptr<WebAppInstallInfo> web_app_info,
    chrome::AppInstallationAcceptanceCallback callback,
    chrome::PwaInProductHelpState iph_state,
    PrefService* prefs,
    feature_engagement::Tracker* tracker)
    : WebContentsObserver(web_contents),
      web_contents_(web_contents),
      install_info_(std::move(web_app_info)),
      callback_(std::move(callback)),
      iph_state_(std::move(iph_state)),
      prefs_(prefs),
      tracker_(tracker) {
  DCHECK(install_info_);
  DCHECK(prefs_);
}

WebAppDetailedInstallDialogDelegate::~WebAppDetailedInstallDialogDelegate() {
  // TODO(crbug.com/1327363): move this to dialog->SetHighlightedButton.
  Browser* browser = chrome::FindBrowserWithWebContents(web_contents_);
  if (!browser)
    return;

  BrowserView* browser_view = BrowserView::GetBrowserViewForBrowser(browser);

  if (browser_view && browser_view->toolbar_button_provider()) {
    PageActionIconView* install_icon =
        browser_view->toolbar_button_provider()->GetPageActionIconView(
            PageActionIconType::kPwaInstall);
    if (install_icon) {
      // Dehighlight the install icon when this dialog is closed.
      browser_view->toolbar_button_provider()
          ->GetPageActionIconView(PageActionIconType::kPwaInstall)
          ->SetHighlighted(false);
    }
  }
}

void WebAppDetailedInstallDialogDelegate::OnAccept() {
  base::RecordAction(base::UserMetricsAction("WebAppDetailedInstallAccepted"));
  if (iph_state_ == chrome::PwaInProductHelpState::kShown) {
    web_app::AppId app_id = web_app::GenerateAppId(install_info_->manifest_id,
                                                   install_info_->start_url);
    web_app::RecordInstallIphInstalled(prefs_, app_id);
    tracker_->NotifyEvent(feature_engagement::events::kDesktopPwaInstalled);
  }

  std::move(callback_).Run(true, std::move(install_info_));
}

void WebAppDetailedInstallDialogDelegate::OnCancel() {
  if (callback_.is_null())
    return;

  base::RecordAction(base::UserMetricsAction("WebAppDetailedInstallCancelled"));
  if (iph_state_ == chrome::PwaInProductHelpState::kShown && install_info_) {
    web_app::AppId app_id = web_app::GenerateAppId(install_info_->manifest_id,
                                                   install_info_->start_url);
    web_app::RecordInstallIphIgnored(prefs_, app_id, base::Time::Now());
  }

  std::move(callback_).Run(false, std::move(install_info_));
}

void WebAppDetailedInstallDialogDelegate::OnVisibilityChanged(
    content::Visibility visibility) {
  if (visibility == content::Visibility::HIDDEN)
    CloseDialog();
}

void WebAppDetailedInstallDialogDelegate::WebContentsDestroyed() {
  CloseDialog();
}

void WebAppDetailedInstallDialogDelegate::DidFinishNavigation(
    content::NavigationHandle* navigation_handle) {
  if (!navigation_handle->IsInPrimaryMainFrame() ||
      !navigation_handle->HasCommitted()) {
    return;
  }

  // Close dialog when navigating to a different domain.
  if (!url::IsSameOriginWith(
          navigation_handle->GetPreviousPrimaryMainFrameURL(),
          navigation_handle->GetURL())) {
    CloseDialog();
  }
}

void WebAppDetailedInstallDialogDelegate::CloseDialog() {
  if (dialog_model() && dialog_model()->host())
    dialog_model()->host()->Close();
}

}  // namespace web_app


text:
<?php namespace MetricLoop\Interrogator\Exceptions;

use Exception;

class SectionNotFoundException extends Exception
{
    //
}


text:
<?php
namespace Kbrw\RiakBundle\Tests\Model\MapReduce\Transformer;

use Kbrw\RiakBundle\Model\MapReduce\Transformer\StringToFloat;
use Kbrw\RiakBundle\Tests\Model\MapReduce\KeyFilterTestCase;

class StringToFloatTest extends KeyFilterTestCase
{
    public function getExpectations()
    {
        return array(
            array('[["string_to_float"]]', new StringToFloat()),
        );
    }
}


text:
/**
 * Test the backup/restore process:
 * - 3 node replica set
 * - Mongo CRUD client
 * - Mongo FSM client
 * - fsyncLock Secondary
 * - cp DB files
 * - fsyncUnlock Secondary
 * - Start mongod as hidden secondary
 * - Wait until new hidden node becomes secondary
 *
 * Some methods for backup used in this test checkpoint the files in the dbpath. This technique will
 * not work for ephemeral storage engines, as they do not store any data in the dbpath.
 * @tags: [requires_persistence]
 */

load("jstests/noPassthrough/libs/backup_restore.js");

(function() {
    "use strict";

    // Run the fsyncLock test. Will return before testing for any engine that doesn't
    // support fsyncLock
    new BackupRestoreTest({backup: 'fsyncLock'}).run();
}());


text:
define(["knockout", "jquery", "knockout-validation", "knockout-postbox", "lib/knockout-bootstrap-select", "lib/knockout-bootstrap-tagsinput"], function (ko, $) {
    // ViewModel for the add video page
    return function addVideoViewModel() {
        var self = this;

        // Common video details
        self.name = ko.observable("").extend({ required: true }).subscribeTo("add-video-name");
        self.description = ko.observable("").subscribeTo("add-video-description");
        self.tags = ko.observableArray().subscribeTo("add-video-tags");

        // The currently selected video source
        self.selectedSource = ko.observable().extend({ required: true });

        // Whether to show the common details entry fields
        self.showCommonDetails = ko.observable(false).syncWith("add-video-showCommonDetails");

        // Whether or not the common details entry has focus
        self.focusCommonDetails = ko.observable(false).subscribeTo("add-video-showCommonDetails");

        // Whether or not saving is available
        self.savingAvailable = ko.observable(false).syncWith("add-video-savingAvailable");

        // Whether or not we're saving
        self.saving = ko.observable(false).syncWith("add-video-saving");

        // The URL to go and view the video once saving has been successful
        self.viewVideoUrl = ko.observable("").subscribeTo("add-video-viewVideoUrl");

        // Adds the video via an AJAX call to the server
        self.addVideo = function () {
            // Indicate we're saving
            self.saving(true);

            // Check for any validation problems
            var validationErrors = ko.validation.group([self.name, self.description, self.tags, self.selectedSource]);
            if (validationErrors().length > 0) {
                validationErrors.showAllMessages();
                self.saving(false);
                return;
            }

            // Pull video details into a JS object
            var videoDetails = {
                name: self.name(),
                description: self.description(),
                tags: self.tags()
            };

            // Publish a message so the child component (YouTube, Upload, etc.) can do the actual saving
            var queueName = self.selectedSource() + "-save-clicked";
            ko.postbox.publish(queueName, videoDetails);
        };
    };
});


text:
<?xml version="1.0" encoding="UTF-8"?>

<rootTag>
  <Award>
    <AwardTitle>PostDoctoral Research Fellowship</AwardTitle>
    <AwardEffectiveDate>10/01/2016</AwardEffectiveDate>
    <AwardExpirationDate>09/30/2020</AwardExpirationDate>
    <AwardAmount>150000</AwardAmount>
    <AwardInstrument>
      <Value>Fellowship</Value>
    </AwardInstrument>
    <Organization>
      03040000
      <Directorate>
        <LongName>Direct For Mathematical & Physical Scien</LongName>
      </Directorate>
      <Division>
        <LongName>Division Of Mathematical Sciences</LongName>
      </Division>
    </Organization>
    <ProgramOfficer>
      <SignBlockName>Bruce P. Palka</SignBlockName>
    </ProgramOfficer>
    <AbstractNarration>This award is made as part of the FY 2016 Mathematical Sciences Postdoctoral Research Fellowships Program. Each of the fellowships supports a research and training project at a host institution in the mathematical sciences, including applications to other disciplines, under the mentorship of a sponsoring scientist. The title of the project for this fellowship to Maria M. Gillespie is "Connections between Crystal Theory, Representations, Tableaux Combinatorics, and Macdonald Polynomials." The host institution for the fellowship is the University of California-Davis, and the sponsoring scientist is Anne Schilling.</AbstractNarration>
    <MinAmdLetterDate>04/01/2016</MinAmdLetterDate>
    <MaxAmdLetterDate>04/01/2016</MaxAmdLetterDate>
    <ARRAAmount/>
    <AwardID>1604262</AwardID>
    <Investigator>
      <FirstName>Maria</FirstName>
      <LastName>Gillespie</LastName>
      <EmailAddress/>
      <StartDate>04/01/2016</StartDate>
      <EndDate/>
      <RoleCode>Principal Investigator</RoleCode>
    </Investigator>
    <Institution>
      <Name>Gillespie Maria M</Name>
      <CityName>Berkeley</CityName>
      <ZipCode>94709</ZipCode>
      <PhoneNumber/>
      <StreetAddress/>
      <CountryName>United States</CountryName>
      <StateName>California</StateName>
      <StateCode>CA</StateCode>
    </Institution>
    <ProgramElement>
      7335
      <Text>WORKFORCE IN THE MATHEMAT SCI</Text>
    </ProgramElement>
    <ProgramReference>
      9219
      <Text>POSTDOCTORAL FELLOWSHIPS IN MATH SCIENCE</Text>
    </ProgramReference>
  </Award>
</rootTag>


text:
export SDS_PORT=9000
export SDS_PATH="/sds"

export SDS_DATA_DIR="$(pwd)/share"

export SDS_SLICK_DRIVER="slick.driver.MySQLDriver$"
export SDS_JDBC_DRIVER="org.mariadb.jdbc.Driver"
export SDS_JDBC_URL="jdbc:mysql://localhost:3306/sds?user=sds_user&password=sds_pass"

sbt stage && ./target/universal/stage/bin/sds -J-Xmx4096M -J-Xms4096M -J-Xss20M -J-server -J-XX:+UseConcMarkSweepGC -J-XX:+CMSClassUnloadingEnabled -DapplyEvolutions.default=true


text:
const mockery = require('mockery')
const ChildProcessMock = require('../fixtures/child_process')

describe('Utils', () => {
  afterEach(() => {
    mockery.deregisterAll()
    mockery.disable()
  })

  beforeEach(() => {
    mockery.enable({
      useCleanCache: true,
      warnOnUnregistered: false
    })
  })

  describe('exit', () => {
    it('should exit', (done) => {
      const oldExit = process.exit
      process.exit = () => done()

      const utils = require('../../src/utils')
      utils.exit(0)

      process.exit = oldExit
    })
  })

  describe('checkInternetConnection', () => {
    it('should resolve true if a connection exists', (done) => {
      mockery.registerMock('dns', {
        lookup(domain, cb) {
          cb(null)
        }
      })

      const utils = require('../../src/utils')

      utils.checkInternetConnection()
        .then((result) => {
          result.should.be.true
          done()
        })
        .catch(err => console.log(err))
    })

    it('should resolve false if a connection does not exists', (done) => {
      mockery.registerMock('dns', {
        lookup(domain, cb) {
          cb({ code: 'ENOTFOUND' })
        }
      })

      const utils = require('../../src/utils')

      utils.checkInternetConnection()
        .then(result => {
          result.should.be.false
          done()
        })
        .catch(err => console.log(err))
    })
  })

  describe('checkExecutionPolicy', () => {
    it('should resolve true if the policy is sufficient', (done) => {
      const cpMock = {
        spawn(_process, _args) {
          return new ChildProcessMock({
            stdout: 'Unrestricted'
          })
        }
      }

      mockery.registerMock('child_process', cpMock)

      const utils = require('../../src/utils')

      utils.checkExecutionPolicy()
        .then(result => {
          result.should.be.true
          done()
        })
        .catch(err => console.log(err))
    })

    it('should resolve false if the policy is not sufficient', (done) => {
      const cpMock = {
        spawn(_process, _args) {
          return new ChildProcessMock({
            stdout: 'Restricted'
          })
        }
      }

      mockery.registerMock('child_process', cpMock)

      const utils = require('../../src/utils')

      utils.checkExecutionPolicy()
        .then(result => {
          result.should.be.false
          done()
        })
        .catch(err => console.log(err))
    })
  })

  describe('isPathAccessible', () => {
    it('should return true if the path is exists', () => {
      const utils = require('../../src/utils')
      const thisExists = utils.isPathAccessible(__dirname)

      thisExists.should.be.true
    })

    it('should return false if the path does not exists', () => {
      const utils = require('../../src/utils')
      const thisExists = utils.isPathAccessible('C:\\fake-path\\')

      thisExists.should.be.false
    })
  })
})


text: export { LetterBb20 as default } from "../../";