text:
ServerInfo{
		Server:     srv,
		FullMethod: "/gctrpc.GoCryptoTrader/SetAllExchangePairs",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServer).SetAllExchangePairs(ctx, req.(*SetExchangeAllPairsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTrader_UpdateExchangeSupportedPairs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateExchangeSupportedPairsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServer).UpdateExchangeSupportedPairs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gctrpc.GoCryptoTrader/UpdateExchangeSupportedPairs",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServer).UpdateExchangeSupportedPairs(ctx, req.(*UpdateExchangeSupportedPairsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTrader_GetExchangeAssets_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetExchangeAssetsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServer).GetExchangeAssets(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gctrpc.GoCryptoTrader/GetExchangeAssets",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServer).GetExchangeAssets(ctx, req.(*GetExchangeAssetsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTrader_WebsocketGetInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(WebsocketGetInfoRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServer).WebsocketGetInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gctrpc.GoCryptoTrader/WebsocketGetInfo",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServer).WebsocketGetInfo(ctx, req.(*WebsocketGetInfoRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTrader_WebsocketSetEnabled_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(WebsocketSetEnabledRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServer).WebsocketSetEnabled(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gctrpc.GoCryptoTrader/WebsocketSetEnabled",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServer).WebsocketSetEnabled(ctx, req.(*WebsocketSetEnabledRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTrader_WebsocketGetSubscriptions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(WebsocketGetSubscriptionsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServer).WebsocketGetSubscriptions(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gctrpc.GoCryptoTrader/WebsocketGetSubscriptions",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServer).WebsocketGetSubscriptions(ctx, req.(*WebsocketGetSubscriptionsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTrader_WebsocketSetProxy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(WebsocketSetProxyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServer).WebsocketSetProxy(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gctrpc.GoCryptoTrader/WebsocketSetProxy",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServer).WebsocketSetProxy(ctx, req.(*WebsocketSetProxyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTrader_WebsocketSetURL_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(WebsocketSetURLRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServer).WebsocketSetURL(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gctrpc.GoCryptoTrader/WebsocketSetURL",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServer).WebsocketSetURL(ctx, req.(*WebsocketSetURLRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTrader_GetRecentTrades_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetSavedTradesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServer).GetRecentTrades(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gctrpc.GoCryptoTrader/GetRecentTrades",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServer).GetRecentTrades(ctx, req.(*GetSavedTradesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTrader_GetHistoricTrades_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(GetSavedTradesRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GoCryptoTraderServer).GetHistoricTrades(m, &goCryptoTraderGetHistoricTradesServer{stream})
}

type GoCryptoTrader_GetHistoricTradesServer interface {
	Send(*SavedTradesResponse) error
	grpc.ServerStream
}

type goCryptoTraderGetHistoricTradesServer struct {
	grpc.ServerStream
}

func (x *goCryptoTraderGetHistoricTradesServer) Send(m *SavedTradesResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _GoCryptoTrader_GetSavedTrades_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetSavedTradesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServer).GetSavedTrades(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gctrpc.GoCryptoTrader/GetSavedTrades",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServer).GetSavedTrades(ctx, req.(*GetSavedTradesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTrader_ConvertTradesToCandles_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ConvertTradesToCandlesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServer).ConvertTradesToCandles(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gctrpc.GoCryptoTrader/ConvertTradesToCandles",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServer).ConvertTradesToCandles(ctx, req.(*ConvertTradesToCandlesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTrader_FindMissingSavedCandleIntervals_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(FindMissingCandlePeriodsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServer).FindMissingSavedCandleIntervals(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gctrpc.GoCryptoTrader/FindMissingSavedCandleIntervals",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServer).FindMissingSavedCandleIntervals(ctx, req.(*FindMissingCandlePeriodsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTrader_FindMissingSavedTradeIntervals_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(FindMissingTradePeriodsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServer).FindMissingSavedTradeIntervals(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gctrpc.GoCryptoTrader/FindMissingSavedTradeIntervals",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServer).FindMissingSavedTradeIntervals(ctx, req.(*FindMissingTradePeriodsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTrader_SetExchangeTradeProcessing_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetExchangeTradeProcessingRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServer).SetExchangeTradeProcessing(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gctrpc.GoCryptoTrader/SetExchangeTradeProcessing",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServer).SetExchangeTradeProcessing(ctx, req.(*SetExchangeTradeProcessingRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTrader_UpsertDataHistoryJob_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpsertDataHistoryJobRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServer).UpsertDataHistoryJob(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gctrpc.GoCryptoTrader/UpsertDataHistoryJob",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServer).UpsertDataHistoryJob(ctx, req.(*UpsertDataHistoryJobRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTrader_GetDataHistoryJobDetails_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetDataHistoryJobDetailsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServer).GetDataHistoryJobDetails(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gctrpc.GoCryptoTrader/GetDataHistoryJobDetails",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServer).GetDataHistoryJobDetails(ctx, req.(*GetDataHistoryJobDetailsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTrader_GetActiveDataHistoryJobs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetInfoRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServer).GetActiveDataHistoryJobs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gctrpc.GoCryptoTrader/GetActiveDataHistoryJobs",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServer).GetActiveDataHistoryJobs(ctx, req.(*GetInfoRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTrader_GetDataHistoryJobsBetween_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetDataHistoryJobsBetweenRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServer).GetDataHistoryJobsBetween(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gctrpc.GoCryptoTrader/GetDataHistoryJobsBetween",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServer).GetDataHistoryJobsBetween(ctx, req.(*GetDataHistoryJobsBetweenRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTrader_GetDataHistoryJobSummary_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetDataHistoryJobDetailsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServer).GetDataHistoryJobSummary(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gctrpc.GoCryptoTrader/GetDataHistoryJobSummary",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServer).GetDataHistoryJobSummary(ctx, req.(*GetDataHistoryJobDetailsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTrader_SetDataHistoryJobStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetDataHistoryJobStatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServer).SetDataHistoryJobStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gctrpc.GoCryptoTrader/SetDataHistoryJobStatus",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServer).SetDataHistoryJobStatus(ctx, req.(*SetDataHistoryJobStatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTrader_UpdateDataHistoryJobPrerequisite_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateDataHistoryJobPrerequisiteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServer).UpdateDataHistoryJobPrerequisite(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gctrpc.GoCryptoTrader/UpdateDataHistoryJobPrerequisite",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServer).UpdateDataHistoryJobPrerequisite(ctx, req.(*UpdateDataHistoryJobPrerequisiteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTrader_GetManagedOrders_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetOrdersRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServer).GetManagedOrders(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gctrpc.GoCryptoTrader/GetManagedOrders",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServer).GetManagedOrders(ctx, req.(*GetOrdersRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTrader_ModifyOrder_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ModifyOrderRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServer).ModifyOrder(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gctrpc.GoCryptoTrader/ModifyOrder",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServer).ModifyOrder(ctx, req.(*ModifyOrderRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTrader_CurrencyStateGetAll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CurrencyStateGetAllRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServer).CurrencyStateGetAll(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gctrpc.GoCryptoTrader/CurrencyStateGetAll",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServer).CurrencyStateGetAll(ctx, req.(*CurrencyStateGetAllRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTrader_CurrencyStateTrading_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CurrencyStateTradingRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServer).CurrencyStateTrading(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gctrpc.GoCryptoTrader/CurrencyStateTrading",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServer).CurrencyStateTrading(ctx, req.(*CurrencyStateTradingRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTrader_CurrencyStateDeposit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CurrencyStateDepositRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServer).CurrencyStateDeposit(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gctrpc.GoCryptoTrader/CurrencyStateDeposit",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServer).CurrencyStateDeposit(ctx, req.(*CurrencyStateDepositRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTrader_CurrencyStateWithdraw_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CurrencyStateWithdrawRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServer).CurrencyStateWithdraw(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gctrpc.GoCryptoTrader/CurrencyStateWithdraw",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServer).CurrencyStateWithdraw(ctx, req.(*CurrencyStateWithdrawRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GoCryptoTrader_CurrencyStateTradingPair_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CurrencyStateTradingPairRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GoCryptoTraderServer).CurrencyStateTradingPair(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gctrpc.GoCryptoTrader/CurrencyStateTradingPair",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GoCryptoTraderServer).CurrencyStateTradingPair(ctx, req.(*CurrencyStateTradingPairRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// GoCryptoTrader_ServiceDesc is the grpc.ServiceDesc for GoCryptoTrader service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var GoCryptoTrader_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "gctrpc.GoCryptoTrader",
	HandlerType: (*GoCryptoTraderServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetInfo",
			Handler:    _GoCryptoTrader_GetInfo_Handler,
		},
		{
			MethodName: "GetSubsystems",
			Handler:    _GoCryptoTrader_GetSubsystems_Handler,
		},
		{
			MethodName: "EnableSubsystem",
			Handler:    _GoCryptoTrader_EnableSubsystem_Handler,
		},
		{
			MethodName: "DisableSubsystem",
			Handler:    _GoCryptoTrader_DisableSubsystem_Handler,
		},
		{
			MethodName: "GetRPCEndpoints",
			Handler:    _GoCryptoTrader_GetRPCEndpoints_Handler,
		},
		{
			MethodName: "GetCommunicationRelayers",
			Handler:    _GoCryptoTrader_GetCommunicationRelayers_Handler,
		},
		{
			MethodName: "GetExchanges",
			Handler:    _GoCryptoTrader_GetExchanges_Handler,
		},
		{
			MethodName: "DisableExchange",
			Handler:    _GoCryptoTrader_DisableExchange_Handler,
		},
		{
			MethodName: "GetExchangeInfo",
			Handler:    _GoCryptoTrader_GetExchangeInfo_Handler,
		},
		{
			MethodName: "GetExchangeOTPCode",
			Handler:    _GoCryptoTrader_GetExchangeOTPCode_Handler,
		},
		{
			MethodName: "GetExchangeOTPCodes",
			Handler:    _GoCryptoTrader_GetExchangeOTPCodes_Handler,
		},
		{
			MethodName: "EnableExchange",
			Handler:    _GoCryptoTrader_EnableExchange_Handler,
		},
		{
			MethodName: "GetTicker",
			Handler:    _GoCryptoTrader_GetTicker_Handler,
		},
		{
			MethodName: "GetTickers",
			Handler:    _GoCryptoTrader_GetTickers_Handler,
		},
		{
			MethodName: "GetOrderbook",
			Handler:    _GoCryptoTrader_GetOrderbook_Handler,
		},
		{
			MethodName: "GetOrderbooks",
			Handler:    _GoCryptoTrader_GetOrderbooks_Handler,
		},
		{
			MethodName: "GetAccountInfo",
			Handler:    _GoCryptoTrader_GetAccountInfo_Handler,
		},
		{
			MethodName: "UpdateAccountInfo",
			Handler:    _GoCryptoTrader_UpdateAccountInfo_Handler,
		},
		{
			MethodName: "GetConfig",
			Handler:    _GoCryptoTrader_GetConfig_Handler,
		},
		{
			MethodName: "GetPortfolio",
			Handler:    _GoCryptoTrader_GetPortfolio_Handler,
		},
		{
			MethodName: "GetPortfolioSummary",
			Handler:    _GoCryptoTrader_GetPortfolioSummary_Handler,
		},
		{
			MethodName: "AddPortfolioAddress",
			Handler:    _GoCryptoTrader_AddPortfolioAddress_Handler,
		},
		{
			MethodName: "RemovePortfolioAddress",
			Handler:    _GoCryptoTrader_RemovePortfolioAddress_Handler,
		},
		{
			MethodName: "GetForexProviders",
			Handler:    _GoCryptoTrader_GetForexProviders_Handler,
		},
		{
			MethodName: "GetForexRates",
			Handler:    _GoCryptoTrader_GetForexRates_Handler,
		},
		{
			MethodName: "GetOrders",
			Handler:    _GoCryptoTrader_GetOrders_Handler,
		},
		{
			MethodName: "GetOrder",
			Handler:    _GoCryptoTrader_GetOrder_Handler,
		},
		{
			MethodName: "SubmitOrder",
			Handler:    _GoCryptoTrader_SubmitOrder_Handler,
		},
		{
			MethodName: "SimulateOrder",
			Handler:    _GoCryptoTrader_SimulateOrder_Handler,
		},
		{
			MethodName: "WhaleBomb",
			Handler:    _GoCryptoTrader_WhaleBomb_Handler,
		},
		{
			MethodName: "CancelOrder",
			Handler:    _GoCryptoTrader_CancelOrder_Handler,
		},
		{
			MethodName: "CancelBatchOrders",
			Handler:    _GoCryptoTrader_CancelBatchOrders_Handler,
		},
		{
			MethodName: "CancelAllOrders",
			Handler:    _GoCryptoTrader_CancelAllOrders_Handler,
		},
		{
			MethodName: "GetEvents",
			Handler:    _GoCryptoTrader_GetEvents_Handler,
		},
		{
			MethodName: "AddEvent",
			Handler:    _GoCryptoTrader_AddEvent_Handler,
		},
		{
			MethodName: "RemoveEvent",
			Handler:    _GoCryptoTrader_RemoveEvent_Handler,
		},
		{
			MethodName: "GetCryptocurrencyDepositAddresses",
			Handler:    _GoCryptoTrader_GetCryptocurrencyDepositAddresses_Handler,
		},
		{
			MethodName: "GetCryptocurrencyDepositAddress",
			Handler:    _GoCryptoTrader_GetCryptocurrencyDepositAddress_Handler,
		},
		{
			MethodName: "GetAvailableTransferChains",
			Handler:    _GoCryptoTrader_GetAvailableTransferChains_Handler,
		},
		{
			MethodName: "WithdrawFiatFunds",
			Handler:    _GoCryptoTrader_WithdrawFiatFunds_Handler,
		},
		{
			MethodName: "WithdrawCryptocurrencyFunds",
			Handler:    _GoCryptoTrader_WithdrawCryptocurrencyFunds_Handler,
		},
		{
			MethodName: "WithdrawalEventByID",
			Handler:    _GoCryptoTrader_WithdrawalEventByID_Handler,
		},
		{
			MethodName: "WithdrawalEventsByExchange",
			Handler:    _GoCryptoTrader_WithdrawalEventsByExchange_Handler,
		},
		{
			MethodName: "WithdrawalEventsByDate",
			Handler:    _GoCryptoTrader_WithdrawalEventsByDate_Handler,
		},
		{
			MethodName: "GetLoggerDetails",
			Handler:    _GoCryptoTrader_GetLoggerDetails_Handler,
		},
		{
			MethodName: "SetLoggerDetails",
			Handler:    _GoCryptoTrader_SetLoggerDetails_Handler,
		},
		{
			MethodName: "GetExchangePairs",
			Handler:    _GoCryptoTrader_GetExchangePairs_Handler,
		},
		{
			MethodName: "SetExchangePair",
			Handler:    _GoCryptoTrader_SetExchangePair_Handler,
		},
		{
			MethodName: "GetAuditEvent",
			Handler:    _GoCryptoTrader_GetAuditEvent_Handler,
		},
		{
			MethodName: "GCTScriptExecute",
			Handler:    _GoCryptoTrader_GCTScriptExecute_Handler,
		},
		{
			MethodName: "GCTScriptUpload",
			Handler:    _GoCryptoTrader_GCTScriptUpload_Handler,
		},
		{
			MethodName: "GCTScriptReadScript",
			Handler:    _GoCryptoTrader_GCTScriptReadScript_Handler,
		},
		{
			MethodName: "GCTScriptStatus",
			Handler:    _GoCryptoTrader_GCTScriptStatus_Handler,
		},
		{
			MethodName: "GCTScriptQuery",
			Handler:    _GoCryptoTrader_GCTScriptQuery_Handler,
		},
		{
			MethodName: "GCTScriptStop",
			Handler:    _GoCryptoTrader_GCTScriptStop_Handler,
		},
		{
			MethodName: "GCTScriptStopAll",
			Handler:    _GoCryptoTrader_GCTScriptStopAll_Handler,
		},
		{
			MethodName: "GCTScriptListAll",
			Handler:    _GoCryptoTrader_GCTScriptListAll_Handler,
		},
		{
			MethodName: "GCTScriptAutoLoadToggle",
			Handler:    _GoCryptoTrader_GCTScriptAutoLoadToggle_Handler,
		},
		{
			MethodName: "GetHistoricCandles",
			Handler:    _GoCryptoTrader_GetHistoricCandles_Handler,
		},
		{
			MethodName: "SetExchangeAsset",
			Handler:    _GoCryptoTrader_SetExchangeAsset_Handler,
		},
		{
			MethodName: "SetAllExchangePairs",
			Handler:    _GoCryptoTrader_SetAllExchangePairs_Handler,
		},
		{
			MethodName: "UpdateExchangeSupportedPairs",
			Handler:    _GoCryptoTrader_UpdateExchangeSupportedPairs_Handler,
		},
		{
			MethodName: "GetExchangeAssets",
			Handler:    _GoCryptoTrader_GetExchangeAssets_Handler,
		},
		{
			MethodName: "WebsocketGetInfo",
			Handler:    _GoCryptoTrader_WebsocketGetInfo_Handler,
		},
		{
			MethodName: "WebsocketSetEnabled",
			Handler:    _GoCryptoTrader_WebsocketSetEnabled_Handler,
		},
		{
			MethodName: "WebsocketGetSubscriptions",
			Handler:    _GoCryptoTrader_WebsocketGetSubscriptions_Handler,
		},
		{
			MethodName: "WebsocketSetProxy",
			Handler:    _GoCryptoTrader_WebsocketSetProxy_Handler,
		},
		{
			MethodName: "WebsocketSetURL",
			Handler:    _GoCryptoTrader_WebsocketSetURL_Handler,
		},
		{
			MethodName: "GetRecentTrades",
			Handler:    _GoCryptoTrader_GetRecentTrades_Handler,
		},
		{
			MethodName: "GetSavedTrades",
			Handler:    _GoCryptoTrader_GetSavedTrades_Handler,
		},
		{
			MethodName: "ConvertTradesToCandles",
			Handler:    _GoCryptoTrader_ConvertTradesToCandles_Handler,
		},
		{
			MethodName: "FindMissingSavedCandleIntervals",
			Handler:    _GoCryptoTrader_FindMissingSavedCandleIntervals_Handler,
		},
		{
			MethodName: "FindMissingSavedTradeIntervals",
			Handler:    _GoCryptoTrader_FindMissingSavedTradeIntervals_Handler,
		},
		{
			MethodName: "SetExchangeTradeProcessing",
			Handler:    _GoCryptoTrader_SetExchangeTradeProcessing_Handler,
		},
		{
			MethodName: "UpsertDataHistoryJob",
			Handler:    _GoCryptoTrader_UpsertDataHistoryJob_Handler,
		},
		{
			MethodName: "GetDataHistoryJobDetails",
			Handler:    _GoCryptoTrader_GetDataHistoryJobDetails_Handler,
		},
		{
			MethodName: "GetActiveDataHistoryJobs",
			Handler:    _GoCryptoTrader_GetActiveDataHistoryJobs_Handler,
		},
		{
			MethodName: "GetDataHistoryJobsBetween",
			Handler:    _GoCryptoTrader_GetDataHistoryJobsBetween_Handler,
		},
		{
			MethodName: "GetDataHistoryJobSummary",
			Handler:    _GoCryptoTrader_GetDataHistoryJobSummary_Handler,
		},
		{
			MethodName: "SetDataHistoryJobStatus",
			Handler:    _GoCryptoTrader_SetDataHistoryJobStatus_Handler,
		},
		{
			MethodName: "UpdateDataHistoryJobPrerequisite",
			Handler:    _GoCryptoTrader_UpdateDataHistoryJobPrerequisite_Handler,
		},
		{
			MethodName: "GetManagedOrders",
			Handler:    _GoCryptoTrader_GetManagedOrders_Handler,
		},
		{
			MethodName: "ModifyOrder",
			Handler:    _GoCryptoTrader_ModifyOrder_Handler,
		},
		{
			MethodName: "CurrencyStateGetAll",
			Handler:    _GoCryptoTrader_CurrencyStateGetAll_Handler,
		},
		{
			MethodName: "CurrencyStateTrading",
			Handler:    _GoCryptoTrader_CurrencyStateTrading_Handler,
		},
		{
			MethodName: "CurrencyStateDeposit",
			Handler:    _GoCryptoTrader_CurrencyStateDeposit_Handler,
		},
		{
			MethodName: "CurrencyStateWithdraw",
			Handler:    _GoCryptoTrader_CurrencyStateWithdraw_Handler,
		},
		{
			MethodName: "CurrencyStateTradingPair",
			Handler:    _GoCryptoTrader_CurrencyStateTradingPair_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetAccountInfoStream",
			Handler:       _GoCryptoTrader_GetAccountInfoStream_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetOrderbookStream",
			Handler:       _GoCryptoTrader_GetOrderbookStream_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetExchangeOrderbookStream",
			Handler:       _GoCryptoTrader_GetExchangeOrderbookStream_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetTickerStream",
			Handler:       _GoCryptoTrader_GetTickerStream_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetExchangeTickerStream",
			Handler:       _GoCryptoTrader_GetExchangeTickerStream_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetHistoricTrades",
			Handler:       _GoCryptoTrader_GetHistoricTrades_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "rpc.proto",
}

license: MIT

license_type: permissive

branch_name: refs/heads/master

gha_license_id: MIT

gha_language: Go

extension: go


text:
@book{vankampen1992,
    abstract = {{This new edition of Van Kampen's standard work has been completely revised and updated. Three major changes have also been made. The Langevin equation receives more attention in a separate chapter in which non-Gaussian and colored noise are introduced. Another additional chapter contains old and new material on first-passage times and related subjects which lay the foundation for the chapter on unstable systems. Finally a completely new chapter has been written on the quantum mechanical foundations of noise.  The references have also been expanded and updated.}},
    author = {Van Kampen, N. G.},
    citeulike-article-id = {791396},
    citeulike-linkout-0 = {http://www.amazon.ca/exec/obidos/redirect?tag=citeulike09-20\&path=ASIN/0444893490},
    citeulike-linkout-1 = {http://www.amazon.de/exec/obidos/redirect?tag=citeulike01-21\&path=ASIN/0444893490},
    citeulike-linkout-2 = {http://www.amazon.fr/exec/obidos/redirect?tag=citeulike06-21\&path=ASIN/0444893490},
    citeulike-linkout-3 = {http://www.amazon.jp/exec/obidos/ASIN/0444893490},
    citeulike-linkout-4 = {http://www.amazon.co.uk/exec/obidos/ASIN/0444893490/citeulike00-21},
    citeulike-linkout-5 = {http://www.amazon.com/exec/obidos/redirect?tag=citeulike07-20\&path=ASIN/0444893490},
    citeulike-linkout-6 = {http://www.worldcat.org/isbn/0444893490},
    citeulike-linkout-7 = {http://books.google.com/books?vid=ISBN0444893490},
    citeulike-linkout-8 = {http://www.amazon.com/gp/search?keywords=0444893490\&index=books\&linkCode=qs},
    citeulike-linkout-9 = {http://www.librarything.com/isbn/0444893490},
    day = {04},
    edition = {2},
    howpublished = {Paperback},
    isbn = {0444893490},
    keywords = {mathematics, physics, randomprocesses},
    month = dec,
    posted-at = {2006-08-09 20:25:31},
    priority = {0},
    publisher = {North Holland},
    title = {Stochastic Processes in Physics and Chemistry, Volume 1, Second Edition ({North-Holland} Personal Library)},
    url = {http://www.amazon.com/exec/obidos/redirect?tag=citeulike07-20\&path=ASIN/0444893490},
    year = {1992}
}

@article{omurtag2000,
    abstract = {The dynamics of large populations of interacting neurons is investigated. Redundancy present in subpopulations of cortical networks is exploited through the introduction of a probabilistic description. A derivation of the kinetic equations for such subpopulations, under general transmembrane dynamics, is presented.},
    author = {Omurtag, A. and Knight, B. W. and Sirovich, L.},
    citeulike-article-id = {5780789},
    citeulike-linkout-0 = {http://dx.doi.org/10.1023/A:1008964915724},
    citeulike-linkout-1 = {http://www.springerlink.com/content/j8327pq70t1355l5},
    comment = {On page 4 one can find nice fokker-planck population equations derivation},
    day = {1},
    doi = {10.1023/A:1008964915724},
    journal = {Journal of Computational Neuroscience},
    keywords = {derivation, fokker-planck, great, omurtag, population\_density},
    month = jan,
    number = {1},
    pages = {51--63},
    posted-at = {2009-09-14 13:33:01},
    priority = {0},
    title = {On the Simulation of Large Populations of Neurons},
    url = {http://dx.doi.org/10.1023/A:1008964915724},
    volume = {8},
    year = {2000}
}

@article{dekamps2003,
    abstract = {{A population density description of large populations of neurons has generated considerable interest recently. The evolution in time of the population density is determined by a partial differential equation (PDE). Most of the algorithms proposed to solve this PDE have used finite difference schemes. Here, I use the method of characteristics to reduce the PDE to a set of ordinary differential equations, which are easy to solve. The method is applied to leaky-integrate-and-fire neurons and produces an algorithm that is efficient and yields a stable and manifestly nonnegative density. Contrary to algorithms based directly on finite difference schemes, this algorithm is insensitive to large density gradients, which may occur during evolution of the density.}},
    author = {de Kamps, M.},
    citeulike-article-id = {9314281},
    citeulike-linkout-0 = {http://dx.doi.org/10.1162/089976603322297322},
    citeulike-linkout-1 = {http://view.ncbi.nlm.nih.gov/pubmed/12959669},
    citeulike-linkout-2 = {http://www.hubmed.org/display.cgi?uids=12959669},
    doi = {10.1162/089976603322297322},
    issn = {0899-7667},
    journal = {Neural Computation},
    keywords = {neurons, spiking},
    month = sep,
    number = {9},
    pages = {2129--2146},
    pmid = {12959669},
    posted-at = {2011-05-19 14:37:28},
    priority = {2},
    title = {{A simple and stable numerical solution for the population density equation.}},
    url = {http://dx.doi.org/10.1162/089976603322297322},
    volume = {15},
    year = {2003}
}

@proceedings{dekamps2006,
    abstract = {{Population density techniques are statistical methods to describe large populations of spiking neurons. They describe the response of such a population to a stochastic input. These techniques are sometimes defined as the interaction of neuronal dynamics and a Poisson point process. In earlier work I showed that one can transform away neuronal dynamics, which leaves only the problem of solving the master equation for the Poisson point process. Previously, I used a numerical solution for the master equation. In this work, I will present an analytic solution, which is based on a formal solution by Sirovich (2003). I will show that using this solution for solving the population density equation results in a much faster and manifestly stable algorithm.}},
    author = {de Kamps, M.},
    booktitle = {Neural Networks, 2006. IJCNN '06. International Joint Conference on},
    citeulike-article-id = {3485148},
    citeulike-linkout-0 = {http://dx.doi.org/10.1109/IJCNN.2006.246666},
    citeulike-linkout-1 = {http://ieeexplore.ieee.org/xpls/abs\_all.jsp?arnumber=1716077},
    doi = {10.1109/IJCNN.2006.246666},
    journal = {Neural Networks, 2006. IJCNN '06. International Joint Conference on},
    pages = {102--109},
    posted-at = {2011-05-19 14:33:48},
    priority = {0},
    title = {{An analytic solution of the reentrant Poisson master equation and its application in the simulation of large groups of spiking neurons}},
    url = {http://dx.doi.org/10.1109/IJCNN.2006.246666},
    year = {2006}
}

@book{gardiner2004,
    abstract = {{This valuable and highly-praised reference collects and explains, in simple
language and reasonably deductive form, those formulas and methods and their
applications used in modern Statistical Physics, including the foundations of
Markov systems, stochastic differential equations, Fokker-Planck equations,
approximation methods, chemical master equations, and quantum-mechanical
Markov processes. The practical orientation and broad coverage appeal to
researchers and academics working in theoretical physics, physical chemistry,
and related fields.

In the third edition of this classic the chapter on quantum Marcov processes
has been replaced by a chapter on numerical treatment of stochastic
differential equations to make the book even more valuable for practitioners.

From the reviews: "Extremely well written and informative... clear, complete,
and fairly rigorous treatment of a larger number of very basic concepts in
stochastic theory." (\_Journal of Quantum Electronics\_)

"A first class book." (\_Optica Acta\_)

"Ideal for people who need a clear introduction to stochastic mathematics and
their applications in physical sciences… an excellent self study and reference
book." (\_Quantnotes.com\_)

"This well-established volume takes a supreme position [among the many books
on the subject].. This extremely valuable contribution to the field of applied
stochastic methods can be recommended to graduate students, researchers, and
university teachers." (\_Optimization\_)}},
    author = {Gardiner, Crispin},
    citeulike-article-id = {3023051},
    citeulike-linkout-0 = {http://www.amazon.ca/exec/obidos/redirect?tag=citeulike09-20\&path=ASIN/3540208828},
    citeulike-linkout-1 = {http://www.amazon.de/exec/obidos/redirect?tag=citeulike01-21\&path=ASIN/3540208828},
    citeulike-linkout-2 = {http://www.amazon.fr/exec/obidos/redirect?tag=citeulike06-21\&path=ASIN/3540208828},
    citeulike-linkout-3 = {http://www.amazon.jp/exec/obidos/ASIN/3540208828},
    citeulike-linkout-4 = {http://www.amazon.co.uk/exec/obidos/ASIN/3540208828/citeulike00-21},
    citeulike-linkout-5 = {http://www.amazon.com/exec/obidos/redirect?tag=citeulike07-20\&path=ASIN/3540208828},
    citeulike-linkout-6 = {http://www.worldcat.org/isbn/3540208828},
    citeulike-linkout-7 = {http://books.google.com/books?vid=ISBN3540208828},
    citeulike-linkout-8 = {http://www.amazon.com/gp/search?keywords=3540208828\&index=books\&linkCode=qs},
    citeulike-linkout-9 = {http://www.librarything.com/isbn/3540208828},
    day = {28},
    edition = {3rd},
    howpublished = {Paperback},
    isbn = {3540208828},
    keywords = {gardiner},
    month = apr,
    posted-at = {2011-09-13 08:28:31},
    priority = {2},
    publisher = {Springer},
    title = {{Handbook of Stochastic Methods: for Physics, Chemistry and the Natural Sciences (Springer Series in Synergetics)}},
    url = {http://www.worldcat.org/isbn/3540208828},
    year = {2004}
}

@book{gerstner2002,
    abstract = {{This introduction to spiking neurons can be used in advanced-level courses in computational neuroscience, theoretical biology, neural modeling, biophysics, or neural networks. It focuses on phenomenological approaches rather than detailed models in order to provide the reader with a conceptual framework. The authors formulate the theoretical concepts clearly without many mathematical details. While the book contains standard material for courses in computational neuroscience, neural modeling, or neural networks, it also provides an entry to current research. No prior knowledge beyond undergraduate mathematics is required.}},
    author = {Gerstner, Wulfram and Kistler, Werner M.},
    citeulike-article-id = {106556},
    citeulike-linkout-0 = {http://www.amazon.ca/exec/obidos/redirect?tag=citeulike09-20\&path=ASIN/0521890799},
    citeulike-linkout-1 = {http://www.amazon.de/exec/obidos/redirect?tag=citeulike01-21\&path=ASIN/0521890799},
    citeulike-linkout-2 = {http://www.amazon.fr/exec/obidos/redirect?tag=citeulike06-21\&path=ASIN/0521890799},
    citeulike-linkout-3 = {http://www.amazon.jp/exec/obidos/ASIN/0521890799},
    citeulike-linkout-4 = {http://www.amazon.co.uk/exec/obidos/ASIN/0521890799/citeulike00-21},
    citeulike-linkout-5 = {http://www.amazon.com/exec/obidos/redirect?tag=citeulike07-20\&path=ASIN/0521890799},
    citeulike-linkout-6 = {http://www.worldcat.org/isbn/0521890799},
    citeulike-linkout-7 = {http://books.google.com/books?vid=ISBN0521890799},
    citeulike-linkout-8 = {http://www.amazon.com/gp/search?keywords=0521890799\&index=books\&linkCode=qs},
    citeulike-linkout-9 = {http://www.librarything.com/isbn/0521890799},
    day = {26},
    edition = {1},
    howpublished = {Paperback},
    isbn = {9780521890793},
    keywords = {brain, spiking},
    month = aug,
    posted-at = {2005-02-28 14:31:03},
    priority = {2},
    publisher = {Cambridge University Press},
    title = {{Spiking Neuron Models: Single Neurons, Populations, Plasticity}},
    url = {http://www.worldcat.org/isbn/0521890799},
    year = {2002}
}

@article{muller2007,
    abstract = {{We propose a Markov process model for spike-frequency adapting neural ensembles that synthesizes existing mean-adaptation approaches, population density methods, and inhomogeneous renewal theory, resulting in a unified and tractable framework that goes beyond renewal and mean-adaptation theories by accounting for correlations between subsequent interspike intervals. A method for efficiently generating inhomogeneous realizations of the proposed Markov process is given, numerical methods for solving the population equation are presented, and an expression for the first-order interspike interval correlation is derived. Further, we show that the full five-dimensional master equation for a conductance-based integrate-and-fire neuron with spike-frequency adaptation and a relative refractory mechanism driven by Poisson spike trains can be reduced to a two-dimensional generalization of the proposed Markov process by an adiabatic elimination of fast variables. For static and dynamic stimulation, negative serial interspike interval correlations and transient population responses, respectively, of Monte Carlo simulations of the full five-dimensional system can be accurately described by the proposed two-dimensional Markov process. We propose a Markov process model for spike-frequency adapting neural ensembles that synthesizes existing mean-adaptation approaches, population density methods, and inhomogeneous renewal theory, resulting in a unified and tractable framework that goes beyond renewal and mean-adaptation theories by accounting for correlations between subsequent interspike intervals. A method for efficiently generating inhomogeneous realizations of the proposed Markov process is given, numerical methods for solving the population equation are presented, and an expression for the first-order interspike interval correlation is derived. Further, we show that the full five-dimensional master equation for a conductance-based integrate-and-fire neuron with spike-frequency adaptation and a relative refractory mechanism driven by Poisson spike trains can be reduced to a two-dimensional generalization of the proposed Markov process by an adiabatic elimination of fast variables. For static and dynamic stimulation, negative serial interspike interval correlations and transient population responses, respectively, of Monte Carlo simulations of the full five-dimensional system can be accurately described by the proposed two-dimensional Markov process.}},
    author = {Muller, E. and Buesing, L. and Schemmel, J. and Meier, K.},
    citeulike-article-id = {4563668},
    citeulike-linkout-0 = {http://dx.doi.org/10.1162/neco.2007.19.11.2958},
    citeulike-linkout-1 = {http://www.mitpressjournals.org/doi/abs/10.1162/neco.2007.19.11.2958},
    citeulike-linkout-2 = {http://view.ncbi.nlm.nih.gov/pubmed/17883347},
    citeulike-linkout-3 = {http://www.hubmed.org/display.cgi?uids=17883347},
    day = {20},
    doi = {10.1162/neco.2007.19.11.2958},
    issn = {0899-7667},
    journal = {Neural Computation},
    keywords = {isi, nonstationarities, renewal},
    month = sep,
    number = {11},
    pages = {2958--3010},
    pmid = {17883347},
    posted-at = {2009-05-20 19:36:32},
    priority = {2},
    publisher = {MIT Press},
    title = {Spike-frequency adapting neural ensembles: {B}eyond mean adaptation and renewal theories.},
    url = {http://dx.doi.org/10.1162/neco.2007.19.11.2958},
    volume = {19},
    year = {2007}
}

@book{risken1996,
    abstract = {{This book deals with the derivation of the Fokker-Planck equation, methods of solving it and some of its applications. Various methods such as the simulation method, the eigenfunction expansion, numerical integration, the variational method, and the matrix continued-fraction method are discussed. This is the first time that this last method, which is very effective in dealing with simple Fokker-Planck equations having two variables, appears in a textbook. The methods of solution are applied to the statistics of a simple laser model and to Brownian motion in potentials. It is shown that the solution of the equation for Brownian motion in a variety of potentials can be expressed in terms suitable for evaluation on a computer. A supplement is included, containing a short review of new material together with some recent references. The book should be very useful to graduate students in physics, chemical physics, and electrical engineering, and also to research workers in these fields.}},
    author = {Risken, Hannes},
    citeulike-article-id = {334659},
    citeulike-linkout-0 = {http://www.amazon.com/exec/obidos/redirect?tag=citeulike07-20\&\#38;path=ASIN/354061530X},
    citeulike-linkout-1 = {http://www.amazon.ca/exec/obidos/redirect?tag=citeulike09-20\&path=ASIN/354061530X},
    citeulike-linkout-10 = {http://www.librarything.com/isbn/354061530X},
    citeulike-linkout-2 = {http://www.amazon.de/exec/obidos/redirect?tag=citeulike01-21\&path=ASIN/354061530X},
    citeulike-linkout-3 = {http://www.amazon.fr/exec/obidos/redirect?tag=citeulike06-21\&path=ASIN/354061530X},
    citeulike-linkout-4 = {http://www.amazon.jp/exec/obidos/ASIN/354061530X},
    citeulike-linkout-5 = {http://www.amazon.co.uk/exec/obidos/ASIN/354061530X/citeulike00-21},
    citeulike-linkout-6 = {http://www.amazon.com/exec/obidos/redirect?tag=citeulike07-20\&path=ASIN/354061530X},
    citeulike-linkout-7 = {http://www.worldcat.org/isbn/354061530X},
    citeulike-linkout-8 = {http://books.google.com/books?vid=ISBN354061530X},
    citeulike-linkout-9 = {http://www.amazon.com/gp/search?keywords=354061530X\&index=books\&linkCode=qs},
    day = {17},
    edition = {2nd ed. 1989. 3rd printing},
    howpublished = {Paperback},
    isbn = {354061530X},
    month = sep,
    posted-at = {2011-02-17 21:14:17},
    priority = {2},
    publisher = {Springer},
    series = {Springer Series in Synergetics},
    title = {{The Fokker-Planck Equation: Methods of Solutions and Applications}},
    url = {http://www.amazon.com/exec/obidos/redirect?tag=citeulike07-20\&path=ASIN/354061530X},
    year = {1996}
}

@article{sirovich2003,
    abstract = {{A novel approach to cortical modelling was introduced by Knight and co-workers in 1996. In their presentation cortical dynamics is formulated in terms of interacting populations of neurons, a perspective that is in part motivated by modern cortical imaging. The approach may be regarded as the application of statistical mechanics to neuronal populations, and the simplest exemplar bears a kinship to the Boltzmann equation of kinetic theory. The disarming simplicity of this linear equation hides the complex behaviour it produces. A purpose of this paper is to investigate and reveal its intricacies by treating a series of solvable special cases. In particular we will focus on issues that relate to the spectral analysis of the underlying operators. A fairly thorough treatment is presented for a simple, but still useful example, that has important consequences for more general situations.}},
    author = {Sirovich, Lawrence},
    citeulike-article-id = {6036188},
    citeulike-linkout-0 = {http://view.ncbi.nlm.nih.gov/pubmed/12790184},
    citeulike-linkout-1 = {http://www.hubmed.org/display.cgi?uids=12790184},
    issn = {0954-898X},
    journal = {Network (Bristol, England)},
    keywords = {network\_dynamics, statistical\_mechanics},
    month = may,
    number = {2},
    pages = {249--272},
    pmid = {12790184},
    posted-at = {2009-10-29 19:07:07},
    priority = {2},
    title = {{Dynamics of neuronal populations: eigenfunction theory; some solvable cases.}},
    url = {http://view.ncbi.nlm.nih.gov/pubmed/12790184},
    volume = {14},
    year = {2003}
}

repository: dekamps/miind

repo_name: dekamps/miind

extension: bib


text:
package bot

import (
	"fmt"
	"runtime"
	"time"

	"github.com/kevwan/chatbot/bot/adapters/input"
	"github.com/kevwan/chatbot/bot/adapters/logic"
	"github.com/kevwan/chatbot/bot/adapters/output"
	"github.com/kevwan/chatbot/bot/adapters/storage"
)

const mega = 1024 * 1024

type ChatBot struct {
	PrintMemStats  bool
	InputAdapter   input.InputAdapter
	LogicAdapter   logic.LogicAdapter
	OutputAdapter  output.OutputAdapter
	StorageAdapter storage.StorageAdapter
	Trainer        Trainer
}

func (chatbot *ChatBot) Train(data interface{}) error {
	start := time.Now()
	defer func() {
		fmt.Printf("Elapsed: %s\n", time.Since(start))
	}()

	if chatbot.PrintMemStats {
		go func() {
			for {
				var m runtime.MemStats
				runtime.ReadMemStats(&m)
				fmt.Printf("Alloc = %vm\nTotalAlloc = %vm\nSys = %vm\nNumGC = %v\n\n",
					m.Alloc/mega, m.TotalAlloc/mega, m.Sys/mega, m.NumGC)
				time.Sleep(5 * time.Second)
			}
		}()
	}

	if err := chatbot.Trainer.Train(data); err != nil {
		return err
	} else {
		return chatbot.StorageAdapter.Sync()
	}
}

func (chatbot *ChatBot) GetResponse(text string) []logic.Answer {
	if chatbot.LogicAdapter.CanProcess(text) {
		return chatbot.LogicAdapter.Process(text)
	}

	return nil
}

repository: rokinluu/chatbot

repo_name: rokinluu/chatbot

branch_name: refs/heads/main


text:
DESCRIPTION = "XBMC customization"

LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/MIT;md5=0835ade698e0bcf8506ecda2f7b4f302"

DEPENDS += "xbmc-startup"
RDEPENDS_${PN} = "xbmc-startup"

PR = "r0"

SRC_URI = "file://advancedsettings.xml \
           file://guisettings.xml \
"

XBMC_USER = "xbmc"
XBMC_HOME = "/home/xbmc/${XBMC_APPLICATION_DIRECTORY_BASE}"
XBMC_USERDATA = "${XBMC_HOME}/userdata"
XBMC_SYSTEM = "/imx6/kodi/share/kodi/system"

do_install () {
        install -o xbmc -g users -d ${D}${XBMC_HOME}
        install -o xbmc -g users -d ${D}${XBMC_USERDATA}
        install -o xbmc -g users -m 0644 ${WORKDIR}/guisettings.xml ${D}${XBMC_USERDATA}

        install -o xbmc -g users -d ${D}${XBMC_SYSTEM}
        install -o xbmc -g users -m 0644 ${WORKDIR}/advancedsettings.xml ${D}${XBMC_SYSTEM}
}

FILES_${PN} += "${XBMC_HOME} ${XBMC_SYSTEM}"

repository: rdm-dev/meta-jens

repo_name: rdm-dev/meta-jens

branch_name: refs/heads/jethro-kiebitzsee

extension: bb


text:
package model

import (
	"github.com/huaweicloud/huaweicloud-sdk-go-v3/core/utils"

	"strings"
)

// OverrideInfo 实例的详细信息
type OverrideInfo struct {

	// 可用区ID
	AvailabilityZoneId string `json:"availability_zone_id"`

	// 实例规格ID
	FlavorId string `json:"flavor_id"`

	// 用户愿意为竞价实例每小时支付的最高价格
	SpotPrice *float64 `json:"spot_price,omitempty"`

	// 优先级。数值越小，优先级越高，优先购买。 取值范围：0到Integer.MAX_VALUE 默认值是Integer.MAX_VALUE
	Priority *int32 `json:"priority,omitempty"`

	// 实例规格的权重。取值越高，单台实例满足计算力需求的能力越大，所需的实例数量越小。 取值范围：大于0 可以根据指定实例规格的计算力和集群单节点最低计算力得出权重值。 假设单节点最低计算力为8vcpu、60GB，则8vcpu、60GB的实例规格权重可设置为1，16vcpu、120GB的实例规格权重可设置为2
	WeightedCapacity *float64 `json:"weighted_capacity,omitempty"`
}

func (o OverrideInfo) String() string {
	data, err := utils.Marshal(o)
	if err != nil {
		return "OverrideInfo struct{}"
	}

	return strings.Join([]string{"OverrideInfo", string(data)}, " ")
}

gha_license_id: NOASSERTION


text:
require xorg-lib-common.inc

DESCRIPTION = "Xprint printer utility client library"
DEPENDS += "libxp libxt"
PR = "r1"
PE = "1"

XORG_PN = "libXprintUtil"

SRC_URI[archive.md5sum] = "22584f1aab1deba253949b562d1f0f45"
SRC_URI[archive.sha256sum] = "72b6ae0420b9601f55be147e8d068f670b951ae73a81423ba25be5875d826e6c"


text:
SUMMARY = "Configuration transcoder utility"
DESCRIPTION = " \
    A utility to save and restore system configurations across \
    format/imaging operations. \
"
SECTION = "base"

LICENSE = "MIT"
LIC_FILES_CHKSUM = "\
    file://${COMMON_LICENSE_DIR}/MIT;md5=0835ade698e0bcf8506ecda2f7b4f302 \
"

inherit allarch ptest

PACKAGES =+ "${PN}-example"

DEPENDS += "bash"

RDEPENDS_${PN} += "bash"
RDEPENDS_${PN}-example += "${PN} bash"
RDEPENDS_${PN}-ptest += "${PN} ${PN}-example bash"

FILES_${PN}-example = "${sysconfdir}/transconf/hooks/example"

S = "${WORKDIR}"

SRC_URI = " \
    file://transconf \
    file://example_transconf_hook \
    file://run-ptest \
"

do_install () {
    install -d ${D}${sbindir}
    install -m 0755 ${S}/transconf ${D}${sbindir}/

    install -d ${D}${sysconfdir}
    install -d ${D}${sysconfdir}/transconf
    install -d ${D}${sysconfdir}/transconf/hooks
    install -m 0755 ${S}/example_transconf_hook ${D}${sysconfdir}/transconf/hooks/example
}

do_install_ptest_append () {
    install -d ${D}${PTEST_PATH}
    install -m 0755 ${S}/run-ptest ${D}${PTEST_PATH}/
}

# XXX OE can't sub-package "${sysconfdir}/transconf/hooks/example" file
#  then package an empty "${sysconfdir}/transconf/hooks/" directory.
#  Workaround in postinst script.
pkg_postinst_${PN} () {
    [ -e "$D${sysconfdir}/transconf" ] || mkdir -m 0755 "$D${sysconfdir}/transconf"
    [ -e "$D${sysconfdir}/transconf/hooks" ] || mkdir -m 0755 "$D${sysconfdir}/transconf/hooks"
}

# XXX Has dependents which are native and/or nativesdk
BBCLASSEXTEND += "native nativesdk"

repository: NIwkoe/meta-nilrt

repo_name: NIwkoe/meta-nilrt

branch_name: refs/heads/nilrt/master/sumo


text: Momin, A. A., Shende, N., Anamtatmakula, A., Ganguly, E., Gurbani, A., Joshi, C. A., & Mahajan, Y. Y. (2021). Mathematical Modeling of Heat Conduction. arXiv preprint arXiv:2107.11737.


text:
@Article{hess-20-2227-2016,
AUTHOR = {Heimhuber, V. and Tulbure, M. G. and Broich, M.},
TITLE = {Modeling 25~years of spatio-temporal surface water and inundation dynamics
on large river basin scale using time series of Earth observation data},
JOURNAL = {Hydrology and Earth System Sciences},
VOLUME = {20},
YEAR = {2016},
NUMBER = {6},
PAGES = {2227--2250},
URL = {https://hess.copernicus.org/articles/20/2227/2016/},
DOI = {10.5194/hess-20-2227-2016}
}


text:
require swupdate.inc

SRCREV = "d39f4b8e00ef1929545b66158e45b82ea922bf81"

do_install_append () {
    # Rename the binaries installed by make install
    test -f ${D}${bindir}/progress && mv ${D}${bindir}/progress ${D}${bindir}/swupdate-progress
    test -f ${D}${bindir}/client && mv ${D}${bindir}/client ${D}${bindir}/swupdate-client
    test -f ${D}${bindir}/hawkbitcfg && mv ${D}${bindir}/hawkbitcfg ${D}${bindir}/swupdate-hawkbitcfg
    test -f ${D}${bindir}/sendtohawkbit && mv ${D}${bindir}/sendtohawkbit ${D}${bindir}/swupdate-sendtohawkbit
}

repository: bdx-iot/meta-swupdate

repo_name: bdx-iot/meta-swupdate


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

package galley

import (
	"testing"

	. "github.com/onsi/gomega"

	"istio.io/istio/pkg/test/framework"
	"istio.io/istio/pkg/test/framework/components/environment"
	"istio.io/istio/pkg/test/framework/components/namespace"
	"istio.io/istio/pkg/test/util/yml"
)

func TestResourceLifecycle(t *testing.T) {
	g := NewGomegaWithT(t)

	ctx := framework.NewContext(t)

	ns := namespace.NewOrFail(t, ctx, "fake", false)

	c := NewOrFail(t, ctx, Config{}).(*nativeComponent)

	gateway := `
apiVersion: networking.istio.io/v1alpha3
kind: Gateway
metadata:
  name: some-ingress
spec:
  servers:
  - port:
      number: 80
      name: http
      protocol: http
    hosts:
    - "*.example.com"
`

	virtualService := `
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: route-for-myapp
spec:
  hosts:
  - some.example.com
  gateways:
  - some-ingress
  http:
  - route:
    - destination:
        host: some.example.internal
`

	// Create resources.
	c.ApplyConfigOrFail(t, ns, yml.JoinString(gateway, virtualService))
	fileInfos, err := readFileInfos(c.configDir)
	g.Expect(err).To(BeNil())
	g.Expect(len(fileInfos)).To(Equal(2))
	g.Expect(len(fileInfos[0].resources)).To(Equal(1))
	g.Expect(len(fileInfos[1].resources)).To(Equal(2))
	g.Expect(fileInfos[0].resources[0].descriptor).To(Equal(yml.Descriptor{
		Kind:       "attributemanifest",
		APIVersion: "config.istio.io/v1alpha2",
		Metadata: yml.Metadata{
			Name:      "istioproxy",
			Namespace: "istio-system",
		},
	}))
	g.Expect(fileInfos[1].resources[0].descriptor).To(Equal(yml.Descriptor{
		Kind:       "Gateway",
		APIVersion: "networking.istio.io/v1alpha3",
		Metadata: yml.Metadata{
			Name:      "some-ingress",
			Namespace: ns.Name(),
		},
	}))
	g.Expect(fileInfos[1].resources[1].descriptor).To(Equal(yml.Descriptor{
		Kind:       "VirtualService",
		APIVersion: "networking.istio.io/v1alpha3",
		Metadata: yml.Metadata{
			Name:      "route-for-myapp",
			Namespace: ns.Name(),
		},
	}))

	gateway = `
apiVersion: networking.istio.io/v1alpha3
kind: Gateway
metadata:
  name: some-ingress
spec:
  servers:
  - port:
      number: 90
      name: http
      protocol: http
    hosts:
    - "*.example.com"
`

	// Update the gateway resource.
	c.ApplyConfigOrFail(t, ns, yml.JoinString(gateway, virtualService))
	fileInfos, err = readFileInfos(c.configDir)
	g.Expect(err).To(BeNil())
	g.Expect(len(fileInfos)).To(Equal(2))
	g.Expect(len(fileInfos[0].resources)).To(Equal(1))
	g.Expect(len(fileInfos[1].resources)).To(Equal(2))
	gatewayResource := newFileResourceMap(fileInfos)[yml.Descriptor{
		Kind:       "Gateway",
		APIVersion: "networking.istio.io/v1alpha3",
		Metadata: yml.Metadata{
			Name:      "some-ingress",
			Namespace: ns.Name(),
		},
	}]
	g.Expect(gatewayResource).ToNot(BeNil())
	g.Expect(gatewayResource.content).To(ContainSubstring("number: 90"))

	// Delete the gateway resource
	c.DeleteConfigOrFail(t, ns, gateway)
	fileInfos, err = readFileInfos(c.configDir)
	g.Expect(err).To(BeNil())
	g.Expect(len(fileInfos)).To(Equal(2))
	g.Expect(len(fileInfos[0].resources)).To(Equal(1))
	g.Expect(len(fileInfos[1].resources)).To(Equal(1))
	g.Expect(fileInfos[1].resources[0].descriptor).To(Equal(yml.Descriptor{
		Kind:       "VirtualService",
		APIVersion: "networking.istio.io/v1alpha3",
		Metadata: yml.Metadata{
			Name:      "route-for-myapp",
			Namespace: ns.Name(),
		},
	}))
}

func TestMain(m *testing.M) {
	framework.
		NewSuite("galley_component_unit_tests", m).
		RequireEnvironment(environment.Native).
		Run()
}

repository: anespo/istio-demo

repo_name: anespo/istio-demo


text:
package scanner

import (
	"github.com/z7zmey/php-parser/comment"
	"github.com/z7zmey/php-parser/position"
)

// Token value returned by lexer
type Token struct {
	Value    string
	position *position.Position
	comments []*comment.Comment
}

// NewToken Token constructor
func NewToken(value string, pos *position.Position) *Token {
	return &Token{
		Value:    value,
		position: pos,
		comments: nil,
	}
}

func (t *Token) String() string {
	return string(t.Value)
}

// Position returns token position
func (t *Token) Position() *position.Position {
	return t.position
}

// Comments returns attached comments
func (t *Token) Comments() []*comment.Comment {
	return t.comments
}

// SetComments attach comments
func (t *Token) SetComments(comments []*comment.Comment) *Token {
	t.comments = comments
	return t
}

repository: chennqqi/php-parser

repo_name: chennqqi/php-parser


text:
# Copyright (C) 2015 Aananth Chellapa Natarajan <c.n.aananth@gmail.com>
# Released under the MIT license (see COPYING.MIT for the terms)

# Base this image on core-image-minimal
include recipes-core/images/core-image-minimal.bb

# Include modules in rootfs
IMAGE_INSTALL += " \
        kernel-modules \
"

SPLASH = "psplash-raspberrypi"

IMAGE_FEATURES += " ssh-server-dropbear"
IMAGE_INSTALL_append = " sota-com sota-updater xdelta usbutils linux-firmware \
                         connman connman-client wpa-supplicant wireless-tools \
                         iw rpm sched-test \
"

repository: aananthcn/meta-aananth

repo_name: aananthcn/meta-aananth


text:
@misc{markdown,
    author    = "John Gruber and Aaron Swartz",
    title     = "The Markdown format",
    year      = "2004",
    url       = "http://daringfireball.net/projects/markdown/syntax"
}

@article{mihalas:2009,
  title={A generalized linear integrate-and-fire neural model produces diverse spiking behaviors},
  author={Mihala{\c{s}}, {\c{S}}tefan and Niebur, Ernst},
  journal={Neural computation},
  volume={21},
  number={3},
  pages={704--718},
  year={2009},
  publisher={MIT Press}
}

@article{nordlie:2009,
  title={Towards reproducible descriptions of neuronal network models},
  author={Nordlie, Eilen and Gewaltig, Marc-Oliver and Plesser, Hans Ekkehard},
  journal={PLoS computational biology},
  volume={5},
  number={8},
  pages={e1000456},
  year={2009},
  publisher={Public Library of Science}
}

@article{folowosele:2011,
  title={Silicon Modeling of the Mihala{\c{s}}--Niebur Neuron},
  author={Folowosele, Fopefolu and Hamilton, Tara Julia and Etienne-Cummings, Ralph},
  journal={IEEE transactions on neural networks},
  volume={22},
  number={12},
  pages={1915--1927},
  year={2011},
  publisher={IEEE}
}

@book{dayan:2001,
  title={Theoretical neuroscience},
  author={Dayan, Peter and Abbott, Laurence F},
  volume={806},
  year={2001},
  publisher={Cambridge, MA: MIT Press}
}


text:
@inproceedings{10.1145/113413.113414,
author = {Hillebrand, Gerd G. and Kanellakis, Paris C. and Mairson, Harry G. and Vardi, Moshe Y.},
title = {Tools for Datalog Boundedness},
year = {1991},
isbn = {0897914309},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/113413.113414},
doi = {10.1145/113413.113414},
booktitle = {Proceedings of the Tenth ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems},
pages = {1–12},
numpages = {12},
location = {Denver, Colorado, USA},
series = {PODS '91}
}

@inproceedings{10.1145/113413.113415,
author = {Afrati, Foto and Cosmadakis, Stavros S. and Yannakakis, Mihalis},
title = {On Datalog vs. Polynomial Time (Extended Abstract)},
year = {1991},
isbn = {0897914309},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/113413.113415},
doi = {10.1145/113413.113415},
booktitle = {Proceedings of the Tenth ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems},
pages = {13–25},
numpages = {13},
location = {Denver, Colorado, USA},
series = {PODS '91}
}

@inproceedings{10.1145/113413.113416,
author = {Vadaparty, Kumar},
title = {On the Power of Rule-Based Languages with Sets},
year = {1991},
isbn = {0897914309},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/113413.113416},
doi = {10.1145/113413.113416},
booktitle = {Proceedings of the Tenth ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems},
pages = {26–36},
numpages = {11},
location = {Denver, Colorado, USA},
series = {PODS '91}
}

@inproceedings{10.1145/113413.113417,
author = {Immerman, Neil and Patnaik, Sushant and Stemple, David},
title = {The Expressiveness of a Family of Finite Set Languages},
year = {1991},
isbn = {0897914309},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/113413.113417},
doi = {10.1145/113413.113417},
booktitle = {Proceedings of the Tenth ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems},
pages = {37–52},
numpages = {16},
location = {Denver, Colorado, USA},
series = {PODS '91}
}

@inproceedings{10.1145/113413.113418,
author = {Garcia-Molina, Hector and Salem, Kenneth},
title = {Non-Deterministic Queue Operations},
year = {1991},
isbn = {0897914309},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/113413.113418},
doi = {10.1145/113413.113418},
booktitle = {Proceedings of the Tenth ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems},
pages = {53–62},
numpages = {10},
location = {Denver, Colorado, USA},
series = {PODS '91}
}

@inproceedings{10.1145/113413.113419,
author = {Krishnakumar, Narayanan and Bernstein, Arthur J.},
title = {Bounded Ignorance in Replicated Systems},
year = {1991},
isbn = {0897914309},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/113413.113419},
doi = {10.1145/113413.113419},
booktitle = {Proceedings of the Tenth ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems},
pages = {63–74},
numpages = {12},
location = {Denver, Colorado, USA},
series = {PODS '91}
}

@inproceedings{10.1145/113413.113420,
author = {Johnson, Donald B. and Raab, Larry},
title = {A Tight Upper Bound on the Benefits of Replication and Consistency Control Protocols},
year = {1991},
isbn = {0897914309},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/113413.113420},
doi = {10.1145/113413.113420},
booktitle = {Proceedings of the Tenth ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems},
pages = {75–81},
numpages = {7},
location = {Denver, Colorado, USA},
series = {PODS '91}
}

@inproceedings{10.1145/113413.113421,
author = {Wang, Wei-hsing and Hsu, Meichun and Pinsky, Eugene},
title = {Modeling Hot Spots in Database Systems (Extended Abstract)},
year = {1991},
isbn = {0897914309},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/113413.113421},
doi = {10.1145/113413.113421},
booktitle = {Proceedings of the Tenth ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems},
pages = {82–91},
numpages = {10},
location = {Denver, Colorado, USA},
series = {PODS '91}
}

@inproceedings{10.1145/113413.113422,
author = {Ross, Kenneth A.},
title = {Modular Acyclicity and Tail Recursion in Logic Programs},
year = {1991},
isbn = {0897914309},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/113413.113422},
doi = {10.1145/113413.113422},
booktitle = {Proceedings of the Tenth ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems},
pages = {92–101},
numpages = {10},
location = {Denver, Colorado, USA},
series = {PODS '91}
}

@inproceedings{10.1145/113413.113423,
author = {Lakshmanan, Laks V. S. and Hern\'{a}ndez, H\'{e}ctor J.},
title = {Structural Query Optimization—a Uniform Framework for Semantic Query Optimization in Deductive Databases},
year = {1991},
isbn = {0897914309},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/113413.113423},
doi = {10.1145/113413.113423},
booktitle = {Proceedings of the Tenth ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems},
pages = {102–114},
numpages = {13},
location = {Denver, Colorado, USA},
series = {PODS '91}
}

@inproceedings{10.1145/113413.113424,
author = {Chaudhuri, Surajit},
title = {Detecting Redundant Tuples during Query Evaluation},
year = {1991},
isbn = {0897914309},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/113413.113424},
doi = {10.1145/113413.113424},
booktitle = {Proceedings of the Tenth ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems},
pages = {115–126},
numpages = {12},
location = {Denver, Colorado, USA},
series = {PODS '91}
}

@inproceedings{10.1145/113413.113425,
author = {Mumick, Inderpal Singh and Pirahesh, Hamid},
title = {Overbound and Right-Linear Queries},
year = {1991},
isbn = {0897914309},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/113413.113425},
doi = {10.1145/113413.113425},
booktitle = {Proceedings of the Tenth ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems},
pages = {127–141},
numpages = {15},
location = {Denver, Colorado, USA},
series = {PODS '91}
}

@inproceedings{10.1145/113413.113426,
author = {Tsur, Shalom},
title = {Deductive Databases in Action},
year = {1991},
isbn = {0897914309},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/113413.113426},
doi = {10.1145/113413.113426},
booktitle = {Proceedings of the Tenth ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems},
pages = {142–153},
numpages = {12},
location = {Denver, Colorado, USA},
series = {PODS '91}
}

@inproceedings{10.1145/113413.113427,
author = {Ganguly, Sumit and Greco, Sergio and Zaniolo, Carlo},
title = {Minimum and Maximum Predicates in Logic Programming},
year = {1991},
isbn = {0897914309},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/113413.113427},
doi = {10.1145/113413.113427},
booktitle = {Proceedings of the Tenth ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems},
pages = {154–163},
numpages = {10},
location = {Denver, Colorado, USA},
series = {PODS '91}
}

@inproceedings{10.1145/113413.113428,
author = {Matsliach, Gabriel},
title = {Performance Analysis of File Organizations That Use Multi-Bucket Data Leaves with Partial Expansions (Extended Abstract)},
year = {1991},
isbn = {0897914309},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/113413.113428},
doi = {10.1145/113413.113428},
booktitle = {Proceedings of the Tenth ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems},
pages = {164–180},
numpages = {17},
location = {Denver, Colorado, USA},
series = {PODS '91}
}

@inproceedings{10.1145/113413.113429,
author = {Helm, Richard and Marriott, Kim and Odersky, Martin},
title = {Constraint-Based Query Optimization for Spatial Databases},
year = {1991},
isbn = {0897914309},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/113413.113429},
doi = {10.1145/113413.113429},
booktitle = {Proceedings of the Tenth ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems},
pages = {181–191},
numpages = {11},
location = {Denver, Colorado, USA},
series = {PODS '91}
}

@inproceedings{10.1145/113413.113430,
author = {Nurmi, Otto and Soisalon-Soininen, Eljas},
title = {Uncoupling Updating and Rebalancing in Chromatic Binary Search Trees},
year = {1991},
isbn = {0897914309},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/113413.113430},
doi = {10.1145/113413.113430},
booktitle = {Proceedings of the Tenth ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems},
pages = {192–198},
numpages = {7},
location = {Denver, Colorado, USA},
series = {PODS '91}
}

@inproceedings{10.1145/113413.113431,
author = {Jakobsson, H\r{a}kan},
title = {Mixed-Approach Algorithms for Transitive Closure (Extended Abstract)},
year = {1991},
isbn = {0897914309},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/113413.113431},
doi = {10.1145/113413.113431},
booktitle = {Proceedings of the Tenth ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems},
pages = {199–205},
numpages = {7},
location = {Denver, Colorado, USA},
series = {PODS '91}
}

@inproceedings{10.1145/113413.113432,
author = {Ross, Kenneth A.},
title = {On Negation in HiLog (Extended Abstract)},
year = {1991},
isbn = {0897914309},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/113413.113432},
doi = {10.1145/113413.113432},
booktitle = {Proceedings of the Tenth ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems},
pages = {206–215},
numpages = {10},
location = {Denver, Colorado, USA},
series = {PODS '91}
}

@inproceedings{10.1145/113413.113433,
author = {Sohn, Kirack and Van Gelder, Allen},
title = {Termination Detection in Logic Programs Using Argument Sizes (Extended Abstract)},
year = {1991},
isbn = {0897914309},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/113413.113433},
doi = {10.1145/113413.113433},
booktitle = {Proceedings of the Tenth ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems},
pages = {216–226},
numpages = {11},
location = {Denver, Colorado, USA},
series = {PODS '91}
}

@inproceedings{10.1145/113413.113434,
author = {Brodsky, Alexander and Sagiv, Yehoshua},
title = {Inference of Inequality Constraints in Logic Programs (Extended Abstracts)},
year = {1991},
isbn = {0897914309},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/113413.113434},
doi = {10.1145/113413.113434},
booktitle = {Proceedings of the Tenth ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems},
pages = {227–240},
numpages = {14},
location = {Denver, Colorado, USA},
series = {PODS '91}
}

@inproceedings{10.1145/113413.113435,
author = {Seib, J\"{u}rgen and Lausen, Georg},
title = {Parallelizing Datalog Programs by Generalized Pivoting},
year = {1991},
isbn = {0897914309},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/113413.113435},
doi = {10.1145/113413.113435},
booktitle = {Proceedings of the Tenth ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems},
pages = {241–251},
numpages = {11},
location = {Denver, Colorado, USA},
series = {PODS '91}
}

@inproceedings{10.1145/113413.113436,
author = {Malvestuto, F. M. and Moscarini, M. and Rafanelli, M.},
title = {Suppressing Marginal Cells to Protect Sensitive Information in a Two-Dimensional Statistical Table (Extended Abstract)},
year = {1991},
isbn = {0897914309},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/113413.113436},
doi = {10.1145/113413.113436},
booktitle = {Proceedings of the Tenth ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems},
pages = {252–258},
numpages = {7},
location = {Denver, Colorado, USA},
series = {PODS '91}
}

@inproceedings{10.1145/113413.113437,
author = {Roy, Shaibal},
title = {Semantic Complexity of Classes of Relational Queries and Query Independent Data Partitioning},
year = {1991},
isbn = {0897914309},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/113413.113437},
doi = {10.1145/113413.113437},
booktitle = {Proceedings of the Tenth ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems},
pages = {259–267},
numpages = {9},
location = {Denver, Colorado, USA},
series = {PODS '91}
}

@inproceedings{10.1145/113413.113438,
author = {Seshadri, S. and Naughton, Jeffrey F.},
title = {On the Expected Size of Recursive Datalog Queries},
year = {1991},
isbn = {0897914309},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/113413.113438},
doi = {10.1145/113413.113438},
booktitle = {Proceedings of the Tenth ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems},
pages = {268–279},
numpages = {12},
location = {Denver, Colorado, USA},
series = {PODS '91}
}

@inproceedings{10.1145/113413.113439,
author = {Baudinet, Marianne and Ni\'{e}zette, Marc and Wolper, Pierre},
title = {On the Representation of Infinite Temporal Data and Queries (Extended Abstract)},
year = {1991},
isbn = {0897914309},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/113413.113439},
doi = {10.1145/113413.113439},
booktitle = {Proceedings of the Tenth ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems},
pages = {280–290},
numpages = {11},
location = {Denver, Colorado, USA},
series = {PODS '91}
}

@inproceedings{10.1145/113413.113440,
author = {Van den Bussche, Jan and Paredaens, Jan},
title = {The Expressive Power Structured Values in Pure OODB's (Extended Abstract)},
year = {1991},
isbn = {0897914309},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/113413.113440},
doi = {10.1145/113413.113440},
booktitle = {Proceedings of the Tenth ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems},
pages = {291–299},
numpages = {9},
location = {Denver, Colorado, USA},
series = {PODS '91}
}

@inproceedings{10.1145/113413.113441,
author = {Beeri, Catriel and Milo, Tova},
title = {Subtyping in OODB's (Extended Abstract)},
year = {1991},
isbn = {0897914309},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/113413.113441},
doi = {10.1145/113413.113441},
booktitle = {Proceedings of the Tenth ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems},
pages = {300–314},
numpages = {15},
location = {Denver, Colorado, USA},
series = {PODS '91}
}

@inproceedings{10.1145/113413.113442,
author = {Grumbach, St\'{e}phane and Vianu, Victor},
title = {Tractable Query Languages for Complex Object Databases},
year = {1991},
isbn = {0897914309},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/113413.113442},
doi = {10.1145/113413.113442},
booktitle = {Proceedings of the Tenth ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems},
pages = {315–327},
numpages = {13},
location = {Denver, Colorado, USA},
series = {PODS '91}
}

@inproceedings{10.1145/113413.113443,
author = {Hull, Richard and Yoshikawa, Masatoshi},
title = {On the Equivalence of Database Restructurings Involving Object Identifiers (Extended Abstract)},
year = {1991},
isbn = {0897914309},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/113413.113443},
doi = {10.1145/113413.113443},
booktitle = {Proceedings of the Tenth ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems},
pages = {328–340},
numpages = {13},
location = {Denver, Colorado, USA},
series = {PODS '91}
}

license: Unlicense

repository: goyalkaraniit/acm-cr

repo_name: goyalkaraniit/acm-cr


text:
package cmd

import (
	"github.com/spf13/cobra"
)

var gitCmd = &cobra.Command{
	Use:   "git",
	Short: "Manage your git projects",
	Long:  `git enables you to configure your git projects with Qovery`,
}

func init() {
	RootCmd.AddCommand(gitCmd)
}

repository: RemiSirdata/qovery-cli

repo_name: RemiSirdata/qovery-cli


text:
/*
Copyright SecureKey Technologies Inc. All Rights Reserved.

SPDX-License-Identifier: Apache-2.0
*/

package models

import (
	"encoding/json"
	"testing"

	"github.com/stretchr/testify/require"

	"github.com/trustbloc/sidetree-core-go/pkg/api/operation"
)

func TestCreateCoreProofFile(t *testing.T) {
	const deactivateOpsNum = 2
	const recoverOpsNum = 2

	recoverOps := generateOperations(recoverOpsNum, operation.TypeRecover)
	deactivateOps := generateOperations(deactivateOpsNum, operation.TypeDeactivate)

	af := CreateCoreProofFile(recoverOps, deactivateOps)
	require.NotNil(t, af)
	require.Equal(t, deactivateOpsNum, len(af.Operations.Deactivate))
	require.Equal(t, recoverOpsNum, len(af.Operations.Recover))
}

func TestParseCoreProofFile(t *testing.T) {
	t.Run("success", func(t *testing.T) {
		const deactivateOpsNum = 3
		const recoverOpsNum = 1

		recoverOps := generateOperations(recoverOpsNum, operation.TypeRecover)
		deactivateOps := generateOperations(deactivateOpsNum, operation.TypeDeactivate)

		model := CreateCoreProofFile(recoverOps, deactivateOps)

		bytes, err := json.Marshal(model)
		require.NoError(t, err)

		parsed, err := ParseCoreProofFile(bytes)
		require.NoError(t, err)

		require.Equal(t, deactivateOpsNum, len(parsed.Operations.Deactivate))
		require.Equal(t, recoverOpsNum, len(parsed.Operations.Recover))
	})

	t.Run("error - unmarshal error", func(t *testing.T) {
		parsed, err := ParseCoreProofFile([]byte("not JSON"))
		require.Error(t, err)
		require.Nil(t, parsed)
		require.Contains(t, err.Error(), "failed to unmarshal core proof file")
	})
}

repository: trustbloc/sidetree-core-go

repo_name: trustbloc/sidetree-core-go


text:
@article{Kalil2015,
  title={ Low-Complexity Power-Efficient Schedulers for LTE Uplink with Delay-Sensitive Traffic },
  author={ M. Kalil, A. Shami, A. Al-Dweik, and S. Muhaidat },
  journal={ IEEE Transactions on Vehicular Technologies },
  volume={},
  pages={},
  year={2015},
}

@article{Meerja2015,
  title={ Hailing the Cloud Empowered Radio Access Networks (CRAN)},
  author={ K. M. Meerja, A. Shami, and A. Refaey },
  journal={ IEEE Wireless Communications },
  volume={},
  pages={},
  year={2015},
}
@article{Liao2015,
  title={ DFVisor: A Distributed FlowVisor Platform for QoS awared Cloud Network Virtualization},
  author={ Lingxia Liao, A. Shami, V. C.M. Leung },
  journal={ IET Networks Journal },
  volume={},
  pages={},
  year={2015},
}
@article{Kalil2015-2,
  title={ QoS-Aware Power-Efficient Scheduler for LTE Uplink },
  author={ M. Kalil, A. Shami, and A. Al-Dweik },
  journal={ IEEE Transactions on Mobile Computing },
  volume={},
  pages={},
  year={2015},
}
@article{Hawilo2014,
  title={ NFV: State of the Art, Challenges and Implementation in Next Generation Mobile Networks (vEPC)},
  author={ H. Hawilo, A. Shami, M. Mirahmadi, and A. Asal },
  journal={ IEEE Network },
  volume={},
  pages={},
  year={2014},
}
@article{Jammal2014,
  title={ Software defined networking: State of the art and research challenges,},
  author={ M. Jammal, T. Singh, A. Shami, R. Asal, Y. Li },
  journal={ Computer Networks Journal },
  volume={72},
  pages={74-98},
  year={2014},
}

@article{Wallace2014,
  title={Concurrent Multipath Transfer using SCTP: Modelling and Congestion Window Management},
  author={ T.D. Wallace, and A. Shami },
  journal={ IEEE Transactions on Mobile Computing },
  volume={13},
  pages={2510-2523},
  year={2014},
}

@article{Yoo2014,
  title={ Intelligent Consensus Modeling for Proline Cis-Trans Isomerization Prediction },
  author={ P. D. Yoo, S. Muhaidat, K. Taha, J. Bentahar, and A. Shami },
  journal={ IEEE/ACM Transactions on Computational Biology and Bioinformatics.},
  volume={},
  pages={},
  year={2014},
}

@article{Altrad2014,
  title={ Opportunistic Spectrum Access in Cognitive Radio Networks Under Imperfect Spectrum Sensing },
  author={ O. Altrad, S. Muhaidat, A. Al-Dweik, and A. Shami },
  journal={ IEEE Transactions on Vehicular Technology },
  volume={63},
  pages={920-925},
  year={2014},
}

@article{ Mirahmadi2014,
  title={ Interference Modeling and Performance Evaluation of Heterogeneous Cellular Networks },
  author={ M. Mirahmadi, A. Al-Dweik, and A. Shami },
  journal={ IEEE Transactions on Communications },
  volume={62},
  pages={2132-2144},
  year={2014},
}

@article{Dechene2014,
  title={ Energy-Aware Resource Allocation Strategies for LTE Uplink with Synchronous HARQ Constraints },
  author={ D. Dechene and A. Shami },
  journal={ IEEE Transactions on Mobile Computing },
  volume={13},
  pages={422-433},
  year={2014},
}

@article{ Mirahmadi2013,
  title={ BER Reduction of OFDM Based Broadband Communication Systems over Multipath Channels with Impulsive Noise },
  author={ M. Mirahmadi, A. Al-Dweik, and A. Shami },
  journal={ IEEE Transactions on Communications },
  volume={61},
  pages={4602-4615},
  year={2013},
}

@article{Mukhtar2013,
  title={ Adaptive Hybrid ARQ System using Turbo Product Codes with Hard/Soft Decoding },
  author={ H. H. Mukhtar, A. Al-Dweik, M. Mualla, and A. Shami },
  journal={ IEEE Communications Letters },
  volume={17},
  pages={2132-2135},
  year={2013},
}

@article{Abusharkh2013,
  title={ Resource Allocation in a Network-Based Cloud Computing Environment: Design Challenges},
  author={ M Abu Sharkh, M Jammal, A Shami, A Ouda },
  journal={ IEEE Communications Magazine },
  volume={51},
  pages={46-52},
  year={2013},
}

@article{parikh2013,
  title={ Comprehensive Investigation of Wireless LAN for IEC 61850 Based Smart Distribution Applications },
  author={ P. Parikh, T. Sidhu, and A. Shami },
  journal={ IEEE Transactions on Industrial Informatics },
  volume={9},
  pages={1466-1476},
  year={2013},
}
@article{southern2013,
  title={ Wireless Security: Securing Mobile UMTS Communications from interoperation of GSM },
  author={ E. Southern, A. Ouda and A. Shami },
  journal={ Wiley Journal on Security and Communication Networks },
  volume={6},
  pages={498-508},
  year={2013},
}

@article{Kennedy2013,
  title={ QoS Design, implementation, and evaluation of an FPGAbased WLAN synchronizer},
  author={ C. Kennedy, D. Dechene, and A. Shami },
  journal={ Wiley Wireless Communications and Mobile Computing Journal,},
  volume={13},
  pages={1082-1094},
  year={2013},
}
@article{Dechene2013,
  title={ Energy efficient QoS constrained scheduler for SC-FDMA uplink },
  author={ D. Dechene and A. Shami },
  journal={ Elsevier Physical Communications },
  volume={8},
  pages={81-90},
  year={2013},
}

@article{Bai2012,
  title={ Power Efficient Scheduling Over Fading Channel For Cross-Layer Optimization},
  author={ X. Bai, A. Shami, S. Primak },
  journal={ Wiley Wireless Communications and Mobile Computing Journal },
  volume={12},
  pages={1215-1224},
  year={2012},
}
@article{wallace2012,
  title={ A Review of Multihoming Issues using the Stream Control Transmission Protocol},
  author={ T. D. Wallace and A. Shami },
  journal={ IEEE Communications Surveys and Tutorials },
  volume={14},
  pages={565-578},
  year={2012},
}
@article{ahmed2012,
  title={ RPR-EPON-WiMAX Hybrid Network: A Solution for Access and Metro Networks},
  author={ M. Mirahmadi and A. Shami },
  journal={ IEEE/OSA Journal of Optical Communications and Networking },
  volume={4},
  pages={173-188},
  year={2012},
}
@article{ Mirahmadi2012,
  title={ Traffic-Prediction-Assisted Dynamic Bandwidth Assignment for Hybrid Optical Wireless Networks},
  author={ M. Mirahmadi and A. Shami },
  journal={ Elsevier Computer Networks Journal },
  volume={56},
  pages={244-259},
  year={2012},
}
@article{dechene2011,
  title={ QoS, Channel and Energy-Aware Packet Scheduling over Multiple Channels },
  author={ D. Dechene and A. Shami },
  journal={ IEEE Transactions on Wireless Communications },
  volume={10},
  pages={1058-1062},
  year={2011},
}
@article{dechene2010,
  title={ Energy Efficient Quality of Service Traffic Scheduler for MIMO Downlink SVD Channels},
  author={ D. Dechene and A. Shami },
  journal={ IEEE Transactions on Wireless Communications },
  volume={9},
  pages={3750-3761},
  year={2010},
}

@article{Meerja2010,
  title={ Analysis of Enhanced Collision Avoidance Scheme Proposed for IEEE 802.11e-Enhanced Distributed Channel Access Protocol},
  author={ K. Meerja and A. Shami },
  journal={ IEEE Transactions on Mobile Computing },
  volume={8},
  pages={1353-1367},
  year={2009},
}
@article{luccini2010,
  title={ Cross-Layer Optimization of Network Performance over MIMO Wireless Mobile Channels },
  author={ M. Luccini, A. Shami, S. Primak },
  journal={ IET Communications Journal },
  volume={4},
  pages={683-696},
  year={2010},
}
@article{bai2008,
  title={ Two Dimensional Cross-layer Optimization for Packet Transmission over Fading Channel },
  author={ X. Bai, and A. Shami },
  journal={ IEEE Transactions on Wireless Communications },
  volume={7},
  pages={3831-3822},
  year={2008},
}

@article{dechene2009,
  title={ Performance Evaluation of MIMO-Aware Media Access Control Protocol},
  author={ D. Dechene, K. Meerja, A. Shami },
  journal={ Elsevier Physical Communication Journal },
  volume={2},
  pages={204-216},
  year={2009},
}

@article{Assi2007,
  title={ Towards Quality-of-Service Protection in Ethernet Passive Optical Networks: Challenges and Solutions},
  author={ C. Assi, M. Maier, and A. Shami },
  journal={ IEEE Network, Special Issue on Advances in Broadband Access Networks },
  volume={21},
  pages={12-19},
  year={2007},
}

@article{Bai2008,
  title={ Robust QoS Control for Single Carrier PMP Mode IEEE 802.16 System },
  author={ X. Bai, A. Shami, and Y. Ye },
  journal={ IEEE Transactions on Mobile Computing },
  volume={7},
  pages={416-429},
  year={2008},
}
@article{ghani2008,
  title={ Value-added services in next-generation SONET/SDH networks},
  author={ N. Ghani, L. Qing, A. Gumaste, A. Shami et al.},
  journal={ IEEE Communications Magazine },
  volume={46},
  pages={64-73},
  year={2008},
}

@article{bai2009,
  title={ Analytical and Experimental Study on Ethernet Passive Optical Networks: Challenges and Solutions },
  author={ X. Bai, A. Shami, and Y. Ye },
  journal={ International Journal of Communication Networks and Distributed Systems },
  volume={2},
  pages={138-159},
  year={2009},
}
@article{wallace2008,
  title={ Scheduling Advance Reservation Requests for WDM Networks with Static Traffic Demands},
  author={ T. D. Wallace, A. Shami, and C. Assi },
  journal={ IEE Proceedings on Communications },
  volume={2},
  pages={1023-1033},
  year={2008},
}

@article{Meerja2007,
  title={ QoSAnalysis of New Distributed Media Access Control Protocols Proposed for IEEE 802.11 Wireless Local Area Networks},
  author={ K. A. Meerja, and A. Shami },
  journal={ IEEE Transactions on Vehicular Technologies },
  volume={56},
  pages={1797-1812},
  year={2007},
}

@article{wallace2007,
  title={ Advance lightpath reservation for WDM networks with dynamic traffic },
  author={ T. Daniel Wallace, A. Shami, and C. Assi },
  journal={ OSA Journal of Optical Networking },
  volume={6},
  pages={913-924},
  year={2007},
}
@article{dhaini2007,
  title={ Per-Stream QoS and Admission Control in Ethernet Passive Optical Networks (EPONs)},
  author={ A. Dhaini, C. Assi, A. Shami and M. Maier },
  journal={ IEEE Journal of Lightwave Technology },
  volume={25},
  pages={1659-1669},
  year={2007},
}

@article{Meerja2008,
  title={Enhancing channel utilization by improving media access coordination in wireless local area networks },
  author={ K. A. Meerja, and A. Shami },
  journal={ Wiley's Wireless Communications and Mobile Computing Journal },
  volume={8},
  pages={155-169},
  year={2008},
}

@article{Assi2006,
  title={ Multiple link failures survivability of optical networks with traffic grooming capability},
  author={ C. Assi, W. Huo, and A. Shami },
  journal={ Elsevier Computer Communications Journal },
  volume={29},
  pages={3900-3912},
  year={2006},
}
@article{Dhaini2007,
  title={ Dynamic Wavelength and Bandwidth Allocation in Hybrid TDM/WDM Ethernet Passive Optical Networks (EPONs)},
  author={ A. Dhaini, C. Assi, M. Maier, A. Shami },
  journal={IEEE/OSA Journal of Lightwave Technology },
  volume={25},
  pages={277-286},
  year={2007},
}

@article{bai2006,
  title={ QoS On the Fairness of Dynamic Bandwidth Allocation Schemes in Ethernet Passive Optical Networks },
  author={ X. Bai, A. Shami, and C. Assi },
  journal={ Elsevier Computer Communications Journal },
  volume={29},
  pages={2123-2135},
  year={2006},
}

@article{hossain2006,
  title={ Ring-based local access PON architecture for supporting private networking capability},
  author={ ASM Delowar Hossain, A. Shami, C. Assi, et al },
  journal={ OSA Journal of Optical Networking },
  volume={5},
  pages={26-39},
  year={2006},
}

@article{khalil2006,
  title={ Dynamic Provisioning of Low-Speed Unicast/Multicast Traffic Demands in Mesh-Based WDM Optical Networks},
  author={ A. Khalil, A. Hadjiantonis, C. Assi, A. Shami, G. Ellinas, and M. A. Ali },
  journal={ IEEE/OSA Journal of Lightwave Technology },
  volume={24},
  pages={681-693},
  year={2006},
}

@article{assi2005,
  title={ Improving Signaling Recovery in Shared Mesh Optical Networks},
  author={ C. Assi, W. Huo, A. Shami, and N. Ghani },
  journal={ Elsevier Computer Communications Journal },
  volume={29},
  pages={59-68},
  year={2005},
}

@article{shami2005,
  title={ QoS Control Schemes for Two-Stage Ethernet Passive Optical Access Networks},
  author={ A. Shami, X. Bai, N. Ghani, C. Assi and H. T. Mouftah },
  journal={ IEEE Journal on Selected Areas in Communications (IEEE JSAC)- (Optical Networking Regular Series)},
  volume={28},
  pages={1467-1478},
  year={2005},
}

@article{assi2005-2,
  title={ Analysis of Capacity Re-Provisioning in Optical Mesh Networks},
  author={ C. Assi, W. Huo, A. Shami, and N. Ghani },
  journal={ IEEE IEEE Communications Letters },
  volume={9},
  pages={558-560},
  year={2005},
}
@article{shami2005-2,
  title={ Jitter Performance in Ethernet Passive Optical Networks},
  author={ A. Shami, X. Bai, C. Assi, and N. Ghani },
  journal={ IEEE/OSA Journal of Lightwave Technology},
  volume={23},
  pages={1745-1753},
  year={2005},
}

@article{ghani2004,
  title={ Intra-ONU Bandwidth Scheduling in Ethernet Passive Optical Networks },
  author={ N. Ghani, A. Shami, C. Assi, M. Y. A. Raja },
  journal={ IEEE Communications Letters },
  volume={8},
  pages={683-686},
  year={2004},
}

@article{assi2004,
  title={  Performance Evaluation of Shared Mesh Protection in WDM Networks },
  author={ C. Assi, A. Khalil, N. Ghani, A. Shami, M. Ali },
  journal={Cluster Computing: The Journal of Networks, Software Tools, and Applications },
  volume={},
  pages={},
  year={2004},
}

@article{shami2003,
  title={ Connection Management Protocols for Dynamic Lightpath Provisioning in Future WDM Networks },
  author={ A. Shami , C. Assi, N. Ghani et al },
  journal={ Photonic Network Communications Journal, Kluwer Academic},
  volume={6},
  pages={25-32},
  year={2003},
}

@article{shami2002,
  title={  Integrated Routing/Signaling Protocols in   GMPLS-based Optical Networks” },
  author={ A. Shami, Y. Ye, C. Assi, S. Dixit, and M. Ali },
  journal={ SPIE Optical Networks },
  volume={3},
  pages={},
  year={2002},
}

@article{assi2002,
  title={  Integrated Routing Algorithms for Provisioning Sub-Wavelength Connections in IP-Over-WDM Networks },
  author={ C. Assi, A. Shami, Y. Ye and M. Ali },
  journal={ Photonic Network Communications Journal, Kluwer Academic },
  volume={4},
  pages={377-390},
  year={2002},
}

@article{assi2002-2,
  title={  Impact of Wavelength Converters on the Performance of Optical Networks },
  author={ C. Assi, A. Shami, M. Ali, Z.  Zhang, and X. Liu },
  journal={ SPIE Optical Networks },
  volume={3},
  pages={},
  year={2002},
}

@article{assi2001,
  title={ Optical Networking and Real-Time Provisioning; An Integrated Vision For The Next-Generation Internet },
  author={ C. Assi, A. Shami, et al. },
  journal={ IEEE Networks },
  volume={15},
  pages={36-45},
  year={2001},
}

@article{ali2001,
  title={ Architectural Options for the Next-Generation Networking Paradigm: Is Optical Internet the Answer?},
  author={  M. A Ali, A. Shami, C. Assi, Y. Ye and Russ Kurtz },
  journal={ Photonic Network Communications Journal, Kluwer Academic },
  volume={3},
  pages={},
  year={2001},
}

extension: bibtex