public void UpdateTailParts()
{
GameObject Tail = ParentObject;
GameObject Owner = Tail.Equipped;
Mutations PMu = Owner.GetPart <Mutations>();
ThickTail TailMutation = base.ParentObject.Equipped.GetPart <Mutations>().GetMutation("ThickTail") as ThickTail;
int ChimeraBoost = ((Owner.StatMod("Strength") + Owner.StatMod("Toughness") + Owner.StatMod("Agility")) / 3);
if (Owner == null)
{
return;
}
if (PMu.HasMutation("Chimera"))
{
SynergyConstruct Construct;
bool SynergizedChi = SynergyEffects.TryGetValue("Chimera", out Construct);
if (SynergizedChi && Construct.IsActive == false)
{
Construct.Effect.Invoke(ParentObject);
Construct.IsActive = true;
}
}
foreach (BaseMutation Mut in PMu.MutationList)
{
SynergyConstruct Construct;
bool Synergized = SynergyEffects.TryGetValue(Mut.Name, out Construct);
if (Synergized && Construct.IsActive == false)
{
Construct.Effect.Invoke(ParentObject);
Construct.IsActive = true;
}
}
}
public void DeleteFromRow()
{
var mutation = Mutations.DeleteFromRow();
Assert.NotNull(mutation.DeleteFromRow);
Assert.True(mutation.IsIdempotent());
}
public async Task CheckAndMutateRow_Validate_RowKey()
{
var client = new TestBigtableClient();
var tableName = new TableName("project", "instance", "table");
await CheckAndMutateRow_ValidateArguments <ArgumentException>(
tableName,
"",
RowFilters.PassAllFilter(),
new[] { Mutations.DeleteFromRow() },
new[] { Mutations.DeleteFromRow() });
await CheckAndMutateRow_ValidateArguments <ArgumentException>(
tableName,
new byte[0],
RowFilters.PassAllFilter(),
new[] { Mutations.DeleteFromRow() },
new[] { Mutations.DeleteFromRow() });
await CheckAndMutateRow_ValidateArguments <ArgumentException>(
tableName,
ByteString.Empty,
RowFilters.PassAllFilter(),
new[] { Mutations.DeleteFromRow() },
new[] { Mutations.DeleteFromRow() });
await CheckAndMutateRow_ValidateArguments <ArgumentException>(
tableName,
public async Task CheckAndMutateRow_Validate_Mutations()
{
var tableName = new TableName("project", "instance", "table");
await CheckAndMutateRow_ValidateArguments <ArgumentException>(
tableName,
"abc",
RowFilters.PassAllFilter(),
null,
null);
await CheckAndMutateRow_ValidateArguments <ArgumentException>(
tableName,
"abc",
RowFilters.PassAllFilter(),
new Mutation[0],
new Mutation[0]);
await CheckAndMutateRow_ValidateArguments <ArgumentException>(
tableName,
"abc",
RowFilters.PassAllFilter(),
new Mutation[] { null },
new[] { Mutations.DeleteFromRow() },
callTrueMutationsOnlyOverload : false);
await CheckAndMutateRow_ValidateArguments <ArgumentException>(
tableName,
"abc",
RowFilters.PassAllFilter(),
new[] { Mutations.DeleteFromRow() },
new Mutation[] { null },
callTrueMutationsOnlyOverload : false);
}
/// <summary>
/// Sends all changes registered on Document sets to Sanity as a transactional set of mutations.
/// </summary>
/// <param name="returnIds"></param>
/// <param name="returnDocuments"></param>
/// <param name="visibility"></param>
/// <returns></returns>
public async Task <SanityMutationResponse> CommitAsync(bool returnIds = false, bool returnDocuments = false, SanityMutationVisibility visibility = SanityMutationVisibility.Sync, CancellationToken cancellationToken = default)
{
var result = await Client.CommitMutationsAsync(Mutations.Build(Client.SerializerSettings), returnIds, returnDocuments, visibility, cancellationToken).ConfigureAwait(false);
Mutations.Clear();
return(result);
}
public void domutate()
{
if (ParentObject.IsPlayer() || ParentObject.IsMemberOfFaction("Templar"))
{
return;
}
int roll = Stat.Random(1, 100);
Log("Titroll:" + roll.ToString() + "/" + Chance.ToString());
if (roll <= Chance)
{
Mutations mutations = ParentObject.GetPart("Mutations") as Mutations;
if (mutations == null)
{
Log("Can mutate, no mutations part");
return;
}
if (!MutationFactory.MutationsByName.ContainsKey(Mutation))
{
Log("Mutation " + Mutation + " isn't recognised");
}
mutations.AddMutation(MutationFactory.MutationsByName[Mutation].CreateInstance(), Level);
Log("mutated");
}
}
public override bool FireEvent(Event E)
{
if (E.ID == "EndTurnEngulfing")
{
if (descriptionSet == false)
{
IPart.ThePlayer.GetPart <Description>().Short = "I'm not a bad slime";
descriptionSet = true;
}
GameObject parameter = E.GetParameter <GameObject>("Object");
if (parameter != null)
{
Damage damage = new Damage(Stat.Random(IPart.ThePlayer.Statistics["Toughness"].BaseValue / 2, IPart.ThePlayer.Statistics["Toughness"].BaseValue));
Event E1 = Event.New("TakeDamage", 0, 0, 0);
E1.AddParameter("Damage", (object)damage);
E1.AddParameter("Owner", (object)this.ParentObject);
E1.AddParameter("Attacker", (object)this.ParentObject);
E1.AddParameter("Message", this.DamageMessage);
parameter.FireEvent(E1);
if (parameter.hitpoints <= 0)
{
if (DifficultyEvaluation.GetDifficultyDescription(parameter) == "&wAverage")
{
this.statGains(1);
}
else if (DifficultyEvaluation.GetDifficultyDescription(parameter) == "&WTough")
{
this.statGains(2);
}
else if (DifficultyEvaluation.GetDifficultyDescription(parameter) == "&rVery Tough")
{
this.statGains(4);
}
else if (DifficultyEvaluation.GetDifficultyDescription(parameter) == "&RImpossible")
{
this.statGains(8);
}
Mutations targetMutations = parameter.GetPart <Mutations>();
Mutations playerMutations = IPart.ThePlayer.GetPart <Mutations>();
if (targetMutations != null)
{
foreach (BaseMutation mutation in targetMutations.MutationList)
{
if (!playerMutations.HasMutation(mutation) && !excludedMutations.Contains(mutation.Name) && mutation.CompatibleWith(IPart.ThePlayer))
{
playerMutations.AddMutation(mutation, 1);
}
}
}
Stomach part = IPart.ThePlayer.GetPart <Stomach>();
IPart.ThePlayer.RemoveEffect("Famished", false);
part.HungerLevel = 0;
part.CookCount = 0;
part.CookingCounter = 0;
part.Water = 30000;
}
}
}
return(true);
}
public override bool HandleEvent(GetDisplayNameEvent E)
{
try
{
if (!NeedsSynergyPrefix)
{
return(true);
}
GameObject Tail = ParentObject;
GameObject Owner = Tail.Equipped;
Mutations HasSynergyMutation = Owner.GetPart <Mutations>();
int Synergies = SynergyMutations.Count(HasSynergyMutation.HasMutation);
if (Synergies >= 3)
{
return(true);
}
foreach (var kv in SynergyEffects)
{
if (HasSynergyMutation.HasMutation(kv.Key))
{
E.AddBase(kv.Value.Prefix, DescriptionBuilder.ORDER_ADJUST_EARLY);
}
}
}
catch
{
}
return(base.HandleEvent(E));
}
private static void ApplyMutations(CharacterTemplate buildTemplate, List <MLNode> mutationNodes)
{
if (!buildTemplate.genotypeEntry.IsMutant)
{
return;
}
Mutations part = buildTemplate.PlayerBody.GetPart <Mutations>();
foreach (MLNode node in mutationNodes)
{
if (node.Entry != null && node.Selected > 0)
{
if (node.Entry.Mutation != null)
{
BaseMutation baseMutation = node.Entry.CreateInstance();
baseMutation.SetVariant(node.Variant);
part.AddMutation(baseMutation, node.Selected);
}
else if (node.Entry.DisplayName == "Chimera")
{
buildTemplate.MutationLevel = "Chimera";
}
else if (node.Entry.DisplayName == "Esper")
{
buildTemplate.MutationLevel = "Esper";
}
}
}
}
/// <summary>
/// Add Test Data into Given Google Cloud Bigtable
/// </summary>
public void InsertTestDataToTable()
{
try
{
if (!IsTableExists())
{
throw new Exception("No Such Table Found");
}
var bigtableClient = BigtableClient.Create();
List <Mutation> Cols = new List <Mutation>();
TableName _table = new TableName(ProjectId, InstanceId, TableName);
var request = new MutateRowsRequest
{
TableNameAsTableName = _table,
};
request.Entries.Add(Mutations.CreateEntry(Guid.NewGuid().ToString(),
Mutations.SetCell(ColumnFamily, "TestColumnName", "Test Column Value")));
bigtableClient.MutateRows(request);
}
catch (RpcException ex)
{
throw ex;
}
catch (Exception ex)
{
throw ex;
}
}
public async Task RetryBeforeTotalExpiration()
{
var request = new MutateRowsRequest
{
Entries =
{
Mutations.CreateEntry("a", Mutations.DeleteFromRow()),
Mutations.CreateEntry("b", Mutations.DeleteFromRow()),
Mutations.CreateEntry("c", Mutations.DeleteFromRow())
}
};
var client = Utilities.CreateMutateRowsMockClient(
request,
entriesForInitialStream: new[]
{
Utilities.CreateMutateRowsResponseEntry(0, Code.Ok),
Utilities.CreateMutateRowsResponseEntry(1, Code.DeadlineExceeded),
Utilities.CreateMutateRowsResponseEntry(2, Code.Ok)
},
entriesForRetryStreams: new[]
{
null, // A null entry will throw an Unavailable RpcException
// 2nd retry response entries
new[] { Utilities.CreateMutateRowsResponseEntry(0, Code.Ok) }
});
await client.MutateRowsAsync(request);
}
public async Task RetryAfterTotalExpiration()
{
var settings = new BigtableServiceApiSettings();
// Don't allow for any time to retry.
settings.MutateRowsSettings = CallSettings.FromExpiration(Expiration.FromTimeout(TimeSpan.Zero));
var request = new MutateRowsRequest
{
Entries =
{
Mutations.CreateEntry("a", Mutations.DeleteFromRow()),
Mutations.CreateEntry("b", Mutations.DeleteFromRow()),
Mutations.CreateEntry("c", Mutations.DeleteFromRow())
}
};
var client = Utilities.CreateMutateRowsMockClient(
request,
entriesForInitialStream: new[]
{
Utilities.CreateMutateRowsResponseEntry(0, Code.Ok),
Utilities.CreateMutateRowsResponseEntry(1, Code.DeadlineExceeded),
Utilities.CreateMutateRowsResponseEntry(2, Code.Ok)
},
entriesForRetryStreams: new[]
{
// 1st retry response entries
new[] { Utilities.CreateMutateRowsResponseEntry(0, Code.Ok) }
},
settings: settings);
var exception = await Assert.ThrowsAsync <RpcException>(() => client.MutateRowsAsync(request));
Assert.Equal(StatusCode.DeadlineExceeded, exception.StatusCode);
}
public void DeleteFromFamily(string familyName)
{
var mutation = Mutations.DeleteFromFamily(familyName);
Assert.NotNull(mutation.DeleteFromFamily);
Assert.Equal(familyName, mutation.DeleteFromFamily.FamilyName);
}
public async Task <BigtableByteString> InsertRowAsync(
TableName tableName,
string familyName = null,
BigtableByteString?qualifierName = null,
BigtableByteString?value = null,
BigtableVersion?version = null)
{
BigtableByteString rowKey = Guid.NewGuid().ToString();
familyName = familyName ?? DefaultColumnFamily;
qualifierName = qualifierName ?? DefaultColumnQualifier;
value = value ?? DefaultValue;
await TableClient.MutateRowAsync(
tableName,
rowKey,
Mutations.SetCell(
familyName,
qualifierName.Value,
value.Value,
version));
await BigtableAssert.HasSingleValueAsync(
TableClient,
tableName,
rowKey,
familyName,
qualifierName.Value,
value.Value,
version);
return(rowKey);
}
protected override async Task DeleteAsync(string persistenceId, SnapshotSelectionCriteria criteria)
{
var filter = RowFilters.Chain
(
RowFilters.ColumnQualifierExact(SnapshotMetaDataColumnQualifier),
// this filter ensures that we only download snapshot metadata
RowFilters.TimestampRange(
ToUtc(criteria.MinTimestamp),
ToUtc(criteria.MaxTimeStamp)?.AddMilliseconds(1)
// add a milliseconds since the upper bound is exclusive
),
RowFilters.CellsPerColumnLimit(1)
);
var readRowsRequest = new ReadRowsRequest
{
TableNameAsTableName = _tableName,
Filter = filter,
Rows = GetRowSet(persistenceId, criteria.MinSequenceNr, criteria.MaxSequenceNr)
};
var deleteMutations = await _bigtableClient
.ReadRows(readRowsRequest)
.Select(SnapshotMetadataFromBigtableRow)
.Where(metadata => SatisfiesTimestampCriteria(criteria, metadata))
.Select(metadata => Mutations.CreateEntry(GetRowKey(persistenceId, metadata.SequenceNr), Mutations.DeleteFromRow()))
.ToList()
.ConfigureAwait(false);
if (deleteMutations.Count > 0)
{
await _bigtableClient.MutateRowsAsync(_tableName, deleteMutations).ConfigureAwait(false);
}
}
public async Task InsertRowsAsync(
TableName tableName,
IEnumerable <BigtableByteString> rowKeys,
string familyName = null,
BigtableByteString?qualifierName = null,
BigtableByteString?valuePrefix = null,
BigtableVersion?version = null)
{
BigtableByteString rowKey = Guid.NewGuid().ToString();
familyName = familyName ?? DefaultColumnFamily;
qualifierName = qualifierName ?? "row_index";
valuePrefix = valuePrefix ?? "";
int counter = 0;
var response = await TableClient.MutateRowsAsync(
tableName,
rowKeys.Select(k =>
Mutations.CreateEntry(
k.Value,
Mutations.SetCell(
familyName,
qualifierName.Value,
valuePrefix.Value.Value.Concat(
new BigtableByteString(counter++).Value),
version))).ToArray());
var entries = response.Entries.OrderBy(e => e.Index);
Assert.True(entries.All(e => e.Status.Code == (int)Code.Ok));
}
public void IdempotentCheckOnMutateRowRequest()
{
var setCell =
Mutations.SetCell("abc", "cq1", "value", new BigtableVersion(-1));
var deleteFromColumn =
Mutations.DeleteFromColumn("abc", "def", new BigtableVersionRange(-1, -1));
var request = new MutateRowRequest
{
Mutations =
{
Mutations.DeleteFromRow(),
setCell,
deleteFromColumn,
Mutations.DeleteFromFamily("abc")
}
};
Assert.True(request.IsIdempotent());
deleteFromColumn.DeleteFromColumn.TimeRange.StartTimestampMicros = -1;
deleteFromColumn.DeleteFromColumn.TimeRange.EndTimestampMicros = -1;
Assert.True(request.IsIdempotent());
setCell.SetCell.TimestampMicros = -1;
Assert.False(request.IsIdempotent());
}
public override Void Execute()
{
if (Mutations.Count() == 0)
{
return(new Void());
}
var mutationMap = new Dictionary <byte[], Dictionary <string, List <Mutation> > >();
foreach (var key in Mutations.GroupBy(x => x.Column.Family.Key))
{
var keyMutations = new Dictionary <string, List <Mutation> >();
foreach (var columnFamily in key.GroupBy(x => x.Column.Family.FamilyName))
{
var columnFamilyMutations = columnFamily
.Where(m => m.Type == MutationType.Added || m.Type == MutationType.Changed)
.Select(m => Helper.CreateInsertedOrChangedMutation(m))
.ToList();
var superColumnsNeedingDeleted = columnFamily
.Where(m => m.Type == MutationType.Removed && m.Column.GetParent().SuperColumn != null);
foreach (var superColumn in superColumnsNeedingDeleted.GroupBy(x => x.Column.GetParent().SuperColumn.ColumnName))
{
columnFamilyMutations.AddRange(Helper.CreateDeletedSuperColumnMutation(superColumn));
}
var columnsNeedingDeleted = columnFamily
.Where(m => m.Type == MutationType.Removed && m.Column.GetParent().SuperColumn == null);
if (columnsNeedingDeleted.Count() > 0)
{
columnFamilyMutations.AddRange(Helper.CreateDeletedColumnMutation(columnsNeedingDeleted));
}
keyMutations.Add(columnFamily.Key, columnFamilyMutations);
}
mutationMap.Add(key.Key.TryToBigEndian(), keyMutations);
}
var client = Session.GetClient();
if (Atomic && client.describe_version() >= RpcApiVersion.Cassandra120)
{
client.atomic_batch_mutate(
mutationMap,
Session.WriteConsistency);
}
else
{
client.batch_mutate(
mutationMap,
Session.WriteConsistency);
}
return(new Void());
}
public void Mutations_Serialize_Should_Generate_When_Create_Added()
{
var mutations = new Mutations();
var result = mutations.AddCreate(new CreateTest()).Serialize();
Assert.NotNull(result);
Assert.NotEmpty(result);
}
public Polymorphism(Polymorphism currentPoly)
{
this.position = currentPoly.position;
this.mutation = currentPoly.mutation;
this.isBackMutation = currentPoly.isBackMutation;
this.numberOfIns = currentPoly.numberOfIns;
this.insertedPolys = currentPoly.insertedPolys;
}
public void CreateEntry()
{
var entry = Mutations.CreateEntry("abc", Mutations.DeleteFromRow());
Assert.Equal("abc", entry.RowKey.ToStringUtf8());
Assert.Equal(1, entry.Mutations.Count);
Assert.NotNull(entry.Mutations[0].DeleteFromRow);
}
public BigtableClientFixture()
{
BigtableClient bigtableClient = BigtableClient.Create();
_bigtableTableAdminClient = BigtableTableAdminClient.Create();
Table table = new Table
{
Granularity = Table.Types.TimestampGranularity.Millis
};
table.ColumnFamilies.Add("stats_summary", new ColumnFamily());
table.ColumnFamilies.Add("cell_plan", new ColumnFamily());
CreateTableRequest createTableRequest = new CreateTableRequest
{
ParentAsInstanceName = new InstanceName(projectId, instanceId),
Table = table,
TableId = tableId,
};
_bigtableTableAdminClient.CreateTable(createTableRequest);
TableName tableName = new TableName(projectId, instanceId, tableId);
BigtableVersion timestamp = new BigtableVersion(new DateTime(2020, 1, 10, 14, 0, 0, DateTimeKind.Utc));
BigtableVersion timestamp_minus_hr = new BigtableVersion(new DateTime(2020, 1, 10, 13, 0, 0, DateTimeKind.Utc));
MutateRowsRequest.Types.Entry[] entries =
{
Mutations.CreateEntry(new BigtableByteString("phone#4c410523#20190501"),
Mutations.SetCell("cell_plan", "data_plan_01gb", "false", timestamp),
Mutations.SetCell("cell_plan", "data_plan_01gb", "true", timestamp_minus_hr),
Mutations.SetCell("cell_plan", "data_plan_05gb", "true", timestamp),
Mutations.SetCell("stats_summary", "connected_cell", "1", timestamp),
Mutations.SetCell("stats_summary", "connected_wifi", "1", timestamp),
Mutations.SetCell("stats_summary", "os_build", "PQ2A.190405.003", timestamp)),
Mutations.CreateEntry(new BigtableByteString("phone#4c410523#20190502"),
Mutations.SetCell("cell_plan", "data_plan_05gb", "true", timestamp),
Mutations.SetCell("stats_summary", "connected_cell", "1", timestamp),
Mutations.SetCell("stats_summary", "connected_wifi", "1", timestamp),
Mutations.SetCell("stats_summary", "os_build", "PQ2A.190405.004", timestamp)),
Mutations.CreateEntry(new BigtableByteString("phone#4c410523#20190505"),
Mutations.SetCell("cell_plan", "data_plan_05gb", "true", timestamp),
Mutations.SetCell("stats_summary", "connected_cell", "0", timestamp),
Mutations.SetCell("stats_summary", "connected_wifi", "1", timestamp),
Mutations.SetCell("stats_summary", "os_build", "PQ2A.190406.000", timestamp)),
Mutations.CreateEntry(new BigtableByteString("phone#5c10102#20190501"),
Mutations.SetCell("cell_plan", "data_plan_10gb", "true", timestamp),
Mutations.SetCell("stats_summary", "connected_cell", "1", timestamp),
Mutations.SetCell("stats_summary", "connected_wifi", "1", timestamp),
Mutations.SetCell("stats_summary", "os_build", "PQ2A.190401.002", timestamp)),
Mutations.CreateEntry(new BigtableByteString("phone#5c10102#20190502"),
Mutations.SetCell("cell_plan", "data_plan_10gb", "true", timestamp),
Mutations.SetCell("stats_summary", "connected_cell", "1", timestamp),
Mutations.SetCell("stats_summary", "connected_wifi", "0", timestamp),
Mutations.SetCell("stats_summary", "os_build", "PQ2A.190406.000", timestamp))
};
bigtableClient.MutateRows(tableName, entries);
}
// Use this for initialization
void Start()
{
cell = gameObject.GetComponent<Stats> ();
mute = gameObject.GetComponent<Mutations> ();
show = false;
posx = 50;
posy = 15;
GUI.color = Color.black;
}
public void SetCell_NonIdempotent()
{
var mutation = Mutations.SetCell("abc", "cq1", "value", new BigtableVersion(-1));
Assert.True(mutation.IsIdempotent());
mutation.SetCell.TimestampMicros = -1;
Assert.False(mutation.IsIdempotent());
}
public async Task CheckAndMutateRow_Validate_TableName()
{
await CheckAndMutateRow_ValidateArguments <ArgumentNullException>(
null,
"abc",
RowFilters.PassAllFilter(),
new[] { Mutations.DeleteFromRow() },
new[] { Mutations.DeleteFromRow() });
}
protected override async Task DeleteAsync(SnapshotMetadata metadata)
{
await _bigtableClient.MutateRowAsync(
_tableName,
GetRowKey(metadata.PersistenceId, metadata.SequenceNr),
new List <Mutation> {
Mutations.DeleteFromRow()
}).ConfigureAwait(false);
}
public void SetCell_String(string familyName)
{
var mutation =
Mutations.SetCell(familyName, "cq1", "value", new BigtableVersion(3));
Assert.NotNull(mutation.SetCell);
Assert.Equal(familyName, mutation.SetCell.FamilyName);
Assert.Equal("cq1", mutation.SetCell.ColumnQualifier.ToStringUtf8());
Assert.Equal("value", mutation.SetCell.Value.ToStringUtf8());
Assert.Equal(3000, mutation.SetCell.TimestampMicros);
}
public void DeleteFromColumn(string familyName)
{
var mutation =
Mutations.DeleteFromColumn(familyName, "cq1", new BigtableVersionRange(1, 2));
Assert.NotNull(mutation.DeleteFromColumn);
Assert.Equal(familyName, mutation.DeleteFromColumn.FamilyName);
Assert.Equal("cq1", mutation.DeleteFromColumn.ColumnQualifier.ToStringUtf8());
Assert.Equal(1000, mutation.DeleteFromColumn.TimeRange.StartTimestampMicros);
Assert.Equal(2000, mutation.DeleteFromColumn.TimeRange.EndTimestampMicros);
}
public async Task CheckAndMutateRow_Validate_RowKey(BigtableByteString rowKey)
{
var tableName = new TableName("project", "instance", "table");
await CheckAndMutateRow_ValidateArguments <ArgumentException>(
tableName,
rowKey,
RowFilters.PassAllFilter(),
new[] { Mutations.DeleteFromRow() },
new[] { Mutations.DeleteFromRow() });
}
public async Task CheckAndMutateRow_Valid_Request()
{
var tableName = new TableName("project", "instance", "table");
await CheckAndMutateRow_ValidateArguments <RequestMadeException>(
tableName,
"abc",
RowFilters.PassAllFilter(),
new[] { Mutations.DeleteFromRow() },
new[] { Mutations.DeleteFromRow() });
}
private CheckAndMutateRowRequest ToMutateRowIfNotExistsRequest(IPersistentRepresentation persistent, ActorSystem system)
{
var request = new CheckAndMutateRowRequest();
request.TableNameAsTableName = _tableName;
var payload = PersistentToBytes(persistent, system);
request.PredicateFilter = RowFilters.PassAllFilter();
request.RowKey = ByteString.CopyFromUtf8(ToRowKeyString(persistent.PersistenceId, persistent.SequenceNr));
request.FalseMutations.Add(Mutations.SetCell(_family, PayloadColumnQualifier, payload, new BigtableVersion(-1)));
return(request);
}
