/// <summary>
/// Executes the Use Case.
/// </summary>
/// <param name="input">Input Message.</param>
/// <returns>Task.</returns>
public async Task Execute(TransferInput input)
{
if (input is null)
{
this._outputPort.WriteError(Messages.InputIsNull);
return;
}
try
{
var originAccount = await this._accountRepository.GetAccount(input.OriginAccountId)
.ConfigureAwait(false);
var destinationAccount = await this._accountRepository.GetAccount(input.DestinationAccountId)
.ConfigureAwait(false);
var debit = await this._accountService.Withdraw(originAccount, input.Amount)
.ConfigureAwait(false);
var credit = await this._accountService.Deposit(destinationAccount, input.Amount)
.ConfigureAwait(false);
await this._unitOfWork.Save()
.ConfigureAwait(false);
this.BuildOutput(debit, originAccount, destinationAccount);
}
catch (AccountNotFoundException ex)
{
this._outputPort.NotFound(ex.Message);
}
}
public async Task Execute(TransferInput input)
{
IAccount originAccount = await _accountRepository.Get(input.OriginAccountId);
if (originAccount == null)
{
_outputHandler.Error($"The account {input.OriginAccountId} does not exist or is already closed.");
return;
}
IAccount destinationAccount = await _accountRepository.Get(input.DestinationAccountId);
if (destinationAccount == null)
{
_outputHandler.Error($"The account {input.DestinationAccountId} does not exist or is already closed.");
return;
}
IDebit debit = originAccount.Withdraw(_entityFactory, input.Amount);
ICredit credit = destinationAccount.Deposit(_entityFactory, input.Amount);
await _accountRepository.Update(originAccount, debit);
await _accountRepository.Update(destinationAccount, credit);
await _unitOfWork.Save();
TransferOutput output = new TransferOutput(
debit,
originAccount.GetCurrentBalance(),
input.OriginAccountId,
input.DestinationAccountId);
_outputHandler.Default(output);
}
/// <summary>
/// Executes the Use Case.
/// </summary>
/// <param name="input">Input Message.</param>
/// <returns>Task.</returns>
public async Task Execute(TransferInput input)
{
try
{
if (input is null)
{
throw new ArgumentNullException(nameof(input));
}
var originAccount = await this.accountRepository.GetAccount(input.OriginAccountId)
.ConfigureAwait(false);
var destinationAccount = await this.accountRepository.GetAccount(input.DestinationAccountId)
.ConfigureAwait(false);
var debit = await this.accountService.Withdraw(originAccount, input.Amount)
.ConfigureAwait(false);
var credit = await this.accountService.Deposit(destinationAccount, input.Amount)
.ConfigureAwait(false);
await this.unitOfWork.Save()
.ConfigureAwait(false);
this.BuildOutput(debit, originAccount, destinationAccount);
}
catch (AccountNotFoundException ex)
{
this.outputPort.NotFound(ex.Message);
return;
}
}
public async Task Execute(TransferInput input)
{
IAccount originAccount;
IAccount destinationAccount;
try
{
originAccount = await _accountRepository.Get(input.OriginAccountId);
destinationAccount = await _accountRepository.Get(
input.DestinationAccountId);
}
catch (AccountNotFoundException ex)
{
_outputPort.NotFound(ex.Message);
return;
}
var debit = originAccount.Withdraw(_entityFactory, input.Amount);
var credit = destinationAccount.Deposit(_entityFactory, input.Amount);
await _accountRepository.Update(originAccount, debit);
await _accountRepository.Update(destinationAccount, credit);
await _unitOfWork.Save();
BuildOutput(debit, originAccount, destinationAccount);
}
public async Task Get_Proposal_Test()
{
//failed case
{
var proposal = await AssociationAuthContractStub.GetProposal.CallAsync(Hash.FromString("Test"));
proposal.ShouldBe(new ProposalOutput());
}
//normal case
{
var organizationAddress = await CreateOrganizationAsync();
var transferInput = new TransferInput()
{
Symbol = "ELF",
Amount = 100,
To = Reviewer1,
Memo = "Transfer"
};
var proposalId = await CreateProposalAsync(Reviewer2KeyPair, organizationAddress);
var getProposal = await AssociationAuthContractStub.GetProposal.SendAsync(proposalId);
getProposal.Output.Proposer.ShouldBe(Reviewer2);
getProposal.Output.ContractMethodName.ShouldBe(nameof(TokenContract.Transfer));
getProposal.Output.ProposalId.ShouldBe(proposalId);
getProposal.Output.OrganizationAddress.ShouldBe(organizationAddress);
getProposal.Output.ToAddress.ShouldBe(TokenContractAddress);
getProposal.Output.Params.ShouldBe(transferInput.ToByteString());
}
}
private async Task <Hash> CreateProposalAsync(ECKeyPair proposalKeyPair, Address organizationAddress)
{
var transferInput = new TransferInput()
{
Symbol = "ELF",
Amount = 100,
To = Tester,
Memo = "Transfer"
};
var createProposalInput = new CreateProposalInput
{
ContractMethodName = nameof(TokenContractStub.Transfer),
ToAddress = TokenContractAddress,
Params = transferInput.ToByteString(),
ExpiredTime = BlockTimeProvider.GetBlockTime().AddDays(2),
OrganizationAddress = organizationAddress
};
ParliamentAuthContractStub = GetParliamentAuthContractTester(proposalKeyPair);
var proposal = await ParliamentAuthContractStub.CreateProposal.SendAsync(createProposalInput);
proposal.TransactionResult.Status.ShouldBe(TransactionResultStatus.Mined);
var proposalCreated = ProposalCreated.Parser.ParseFrom(proposal.TransactionResult.Logs[0].NonIndexed).ProposalId;
proposal.Output.ShouldBe(proposalCreated);
return(proposal.Output);
}
public async Task Get_Proposal_Test()
{
await InitializeParliamentContracts();
var minimalApprovalThreshold = 6667;
var maximalAbstentionThreshold = 2000;
var maximalRejectionThreshold = 3000;
var minimalVoteThreshold = 8000;
var organizationAddress = await CreateOrganizationAsync(minimalApprovalThreshold,
maximalAbstentionThreshold, maximalRejectionThreshold, minimalVoteThreshold);
var transferInput = new TransferInput()
{
Symbol = "ELF",
Amount = 100,
To = Tester,
Memo = "Transfer"
};
var proposalId = await CreateProposalAsync(DefaultSenderKeyPair, organizationAddress);
var getProposal = await ParliamentContractStub.GetProposal.SendAsync(proposalId);
getProposal.Output.Proposer.ShouldBe(DefaultSender);
getProposal.Output.ContractMethodName.ShouldBe(nameof(TokenContractStub.Transfer));
getProposal.Output.ProposalId.ShouldBe(proposalId);
getProposal.Output.OrganizationAddress.ShouldBe(organizationAddress);
getProposal.Output.ToAddress.ShouldBe(TokenContractAddress);
getProposal.Output.Params.ShouldBe(transferInput.ToByteString());
}
public override AssetMoveReturnDto MoveAssetFromMainAddress(AssetMoveDto input)
{
var holderInfo = GetHolderInfo(input.HolderId);
CheckMoveFromMainPermission(holderInfo, input.Amount);
var virtualUserAddress = GetVirtualUserAddress(input);
var tokenInput = new TransferInput()
{
To = Context.ConvertVirtualAddressToContractAddress(virtualUserAddress),
Amount = input.Amount,
Symbol = holderInfo.Symbol
};
Context.SendVirtualInline(input.HolderId, State.TokenContract.Value,
nameof(State.TokenContract.Transfer), tokenInput);
AssetMoveReturnDto result = new AssetMoveReturnDto();
result.Success = true;
return(result);
}
private void Create(TransferInput transferInput)
{
var transferEntity = ObjectMapper.Map <Transfer>(transferInput);
SetAuditInsert(transferEntity);
transferRepository.Insert(transferEntity);
CurrentUnitOfWork.SaveChanges();
}
public void GivenValidData_InputCreated()
{
var actual = new TransferInput(
new AccountId(Guid.NewGuid()),
new AccountId(Guid.NewGuid()),
new PositiveMoney(10));
Assert.NotNull(actual);
}
public async Task<IActionResult> Transfer([FromForm][Required] TransferRequest request)
{
var input = new TransferInput(
new AccountId(request.OriginAccountId),
new AccountId(request.DestinationAccountId),
new PositiveMoney(request.Amount));
await _mediator.PublishAsync(input);
return _presenter.ViewModel;
}
public void GivenValidData_InputCreated()
{
var actual = new TransferInput(
Guid.NewGuid(),
Guid.NewGuid(),
new PositiveAmount(10)
);
Assert.NotNull(actual);
}
public IActionResult Post([FromBody] TransferInput input)
{
Image image = Image.CurrentImage;
List <Color> NewPalette = ColorTransfer.FormatPalette(input.NewPalette);
image.TransferPalette(NewPalette);
return(Json(image.GetPixelArray()));
}
public void CreateOrEditTransfer(TransferInput transferInput)
{
if (transferInput.Id == 0)
{
Create(transferInput);
}
else
{
Update(transferInput);
}
}
internal TransferInput TransferInput(Address address)
{
var transferInput = new TransferInput
{
Symbol = "ELF",
Amount = 100,
To = address,
Memo = "Transfer"
};
return transferInput;
}
private void Update(TransferInput transferInput)
{
var transferEntity = transferRepository.GetAll().Where(x => !x.IsDelete).SingleOrDefault(x => x.Id == transferInput.Id);
if (transferEntity == null)
{
}
ObjectMapper.Map(transferInput, transferEntity);
SetAuditEdit(transferEntity);
transferRepository.Update(transferEntity);
CurrentUnitOfWork.SaveChanges();
}
public async Task <IActionResult> Transfer([FromBody][Required] TransferRequest request)
{
var transferInput = new TransferInput(
request.OriginAccountId,
request.DestinationAccountId,
new PositiveMoney(request.Amount)
);
await _TransferUseCase.Execute(transferInput);
return(_presenter.ViewModel);
}
public async Task <IActionResult> Transfer(
[FromServices] IMediator mediator,
[FromServices] TransferPresenter presenter,
[FromForm][Required] TransferRequest request)
{
var input = new TransferInput(
request.OriginAccountId,
request.DestinationAccountId,
request.Amount);
await mediator.PublishAsync(input)
.ConfigureAwait(false);
return(presenter.ViewModel);
}
public async Task Execute(TransferInput input)
{
var originAccount = await _accountRepository.Get(input.OriginAccountId);
var destinationAccount = await _accountRepository.Get(input.DestinationAccountId);
var debit = originAccount.Withdraw(_entityFactory, input.Amount);
var credit = destinationAccount.Deposit(_entityFactory, input.Amount);
await _accountRepository.Update(originAccount, debit);
await _accountRepository.Update(destinationAccount, credit);
await _unitOfWork.Save();
BuildOutput(debit, originAccount, destinationAccount);
}
public override Empty FailInlineTransfer(TransferInput input)
{
State.TokenContract.Transfer.Send(new MultiToken.TransferInput
{
Symbol = "ELF",
Amount = input.Amount,
To = input.To,
Memo = input.Memo
});
Context.SendInline(State.TokenContract.Value, "Burn", new BurnInput
{
Symbol = "ELF",
Amount = input.Amount.Div(10)
}.ToByteString());
return(new Empty());
}
/// <summary>
/// Executes the Use Case.
/// </summary>
/// <param name="input">Input Message.</param>
/// <returns>Task.</returns>
public async Task Execute(TransferInput input)
{
if (input is null)
{
this._transferOutputPort.WriteError(Messages.InputIsNull);
return;
}
IAccount originAccount = await this._accountRepository
.GetAccount(input.OriginAccountId)
.ConfigureAwait(false);
if (originAccount == null)
{
this._transferOutputPort
.NotFound(Messages.AccountDoesNotExist);
return;
}
IAccount destinationAccount = await this._accountRepository
.GetAccount(input.DestinationAccountId)
.ConfigureAwait(false);
if (destinationAccount == null)
{
this._transferOutputPort
.NotFound(Messages.AccountDoesNotExist);
return;
}
IDebit debit = await this._accountService
.Withdraw(originAccount, input.Amount)
.ConfigureAwait(false);
await this._accountService
.Deposit(destinationAccount, input.Amount)
.ConfigureAwait(false);
await this._unitOfWork
.Save()
.ConfigureAwait(false);
this.BuildOutput(debit, originAccount, destinationAccount);
}
public async Task Execute(TransferInput input)
{
IAccount originAccount = await _accountRepository.Get(input.OriginAccountId);
if (originAccount == null)
{
_outputHandler.Error($"The account {input.OriginAccountId} does not exist or is already closed.");
return;
}
IAccount destinationAccount = await _accountRepository.Get(input.DestinationAccountId);
if (destinationAccount == null)
{
_outputHandler.Error($"The account {input.DestinationAccountId} does not exist or is already closed.");
return;
}
IDebit debit = originAccount.Withdraw(_entityFactory, input.Amount);
ICredit credit = destinationAccount.Deposit(_entityFactory, input.Amount);
await _accountRepository.Update(originAccount, debit);
await _accountRepository.Update(destinationAccount, credit);
// Publish the event to the enterprice service bus
await _serviceBus.PublishEventAsync(new Shared.Events.TransferCompleted()
{
OriginalAccountId = originAccount.Id, DestinationAccountId = destinationAccount.Id, Amount = input.Amount.ToMoney().ToDecimal()
});
await _unitOfWork.Save();
TransferOutput output = new TransferOutput(
debit,
originAccount.GetCurrentBalance(),
input.OriginAccountId,
input.DestinationAccountId);
_outputHandler.Default(output);
}
public async Task Get_Proposal_Test()
{
var organizationAddress = await CreateOrganizationAsync();
var transferInput = new TransferInput()
{
Symbol = "ELF",
Amount = 100,
To = Tester,
Memo = "Transfer"
};
var proposalId = await CreateProposalAsync(DefaultSenderKeyPair, organizationAddress);
var getProposal = await ParliamentAuthContractStub.GetProposal.SendAsync(proposalId);
getProposal.Output.Proposer.ShouldBe(DefaultSender);
getProposal.Output.ContractMethodName.ShouldBe(nameof(TokenContractStub.Transfer));
getProposal.Output.ProposalId.ShouldBe(proposalId);
getProposal.Output.OrganizationAddress.ShouldBe(organizationAddress);
getProposal.Output.ToAddress.ShouldBe(TokenContractAddress);
getProposal.Output.Params.ShouldBe(transferInput.ToByteString());
}
public async Task <Hash> Create_Proposal(Address organizationAddress)
{
_transferInput = new TransferInput()
{
Symbol = "ELF",
Amount = 100,
To = Tester,
Memo = "Transfer"
};
_createProposalInput = new CreateProposalInput
{
ContractMethodName = nameof(TokenContract.Transfer),
ToAddress = TokenContractAddress,
Params = _transferInput.ToByteString(),
ExpiredTime = BlockTimeProvider.GetBlockTime().AddDays(2).ToTimestamp(),
OrganizationAddress = organizationAddress
};
var proposal = await ParliamentAuthContractStub.CreateProposal.SendAsync(_createProposalInput);
proposal.TransactionResult.Status.ShouldBe(TransactionResultStatus.Mined);
return(proposal.Output);
}
public async Task Execute(TransferInput input)
{
try
{
var originAccount = await _accountRepository.Get(input.OriginAccountId);
var destinationAccount = await _accountRepository.Get(input.DestinationAccountId);
var debit = await _accountService.Withdraw(originAccount, input.Amount);
var credit = await _accountService.Deposit(destinationAccount, input.Amount);
await _unitOfWork.Save();
BuildOutput(debit, originAccount, destinationAccount);
}
catch (AccountNotFoundException ex)
{
_outputPort.NotFound(ex.Message);
return;
}
}
private async Task <Hash> CreateProposalAsync(ECKeyPair proposalKeyPair, Address organizationAddress)
{
var transferInput = new TransferInput()
{
Symbol = "ELF",
Amount = 100,
To = Reviewer1,
Memo = "Transfer"
};
AssociationAuthContractStub = GetAssociationAuthContractTester(proposalKeyPair);
var createProposalInput = new CreateProposalInput
{
ContractMethodName = nameof(TokenContract.Transfer),
ToAddress = TokenContractAddress,
Params = transferInput.ToByteString(),
ExpiredTime = BlockTimeProvider.GetBlockTime().AddDays(2),
OrganizationAddress = organizationAddress
};
var proposal = await AssociationAuthContractStub.CreateProposal.SendAsync(createProposalInput);
return(proposal.Output);
}
public async Task <Hash> Create_Proposal()
{
_organizationAddress = await Create_Organization();
_transferInput = new TransferInput()
{
Symbol = "ELF",
Amount = 100,
To = Reviewer1,
Memo = "Transfer"
};
AssociationAuthContractStub = GetAssociationAuthContractTester(Reviewer2KeyPair);
_createProposalInput = new CreateProposalInput
{
ContractMethodName = nameof(TokenContract.Transfer),
ToAddress = TokenContractAddress,
Params = _transferInput.ToByteString(),
ExpiredTime = BlockTimeProvider.GetBlockTime().AddDays(2).ToTimestamp(),
OrganizationAddress = _organizationAddress
};
var proposal = await AssociationAuthContractStub.CreateProposal.SendAsync(_createProposalInput);
return(proposal.Output);
}
/// <summary>
/// Create a new Layer based on the LayerParameter.
/// </summary>
/// <param name="cuda">Specifies the CudaDnn connection to Cuda.</param>
/// <param name="log">Specifies the Log for output.</param>
/// <param name="p">Specifies the LayerParameter that contains the LayerType to create.</param>
/// <param name="evtCancel">Specifies the CancelEvent used by some Layers when created.</param>
/// <param name="imgDb">Optionally, specifies the CaffeImageDatabase used by data Layers.</param>
/// <param name="trxinput">Optionally, specifies the transfer input object used by some of the data Layers.</param>
/// <returns></returns>
public static Layer <T> Create(CudaDnn <T> cuda, Log log, LayerParameter p, CancelEvent evtCancel, IXImageDatabase imgDb = null, TransferInput trxinput = null)
{
switch (p.type)
{
case LayerParameter.LayerType.ABSVAL:
return(new AbsValLayer <T>(cuda, log, p));
case LayerParameter.LayerType.ACCURACY:
return(new AccuracyLayer <T>(cuda, log, p));
case LayerParameter.LayerType.ARGMAX:
return(new ArgMaxLayer <T>(cuda, log, p));
case LayerParameter.LayerType.BATCHDATA:
return(new BatchDataLayer <T>(cuda, log, p, imgDb, evtCancel, (trxinput != null) ? trxinput.Set : null));
case LayerParameter.LayerType.BATCHNORM:
return(new BatchNormLayer <T>(cuda, log, p));
case LayerParameter.LayerType.BATCHREINDEX:
return(new BatchReindexLayer <T>(cuda, log, p));
case LayerParameter.LayerType.BNLL:
return(new BNLLLayer <T>(cuda, log, p));
case LayerParameter.LayerType.BIAS:
return(new BiasLayer <T>(cuda, log, p));
case LayerParameter.LayerType.BINARYHASH:
return(new BinaryHashLayer <T>(cuda, log, p));
case LayerParameter.LayerType.CONCAT:
return(new ConcatLayer <T>(cuda, log, p));
case LayerParameter.LayerType.CONTRASTIVE_LOSS:
return(new ContrastiveLossLayer <T>(cuda, log, p));
case LayerParameter.LayerType.CONVOLUTION:
return(new ConvolutionLayer <T>(cuda, log, p));
case LayerParameter.LayerType.CROP:
return(new CropLayer <T>(cuda, log, p));
case LayerParameter.LayerType.DECONVOLUTION:
return(new DeconvolutionLayer <T>(cuda, log, p));
case LayerParameter.LayerType.IM2COL:
return(new Im2colLayer <T>(cuda, log, p));
case LayerParameter.LayerType.DATA:
return(new DataLayer <T>(cuda, log, p, imgDb, evtCancel));
case LayerParameter.LayerType.DEBUG:
return(new DebugLayer <T>(cuda, log, p));
case LayerParameter.LayerType.DROPOUT:
return(new DropoutLayer <T>(cuda, log, p));
case LayerParameter.LayerType.DUMMYDATA:
return(new DummyDataLayer <T>(cuda, log, p));
case LayerParameter.LayerType.ELTWISE:
return(new EltwiseLayer <T>(cuda, log, p));
case LayerParameter.LayerType.ELU:
return(new ELULayer <T>(cuda, log, p));
case LayerParameter.LayerType.EMBED:
return(new EmbedLayer <T>(cuda, log, p));
case LayerParameter.LayerType.EUCLIDEAN_LOSS:
return(new EuclideanLossLayer <T>(cuda, log, p));
case LayerParameter.LayerType.EXP:
return(new ExpLayer <T>(cuda, log, p));
case LayerParameter.LayerType.FILTER:
return(new FilterLayer <T>(cuda, log, p));
case LayerParameter.LayerType.FLATTEN:
return(new FlattenLayer <T>(cuda, log, p));
case LayerParameter.LayerType.GRN:
return(new GRNLayer <T>(cuda, log, p));
case LayerParameter.LayerType.GRADIENTSCALER:
return(new GradientScaleLayer <T>(cuda, log, p));
case LayerParameter.LayerType.HINGE_LOSS:
return(new HingeLossLayer <T>(cuda, log, p));
case LayerParameter.LayerType.INFOGAIN_LOSS:
return(new InfogainLossLayer <T>(cuda, log, p));
case LayerParameter.LayerType.INNERPRODUCT:
return(new InnerProductLayer <T>(cuda, log, p));
case LayerParameter.LayerType.KNN:
return(new KnnLayer <T>(cuda, log, p));
case LayerParameter.LayerType.LOG:
return(new LogLayer <T>(cuda, log, p));
case LayerParameter.LayerType.LABELMAPPING:
return(new LabelMappingLayer <T>(cuda, log, p, imgDb));
case LayerParameter.LayerType.LRN:
return(new LRNLayer <T>(cuda, log, p));
case LayerParameter.LayerType.MEMORYDATA:
return(new MemoryDataLayer <T>(cuda, log, p));
case LayerParameter.LayerType.MULTINOMIALLOGISTIC_LOSS:
return(new MultinomialLogisticLossLayer <T>(cuda, log, p));
case LayerParameter.LayerType.MVN:
return(new MVNLayer <T>(cuda, log, p));
case LayerParameter.LayerType.NORMALIZATION:
return(new NormalizationLayer <T>(cuda, log, p));
case LayerParameter.LayerType.POOLING:
return(new PoolingLayer <T>(cuda, log, p));
case LayerParameter.LayerType.UNPOOLING1:
return(new UnPoolingLayer1 <T>(cuda, log, p));
case LayerParameter.LayerType.UNPOOLING2:
return(new UnPoolingLayer2 <T>(cuda, log, p));
case LayerParameter.LayerType.POWER:
return(new PowerLayer <T>(cuda, log, p));
case LayerParameter.LayerType.PRELU:
return(new PReLULayer <T>(cuda, log, p));
case LayerParameter.LayerType.REDUCTION:
return(new ReductionLayer <T>(cuda, log, p));
case LayerParameter.LayerType.REINFORCEMENT_LOSS:
return(new ReinforcementLossLayer <T>(cuda, log, p, (trxinput != null) ? trxinput.Get : null));
case LayerParameter.LayerType.RELU:
return(new ReLULayer <T>(cuda, log, p));
case LayerParameter.LayerType.RESHAPE:
return(new ReshapeLayer <T>(cuda, log, p));
case LayerParameter.LayerType.SCALE:
return(new ScaleLayer <T>(cuda, log, p));
case LayerParameter.LayerType.SIGMOID:
return(new SigmoidLayer <T>(cuda, log, p));
case LayerParameter.LayerType.SIGMOIDCROSSENTROPY_LOSS:
return(new SigmoidCrossEntropyLossLayer <T>(cuda, log, p));
case LayerParameter.LayerType.SILENCE:
return(new SilenceLayer <T>(cuda, log, p));
case LayerParameter.LayerType.SLICE:
return(new SliceLayer <T>(cuda, log, p));
case LayerParameter.LayerType.SOFTMAX:
return(new SoftmaxLayer <T>(cuda, log, p));
case LayerParameter.LayerType.SOFTMAXWITH_LOSS:
return(new SoftmaxLossLayer <T>(cuda, log, p));
case LayerParameter.LayerType.SPLIT:
return(new SplitLayer <T>(cuda, log, p));
case LayerParameter.LayerType.SPP:
return(new SPPLayer <T>(cuda, log, p));
case LayerParameter.LayerType.SWISH:
return(new SwishLayer <T>(cuda, log, p));
case LayerParameter.LayerType.TANH:
return(new TanhLayer <T>(cuda, log, p));
case LayerParameter.LayerType.THRESHOLD:
return(new ThresholdLayer <T>(cuda, log, p));
case LayerParameter.LayerType.TRIPLET_LOSS_SIMPLE:
return(new TripletLossSimpleLayer <T>(cuda, log, p));
case LayerParameter.LayerType.TRIPLET_LOSS:
return(new TripletLossLayer <T>(cuda, log, p));
case LayerParameter.LayerType.TRIPLET_SELECT:
return(new TripletSelectLayer <T>(cuda, log, p));
case LayerParameter.LayerType.TRIPLET_DATA:
return(new TripletDataLayer <T>(cuda, log, p, imgDb, evtCancel));
case LayerParameter.LayerType.TILE:
return(new TileLayer <T>(cuda, log, p));
case LayerParameter.LayerType.LSTM_SIMPLE:
return(new LSTMSimpleLayer <T>(cuda, log, p));
case LayerParameter.LayerType.RNN:
return(new RNNLayer <T>(cuda, log, p, evtCancel));
case LayerParameter.LayerType.LSTM:
return(new LSTMLayer <T>(cuda, log, p, evtCancel));
case LayerParameter.LayerType.LSTM_UNIT:
return(new LSTMUnitLayer <T>(cuda, log, p));
case LayerParameter.LayerType.INPUT:
return(new InputLayer <T>(cuda, log, p));
default:
log.FAIL("Unknown layer type: " + p.type.ToString());
break;
}
throw new NotImplementedException("The layer type: " + p.type.ToString() + " is not implemented yet.");
}
public override Empty Transfer(TransferInput input)
{
AssertValidToken(input.Symbol, input.Amount);
DoTransfer(Context.Sender, input.To, input.Symbol, input.Amount, input.Memo);
return(new Empty());
}
private void Transfer(TransferInput input)
{
SetContractStateRequired(State.TokenContract, SmartContractConstants.TokenContractSystemName);
State.TokenContract.Transfer.Send(input);
}
