text:
package main

import (
	"fmt"
	"time"
)

func main() {
	go func() {
		x := 0
		ticker := time.NewTicker(time.Second)
		for _ = range ticker.C {
			x++
			fmt.Printf("%d second elapsed...\n", x)
		}
	}()

// START CODE OMIT
	done := make(chan struct{})
	go func() {
		defer func() {
			done <- struct{}{} // このgoroutineが終了したらお知らせを送る // HL
		}()
		time.Sleep(5 * time.Second)
		fmt.Println("Goroutine fired!")
	}()

	<-done // お知らせが来るまで待つ // HL
// END CODE OMIT
}

repository: lestrrat/go-slides

repo_name: lestrrat/go-slides

gha_language: Go


text:
SUMMARY = "GTK support library for colord"
HOMEPAGE = "https://www.freedesktop.org/software/colord/"

LICENSE = "LGPLv3"
LIC_FILES_CHKSUM = "file://COPYING;md5=e6a600fd5e1d9cbde2d983680233ad02"

SRC_URI = "https://www.freedesktop.org/software/colord/releases/colord-gtk-${PV}.tar.xz"
SRC_URI[md5sum] = "bb9d6f3c037152ad791003375aa6c16c"
SRC_URI[sha256sum] = "28d00b7f157ea3e2ea5315387b2660fde82faba16674861c50465e55d61a3e45"

DEPENDS = "lcms glib-2.0 intltool-native gtk+3 glib-2.0-native colord"

inherit pkgconfig gettext autotools

EXTRA_OECONF = "--enable-introspection=no --disable-gtk-doc"

license: MIT

repository: dma/citadel

license_type: permissive

repo_name: dma/citadel

branch_name: refs/heads/master

extension: bb


text:
#ifndef _IRIS_APPLICATION_ANDROID_H_
#define _IRIS_APPLICATION_ANDROID_H_

#include "platform\PlatformMacros.h"
#include "platform\ApplicationProtocol.h"

#if TARGET_PLATFORM == PLATFORM_ANDROID

IRIS_BEGIN

class Application : public ApplicationProtocol
{
public:
private:
protected:
};

IRIS_END

#endif

#endif // _IRIS_APPLICATION_ANDROID_H_

repository: pixelsquare/iris-engine-opengl

repo_name: pixelsquare/iris-engine-opengl

extension: h


text:
// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT.

package auditmanager

import (
	"k8s.io/autoscaler/cluster-autoscaler/cloudprovider/aws/aws-sdk-go/private/protocol"
)

const (

	// ErrCodeAccessDeniedException for service response error code
	// "AccessDeniedException".
	//
	// Your account isn't registered with Audit Manager. Check the delegated administrator
	// setup on the Audit Manager settings page, and try again.
	ErrCodeAccessDeniedException = "AccessDeniedException"

	// ErrCodeInternalServerException for service response error code
	// "InternalServerException".
	//
	// An internal service error occurred during the processing of your request.
	// Try again later.
	ErrCodeInternalServerException = "InternalServerException"

	// ErrCodeResourceNotFoundException for service response error code
	// "ResourceNotFoundException".
	//
	// The resource that's specified in the request can't be found.
	ErrCodeResourceNotFoundException = "ResourceNotFoundException"

	// ErrCodeValidationException for service response error code
	// "ValidationException".
	//
	// The request has invalid or missing parameters.
	ErrCodeValidationException = "ValidationException"
)

var exceptionFromCode = map[string]func(protocol.ResponseMetadata) error{
	"AccessDeniedException":     newErrorAccessDeniedException,
	"InternalServerException":   newErrorInternalServerException,
	"ResourceNotFoundException": newErrorResourceNotFoundException,
	"ValidationException":       newErrorValidationException,
}

repository: kubernetes/autoscaler

repo_name: kubernetes/autoscaler

extension: go


text:
package avp

import (
	"context"
	"encoding/json"
	"io"
	"sync"

	avp "github.com/pion/ion-avp/pkg"
	log "github.com/pion/ion-log"
	sfu "github.com/pion/ion-sfu/cmd/signal/grpc/proto"
	"github.com/pion/webrtc/v3"
	"google.golang.org/grpc"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
)

// SFU client
type SFU struct {
	ctx        context.Context
	cancel     context.CancelFunc
	client     sfu.SFUClient
	config     avp.Config
	mu         sync.RWMutex
	onCloseFn  func()
	transports map[string]*avp.WebRTCTransport
}

// NewSFU intializes a new SFU client
func NewSFU(addr string, config avp.Config) (*SFU, error) {
	log.Infof("Connecting to sfu: %s", addr)
	// Set up a connection to the sfu server.
	conn, err := grpc.Dial(addr, grpc.WithInsecure(), grpc.WithBlock())
	if err != nil {
		log.Errorf("did not connect: %v", err)
		return nil, err
	}

	ctx, cancel := context.WithCancel(context.Background())
	return &SFU{
		ctx:        ctx,
		cancel:     cancel,
		client:     sfu.NewSFUClient(conn),
		config:     config,
		transports: make(map[string]*avp.WebRTCTransport),
	}, nil
}

// GetTransport returns a webrtc transport for a session
func (s *SFU) GetTransport(sid string) (*avp.WebRTCTransport, error) {
	s.mu.Lock()
	defer s.mu.Unlock()

	t := s.transports[sid]

	// no transport yet, create one
	if t == nil {
		var err error
		if t, err = s.join(sid); err != nil {
			return nil, err
		}
		t.OnClose(func() {
			s.mu.Lock()
			defer s.mu.Unlock()
			delete(s.transports, sid)
			if len(s.transports) == 0 && s.onCloseFn != nil {
				s.cancel()
				s.onCloseFn()
			}
		})
		s.transports[sid] = t
	}

	return t, nil
}

// OnClose handler called when sfu client is closed
func (s *SFU) OnClose(f func()) {
	s.onCloseFn = f
}

// Join creates an sfu client and join the session.
// All tracks will be relayed to the avp.
func (s *SFU) join(sid string) (*avp.WebRTCTransport, error) {
	log.Infof("Joining sfu session: %s", sid)

	sfustream, err := s.client.Signal(s.ctx)

	if err != nil {
		log.Errorf("error creating sfu stream: %s", err)
		return nil, err
	}

	t := avp.NewWebRTCTransport(sid, s.config)

	offer, err := t.CreateOffer()
	if err != nil {
		log.Errorf("Error creating offer: %v", err)
		return nil, err
	}

	marshalled, err := json.Marshal(offer)
	if err != nil {
		return nil, err
	}

	log.Debugf("Send offer:\n %s", offer.SDP)
	err = sfustream.Send(
		&sfu.SignalRequest{
			Payload: &sfu.SignalRequest_Join{
				Join: &sfu.JoinRequest{
					Sid:         sid,
					Uid:         "",
					Description: marshalled,
				},
			},
		},
	)

	if err != nil {
		log.Errorf("Error sending publish request: %v", err)
		return nil, err
	}

	t.OnICECandidate(func(c *webrtc.ICECandidate, target int) {
		if c == nil {
			// Gathering done
			return
		}
		bytes, err := json.Marshal(c.ToJSON())
		if err != nil {
			log.Errorf("OnIceCandidate error %s", err)
		}
		err = sfustream.Send(&sfu.SignalRequest{
			Payload: &sfu.SignalRequest_Trickle{
				Trickle: &sfu.Trickle{
					Init:   string(bytes),
					Target: sfu.Trickle_Target(target),
				},
			},
		})
		if err != nil {
			log.Errorf("OnIceCandidate error %s", err)
		}
	})

	go func() {
		// Handle sfu stream messages
		for {
			res, err := sfustream.Recv()

			if err != nil {
				if err == io.EOF {
					// WebRTC Transport closed
					log.Infof("WebRTC Transport Closed")
					err = sfustream.CloseSend()
					if err != nil {
						log.Errorf("error sending close: %s", err)
					}
					return
				}

				errStatus, _ := status.FromError(err)
				if errStatus.Code() == codes.Canceled {
					err = sfustream.CloseSend()
					if err != nil {
						log.Errorf("error sending close: %s", err)
					}
					return
				}

				log.Errorf("Error receiving signal response: %v", err)
				return
			}

			switch payload := res.Payload.(type) {
			case *sfu.SignalReply_Join:
				// Set the remote SessionDescription
				log.Debugf("got answer: %s", payload.Join.Description)

				var sdp webrtc.SessionDescription
				err := json.Unmarshal(payload.Join.Description, &sdp)
				if err != nil {
					log.Errorf("sdp unmarshal error: %v", err)
					return
				}

				if err = t.SetRemoteDescription(sdp); err != nil {
					log.Errorf("join error %s", err)
					return
				}

			case *sfu.SignalReply_Description:
				var sdp webrtc.SessionDescription
				err := json.Unmarshal(payload.Description, &sdp)
				if err != nil {
					log.Errorf("sdp unmarshal error: %v", err)
					return
				}

				if sdp.Type == webrtc.SDPTypeOffer {
					log.Debugf("got offer: %v", sdp)

					var answer webrtc.SessionDescription
					answer, err = t.Answer(sdp)
					if err != nil {
						log.Errorf("negotiate error %s", err)
						continue
					}

					marshalled, err = json.Marshal(answer)
					if err != nil {
						log.Errorf("sdp marshall error %s", err)
						continue
					}

					err = sfustream.Send(&sfu.SignalRequest{
						Payload: &sfu.SignalRequest_Description{
							Description: marshalled,
						},
					})

					if err != nil {
						log.Errorf("negotiate error %s", err)
						continue
					}
				} else if sdp.Type == webrtc.SDPTypeAnswer {
					log.Debugf("got answer: %v", sdp)
					err = t.SetRemoteDescription(sdp)

					if err != nil {
						log.Errorf("negotiate error %s", err)
						continue
					}
				}
			case *sfu.SignalReply_Trickle:
				var candidate webrtc.ICECandidateInit
				_ = json.Unmarshal([]byte(payload.Trickle.Init), &candidate)
				err := t.AddICECandidate(candidate, int(payload.Trickle.Target))
				if err != nil {
					log.Errorf("error adding ice candidate: %e", err)
				}
			}
		}
	}()

	return t, nil
}

gha_license_id: MIT


text:
DESCRIPTION = "Minimal initramfs image for Tegra210 platforms with xusb firmware"
LICENSE = "MIT"

PACKAGE_INSTALL = "\
    tegra-firmware-xusb \
    tegra210-minimal-init \
"

IMAGE_FEATURES = ""
IMAGE_LINGUAS = ""
IMAGE_FSTYPES = "${INITRAMFS_FSTYPES}"

COPY_LIC_MANIFEST = "0"
COPY_LIC_DIRS = "0"

COMPATIBLE_MACHINE = "(tegra210)"

KERNELDEPMODDEPEND = ""

inherit core-image


text:
package internal

import (
	"strings"
	"testing"
)

type SnakeTest struct {
	input  string
	output string
}

var tests = []SnakeTest{
	{"a", "a"},
	{"snake", "snake"},
	{"A", "a"},
	{"ID", "id"},
	{"MOTD", "motd"},
	{"Snake", "snake"},
	{"SnakeTest", "snake_test"},
	{"APIResponse", "api_response"},
	{"SnakeID", "snake_id"},
	{"Snake_Id", "snake_id"},
	{"Snake_ID", "snake_id"},
	{"SnakeIDGoogle", "snake_id_google"},
	{"LinuxMOTD", "linux_motd"},
	{"OMGWTFBBQ", "omgwtfbbq"},
	{"omg_wtf_bbq", "omg_wtf_bbq"},
	{"woof_woof", "woof_woof"},
	{"_woof_woof", "_woof_woof"},
	{"woof_woof_", "woof_woof_"},
	{"WOOF", "woof"},
	{"Woof", "woof"},
	{"woof", "woof"},
	{"woof0_woof1", "woof0_woof1"},
	{"_woof0_woof1_2", "_woof0_woof1_2"},
	{"woof0_WOOF1_2", "woof0_woof1_2"},
	{"WOOF0", "woof0"},
	{"Woof1", "woof1"},
	{"woof2", "woof2"},
	{"woofWoof", "woof_woof"},
	{"woofWOOF", "woof_woof"},
	{"woof_WOOF", "woof_woof"},
	{"Woof_WOOF", "woof_woof"},
	{"WOOFWoofWoofWOOFWoofWoof", "woof_woof_woof_woof_woof_woof"},
	{"WOOF_Woof_woof_WOOF_Woof_woof", "woof_woof_woof_woof_woof_woof"},
	{"Woof_W", "woof_w"},
	{"Woof_w", "woof_w"},
	{"WoofW", "woof_w"},
	{"Woof_W_", "woof_w_"},
	{"Woof_w_", "woof_w_"},
	{"WoofW_", "woof_w_"},
	{"WOOF_", "woof_"},
	{"W_Woof", "w_woof"},
	{"w_Woof", "w_woof"},
	{"WWoof", "w_woof"},
	{"_W_Woof", "_w_woof"},
	{"_w_Woof", "_w_woof"},
	{"_WWoof", "_w_woof"},
	{"_WOOF", "_woof"},
	{"_woof", "_woof"},
}

func TestSnakeCase(t *testing.T) {
	for _, test := range tests {
		if SnakeCase(test.input) != test.output {
			t.Errorf("SnakeCase(%q) -> %q, want %q", test.input, SnakeCase(test.input), test.output)
		}
	}
}

func BenchmarkSnakeCase(b *testing.B) {
	for i := 0; i < b.N; i++ {
		for _, test := range tests {
			SnakeCase(test.input)
		}
	}
}

func BenchmarkToLower(b *testing.B) {
	for i := 0; i < b.N; i++ {
		for _, test := range tests {
			strings.ToLower(test.input)
		}
	}
}

repository: utrack/clay

repo_name: utrack/clay


text:
@article{bates2019simulators,
 author = {Bates, Lyndel J and Larue, Grégoire S and Filtness, Ashleigh J and Hawkins, Alana},
 journal = {Journal of the Australasian College of Road Safety},
 publisher = {Australasian College of Road Safety},
 title = {Simulators, driver education and disadvantaged groups: A scoping review},
 year = {2019}
}

license: Unlicense,MIT

detected_licenses: Unlicense MIT

gha_license_id: NOASSERTION

extension: bib


text:
# base recipe: meta-rauc/recipes-support/zstd/zstd_git.bb
# base branch: warrior
# base commit: f6a5845f22c791e4ef33f09ecada1c51c020b597

SUMMARY = "Zstandard - Fast real-time compression algorithm"
HOMEPAGE = "http://www.zstd.net"
LICENSE = "BSD & GPLv2"
LIC_FILES_CHKSUM = "file://LICENSE;md5=c7f0b161edbe52f5f345a3d1311d0b32 \
                    file://contrib/linux-kernel/COPYING;md5=39bba7d2cf0ba1036f2a6e2be52fe3f0"

inherit debian-package
require recipes-debian/sources/libzstd.inc

DEBIAN_UNPACK_DIR = "${WORKDIR}/zstd-${PV}"

EXTRA_OECMAKE_append = " -DTHREADS_PTHREAD_ARG=0"

do_install() {
    oe_runmake DESTDIR=${D} install
}

BBCLASSEXTEND = "native nativesdk"

repository: miraclelinux/meta-debian-extended

repo_name: miraclelinux/meta-debian-extended

branch_name: refs/heads/warrior

gha_language: BitBake


text:
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: walletrpc/walletkit.proto

package walletrpc // import "github.com/BTCGPU/lnd/lnrpc/walletrpc"

import (
	context "context"
	fmt "fmt"
	math "math"

	lnrpc "github.com/BTCGPU/lnd/lnrpc"
	signrpc "github.com/BTCGPU/lnd/lnrpc/signrpc"
	proto "github.com/golang/protobuf/proto"
	grpc "google.golang.org/grpc"
)

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

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

type WitnessType int32

const (
	WitnessType_UNKNOWN_WITNESS WitnessType = 0
	//
	//A witness that allows us to spend the output of a commitment transaction
	//after a relative lock-time lockout.
	WitnessType_COMMITMENT_TIME_LOCK WitnessType = 1
	//
	//A witness that allows us to spend a settled no-delay output immediately on a
	//counterparty's commitment transaction.
	WitnessType_COMMITMENT_NO_DELAY WitnessType = 2
	//
	//A witness that allows us to sweep the settled output of a malicious
	//counterparty's who broadcasts a revoked commitment transaction.
	WitnessType_COMMITMENT_REVOKE WitnessType = 3
	//
	//A witness that allows us to sweep an HTLC which we offered to the remote
	//party in the case that they broadcast a revoked commitment state.
	WitnessType_HTLC_OFFERED_REVOKE WitnessType = 4
	//
	//A witness that allows us to sweep an HTLC output sent to us in the case that
	//the remote party broadcasts a revoked commitment state.
	WitnessType_HTLC_ACCEPTED_REVOKE WitnessType = 5
	//
	//A witness that allows us to sweep an HTLC output that we extended to a
	//party, but was never fulfilled.  This HTLC output isn't directly on the
	//commitment transaction, but is the result of a confirmed second-level HTLC
	//transaction. As a result, we can only spend this after a CSV delay.
	WitnessType_HTLC_OFFERED_TIMEOUT_SECOND_LEVEL WitnessType = 6
	//
	//A witness that allows us to sweep an HTLC output that was offered to us, and
	//for which we have a payment preimage. This HTLC output isn't directly on our
	//commitment transaction, but is the result of confirmed second-level HTLC
	//transaction. As a result, we can only spend this after a CSV delay.
	WitnessType_HTLC_ACCEPTED_SUCCESS_SECOND_LEVEL WitnessType = 7
	//
	//A witness that allows us to sweep an HTLC that we offered to the remote
	//party which lies in the commitment transaction of the remote party. We can
	//spend this output after the absolute CLTV timeout of the HTLC as passed.
	WitnessType_HTLC_OFFERED_REMOTE_TIMEOUT WitnessType = 8
	//
	//A witness that allows us to sweep an HTLC that was offered to us by the
	//remote party. We use this witness in the case that the remote party goes to
	//chain, and we know the pre-image to the HTLC. We can sweep this without any
	//additional timeout.
	WitnessType_HTLC_ACCEPTED_REMOTE_SUCCESS WitnessType = 9
	//
	//A witness that allows us to sweep an HTLC from the remote party's commitment
	//transaction in the case that the broadcast a revoked commitment, but then
	//also immediately attempt to go to the second level to claim the HTLC.
	WitnessType_HTLC_SECOND_LEVEL_REVOKE WitnessType = 10
	//
	//A witness type that allows us to spend a regular p2wkh output that's sent to
	//an output which is under complete control of the backing wallet.
	WitnessType_WITNESS_KEY_HASH WitnessType = 11
	//
	//A witness type that allows us to sweep an output that sends to a nested P2SH
	//script that pays to a key solely under our control.
	WitnessType_NESTED_WITNESS_KEY_HASH WitnessType = 12
)

var WitnessType_name = map[int32]string{
	0:  "UNKNOWN_WITNESS",
	1:  "COMMITMENT_TIME_LOCK",
	2:  "COMMITMENT_NO_DELAY",
	3:  "COMMITMENT_REVOKE",
	4:  "HTLC_OFFERED_REVOKE",
	5:  "HTLC_ACCEPTED_REVOKE",
	6:  "HTLC_OFFERED_TIMEOUT_SECOND_LEVEL",
	7:  "HTLC_ACCEPTED_SUCCESS_SECOND_LEVEL",
	8:  "HTLC_OFFERED_REMOTE_TIMEOUT",
	9:  "HTLC_ACCEPTED_REMOTE_SUCCESS",
	10: "HTLC_SECOND_LEVEL_REVOKE",
	11: "WITNESS_KEY_HASH",
	12: "NESTED_WITNESS_KEY_HASH",
}

var WitnessType_value = map[string]int32{
	"UNKNOWN_WITNESS":                    0,
	"COMMITMENT_TIME_LOCK":               1,
	"COMMITMENT_NO_DELAY":                2,
	"COMMITMENT_REVOKE":                  3,
	"HTLC_OFFERED_REVOKE":                4,
	"HTLC_ACCEPTED_REVOKE":               5,
	"HTLC_OFFERED_TIMEOUT_SECOND_LEVEL":  6,
	"HTLC_ACCEPTED_SUCCESS_SECOND_LEVEL": 7,
	"HTLC_OFFERED_REMOTE_TIMEOUT":        8,
	"HTLC_ACCEPTED_REMOTE_SUCCESS":       9,
	"HTLC_SECOND_LEVEL_REVOKE":           10,
	"WITNESS_KEY_HASH":                   11,
	"NESTED_WITNESS_KEY_HASH":            12,
}

func (x WitnessType) String() string {
	return proto.EnumName(WitnessType_name, int32(x))
}

func (WitnessType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_6cc6942ac78249e5, []int{0}
}

type KeyReq struct {
	//*
	//Is the key finger print of the root pubkey that this request is targeting.
	//This allows the WalletKit to possibly serve out keys for multiple HD chains
	//via public derivation.
	KeyFingerPrint int32 `protobuf:"varint,1,opt,name=key_finger_print,json=keyFingerPrint,proto3" json:"key_finger_print,omitempty"`
	//*
	//The target key family to derive a key from. In other contexts, this is
	//known as the "account".
	KeyFamily            int32    `protobuf:"varint,2,opt,name=key_family,json=keyFamily,proto3" json:"key_family,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_KeyReq proto.InternalMessageInfo

func (m *KeyReq) GetKeyFingerPrint() int32 {
	if m != nil {
		return m.KeyFingerPrint
	}
	return 0
}

func (m *KeyReq) GetKeyFamily() int32 {
	if m != nil {
		return m.KeyFamily
	}
	return 0
}

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

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

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

var xxx_messageInfo_AddrRequest proto.InternalMessageInfo

type AddrResponse struct {
	//*
	//The address encoded using a bech32 format.
	Addr                 string   `protobuf:"bytes,1,opt,name=addr,proto3" json:"addr,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_AddrResponse proto.InternalMessageInfo

func (m *AddrResponse) GetAddr() string {
	if m != nil {
		return m.Addr
	}
	return ""
}

type Transaction struct {
	//*
	//The raw serialized transaction.
	TxHex                []byte   `protobuf:"bytes,1,opt,name=tx_hex,json=txHex,proto3" json:"tx_hex,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Transaction proto.InternalMessageInfo

func (m *Transaction) GetTxHex() []byte {
	if m != nil {
		return m.TxHex
	}
	return nil
}

type PublishResponse struct {
	//*
	//If blank, then no error occurred and the transaction was successfully
	//published. If not the empty string, then a string representation of the
	//broadcast error.
	//
	//TODO(roasbeef): map to a proper enum type
	PublishError         string   `protobuf:"bytes,1,opt,name=publish_error,json=publishError,proto3" json:"publish_error,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_PublishResponse proto.InternalMessageInfo

func (m *PublishResponse) GetPublishError() string {
	if m != nil {
		return m.PublishError
	}
	return ""
}

type SendOutputsRequest struct {
	//*
	//The number of satoshis per kilo weight that should be used when crafting
	//this transaction.
	SatPerKw int64 `protobuf:"varint,1,opt,name=sat_per_kw,json=satPerKw,proto3" json:"sat_per_kw,omitempty"`
	//*
	//A slice of the outputs that should be created in the transaction produced.
	Outputs              []*signrpc.TxOut `protobuf:"bytes,2,rep,name=outputs,proto3" json:"outputs,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

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

var xxx_messageInfo_SendOutputsRequest proto.InternalMessageInfo

func (m *SendOutputsRequest) GetSatPerKw() int64 {
	if m != nil {
		return m.SatPerKw
	}
	return 0
}

func (m *SendOutputsRequest) GetOutputs() []*signrpc.TxOut {
	if m != nil {
		return m.Outputs
	}
	return nil
}

type SendOutputsResponse struct {
	//*
	//The serialized transaction sent out on the network.
	RawTx                []byte   `protobuf:"bytes,1,opt,name=raw_tx,json=rawTx,proto3" json:"raw_tx,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_SendOutputsResponse proto.InternalMessageInfo

func (m *SendOutputsResponse) GetRawTx() []byte {
	if m != nil {
		return m.RawTx
	}
	return nil
}

type EstimateFeeRequest struct {
	//*
	//The number of confirmations to shoot for when estimating the fee.
	ConfTarget           int32    `protobuf:"varint,1,opt,name=conf_target,json=confTarget,proto3" json:"conf_target,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_EstimateFeeRequest proto.InternalMessageInfo

func (m *EstimateFeeRequest) GetConfTarget() int32 {
	if m != nil {
		return m.ConfTarget
	}
	return 0
}

type EstimateFeeResponse struct {
	//*
	//The amount of satoshis per kw that should be used in order to reach the
	//confirmation target in the request.
	SatPerKw             int64    `protobuf:"varint,1,opt,name=sat_per_kw,json=satPerKw,proto3" json:"sat_per_kw,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_EstimateFeeResponse proto.InternalMessageInfo

func (m *EstimateFeeResponse) GetSatPerKw() int64 {
	if m != nil {
		return m.SatPerKw
	}
	return 0
}

type PendingSweep struct {
	// The outpoint of the output we're attempting to sweep.
	Outpoint *lnrpc.OutPoint `protobuf:"bytes,1,opt,name=outpoint,proto3" json:"outpoint,omitempty"`
	// The witness type of the output we're attempting to sweep.
	WitnessType WitnessType `protobuf:"varint,2,opt,name=witness_type,proto3,enum=walletrpc.WitnessType" json:"witness_type,omitempty"`
	// The value of the output we're attempting to sweep.
	AmountSat uint32 `protobuf:"varint,3,opt,name=amount_sat,proto3" json:"amount_sat,omitempty"`
	//
	//The fee rate we'll use to sweep the output. The fee rate is only determined
	//once a sweeping transaction for the output is created, so it's possible for
	//this to be 0 before this.
	SatPerByte uint32 `protobuf:"varint,4,opt,name=sat_per_byte,proto3" json:"sat_per_byte,omitempty"`
	// The number of broadcast attempts we've made to sweep the output.
	BroadcastAttempts uint32 `protobuf:"varint,5,opt,name=broadcast_attempts,proto3" json:"broadcast_attempts,omitempty"`
	//
	//The next height of the chain at which we'll attempt to broadcast the
	//sweep transaction of the output.
	NextBroadcastHeight  uint32   `protobuf:"varint,6,opt,name=next_broadcast_height,proto3" json:"next_broadcast_height,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_PendingSweep proto.InternalMessageInfo

func (m *PendingSweep) GetOutpoint() *lnrpc.OutPoint {
	if m != nil {
		return m.Outpoint
	}
	return nil
}

func (m *PendingSweep) GetWitnessType() WitnessType {
	if m != nil {
		return m.WitnessType
	}
	return WitnessType_UNKNOWN_WITNESS
}

func (m *PendingSweep) GetAmountSat() uint32 {
	if m != nil {
		return m.AmountSat
	}
	return 0
}

func (m *PendingSweep) GetSatPerByte() uint32 {
	if m != nil {
		return m.SatPerByte
	}
	return 0
}

func (m *PendingSweep) GetBroadcastAttempts() uint32 {
	if m != nil {
		return m.BroadcastAttempts
	}
	return 0
}

func (m *PendingSweep) GetNextBroadcastHeight() uint32 {
	if m != nil {
		return m.NextBroadcastHeight
	}
	return 0
}

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

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

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

var xxx_messageInfo_PendingSweepsRequest proto.InternalMessageInfo

type PendingSweepsResponse struct {
	//
	//The set of outputs currently being swept by lnd's central batching engine.
	PendingSweeps        []*PendingSweep `protobuf:"bytes,1,rep,name=pending_sweeps,proto3" json:"pending_sweeps,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

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

var xxx_messageInfo_PendingSweepsResponse proto.InternalMessageInfo

func (m *PendingSweepsResponse) GetPendingSweeps() []*PendingSweep {
	if m != nil {
		return m.PendingSweeps
	}
	return nil
}

type BumpFeeRequest struct {
	// The input we're attempting to bump the fee of.
	Outpoint *lnrpc.OutPoint `protobuf:"bytes,1,opt,name=outpoint,proto3" json:"outpoint,omitempty"`
	// The target number of blocks that the input should be spent within.
	TargetConf uint32 `protobuf:"varint,2,opt,name=target_conf,proto3" json:"target_conf,omitempty"`
	//
	//The fee rate, expressed in sat/byte, that should be used to spend the input
	//with.
	SatPerByte           uint32   `protobuf:"varint,3,opt,name=sat_per_byte,proto3" json:"sat_per_byte,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_BumpFeeRequest proto.InternalMessageInfo

func (m *BumpFeeRequest) GetOutpoint() *lnrpc.OutPoint {
	if m != nil {
		return m.Outpoint
	}
	return nil
}

func (m *BumpFeeRequest) GetTargetConf() uint32 {
	if m != nil {
		return m.TargetConf
	}
	return 0
}

func (m *BumpFeeRequest) GetSatPerByte() uint32 {
	if m != nil {
		return m.SatPerByte
	}
	return 0
}

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

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

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

var xxx_messageInfo_BumpFeeResponse proto.InternalMessageInfo

func init() {
	proto.RegisterEnum("walletrpc.WitnessType", WitnessType_name, WitnessType_value)
	proto.RegisterType((*KeyReq)(nil), "walletrpc.KeyReq")
	proto.RegisterType((*AddrRequest)(nil), "walletrpc.AddrRequest")
	proto.RegisterType((*AddrResponse)(nil), "walletrpc.AddrResponse")
	proto.RegisterType((*Transaction)(nil), "walletrpc.Transaction")
	proto.RegisterType((*PublishResponse)(nil), "walletrpc.PublishResponse")
	proto.RegisterType((*SendOutputsRequest)(nil), "walletrpc.SendOutputsRequest")
	proto.RegisterType((*SendOutputsResponse)(nil), "walletrpc.SendOutputsResponse")
	proto.RegisterType((*EstimateFeeRequest)(nil), "walletrpc.EstimateFeeRequest")
	proto.RegisterType((*EstimateFeeResponse)(nil), "walletrpc.EstimateFeeResponse")
	proto.RegisterType((*PendingSweep)(nil), "walletrpc.PendingSweep")
	proto.RegisterType((*PendingSweepsRequest)(nil), "walletrpc.PendingSweepsRequest")
	proto.RegisterType((*PendingSweepsResponse)(nil), "walletrpc.PendingSweepsResponse")
	proto.RegisterType((*BumpFeeRequest)(nil), "walletrpc.BumpFeeRequest")
	proto.RegisterType((*BumpFeeResponse)(nil), "walletrpc.BumpFeeResponse")
}

func init() { proto.RegisterFile("walletrpc/walletkit.proto", fileDescriptor_6cc6942ac78249e5) }

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

// WalletKitClient is the client API for WalletKit service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type WalletKitClient interface {
	//*
	//DeriveNextKey attempts to derive the *next* key within the key family
	//(account in BIP43) specified. This method should return the next external
	//child within this branch.
	DeriveNextKey(ctx context.Context, in *KeyReq, opts ...grpc.CallOption) (*signrpc.KeyDescriptor, error)
	//*
	//DeriveKey attempts to derive an arbitrary key specified by the passed
	//KeyLocator.
	DeriveKey(ctx context.Context, in *signrpc.KeyLocator, opts ...grpc.CallOption) (*signrpc.KeyDescriptor, error)
	//*
	//NextAddr returns the next unused address within the wallet.
	NextAddr(ctx context.Context, in *AddrRequest, opts ...grpc.CallOption) (*AddrResponse, error)
	//*
	//PublishTransaction attempts to publish the passed transaction to the
	//network. Once this returns without an error, the wallet will continually
	//attempt to re-broadcast the transaction on start up, until it enters the
	//chain.
	PublishTransaction(ctx context.Context, in *Transaction, opts ...grpc.CallOption) (*PublishResponse, error)
	//*
	//SendOutputs is similar to the existing sendmany call in Bitcoind, and
	//allows the caller to create a transaction that sends to several outputs at
	//once. This is ideal when wanting to batch create a set of transactions.
	SendOutputs(ctx context.Context, in *SendOutputsRequest, opts ...grpc.CallOption) (*SendOutputsResponse, error)
	//*
	//EstimateFee attempts to query the internal fee estimator of the wallet to
	//determine the fee (in sat/kw) to attach to a transaction in order to
	//achieve the confirmation target.
	EstimateFee(ctx context.Context, in *EstimateFeeRequest, opts ...grpc.CallOption) (*EstimateFeeResponse, error)
	//
	//PendingSweeps returns lists of on-chain outputs that lnd is currently
	//attempting to sweep within its central batching engine. Outputs with similar
	//fee rates are batched together in order to sweep them within a single
	//transaction.
	//
	//NOTE: Some of the fields within PendingSweepsRequest are not guaranteed to
	//remain supported. This is an advanced API that depends on the internals of
	//the UtxoSweeper, so things may change.
	PendingSweeps(ctx context.Context, in *PendingSweepsRequest, opts ...grpc.CallOption) (*PendingSweepsResponse, error)
	//
	//BumpFee bumps the fee of an arbitrary input within a transaction. This RPC
	//takes a different approach than bitcoind's bumpfee command. lnd has a
	//central batching engine in which inputs with similar fee rates are batched
	//together to save on transaction fees. Due to this, we cannot rely on
	//bumping the fee on a specific transaction, since transactions can change at
	//any point with the addition of new inputs. The list of inputs that
	//currently exist within lnd's central batching engine can be retrieved
	//through the PendingSweeps RPC.
	//
	//When bumping the fee of an input that currently exists within lnd's central
	//batching engine, a higher fee transaction will be created that replaces the
	//lower fee transaction through the Replace-By-Fee (RBF) policy. If it
	//
	//This RPC also serves useful when wanting to perform a Child-Pays-For-Parent
	//(CPFP), where the child transaction pays for its parent's fee. This can be
	//done by specifying an outpoint within the low fee transaction that is under
	//the control of the wallet.
	//
	//The fee preference can be expressed either as a specific fee rate or a delta
	//of blocks in which the output should be swept on-chain within. If a fee
	//preference is not explicitly specified, then an error is returned.
	//
	//Note that this RPC currently doesn't perform any validation checks on the
	//fee preference being provided. For now, the responsibility of ensuring that
	//the new fee preference is sufficient is delegated to the user.
	BumpFee(ctx context.Context, in *BumpFeeRequest, opts ...grpc.CallOption) (*BumpFeeResponse, error)
}

type walletKitClient struct {
	cc *grpc.ClientConn
}

func NewWalletKitClient(cc *grpc.ClientConn) WalletKitClient {
	return &walletKitClient{cc}
}

func (c *walletKitClient) DeriveNextKey(ctx context.Context, in *KeyReq, opts ...grpc.CallOption) (*signrpc.KeyDescriptor, error) {
	out := new(signrpc.KeyDescriptor)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletKit/DeriveNextKey", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletKitClient) DeriveKey(ctx context.Context, in *signrpc.KeyLocator, opts ...grpc.CallOption) (*signrpc.KeyDescriptor, error) {
	out := new(signrpc.KeyDescriptor)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletKit/DeriveKey", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletKitClient) NextAddr(ctx context.Context, in *AddrRequest, opts ...grpc.CallOption) (*AddrResponse, error) {
	out := new(AddrResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletKit/NextAddr", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletKitClient) PublishTransaction(ctx context.Context, in *Transaction, opts ...grpc.CallOption) (*PublishResponse, error) {
	out := new(PublishResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletKit/PublishTransaction", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletKitClient) SendOutputs(ctx context.Context, in *SendOutputsRequest, opts ...grpc.CallOption) (*SendOutputsResponse, error) {
	out := new(SendOutputsResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletKit/SendOutputs", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletKitClient) EstimateFee(ctx context.Context, in *EstimateFeeRequest, opts ...grpc.CallOption) (*EstimateFeeResponse, error) {
	out := new(EstimateFeeResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletKit/EstimateFee", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletKitClient) PendingSweeps(ctx context.Context, in *PendingSweepsRequest, opts ...grpc.CallOption) (*PendingSweepsResponse, error) {
	out := new(PendingSweepsResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletKit/PendingSweeps", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletKitClient) BumpFee(ctx context.Context, in *BumpFeeRequest, opts ...grpc.CallOption) (*BumpFeeResponse, error) {
	out := new(BumpFeeResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletKit/BumpFee", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// WalletKitServer is the server API for WalletKit service.
type WalletKitServer interface {
	//*
	//DeriveNextKey attempts to derive the *next* key within the key family
	//(account in BIP43) specified. This method should return the next external
	//child within this branch.
	DeriveNextKey(context.Context, *KeyReq) (*signrpc.KeyDescriptor, error)
	//*
	//DeriveKey attempts to derive an arbitrary key specified by the passed
	//KeyLocator.
	DeriveKey(context.Context, *signrpc.KeyLocator) (*signrpc.KeyDescriptor, error)
	//*
	//NextAddr returns the next unused address within the wallet.
	NextAddr(context.Context, *AddrRequest) (*AddrResponse, error)
	//*
	//PublishTransaction attempts to publish the passed transaction to the
	//network. Once this returns without an error, the wallet will continually
	//attempt to re-broadcast the transaction on start up, until it enters the
	//chain.
	PublishTransaction(context.Context, *Transaction) (*PublishResponse, error)
	//*
	//SendOutputs is similar to the existing sendmany call in Bitcoind, and
	//allows the caller to create a transaction that sends to several outputs at
	//once. This is ideal when wanting to batch create a set of transactions.
	SendOutputs(context.Context, *SendOutputsRequest) (*SendOutputsResponse, error)
	//*
	//EstimateFee attempts to query the internal fee estimator of the wallet to
	//determine the fee (in sat/kw) to attach to a transaction in order to
	//achieve the confirmation target.
	EstimateFee(context.Context, *EstimateFeeRequest) (*EstimateFeeResponse, error)
	//
	//PendingSweeps returns lists of on-chain outputs that lnd is currently
	//attempting to sweep within its central batching engine. Outputs with similar
	//fee rates are batched together in order to sweep them within a single
	//transaction.
	//
	//NOTE: Some of the fields within PendingSweepsRequest are not guaranteed to
	//remain supported. This is an advanced API that depends on the internals of
	//the UtxoSweeper, so things may change.
	PendingSweeps(context.Context, *PendingSweepsRequest) (*PendingSweepsResponse, error)
	//
	//BumpFee bumps the fee of an arbitrary input within a transaction. This RPC
	//takes a different approach than bitcoind's bumpfee command. lnd has a
	//central batching engine in which inputs with similar fee rates are batched
	//together to save on transaction fees. Due to this, we cannot rely on
	//bumping the fee on a specific transaction, since transactions can change at
	//any point with the addition of new inputs. The list of inputs that
	//currently exist within lnd's central batching engine can be retrieved
	//through the PendingSweeps RPC.
	//
	//When bumping the fee of an input that currently exists within lnd's central
	//batching engine, a higher fee transaction will be created that replaces the
	//lower fee transaction through the Replace-By-Fee (RBF) policy. If it
	//
	//This RPC also serves useful when wanting to perform a Child-Pays-For-Parent
	//(CPFP), where the child transaction pays for its parent's fee. This can be
	//done by specifying an outpoint within the low fee transaction that is under
	//the control of the wallet.
	//
	//The fee preference can be expressed either as a specific fee rate or a delta
	//of blocks in which the output should be swept on-chain within. If a fee
	//preference is not explicitly specified, then an error is returned.
	//
	//Note that this RPC currently doesn't perform any validation checks on the
	//fee preference being provided. For now, the responsibility of ensuring that
	//the new fee preference is sufficient is delegated to the user.
	BumpFee(context.Context, *BumpFeeRequest) (*BumpFeeResponse, error)
}

func RegisterWalletKitServer(s *grpc.Server, srv WalletKitServer) {
	s.RegisterService(&_WalletKit_serviceDesc, srv)
}

func _WalletKit_DeriveNextKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(KeyReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletKitServer).DeriveNextKey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletKit/DeriveNextKey",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletKitServer).DeriveNextKey(ctx, req.(*KeyReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletKit_DeriveKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(signrpc.KeyLocator)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletKitServer).DeriveKey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletKit/DeriveKey",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletKitServer).DeriveKey(ctx, req.(*signrpc.KeyLocator))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletKit_NextAddr_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddrRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletKitServer).NextAddr(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletKit/NextAddr",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletKitServer).NextAddr(ctx, req.(*AddrRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletKit_PublishTransaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Transaction)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletKitServer).PublishTransaction(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletKit/PublishTransaction",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletKitServer).PublishTransaction(ctx, req.(*Transaction))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletKit_SendOutputs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SendOutputsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletKitServer).SendOutputs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletKit/SendOutputs",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletKitServer).SendOutputs(ctx, req.(*SendOutputsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletKit_EstimateFee_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EstimateFeeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletKitServer).EstimateFee(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletKit/EstimateFee",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletKitServer).EstimateFee(ctx, req.(*EstimateFeeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletKit_PendingSweeps_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PendingSweepsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletKitServer).PendingSweeps(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletKit/PendingSweeps",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletKitServer).PendingSweeps(ctx, req.(*PendingSweepsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletKit_BumpFee_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BumpFeeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletKitServer).BumpFee(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletKit/BumpFee",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletKitServer).BumpFee(ctx, req.(*BumpFeeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _WalletKit_serviceDesc = grpc.ServiceDesc{
	ServiceName: "walletrpc.WalletKit",
	HandlerType: (*WalletKitServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "DeriveNextKey",
			Handler:    _WalletKit_DeriveNextKey_Handler,
		},
		{
			MethodName: "DeriveKey",
			Handler:    _WalletKit_DeriveKey_Handler,
		},
		{
			MethodName: "NextAddr",
			Handler:    _WalletKit_NextAddr_Handler,
		},
		{
			MethodName: "PublishTransaction",
			Handler:    _WalletKit_PublishTransaction_Handler,
		},
		{
			MethodName: "SendOutputs",
			Handler:    _WalletKit_SendOutputs_Handler,
		},
		{
			MethodName: "EstimateFee",
			Handler:    _WalletKit_EstimateFee_Handler,
		},
		{
			MethodName: "PendingSweeps",
			Handler:    _WalletKit_PendingSweeps_Handler,
		},
		{
			MethodName: "BumpFee",
			Handler:    _WalletKit_BumpFee_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "walletrpc/walletkit.proto",
}

repository: BTCGPU/lnd

repo_name: BTCGPU/lnd


text:
DESCRIPTION = "Enlightenment DR17 theme for Angstrom"
LICENSE = "MIT/BSD"
DEPENDS = "edje-native eet-native e-wm places gnome-icon-theme"

PACKAGES_DYNAMIC = "e-wm-config-angstrom*"

PR = "r14"

SRC_URI = " \
          file://configs \
          "
S = "${WORKDIR}/configs"

# [09:16:17] * koen mumbles something about binary config file
# [09:16:19] <raster> eet -d e.cfg config e.src
# [09:16:29] <raster> will get u a test dump of it (as e.src)
# [09:17:09] <raster> eet -e e.cfg config e.src 1
# [09:17:12] <raster> will re-encode

do_compile() {
rm ${S}/patches -rf
for dir in ${S}/* ; do
	cd $dir
	for i in *.src ; do
		eet -e $(echo $i | sed s:src:cfg:g) config $i 1
	done
done
}

do_install() {
 	for i in ${WORKDIR}/configs/* ; do
		install -d ${D}${datadir}/enlightenment/data/config/$(basename $i)/

		install -m 0644 ${S}/$(basename $i)/*.cfg ${D}${datadir}/enlightenment/data/config/$(basename $i)/
		install -m 0644 ${S}/$(basename $i)/*.desktop ${D}${datadir}/enlightenment/data/config/$(basename $i)/
		install -m 0644 ${S}/$(basename $i)/*.png ${D}${datadir}/enlightenment/data/config/$(basename $i)/
	done
}

RDEPENDS_${PN} = "e-wm places gnome-icon-theme"

python populate_packages_prepend () {
	angstrom_e_dir = bb.data.expand('${datadir}/enlightenment/data/config', d)
	do_split_packages(d, angstrom_e_dir, '(.*)', 'e-wm-config-%s', 'E17 window manager %s config', extra_depends='e-wm places gnome-icon-theme', allow_links=True, allow_dirs=True)
}

PACKAGE_ARCH = "all"

repository: overo/overo-oe-natty

repo_name: overo/overo-oe-natty

branch_name: HEAD


text:
package main

import (
	"crypto/md5"
	"crypto/sha1"
	"crypto/sha256"
	"fmt"
	"io"
	"os"
)

func main() {
	if len(os.Args) < 2 {
		fmt.Fprintf(os.Stderr, "Error! Not enough arguments given.\n")
		fmt.Fprintf(os.Stderr, "Usage: %s [files to generate checksums]\n", os.Args[0])
		fmt.Fprintf(os.Stderr, "Example: %s firstfile.txt folder/anotherfile.txt /etc/thirdfile.txt\n", os.Args[0])
	}

	filelist := os.Args[1:]

	if err := hashAndPrint(filelist); err != nil {
		fmt.Fprintf(os.Stderr, "Could not hash files! Error:\n%s", err)
		os.Exit(1)
	}

}

func hashAndPrint(filelist []string) error {
	hsha256 := sha256.New()
	hsha1 := sha1.New()
	hmd5 := md5.New()

	for _, file := range filelist {
		// We print a newline at the very beginning to make sure the output is clearly seperated and very readable
		fmt.Print("\n")
		f, err := os.Open(file)
		if os.IsNotExist(err) {
			fmt.Fprintf(os.Stderr, "Could not open file for reading: %s\n", file)
			continue
		} else if err != nil {
			return err
		}
		defer f.Close()

		data := make([]byte, 4096)

		for {
			data = data[:cap(data)]
			n, err := f.Read(data)
			if err != nil {
				if err == io.EOF {
					break
				}
				return err
			}
			data = data[:n]
			hsha256.Write(data)
			hsha1.Write(data)
			hmd5.Write(data)
		}

		fmt.Println(file)
		fmt.Printf("SHA256: %x\n", hsha256.Sum(nil))
		fmt.Printf("SHA1: %x\n", hsha1.Sum(nil))
		fmt.Printf("MD5: %x\n", hmd5.Sum(nil))

		// Reset our hashes to initial value, this allows us to reuse the same ones we created above
		hsha256.Reset()
		hsha1.Reset()
		hmd5.Reset()
	}

	return nil
}


text:
require bug-app.inc

DESCRIPTION = "A super simple app that demonstrates the JNotify API."
HOMEPAGE = "http://buglabs.net/applications/JNotify+Home+Dir+Listener"

DEPENDS += "net.contentobjects.jnotify "

PV = "2"

SRC_LINK = "http://buglabs.net/program_version/download/1036"

APIVERSION = "1.4.3"


text:
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.28.1
// 	protoc        v3.21.12
// source: pb/circuitv1.proto

package pb

import (
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	reflect "reflect"
	sync "sync"
)

const (
	// Verify that this generated code is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	// Verify that runtime/protoimpl is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

type CircuitRelay_Status int32

const (
	CircuitRelay_SUCCESS                    CircuitRelay_Status = 100
	CircuitRelay_HOP_SRC_ADDR_TOO_LONG      CircuitRelay_Status = 220
	CircuitRelay_HOP_DST_ADDR_TOO_LONG      CircuitRelay_Status = 221
	CircuitRelay_HOP_SRC_MULTIADDR_INVALID  CircuitRelay_Status = 250
	CircuitRelay_HOP_DST_MULTIADDR_INVALID  CircuitRelay_Status = 251
	CircuitRelay_HOP_NO_CONN_TO_DST         CircuitRelay_Status = 260
	CircuitRelay_HOP_CANT_DIAL_DST          CircuitRelay_Status = 261
	CircuitRelay_HOP_CANT_OPEN_DST_STREAM   CircuitRelay_Status = 262
	CircuitRelay_HOP_CANT_SPEAK_RELAY       CircuitRelay_Status = 270
	CircuitRelay_HOP_CANT_RELAY_TO_SELF     CircuitRelay_Status = 280
	CircuitRelay_STOP_SRC_ADDR_TOO_LONG     CircuitRelay_Status = 320
	CircuitRelay_STOP_DST_ADDR_TOO_LONG     CircuitRelay_Status = 321
	CircuitRelay_STOP_SRC_MULTIADDR_INVALID CircuitRelay_Status = 350
	CircuitRelay_STOP_DST_MULTIADDR_INVALID CircuitRelay_Status = 351
	CircuitRelay_STOP_RELAY_REFUSED         CircuitRelay_Status = 390
	CircuitRelay_MALFORMED_MESSAGE          CircuitRelay_Status = 400
)

// Enum value maps for CircuitRelay_Status.
var (
	CircuitRelay_Status_name = map[int32]string{
		100: "SUCCESS",
		220: "HOP_SRC_ADDR_TOO_LONG",
		221: "HOP_DST_ADDR_TOO_LONG",
		250: "HOP_SRC_MULTIADDR_INVALID",
		251: "HOP_DST_MULTIADDR_INVALID",
		260: "HOP_NO_CONN_TO_DST",
		261: "HOP_CANT_DIAL_DST",
		262: "HOP_CANT_OPEN_DST_STREAM",
		270: "HOP_CANT_SPEAK_RELAY",
		280: "HOP_CANT_RELAY_TO_SELF",
		320: "STOP_SRC_ADDR_TOO_LONG",
		321: "STOP_DST_ADDR_TOO_LONG",
		350: "STOP_SRC_MULTIADDR_INVALID",
		351: "STOP_DST_MULTIADDR_INVALID",
		390: "STOP_RELAY_REFUSED",
		400: "MALFORMED_MESSAGE",
	}
	CircuitRelay_Status_value = map[string]int32{
		"SUCCESS":                    100,
		"HOP_SRC_ADDR_TOO_LONG":      220,
		"HOP_DST_ADDR_TOO_LONG":      221,
		"HOP_SRC_MULTIADDR_INVALID":  250,
		"HOP_DST_MULTIADDR_INVALID":  251,
		"HOP_NO_CONN_TO_DST":         260,
		"HOP_CANT_DIAL_DST":          261,
		"HOP_CANT_OPEN_DST_STREAM":   262,
		"HOP_CANT_SPEAK_RELAY":       270,
		"HOP_CANT_RELAY_TO_SELF":     280,
		"STOP_SRC_ADDR_TOO_LONG":     320,
		"STOP_DST_ADDR_TOO_LONG":     321,
		"STOP_SRC_MULTIADDR_INVALID": 350,
		"STOP_DST_MULTIADDR_INVALID": 351,
		"STOP_RELAY_REFUSED":         390,
		"MALFORMED_MESSAGE":          400,
	}
)

func (x CircuitRelay_Status) Enum() *CircuitRelay_Status {
	p := new(CircuitRelay_Status)
	*p = x
	return p
}

func (x CircuitRelay_Status) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (CircuitRelay_Status) Descriptor() protoreflect.EnumDescriptor {
	return file_pb_circuitv1_proto_enumTypes[0].Descriptor()
}

func (CircuitRelay_Status) Type() protoreflect.EnumType {
	return &file_pb_circuitv1_proto_enumTypes[0]
}

func (x CircuitRelay_Status) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Do not use.
func (x *CircuitRelay_Status) UnmarshalJSON(b []byte) error {
	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
	if err != nil {
		return err
	}
	*x = CircuitRelay_Status(num)
	return nil
}

// Deprecated: Use CircuitRelay_Status.Descriptor instead.
func (CircuitRelay_Status) EnumDescriptor() ([]byte, []int) {
	return file_pb_circuitv1_proto_rawDescGZIP(), []int{0, 0}
}

type CircuitRelay_Type int32

const (
	CircuitRelay_HOP     CircuitRelay_Type = 1
	CircuitRelay_STOP    CircuitRelay_Type = 2
	CircuitRelay_STATUS  CircuitRelay_Type = 3
	CircuitRelay_CAN_HOP CircuitRelay_Type = 4
)

// Enum value maps for CircuitRelay_Type.
var (
	CircuitRelay_Type_name = map[int32]string{
		1: "HOP",
		2: "STOP",
		3: "STATUS",
		4: "CAN_HOP",
	}
	CircuitRelay_Type_value = map[string]int32{
		"HOP":     1,
		"STOP":    2,
		"STATUS":  3,
		"CAN_HOP": 4,
	}
)

func (x CircuitRelay_Type) Enum() *CircuitRelay_Type {
	p := new(CircuitRelay_Type)
	*p = x
	return p
}

func (x CircuitRelay_Type) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (CircuitRelay_Type) Descriptor() protoreflect.EnumDescriptor {
	return file_pb_circuitv1_proto_enumTypes[1].Descriptor()
}

func (CircuitRelay_Type) Type() protoreflect.EnumType {
	return &file_pb_circuitv1_proto_enumTypes[1]
}

func (x CircuitRelay_Type) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Do not use.
func (x *CircuitRelay_Type) UnmarshalJSON(b []byte) error {
	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
	if err != nil {
		return err
	}
	*x = CircuitRelay_Type(num)
	return nil
}

// Deprecated: Use CircuitRelay_Type.Descriptor instead.
func (CircuitRelay_Type) EnumDescriptor() ([]byte, []int) {
	return file_pb_circuitv1_proto_rawDescGZIP(), []int{0, 1}
}

type CircuitRelay struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Type    *CircuitRelay_Type   `protobuf:"varint,1,opt,name=type,enum=circuitv1.pb.CircuitRelay_Type" json:"type,omitempty"` // Type of the message
	SrcPeer *CircuitRelay_Peer   `protobuf:"bytes,2,opt,name=srcPeer" json:"srcPeer,omitempty"`                                // srcPeer and dstPeer are used when Type is HOP or STOP
	DstPeer *CircuitRelay_Peer   `protobuf:"bytes,3,opt,name=dstPeer" json:"dstPeer,omitempty"`
	Code    *CircuitRelay_Status `protobuf:"varint,4,opt,name=code,enum=circuitv1.pb.CircuitRelay_Status" json:"code,omitempty"` // Status code, used when Type is STATUS
}

func (x *CircuitRelay) Reset() {
	*x = CircuitRelay{}
	if protoimpl.UnsafeEnabled {
		mi := &file_pb_circuitv1_proto_msgTypes[0]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *CircuitRelay) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*CircuitRelay) ProtoMessage() {}

func (x *CircuitRelay) ProtoReflect() protoreflect.Message {
	mi := &file_pb_circuitv1_proto_msgTypes[0]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use CircuitRelay.ProtoReflect.Descriptor instead.
func (*CircuitRelay) Descriptor() ([]byte, []int) {
	return file_pb_circuitv1_proto_rawDescGZIP(), []int{0}
}

func (x *CircuitRelay) GetType() CircuitRelay_Type {
	if x != nil && x.Type != nil {
		return *x.Type
	}
	return CircuitRelay_HOP
}

func (x *CircuitRelay) GetSrcPeer() *CircuitRelay_Peer {
	if x != nil {
		return x.SrcPeer
	}
	return nil
}

func (x *CircuitRelay) GetDstPeer() *CircuitRelay_Peer {
	if x != nil {
		return x.DstPeer
	}
	return nil
}

func (x *CircuitRelay) GetCode() CircuitRelay_Status {
	if x != nil && x.Code != nil {
		return *x.Code
	}
	return CircuitRelay_SUCCESS
}

type CircuitRelay_Peer struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Id    []byte   `protobuf:"bytes,1,req,name=id" json:"id,omitempty"`       // peer id
	Addrs [][]byte `protobuf:"bytes,2,rep,name=addrs" json:"addrs,omitempty"` // peer's known addresses
}

func (x *CircuitRelay_Peer) Reset() {
	*x = CircuitRelay_Peer{}
	if protoimpl.UnsafeEnabled {
		mi := &file_pb_circuitv1_proto_msgTypes[1]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *CircuitRelay_Peer) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*CircuitRelay_Peer) ProtoMessage() {}

func (x *CircuitRelay_Peer) ProtoReflect() protoreflect.Message {
	mi := &file_pb_circuitv1_proto_msgTypes[1]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use CircuitRelay_Peer.ProtoReflect.Descriptor instead.
func (*CircuitRelay_Peer) Descriptor() ([]byte, []int) {
	return file_pb_circuitv1_proto_rawDescGZIP(), []int{0, 0}
}

func (x *CircuitRelay_Peer) GetId() []byte {
	if x != nil {
		return x.Id
	}
	return nil
}

func (x *CircuitRelay_Peer) GetAddrs() [][]byte {
	if x != nil {
		return x.Addrs
	}
	return nil
}

var File_pb_circuitv1_proto protoreflect.FileDescriptor

var file_pb_circuitv1_proto_rawDesc = []byte{
	0x0a, 0x12, 0x70, 0x62, 0x2f, 0x63, 0x69, 0x72, 0x63, 0x75, 0x69, 0x74, 0x76, 0x31, 0x2e, 0x70,
	0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0c, 0x63, 0x69, 0x72, 0x63, 0x75, 0x69, 0x74, 0x76, 0x31, 0x2e,
	0x70, 0x62, 0x22, 0x97, 0x06, 0x0a, 0x0c, 0x43, 0x69, 0x72, 0x63, 0x75, 0x69, 0x74, 0x52, 0x65,
	0x6c, 0x61, 0x79, 0x12, 0x33, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28,
	0x0e, 0x32, 0x1f, 0x2e, 0x63, 0x69, 0x72, 0x63, 0x75, 0x69, 0x74, 0x76, 0x31, 0x2e, 0x70, 0x62,
	0x2e, 0x43, 0x69, 0x72, 0x63, 0x75, 0x69, 0x74, 0x52, 0x65, 0x6c, 0x61, 0x79, 0x2e, 0x54, 0x79,
	0x70, 0x65, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x39, 0x0a, 0x07, 0x73, 0x72, 0x63, 0x50,
	0x65, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x63, 0x69, 0x72, 0x63,
	0x75, 0x69, 0x74, 0x76, 0x31, 0x2e, 0x70, 0x62, 0x2e, 0x43, 0x69, 0x72, 0x63, 0x75, 0x69, 0x74,
	0x52, 0x65, 0x6c, 0x61, 0x79, 0x2e, 0x50, 0x65, 0x65, 0x72, 0x52, 0x07, 0x73, 0x72, 0x63, 0x50,
	0x65, 0x65, 0x72, 0x12, 0x39, 0x0a, 0x07, 0x64, 0x73, 0x74, 0x50, 0x65, 0x65, 0x72, 0x18, 0x03,
	0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x63, 0x69, 0x72, 0x63, 0x75, 0x69, 0x74, 0x76, 0x31,
	0x2e, 0x70, 0x62, 0x2e, 0x43, 0x69, 0x72, 0x63, 0x75, 0x69, 0x74, 0x52, 0x65, 0x6c, 0x61, 0x79,
	0x2e, 0x50, 0x65, 0x65, 0x72, 0x52, 0x07, 0x64, 0x73, 0x74, 0x50, 0x65, 0x65, 0x72, 0x12, 0x35,
	0x0a, 0x04, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x21, 0x2e, 0x63,
	0x69, 0x72, 0x63, 0x75, 0x69, 0x74, 0x76, 0x31, 0x2e, 0x70, 0x62, 0x2e, 0x43, 0x69, 0x72, 0x63,
	0x75, 0x69, 0x74, 0x52, 0x65, 0x6c, 0x61, 0x79, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52,
	0x04, 0x63, 0x6f, 0x64, 0x65, 0x1a, 0x2c, 0x0a, 0x04, 0x50, 0x65, 0x65, 0x72, 0x12, 0x0e, 0x0a,
	0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x02, 0x28, 0x0c, 0x52, 0x02, 0x69, 0x64, 0x12, 0x14, 0x0a,
	0x05, 0x61, 0x64, 0x64, 0x72, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x05, 0x61, 0x64,
	0x64, 0x72, 0x73, 0x22, 0xc2, 0x03, 0x0a, 0x06, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x0b,
	0x0a, 0x07, 0x53, 0x55, 0x43, 0x43, 0x45, 0x53, 0x53, 0x10, 0x64, 0x12, 0x1a, 0x0a, 0x15, 0x48,
	0x4f, 0x50, 0x5f, 0x53, 0x52, 0x43, 0x5f, 0x41, 0x44, 0x44, 0x52, 0x5f, 0x54, 0x4f, 0x4f, 0x5f,
	0x4c, 0x4f, 0x4e, 0x47, 0x10, 0xdc, 0x01, 0x12, 0x1a, 0x0a, 0x15, 0x48, 0x4f, 0x50, 0x5f, 0x44,
	0x53, 0x54, 0x5f, 0x41, 0x44, 0x44, 0x52, 0x5f, 0x54, 0x4f, 0x4f, 0x5f, 0x4c, 0x4f, 0x4e, 0x47,
	0x10, 0xdd, 0x01, 0x12, 0x1e, 0x0a, 0x19, 0x48, 0x4f, 0x50, 0x5f, 0x53, 0x52, 0x43, 0x5f, 0x4d,
	0x55, 0x4c, 0x54, 0x49, 0x41, 0x44, 0x44, 0x52, 0x5f, 0x49, 0x4e, 0x56, 0x41, 0x4c, 0x49, 0x44,
	0x10, 0xfa, 0x01, 0x12, 0x1e, 0x0a, 0x19, 0x48, 0x4f, 0x50, 0x5f, 0x44, 0x53, 0x54, 0x5f, 0x4d,
	0x55, 0x4c, 0x54, 0x49, 0x41, 0x44, 0x44, 0x52, 0x5f, 0x49, 0x4e, 0x56, 0x41, 0x4c, 0x49, 0x44,
	0x10, 0xfb, 0x01, 0x12, 0x17, 0x0a, 0x12, 0x48, 0x4f, 0x50, 0x5f, 0x4e, 0x4f, 0x5f, 0x43, 0x4f,
	0x4e, 0x4e, 0x5f, 0x54, 0x4f, 0x5f, 0x44, 0x53, 0x54, 0x10, 0x84, 0x02, 0x12, 0x16, 0x0a, 0x11,
	0x48, 0x4f, 0x50, 0x5f, 0x43, 0x41, 0x4e, 0x54, 0x5f, 0x44, 0x49, 0x41, 0x4c, 0x5f, 0x44, 0x53,
	0x54, 0x10, 0x85, 0x02, 0x12, 0x1d, 0x0a, 0x18, 0x48, 0x4f, 0x50, 0x5f, 0x43, 0x41, 0x4e, 0x54,
	0x5f, 0x4f, 0x50, 0x45, 0x4e, 0x5f, 0x44, 0x53, 0x54, 0x5f, 0x53, 0x54, 0x52, 0x45, 0x41, 0x4d,
	0x10, 0x86, 0x02, 0x12, 0x19, 0x0a, 0x14, 0x48, 0x4f, 0x50, 0x5f, 0x43, 0x41, 0x4e, 0x54, 0x5f,
	0x53, 0x50, 0x45, 0x41, 0x4b, 0x5f, 0x52, 0x45, 0x4c, 0x41, 0x59, 0x10, 0x8e, 0x02, 0x12, 0x1b,
	0x0a, 0x16, 0x48, 0x4f, 0x50, 0x5f, 0x43, 0x41, 0x4e, 0x54, 0x5f, 0x52, 0x45, 0x4c, 0x41, 0x59,
	0x5f, 0x54, 0x4f, 0x5f, 0x53, 0x45, 0x4c, 0x46, 0x10, 0x98, 0x02, 0x12, 0x1b, 0x0a, 0x16, 0x53,
	0x54, 0x4f, 0x50, 0x5f, 0x53, 0x52, 0x43, 0x5f, 0x41, 0x44, 0x44, 0x52, 0x5f, 0x54, 0x4f, 0x4f,
	0x5f, 0x4c, 0x4f, 0x4e, 0x47, 0x10, 0xc0, 0x02, 0x12, 0x1b, 0x0a, 0x16, 0x53, 0x54, 0x4f, 0x50,
	0x5f, 0x44, 0x53, 0x54, 0x5f, 0x41, 0x44, 0x44, 0x52, 0x5f, 0x54, 0x4f, 0x4f, 0x5f, 0x4c, 0x4f,
	0x4e, 0x47, 0x10, 0xc1, 0x02, 0x12, 0x1f, 0x0a, 0x1a, 0x53, 0x54, 0x4f, 0x50, 0x5f, 0x53, 0x52,
	0x43, 0x5f, 0x4d, 0x55, 0x4c, 0x54, 0x49, 0x41, 0x44, 0x44, 0x52, 0x5f, 0x49, 0x4e, 0x56, 0x41,
	0x4c, 0x49, 0x44, 0x10, 0xde, 0x02, 0x12, 0x1f, 0x0a, 0x1a, 0x53, 0x54, 0x4f, 0x50, 0x5f, 0x44,
	0x53, 0x54, 0x5f, 0x4d, 0x55, 0x4c, 0x54, 0x49, 0x41, 0x44, 0x44, 0x52, 0x5f, 0x49, 0x4e, 0x56,
	0x41, 0x4c, 0x49, 0x44, 0x10, 0xdf, 0x02, 0x12, 0x17, 0x0a, 0x12, 0x53, 0x54, 0x4f, 0x50, 0x5f,
	0x52, 0x45, 0x4c, 0x41, 0x59, 0x5f, 0x52, 0x45, 0x46, 0x55, 0x53, 0x45, 0x44, 0x10, 0x86, 0x03,
	0x12, 0x16, 0x0a, 0x11, 0x4d, 0x41, 0x4c, 0x46, 0x4f, 0x52, 0x4d, 0x45, 0x44, 0x5f, 0x4d, 0x45,
	0x53, 0x53, 0x41, 0x47, 0x45, 0x10, 0x90, 0x03, 0x22, 0x32, 0x0a, 0x04, 0x54, 0x79, 0x70, 0x65,
	0x12, 0x07, 0x0a, 0x03, 0x48, 0x4f, 0x50, 0x10, 0x01, 0x12, 0x08, 0x0a, 0x04, 0x53, 0x54, 0x4f,
	0x50, 0x10, 0x02, 0x12, 0x0a, 0x0a, 0x06, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x10, 0x03, 0x12,
	0x0b, 0x0a, 0x07, 0x43, 0x41, 0x4e, 0x5f, 0x48, 0x4f, 0x50, 0x10, 0x04,
}

var (
	file_pb_circuitv1_proto_rawDescOnce sync.Once
	file_pb_circuitv1_proto_rawDescData = file_pb_circuitv1_proto_rawDesc
)

func file_pb_circuitv1_proto_rawDescGZIP() []byte {
	file_pb_circuitv1_proto_rawDescOnce.Do(func() {
		file_pb_circuitv1_proto_rawDescData = protoimpl.X.CompressGZIP(file_pb_circuitv1_proto_rawDescData)
	})
	return file_pb_circuitv1_proto_rawDescData
}

var file_pb_circuitv1_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
var file_pb_circuitv1_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
var file_pb_circuitv1_proto_goTypes = []interface{}{
	(CircuitRelay_Status)(0),  // 0: circuitv1.pb.CircuitRelay.Status
	(CircuitRelay_Type)(0),    // 1: circuitv1.pb.CircuitRelay.Type
	(*CircuitRelay)(nil),      // 2: circuitv1.pb.CircuitRelay
	(*CircuitRelay_Peer)(nil), // 3: circuitv1.pb.CircuitRelay.Peer
}
var file_pb_circuitv1_proto_depIdxs = []int32{
	1, // 0: circuitv1.pb.CircuitRelay.type:type_name -> circuitv1.pb.CircuitRelay.Type
	3, // 1: circuitv1.pb.CircuitRelay.srcPeer:type_name -> circuitv1.pb.CircuitRelay.Peer
	3, // 2: circuitv1.pb.CircuitRelay.dstPeer:type_name -> circuitv1.pb.CircuitRelay.Peer
	0, // 3: circuitv1.pb.CircuitRelay.code:type_name -> circuitv1.pb.CircuitRelay.Status
	4, // [4:4] is the sub-list for method output_type
	4, // [4:4] is the sub-list for method input_type
	4, // [4:4] is the sub-list for extension type_name
	4, // [4:4] is the sub-list for extension extendee
	0, // [0:4] is the sub-list for field type_name
}

func init() { file_pb_circuitv1_proto_init() }
func file_pb_circuitv1_proto_init() {
	if File_pb_circuitv1_proto != nil {
		return
	}
	if !protoimpl.UnsafeEnabled {
		file_pb_circuitv1_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*CircuitRelay); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_pb_circuitv1_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*CircuitRelay_Peer); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: file_pb_circuitv1_proto_rawDesc,
			NumEnums:      2,
			NumMessages:   2,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_pb_circuitv1_proto_goTypes,
		DependencyIndexes: file_pb_circuitv1_proto_depIdxs,
		EnumInfos:         file_pb_circuitv1_proto_enumTypes,
		MessageInfos:      file_pb_circuitv1_proto_msgTypes,
	}.Build()
	File_pb_circuitv1_proto = out.File
	file_pb_circuitv1_proto_rawDesc = nil
	file_pb_circuitv1_proto_goTypes = nil
	file_pb_circuitv1_proto_depIdxs = nil
}


text:
require recipes-devtools-arc/gcc/gcc-${PV}.inc
require recipes-devtools/gcc/gcc-cross-canadian.inc

EXTRA_OECONF_append_libc-baremetal = " --without-headers"
EXTRA_OECONF_remove_libc-baremetal = "--with-sysroot=/not/exist"
EXTRA_OECONF_remove_libc-baremetal = "--with-build-sysroot=${STAGING_DIR_TARGET}"
EXTRA_OECONF_append_libc-baremetal = " --enable-plugin "

repository: cheeyanglee/meta-zephyr

repo_name: cheeyanglee/meta-zephyr


text:
#pragma warning (disable: 26495)

///////////////////////////////////////////////////////////////////////////////////////////
//
// 4D Vector Constructors
//
///////////////////////////////////////////////////////////////////////////////////////////
namespace dseed
{

	inline f32x4_t::f32x4_t() noexcept { }
	inline f32x4_t::f32x4_t(float v) noexcept
#if DONT_USE_SIMD
		: _x(v), _y(v), _z(v), _w(v)
#elif !DONT_USE_SSE
		: _intrinsic(_mm_set1_ps(v))
#elif !DONT_USE_NEON
		: _intrinsic(vmovq_n_f32(v))
#endif
	{ }
	inline f32x4_t::f32x4_t(float x, float y, float z, float w) noexcept
#if DONT_USE_SIMD
		: _x(x), _y(y), _z(z), _w(w)
#elif !DONT_USE_SSE
		: _intrinsic(_mm_set_ps(w, z, y, x))
#endif
	{
#if !DONT_USE_NEON
		float temp[] = { x, y, z, w };
		_intrinsic = vld1q_f32(temp);
#endif
	}
	inline f32x4_t::f32x4_t(const float arr[4]) noexcept
	{
#if !DONT_USE_SSE
		_intrinsic = _mm_load_ps(arr);
#elif !DONT_USE_NEON
		_intrinsic = vld1q_f32(arr);
#elif DONT_USE_SIMD
		_x = arr[0]; _y = arr[1]; _z = arr[2]; _w = arr[3];
#endif
	}
	inline f32x4_t::f32x4_t(const f32x4_t* v) noexcept
#if DONT_USE_SIMD
		: _x(v->_x), _y(v->_y), _z(v->_z), _w(v->_w)
#elif !DONT_USE_SSE || !DONT_USE_NEON
		: _intrinsic(v->_intrinsic)
#endif
	{ }
	inline f32x4_t::f32x4_t(const f32x4_t& v) noexcept
#if DONT_USE_SIMD
		: _x(v._x), _y(v._y), _z(v._z), _w(v._w)
#elif !DONT_USE_SSE || !DONT_USE_NEON
		: _intrinsic(v._intrinsic)
#endif
	{ }
#if !DONT_USE_SSE
	inline f32x4_t::f32x4_t(__m128 v) noexcept : _intrinsic(v) { }
#elif !DONT_USE_NEON
	f32x4_t(float32x4_t v) : _intrinsoc(v) noexcept { }
#endif

	inline f32x4_t f32x4_t::load(const float arr[4]) noexcept
	{
		return f32x4_t(arr);
	}
	inline void f32x4_t::store(float arr[4], const f32x4_t* v) noexcept
	{
#if !DONT_USE_SSE
		_mm_store_ps(arr, v->_intrinsic);
#elif !DONT_USE_NEON
		vst1q_f32(arr, v->_intrinsic);
#elif DONT_USE_SIMD
		memcpy(arr, v, sizeof(vector4f));
#endif
	}

	inline i32x4_t::i32x4_t() noexcept { }
	inline i32x4_t::i32x4_t(int v) noexcept
#if DONT_USE_SIMD
		: _x(v), _y(v), _z(v), _w(v)
#elif !DONT_USE_SSE
		: _intrinsic(_mm_set1_epi32(v))
#elif !DONT_USE_NEON
		: _intrinsic(vmovq_n_i32(v))
#endif
	{ }
	inline i32x4_t::i32x4_t(int x, int y, int z, int w) noexcept
#if DONT_USE_SIMD
		: _x(x), _y(y), _z(z), _w(w)
#elif !DONT_USE_SSE
		: _intrinsic(_mm_set_epi32(w, z, y, x))
#endif
	{
#if !DONT_USE_NEON
		int arr[4] = { x, y, z, w };
		_intrinsic = vld1q_f32(arr);
#endif
	}
	inline i32x4_t::i32x4_t(const int arr[4]) noexcept
	{
#if !DONT_USE_SSE
		_intrinsic = _mm_load_si128((const __m128i*)arr);
#elif !DONT_USE_NEON
		_intrinsic = vld1q_i32(arr);
#elif DONT_USE_SIMD
		_x = arr[0]; _y = arr[1]; _z = arr[2]; _w = arr[3];
#endif
	}
	inline i32x4_t::i32x4_t(const i32x4_t* v) noexcept
#if DONT_USE_SIMD
		: _x(v->_x), _y(v->_y), _z(v->_z), _w(v->_w)
#elif !DONT_USE_SSE
		: _intrinsic(v->_intrinsic)
#elif !DONT_USE_NEON
		: _intrinsic(v->_intrinsic)
#endif
	{ }
	inline i32x4_t::i32x4_t(const i32x4_t& v) noexcept
#if DONT_USE_SIMD
		: _x(v._x), _y(v._y), _z(v._z), _w(v._w)
#elif !DONT_USE_SSE
		: _intrinsic(v._intrinsic)
#elif !DONT_USE_NEON
		: _intrinsic(v._intrinsic)
#endif
	{ }
#if !DONT_USE_SSE
	inline i32x4_t::i32x4_t(__m128i v) noexcept { _intrinsic = v; }
#elif !DONT_USE_NEON
	i32x4_t::i32x4_t(int32x4_t v) noexcept { _intrinsic = v; }
#endif

	inline i32x4_t i32x4_t::load(const int arr[4]) noexcept
	{
		return i32x4_t(arr);
	}
	inline void i32x4_t::store(int arr[4], const i32x4_t* v) noexcept
	{
#if !DONT_USE_SSE
		_mm_store_si128((__m128i*)arr, v->_intrinsic);
#elif !DONT_USE_NEON
		vst1q_i32(arr, v->_intrinsic);
#elif DONT_USE_SIMD
		memcpy(arr, v, sizeof(i32x4_t));
#endif
	}
}

repository: daramkun/Degra

repo_name: daramkun/Degra

extension: inl


text:
DESCRIPTION = "graphlcd"
PRIORITY = "optional"
LICENSE = "GPLv2"
LIC_FILES_CHKSUM = "file://COPYING;md5=393a5ca445f6965873eca0259a17f833"

DEPENDS = "freetype fontconfig"

SRC_URI = "git://github.com/MaxWiesel/graphlcd-base.git;protocol=https"

S = "${WORKDIR}/git"
SRCREV = "${AUTOREV}"

EXTRA_OEMAKE += '"INCLUDES=-I${STAGING_INCDIR} -I${STAGING_INCDIR}/freetype2 -I${S}" "UDEVRULESDIR=${D}/etc/udev/rules.d"'

inherit autotools-brokensep pkgconfig

do_configure_prepend() {
	#hack: we dont have io.h for arm 32bit
	touch ${STAGING_INCDIR}/sys/io.h
}

do_install_prepend() {
	install -d ${D}/etc/udev/rules.d
}

do_install_append() {
	install -d ${D}/usr
	mv ${D}/bin ${D}/usr/bin
	mv ${D}/lib ${D}/usr/lib
	mv ${D}/include ${D}/usr/include
}

FILES_${PN} = "/usr/bin /usr/lib /etc"
FILES_${PN}-dev = "/usr/include"

INSANE_SKIP_${PN} = "dev-so"

repository: neutrino-hd/meta-neutrino

repo_name: neutrino-hd/meta-neutrino


text:
SUMMARY = "WPE cross-compilation image with wpebackend-fdo. \
           This is useful for creating a SDK for cross-building WPE. \
           The SDK for ARMv7 will default to use the traditional ISA. \
           To use Thumb2 you have to pass the -mthumb compiler flag."

LICENSE = "BSD"

inherit core-image

# distro_features_check is going to be removed after dunfell
# ref: https://git.yoctoproject.org/cgit/cgit.cgi/poky/commit/meta/classes/features_check.bbclass?h=master-next&id=9702544b3e75d761d86cae7e8b36f3f2625b68ce
#   Temporarily support the old class name with a warning about future deprecation.
inherit ${@bb.utils.contains_any("LAYERSERIES_CORENAMES", 'zeus warrior', 'distro_features_check', 'features_check', d)}

REQUIRED_DISTRO_FEATURES = "wayland"

PREFERRED_PROVIDER_virtual/wpebackend = "wpebackend-fdo"
CORE_IMAGE_BASE_INSTALL += "wpebackend-fdo wpewebkit"

repository: oceanicsystems/meta-webkit

repo_name: oceanicsystems/meta-webkit


text:
SUMMARY = "node-taglib is a simple binding to TagLib in Javascript"
SECTION = "nodejs/module"
LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://LICENSE;md5=496b4c45fbf47bb331ecf4d6863327a3"

DEPENDS = "node-gyp-native taglib"

PV = "0.8.0+gitr${SRCPV}"

SRC_URI = "git://github.com/nikhilm/node-taglib.git \
    file://0001-binding.gyp-Use-pkg-config-to-find-taglib-flags.patch \
"
SRCREV = "a61fbbd4c8a759e639f766132dc34060a98f3c23"
S = "${WORKDIR}/git"

do_configure() {
    export LD="${CXX}"
    export GYP_DEFINES="sysroot=${STAGING_DIR_HOST}"
    node-gyp --arch ${TARGET_ARCH} configure
}

do_compile() {
    export LD="${CXX}"
    export GYP_DEFINES="sysroot=${STAGING_DIR_HOST}"
    node-gyp --arch ${TARGET_ARCH} build
}

do_install() {
    install -d ${D}${libdir}/nodejs
    install ${S}/build/Release/taglib.node ${D}${libdir}/nodejs/
}

FILES_${PN} += "${libdir}/nodejs"
FILES_${PN}-dbg += "${libdir}/nodejs/.debug"

repository: Andolamin/meta-webos-ports

repo_name: Andolamin/meta-webos-ports


text:
file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/abc.txt" "test content")
set(user_script_ "${CMAKE_CURRENT_BINARY_DIR}/user-script.cmake")
file(WRITE "${user_script_}"
  "file(INSTALL DESTINATION \"\${CMAKE_INSTALL_PREFIX}/foo\"
    TYPE FILE FILES \"${CMAKE_CURRENT_BINARY_DIR}/abc.txt\")")

if(RunCMake_SUBTEST_SUFFIX STREQUAL "both")
    set(CPACK_INSTALL_SCRIPT "${user_script_}")
    set(CPACK_INSTALL_SCRIPTS "${CPACK_INSTALL_SCRIPT}")

elseif(RunCMake_SUBTEST_SUFFIX STREQUAL "singular")
    set(CPACK_INSTALL_SCRIPT "${user_script_}")

elseif(RunCMake_SUBTEST_SUFFIX STREQUAL "plural")
    set(CPACK_INSTALL_SCRIPTS "${user_script_}")

else()
    message(FATAL_ERROR "Unexpected subtest name: ${RunCMake_SUBTEST_SUFFIX}")

endif()

function(run_after_include_cpack)
  file(READ "${CPACK_OUTPUT_CONFIG_FILE}" conf_file_)
  string(REGEX REPLACE "SET\\(CPACK_INSTALL_CMAKE_PROJECTS [^)]*\\)" "" conf_file_ "${conf_file_}")
  file(WRITE "${CPACK_OUTPUT_CONFIG_FILE}" "${conf_file_}")
endfunction()

branch_name: refs/heads/main

extension: cmake


text:
@inProceedings{ogarrio16,
  title = {A Hybrid Causal Search Algorithm for Latent Variable Models},
  author = {Ogarrio, Juan Miguel and Spirtes, Peter and Ramsey, Joe},
  pages = {368-379},
  abstract = {Existing score-based causal model search algorithms such as \textit{GES} (and a speeded up version, \textit{FGS}) are asymptotically correct, fast, and reliable, but make the unrealistic assumption that the true causal graph does not contain any unmeasured confounders. There are several constraint-based causal search algorithms (e.g \textit{RFCI}, \emph{FCI}, or \emph{FCI+}) that are asymptotically correct without assuming that there are no unmeasured confounders, but often perform poorly on small samples. We describe a combined score and constraint-based algorithm, \emph{GFCI}, that we prove is asymptotically correct. On synthetic data, \textit{GFCI} is only slightly slower than \emph{RFCI} but more accurate than \textit{FCI}, \textit{RFCI} and \textit{FCI+}.},
}

repository: mreid/papersite

repo_name: mreid/papersite

gha_language: TeX


text:
file(REMOVE_RECURSE
  "CMakeFiles/CMakeLibTests.dir/CMakeLibTests.cxx.o"
  "CMakeFiles/CMakeLibTests.dir/testGeneratedFileStream.cxx.o"
  "CMakeFiles/CMakeLibTests.dir/testRST.cxx.o"
  "CMakeFiles/CMakeLibTests.dir/testSystemTools.cxx.o"
  "CMakeFiles/CMakeLibTests.dir/testUTF8.cxx.o"
  "CMakeFiles/CMakeLibTests.dir/testXMLParser.cxx.o"
  "CMakeFiles/CMakeLibTests.dir/testXMLSafe.cxx.o"
  "CMakeLibTests.pdb"
  "CMakeLibTests"
)

# Per-language clean rules from dependency scanning.
foreach(lang CXX)
  include(CMakeFiles/CMakeLibTests.dir/cmake_clean_${lang}.cmake OPTIONAL)
endforeach()


text:
// Copyright 2020 The VectorSQL Authors.
//
// Code is licensed under Apache License, Version 2.0.

package transforms

import (
	"context"

	"base/xlog"
	"config"
	"sessions"
)

type TransformContext struct {
	ctx              context.Context
	log              *xlog.Log
	conf             *config.Config
	progressCallback func(values *sessions.ProgressValues)
}

func NewTransformContext(ctx context.Context, log *xlog.Log, conf *config.Config) *TransformContext {
	return &TransformContext{
		ctx:  ctx,
		log:  log,
		conf: conf,
	}
}

func (ctx *TransformContext) SetProgressCallback(fn func(pv *sessions.ProgressValues)) {
	ctx.progressCallback = fn
}

repository: BohuTANG/vectorsql

repo_name: BohuTANG/vectorsql


text:
package fuse

import (
	"log"
	"os"
	"fmt"
)

var _ = log.Print
var _ = fmt.Print

// LoggingFileSystem is a wrapper that prints out what a FileSystem is doing.
type LoggingFileSystem struct {
	FileSystem
}

func NewLoggingFileSystem(fs FileSystem) *LoggingFileSystem {
	t := new(LoggingFileSystem)
	t.FileSystem = fs
	return t
}

func (me *LoggingFileSystem) Print(name string, arg string) {
	log.Printf("Op %s arg %s", name, arg)
}

func (me *LoggingFileSystem) GetAttr(name string, context *Context) (*os.FileInfo, Status) {
	me.Print("GetAttr", name)
	return me.FileSystem.GetAttr(name, context)
}

func (me *LoggingFileSystem) GetXAttr(name string, attr string, context *Context) ([]byte, Status) {
	me.Print("GetXAttr", name)
	return me.FileSystem.GetXAttr(name, attr, context)
}

func (me *LoggingFileSystem) SetXAttr(name string, attr string, data []byte, flags int, context *Context) Status {
	me.Print("SetXAttr", name)
	return me.FileSystem.SetXAttr(name, attr, data, flags, context)
}

func (me *LoggingFileSystem) ListXAttr(name string, context *Context) ([]string, Status) {
	me.Print("ListXAttr", name)
	return me.FileSystem.ListXAttr(name, context)
}

func (me *LoggingFileSystem) RemoveXAttr(name string, attr string, context *Context) Status {
	me.Print("RemoveXAttr", name)
	return me.FileSystem.RemoveXAttr(name, attr, context)
}

func (me *LoggingFileSystem) Readlink(name string, context *Context) (string, Status) {
	me.Print("Readlink", name)
	return me.FileSystem.Readlink(name, context)
}

func (me *LoggingFileSystem) Mknod(name string, mode uint32, dev uint32, context *Context) Status {
	me.Print("Mknod", name)
	return me.FileSystem.Mknod(name, mode, dev, context)
}

func (me *LoggingFileSystem) Mkdir(name string, mode uint32, context *Context) Status {
	me.Print("Mkdir", name)
	return me.FileSystem.Mkdir(name, mode, context)
}

func (me *LoggingFileSystem) Unlink(name string, context *Context) (code Status) {
	me.Print("Unlink", name)
	return me.FileSystem.Unlink(name, context)
}

func (me *LoggingFileSystem) Rmdir(name string, context *Context) (code Status) {
	me.Print("Rmdir", name)
	return me.FileSystem.Rmdir(name, context)
}

func (me *LoggingFileSystem) Symlink(value string, linkName string, context *Context) (code Status) {
	me.Print("Symlink", linkName)
	return me.FileSystem.Symlink(value, linkName, context)
}

func (me *LoggingFileSystem) Rename(oldName string, newName string, context *Context) (code Status) {
	me.Print("Rename", oldName)
	return me.FileSystem.Rename(oldName, newName, context)
}

func (me *LoggingFileSystem) Link(oldName string, newName string, context *Context) (code Status) {
	me.Print("Link", newName)
	return me.FileSystem.Link(oldName, newName, context)
}

func (me *LoggingFileSystem) Chmod(name string, mode uint32, context *Context) (code Status) {
	me.Print("Chmod", name)
	return me.FileSystem.Chmod(name, mode, context)
}

func (me *LoggingFileSystem) Chown(name string, uid uint32, gid uint32, context *Context) (code Status) {
	me.Print("Chown", name)
	return me.FileSystem.Chown(name, uid, gid, context)
}

func (me *LoggingFileSystem) Truncate(name string, offset uint64, context *Context) (code Status) {
	me.Print("Truncate", name)
	return me.FileSystem.Truncate(name, offset, context)
}

func (me *LoggingFileSystem) Open(name string, flags uint32, context *Context) (file File, code Status) {
	me.Print("Open", name)
	return me.FileSystem.Open(name, flags, context)
}

func (me *LoggingFileSystem) OpenDir(name string, context *Context) (stream chan DirEntry, status Status) {
	me.Print("OpenDir", name)
	return me.FileSystem.OpenDir(name, context)
}

func (me *LoggingFileSystem) OnMount(nodeFs *PathNodeFs) {
	me.Print("OnMount", "")
	me.FileSystem.OnMount(nodeFs)
}

func (me *LoggingFileSystem) OnUnmount() {
	me.Print("OnUnmount", "")
	me.FileSystem.OnUnmount()
}

func (me *LoggingFileSystem) Access(name string, mode uint32, context *Context) (code Status) {
	me.Print("Access", name)
	return me.FileSystem.Access(name, mode, context)
}

func (me *LoggingFileSystem) Create(name string, flags uint32, mode uint32, context *Context) (file File, code Status) {
	me.Print("Create", name)
	return me.FileSystem.Create(name, flags, mode, context)
}

func (me *LoggingFileSystem) Utimens(name string, AtimeNs uint64, CtimeNs uint64, context *Context) (code Status) {
	me.Print("Utimens", name)
	return me.FileSystem.Utimens(name, AtimeNs, CtimeNs, context)
}

repository: lht/go-fuse

repo_name: lht/go-fuse