public override async Task <SearchOpponentRespons> SearchOpponent(SearchOpponentRequest request, ServerCallContext context) { try { BoardGamesOnline.Models.Match match = await this.service.SearchOpponentAsync(new SearchOpponent { GameType = (GameTypes)request.GameType, UserId = request.UserId }); if (match == null) { return(new SearchOpponentRespons { Respons = new ServerResponse { Status = ServiceResponseStatus.Cancel } }); } Match mapMatch = Mapping.Mapper.Map <Match>(match); return(new SearchOpponentRespons { Match = mapMatch, Respons = new ServerResponse { Status = ServiceResponseStatus.Ok } }); } catch (Exception e) { MapField <string, string> mf = new MapField <string, string>(); mf.Add("Exception", e.Message); return(new SearchOpponentRespons { Respons = new ServerResponse { Status = ServiceResponseStatus.Error, Messages = { mf } } }); } }
/// <summary> /// Convert from <see cref="PropertyBag"/> to a <see cref="MapField{key,value}"/> /// </summary> /// <param name="propertyBag"><see cref="PropertyBag"/> to convert from</param> /// <returns>Converted <see cref="MapField{key,value}"/></returns> public static MapField <string, System.Protobuf.Object> ToProtobuf(this PropertyBag propertyBag) { var mapField = new MapField <string, System.Protobuf.Object>(); propertyBag.ForEach(keyValue => { var obj = new System.Protobuf.Object(); var type = keyValue.Value.GetProtobufType(); obj.Type = (int)type; var stream = new MemoryStream(); using (var outputStream = new CodedOutputStream(stream)) { keyValue.Value.WriteWithTypeTo(type, outputStream); outputStream.Flush(); stream.Flush(); stream.Seek(0, SeekOrigin.Begin); obj.Content = ByteString.CopyFrom(stream.ToArray()); } mapField.Add(keyValue.Key, obj); }); return(mapField); }
private void SetServers(MapField <string, string> res) { foreach (var s in PupExec.Servs) { res.Add(s.Key, s.Value.URL); } }
private void InternalAdd(TKey key, TValue value) { _internal.Add(key, value); if (_isMessageType) { SetParent(key, value); } }
public static void AddLabels(this MapField <string, string> map) { var settings = Properties.Settings.Default; if (!string.IsNullOrWhiteSpace(settings.LabelKey)) { map.Add(settings.LabelKey, settings.LabelValue); } }
/// <summary> /// Adds a GQL parameter with the specified value. /// </summary> /// <param name="parameters">The mapping of GQL query parameters to add to. Must not be null.</param> /// <param name="parameterName">The name of the parameter. Must not be null.</param> /// <param name="value">The value to add. May be null, which indicates /// a value with <see cref="Value.NullValue"/> set.</param> public static void Add(this MapField <string, GqlQueryParameter> parameters, string parameterName, Value value) { GaxPreconditions.CheckNotNull(parameters, nameof(parameters)); GaxPreconditions.CheckNotNull(parameterName, nameof(parameterName)); GaxPreconditions.CheckNotNull(value, nameof(value)); parameters.Add(parameterName, new GqlQueryParameter { Value = value ?? Value.ForNull() }); }
public MapField <string, float> Convert(IScoring scoring, ResolutionContext context) { var response = new MapField <string, float>(); foreach (var(statName, statWeighting) in scoring) { response.Add(statName, statWeighting); } return(response); }
void Start() { //get transforms of cars for (int i = 0; i < cars.Count(); i++) { var newTrans = new GameObject().transform; newTrans.localPosition = cars[i].transform.localPosition; newTrans.localRotation = cars[i].transform.localRotation; carTransforms.Add(i, newTrans); } }
public void AddField(MapField <string, Value> fields, String fieldName, long fieldValue) { if (fields.ContainsKey(fieldName)) { fields[fieldName].IntegerValue = fieldValue; } else { Value value = new Value(); value.IntegerValue = fieldValue; fields.Add(fieldName, value); } }
public void AddField(MapField <string, Value> fields, String fieldName, String fieldValue) { if (fields.ContainsKey(fieldName)) { fields[fieldName].StringValue = fieldValue; } else { Value strValue = new Value(); strValue.StringValue = fieldValue; fields.Add(fieldName, strValue); } }
public static MapField <string, string> ToMapFields(Dictionary <string, string> tags) { MapField <string, string> keyValuePairs = new MapField <string, string>(); if (tags != null) { foreach (var item in tags) { keyValuePairs.Add(item.Key, item.Value); } } return(keyValuePairs); }
//Create message payload public PubsubMessage GetPubSubMessage(bool ruleActionCompleted, MapField <String, String> attributes) { attributes.Add("RuleActionExecuted", ruleActionCompleted.ToString()); PubsubMessage message = new PubsubMessage { // The data is any arbitrary ByteString. Here, we're using text. Data = ByteString.CopyFromUtf8("Rule action executed notification"), // The attributes provide metadata in a string-to-string dictionary. Attributes = { attributes } }; return(message); }
/// <summary> /// Adds all the items contained in <paramref name="items"/> to the given <see cref="MapField{TKey,TValue}" />. /// </summary> /// <param name="map">The collections items should be added to.</param> /// <param name="items">The items to add to the collection.</param> /// <typeparam name="TKey">The type of the key of the map.</typeparam> /// <typeparam name="TValue">The type of the values of the map.</typeparam> public static void Add <TKey, TValue>(this MapField <TKey, TValue> map, IReadOnlyDictionary <TKey, TValue> items) { _ = map ?? throw new ArgumentNullException(nameof(map)); if (items is null) { return; } foreach (var item in items) { map.Add(item.Key, item.Value); } }
/// <summary> /// Dictionary<string, string> convert MapField<string, ByteString> /// </summary> /// <param name="map"></param> /// <returns></returns> public static MapField <string, ByteString> ConvertMapField(Dictionary <string, string> map) { var res = new MapField <string, ByteString>(); if (map != null && map.Count > 0) { foreach (var item in map) { res.Add(item.Key, ConvertToByteString(item.Value)); } } return(res); }
private static MapField <string, string> MetadataToMap(Metadata metadata) { var dict = new MapField <string, string>(); if (metadata == null) { return(dict); } foreach (var e in metadata) { if (e.IsBinary) { dict.Add(e.Key + " (binary)", Convert.ToBase64String(e.ValueBytes)); } else { dict.Add(e.Key, e.Value); } } return(dict); }
public void MergeFrom(PlayerStats other) { if (other != null) { if (other.PlayerId != 0) { PlayerId = other.PlayerId; } if (other.FightId != 0) { FightId = other.FightId; } stats_.Add((IDictionary <int, int>)other.stats_); titles_.Add((IEnumerable <int>)other.titles_); _unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } }
internal AzFunctionInfo(RpcFunctionMetadata metadata) { FunctionName = metadata.Name; Directory = metadata.Directory; EntryPoint = metadata.EntryPoint; ScriptPath = metadata.ScriptFile; AllBindings = new MapField <string, BindingInfo>(); OutputBindings = new MapField <string, BindingInfo>(); foreach (var binding in metadata.Bindings) { string bindingName = binding.Key; BindingInfo bindingInfo = binding.Value; AllBindings.Add(bindingName, bindingInfo); // PowerShell doesn't support the 'InOut' type binding if (bindingInfo.Direction == BindingInfo.Types.Direction.In) { switch (bindingInfo.Type) { case OrchestrationTrigger: Type = AzFunctionType.OrchestrationFunction; break; case ActivityTrigger: Type = AzFunctionType.ActivityFunction; break; default: Type = AzFunctionType.RegularFunction; break; } continue; } if (bindingInfo.Direction == BindingInfo.Types.Direction.Out) { OutputBindings.Add(bindingName, bindingInfo); } } }
public Cards(IEnumerable <SabberStoneCore.Model.Card> allCards) { cards_ = new MapField <int, Card>(); foreach (var card in allCards) { if (card.Name == null) { continue; } cards_.Add(card.AssetId, new Card { Id = card.AssetId, Name = card.Name, StringId = card.Id }); } }
public FunctionInfo(RpcFunctionMetadata metadata) { FunctionName = metadata.Name; Directory = metadata.Directory; EntryPoint = metadata.EntryPoint; ScriptPath = metadata.ScriptFile; AllBindings = new MapField <string, BindingInfo>(); OutputBindings = new MapField <string, BindingInfo>(); foreach (var binding in metadata.Bindings) { AllBindings.Add(binding.Key, binding.Value); // PowerShell doesn't support the 'InOut' type binding if (binding.Value.Direction == BindingInfo.Types.Direction.Out) { OutputBindings.Add(binding.Key, binding.Value); } } }
public void MergeFrom(FightSnapshot other) { if (other != null) { if (other.FightId != 0) { FightId = other.FightId; } entities_.Add((IEnumerable <Types.EntitySnapshot>)other.entities_); if (other.TurnIndex != 0) { TurnIndex = other.TurnIndex; } if (other.TurnRemainingTimeSec != 0) { TurnRemainingTimeSec = other.TurnRemainingTimeSec; } playersCompanions_.Add((IDictionary <int, Types.Companions>)other.playersCompanions_); playersCardsCount_.Add((IDictionary <int, int>)other.playersCardsCount_); _unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } }
public FieldObject Terminate() { if (sideEffectStates.Count == 1) { Tuple <string, IAggregateFunction> tuple = sideEffectStates[0]; IAggregateFunction sideEffectState = tuple.Item2; return(sideEffectState.Terminate()); } else { MapField map = new MapField(); foreach (Tuple <string, IAggregateFunction> tuple in sideEffectStates) { string key = tuple.Item1; IAggregateFunction sideEffectState = tuple.Item2; map.Add(new StringField(key), sideEffectState.Terminate()); } return(map); } }
internal override List <RawRecord> CrossApply(RawRecord record) { MapField valueMap = new MapField(); FieldObject inputTarget = record[this.inputTargetIndex]; if (inputTarget is VertexField) { VertexField vertexField = (VertexField)inputTarget; if (this.propertyNameList.Any()) { foreach (string propertyName in this.propertyNameList) { FieldObject property = vertexField[propertyName]; if (property == null) { continue; } List <FieldObject> values = new List <FieldObject>(); VertexPropertyField vp = property as VertexPropertyField; if (vp != null) { foreach (VertexSinglePropertyField vsp in vp.Multiples.Values) { values.Add(vsp); } } valueMap.Add(new StringField(propertyName), new CollectionField(values)); } } else { foreach (VertexPropertyField property in vertexField.VertexProperties.Values) { string propertyName = property.PropertyName; Debug.Assert(!VertexField.IsVertexMetaProperty(propertyName)); Debug.Assert(!propertyName.Equals(KW_VERTEX_EDGE)); Debug.Assert(!propertyName.Equals(KW_VERTEX_REV_EDGE)); switch (propertyName) { case "_rid": case "_self": case "_etag": case "_attachments": case "_ts": continue; default: List <FieldObject> values = new List <FieldObject>(); foreach (VertexSinglePropertyField singleVp in property.Multiples.Values) { values.Add(singleVp); } valueMap.Add(new StringField(propertyName), new CollectionField(values)); break; } } } } else if (inputTarget is EdgeField) { EdgeField edgeField = (EdgeField)inputTarget; if (this.propertyNameList.Any()) { foreach (string propertyName in this.propertyNameList) { FieldObject property = edgeField[propertyName]; if (property == null) { continue; } EdgePropertyField edgePf = property as EdgePropertyField; if (edgePf != null) { valueMap.Add(new StringField(propertyName), edgePf); } } } else { foreach (KeyValuePair <string, EdgePropertyField> propertyPair in edgeField.EdgeProperties) { string propertyName = propertyPair.Key; EdgePropertyField edgePropertyField = propertyPair.Value; switch (propertyName) { // Reserved properties for meta-data case KW_EDGE_ID: //case KW_EDGE_OFFSET: case KW_EDGE_SRCV: case KW_EDGE_SINKV: case KW_EDGE_SRCV_LABEL: case KW_EDGE_SINKV_LABEL: continue; default: valueMap.Add(new StringField(propertyName), edgePropertyField); break; } } } } else if (inputTarget is VertexSinglePropertyField) { VertexSinglePropertyField singleVp = inputTarget as VertexSinglePropertyField; if (this.propertyNameList.Any()) { foreach (string propertyName in this.propertyNameList) { FieldObject property = singleVp[propertyName]; if (property == null) { continue; } ValuePropertyField metaPf = property as ValuePropertyField; if (metaPf != null) { valueMap.Add(new StringField(propertyName), metaPf); } } } else { foreach (KeyValuePair <string, ValuePropertyField> kvp in singleVp.MetaProperties) { valueMap.Add(new StringField(kvp.Key), kvp.Value); } } } else { throw new GraphViewException("The input of valueMap() cannot be a meta or edge property."); } RawRecord result = new RawRecord(); result.Append(valueMap); return(new List <RawRecord> { result }); }
public void MergeFrom(EntitySnapshot other) { if (other == null) { return; } if (other.EntityId != 0) { EntityId = other.EntityId; } if (other.EntityType != 0) { EntityType = other.EntityType; } if (other.name_ != null && (name_ == null || other.Name != "")) { Name = other.Name; } if (other.defId_.HasValue && (!defId_.HasValue || other.DefId != 0)) { DefId = other.DefId; } if (other.weaponId_.HasValue && (!weaponId_.HasValue || other.WeaponId != 0)) { WeaponId = other.WeaponId; } if (other.genderId_.HasValue && (!genderId_.HasValue || other.GenderId != 0)) { GenderId = other.GenderId; } if (other.playerIndexInFight_.HasValue && (!playerIndexInFight_.HasValue || other.PlayerIndexInFight != 0)) { PlayerIndexInFight = other.PlayerIndexInFight; } if (other.ownerId_.HasValue && (!ownerId_.HasValue || other.OwnerId != 0)) { OwnerId = other.OwnerId; } if (other.teamId_.HasValue && (!teamId_.HasValue || other.TeamId != 0)) { TeamId = other.TeamId; } if (other.level_.HasValue && (!level_.HasValue || other.Level != 0)) { Level = other.Level; } properties_.Add((IEnumerable <int>)other.properties_); if (other.position_ != null) { if (position_ == null) { position_ = new CellCoord(); } Position.MergeFrom(other.Position); } if (other.direction_.HasValue && (!direction_.HasValue || other.Direction != 0)) { Direction = other.Direction; } caracs_.Add((IDictionary <int, int>)other.caracs_); if (other.customSkin_ != null && (customSkin_ == null || other.CustomSkin != "")) { CustomSkin = other.CustomSkin; } if (other.actionDoneThisTurn_.HasValue && (!actionDoneThisTurn_.HasValue || other.ActionDoneThisTurn != false)) { ActionDoneThisTurn = other.ActionDoneThisTurn; } _unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); }
public async Task <ActionResult> HandleRequest([FromBody] dynamic request) { // Read the request JSON asynchronously, as the Google.Protobuf library // doesn't (yet) support asynchronous parsing. //string requestJson; //using (TextReader reader = new StreamReader(Request.Body)) //{ // requestJson = await reader.ReadToEndAsync(); //} //// Parse the body of the request using the Protobuf JSON parser, //// *not* Json.NET. //var request = jsonParser.Parse<WebhookRequest>(requestJson); // Note: you should authenticate the request here. var message = new Message { Text = new Text { Text_ = { "Hello world" } } }; var payload = new MapField <string, Value>(); var responseText = "Hello word"; var textToSpeech = new Value { StringValue = responseText }; var simpleResponse = new Struct { }; simpleResponse.Fields.Add("textToSpeech", textToSpeech); var googlePayload = new Google.Protobuf.WellKnownTypes.Value { StructValue = new Google.Protobuf.WellKnownTypes.Struct { } }; payload.Add("google", googlePayload); // Populate the response var response = new WebhookResponse() { FulfillmentMessages = { message }, Payload = new Google.Protobuf.WellKnownTypes.Struct { Fields = { payload } } }; // Ask Protobuf to format the JSON to return. // Again, we don't want to use Json.NET - it doesn't know how to handle Struct // values etc. string responseJson = response.ToString(); return(Content(responseJson, "application/json")); }
public void Null_Capability_Value_Throws_Error() { MapField <string, string> addedCapabilities = new MapField <string, string>(); Assert.Throws <ArgumentNullException>(() => addedCapabilities.Add(testCapability2, null)); }
internal void Load(FunctionLoadRequest request) { // TODO: catch "load" issues at "func start" time. // ex. Script doesn't exist, entry point doesn't exist _loadedFunctions.Add(request.FunctionId, new AzFunctionInfo(request.Metadata)); }
public T ReadField <T>(int tag) { Type type = typeof(T); if (type == typeof(ByteField)) { return((T)(object)new ByteField(tag, Read <byte>(tag))); } else if (type == typeof(ShortField)) { return((T)(object)new ShortField(tag, Read <short>(tag))); } else if (type == typeof(IntField)) { return((T)(object)new IntField(tag, Read <int>(tag))); } else if (type == typeof(LongField)) { return((T)(object)new LongField(tag, Read <long>(tag))); } else if (type == typeof(FloatField)) { return((T)(object)new FloatField(tag, Read <float>(tag))); } else if (type == typeof(DoubleField)) { return((T)(object)new DoubleField(tag, Read <double>(tag))); } else if (type == typeof(StringField)) { return((T)(object)new StringField(tag, Read <string>(tag))); } else { if (SkipToTag(tag)) { Header header = ReadHeader(); switch (header.Type) { case Type_Map: if (type == typeof(MapField)) { int count = Read <int>(0); if (count < 0) { throw new Exception("Count invalid."); } MapField result = new MapField(header.Tag); for (int i = 0; i < count; i++) { result.Add(ReadField(), ReadField()); } return((T)(object)result); } break; case Type_List: if (type == typeof(ListField)) { int count = Read <int>(0); if (count < 0) { throw new Exception("Count invalid."); } ListField result = new ListField(header.Tag); for (int i = 0; i < count; i++) { result.Add(ReadField()); } return((T)(object)result); } break; case Type_StructBegin: if (type == typeof(StructField)) { StructField result = new StructField(header.Tag); while (true) { Header test = PeakHeader(); if (test.Type == Type_StructEnd) { Seek(test.Count); break; } JceField field = ReadField(); result.Set(field.Tag, field); } return((T)(object)result); } break; case Type_StructEnd: throw new Exception("Got struct end field without struct begin tag."); case Type_Zero: if (type == typeof(ZeroField)) { return((T)(object)new ZeroField(header.Tag)); } break; case Type_ByteArray: if (type == typeof(ByteArrayField)) { Header check = ReadHeader(); if (check.Type != Type_Byte) { throw new Exception("Data incorrect in type " + Type_ByteArray + ",except " + Type_Byte + " but got " + header.Type); } int length = Read <int>(0); if (length < 0) { throw new Exception("Length error."); } return((T)(object)new ByteArrayField(header.Tag, Read(length))); } break; default: throw new ArgumentException("Unknown type " + header.Type + "."); } throw new ArgumentException("Type mismatch."); } throw new Exception("Tag not exists."); } }