github.com/Kindred87/Obsidian@v0.0.0-20210809203756-86936424b848/api/obsidian_grpc.pb.go

// Code generated by protoc-gen-go-grpc. DO NOT EDIT.

package api

import (
	context "context"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
)

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
// Requires gRPC-Go v1.32.0 or later.
const _ = grpc.SupportPackageIsVersion7

// ObsidianClient is the client API for Obsidian service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type ObsidianClient interface {
	AddDatasource(ctx context.Context, in *DatasourceAddRequest, opts ...grpc.CallOption) (*Response, error)
	CheckForDatasource(ctx context.Context, in *CheckDatasourceRequest, opts ...grpc.CallOption) (*CheckDatasourceResponse, error)
	HTMLNodeHelper(ctx context.Context, in *HTMLNodeRequest, opts ...grpc.CallOption) (*HTMlNodeResponse, error)
	HTMLSearch(ctx context.Context, in *HTMLSearchRequest, opts ...grpc.CallOption) (*HTMLSearchResponse, error)
}

type obsidianClient struct {
	cc grpc.ClientConnInterface
}

func NewObsidianClient(cc grpc.ClientConnInterface) ObsidianClient {
	return &obsidianClient{cc}
}

func (c *obsidianClient) AddDatasource(ctx context.Context, in *DatasourceAddRequest, opts ...grpc.CallOption) (*Response, error) {
	out := new(Response)
	err := c.cc.Invoke(ctx, "/api.Obsidian/AddDatasource", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *obsidianClient) CheckForDatasource(ctx context.Context, in *CheckDatasourceRequest, opts ...grpc.CallOption) (*CheckDatasourceResponse, error) {
	out := new(CheckDatasourceResponse)
	err := c.cc.Invoke(ctx, "/api.Obsidian/CheckForDatasource", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *obsidianClient) HTMLNodeHelper(ctx context.Context, in *HTMLNodeRequest, opts ...grpc.CallOption) (*HTMlNodeResponse, error) {
	out := new(HTMlNodeResponse)
	err := c.cc.Invoke(ctx, "/api.Obsidian/HTMLNodeHelper", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *obsidianClient) HTMLSearch(ctx context.Context, in *HTMLSearchRequest, opts ...grpc.CallOption) (*HTMLSearchResponse, error) {
	out := new(HTMLSearchResponse)
	err := c.cc.Invoke(ctx, "/api.Obsidian/HTMLSearch", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ObsidianServer is the server API for Obsidian service.
// All implementations must embed UnimplementedObsidianServer
// for forward compatibility
type ObsidianServer interface {
	AddDatasource(context.Context, *DatasourceAddRequest) (*Response, error)
	CheckForDatasource(context.Context, *CheckDatasourceRequest) (*CheckDatasourceResponse, error)
	HTMLNodeHelper(context.Context, *HTMLNodeRequest) (*HTMlNodeResponse, error)
	HTMLSearch(context.Context, *HTMLSearchRequest) (*HTMLSearchResponse, error)
	mustEmbedUnimplementedObsidianServer()
}

// UnimplementedObsidianServer must be embedded to have forward compatible implementations.
type UnimplementedObsidianServer struct {
}

func (UnimplementedObsidianServer) AddDatasource(context.Context, *DatasourceAddRequest) (*Response, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddDatasource not implemented")
}
func (UnimplementedObsidianServer) CheckForDatasource(context.Context, *CheckDatasourceRequest) (*CheckDatasourceResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CheckForDatasource not implemented")
}
func (UnimplementedObsidianServer) HTMLNodeHelper(context.Context, *HTMLNodeRequest) (*HTMlNodeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method HTMLNodeHelper not implemented")
}
func (UnimplementedObsidianServer) HTMLSearch(context.Context, *HTMLSearchRequest) (*HTMLSearchResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method HTMLSearch not implemented")
}
func (UnimplementedObsidianServer) mustEmbedUnimplementedObsidianServer() {}

// UnsafeObsidianServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to ObsidianServer will
// result in compilation errors.
type UnsafeObsidianServer interface {
	mustEmbedUnimplementedObsidianServer()
}

func RegisterObsidianServer(s grpc.ServiceRegistrar, srv ObsidianServer) {
	s.RegisterService(&Obsidian_ServiceDesc, srv)
}

func _Obsidian_AddDatasource_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DatasourceAddRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ObsidianServer).AddDatasource(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.Obsidian/AddDatasource",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ObsidianServer).AddDatasource(ctx, req.(*DatasourceAddRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Obsidian_CheckForDatasource_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CheckDatasourceRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ObsidianServer).CheckForDatasource(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.Obsidian/CheckForDatasource",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ObsidianServer).CheckForDatasource(ctx, req.(*CheckDatasourceRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Obsidian_HTMLNodeHelper_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(HTMLNodeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ObsidianServer).HTMLNodeHelper(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.Obsidian/HTMLNodeHelper",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ObsidianServer).HTMLNodeHelper(ctx, req.(*HTMLNodeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Obsidian_HTMLSearch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(HTMLSearchRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ObsidianServer).HTMLSearch(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.Obsidian/HTMLSearch",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ObsidianServer).HTMLSearch(ctx, req.(*HTMLSearchRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// Obsidian_ServiceDesc is the grpc.ServiceDesc for Obsidian service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var Obsidian_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "api.Obsidian",
	HandlerType: (*ObsidianServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "AddDatasource",
			Handler:    _Obsidian_AddDatasource_Handler,
		},
		{
			MethodName: "CheckForDatasource",
			Handler:    _Obsidian_CheckForDatasource_Handler,
		},
		{
			MethodName: "HTMLNodeHelper",
			Handler:    _Obsidian_HTMLNodeHelper_Handler,
		},
		{
			MethodName: "HTMLSearch",
			Handler:    _Obsidian_HTMLSearch_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "obsidian.proto",
}