internal Type(ValueGroup valueGroup, sbyte typeId, Value minValue, Value maxValue) { this.ValueGroup = valueGroup; this.TypeId = typeId; this._minValue = minValue; this._maxValue = maxValue; }
/// <summary> /// ツイートする。 /// </summary> /// <param name="parameters"></param> public async Task Tweet(ServicePostParameters parameters) { var query = new Query { ["status"] = parameters.Text, }; if (parameters.Attachments.HasItems) { var mediaIds = await this._account.Media.Uploads(parameters.Attachments) .ConfigureAwait(false); query["media_ids"] = new ValueGroup(mediaIds); } if (parameters.IsContainsWarningAttachment) { query["possibly_sensitive"] = true; } //if (parameters.ReplyToStatus != null) //{ // query["in_reply_to_status_id"] = parameters.ReplyToStatus.Id; //} await this._account.Api.Statuses.Update(query).ConfigureAwait(false); }
public Coordinate GetPos(uint coord_x, uint coord_z) { const uint NEGATIVE_OUTBOUND = 1000; if (coord_x > NEGATIVE_OUTBOUND) { coord_x = 0; } else if (coord_x > num_rects) { coord_x = num_rects; } if (coord_z > NEGATIVE_OUTBOUND) { coord_z = 0; } else if (coord_z > num_rects) { coord_z = num_rects; } ValueGroup <uint, uint> Key = new ValueGroup <uint, uint>(coord_x, coord_z); if (Coords.ContainsKey(Key)) { return(Coords[Key]); } else { return(null); } }
public void RemoveCoord(ValueGroup <uint, uint> key) { if (Coords.ContainsKey(key)) { Coords.Remove(key); } }
/// <summary> /// Select the path corresponding to the given ValueGroup. Creates the path if needed, /// and rethrows any create time exception as a RuntimeException. /// </summary> /// <param name="valueGroup"> target value group </param> /// <returns> selected part </returns> internal virtual T UncheckedSelect(ValueGroup valueGroup) { switch (valueGroup.innerEnumValue) { case ValueGroup.InnerEnum.DATE: return(Date()); case ValueGroup.InnerEnum.LOCAL_DATE_TIME: return(LocalDateTime()); case ValueGroup.InnerEnum.ZONED_DATE_TIME: return(ZonedDateTime()); case ValueGroup.InnerEnum.LOCAL_TIME: return(LocalTime()); case ValueGroup.InnerEnum.ZONED_TIME: return(ZonedTime()); case ValueGroup.InnerEnum.DURATION: return(Duration()); default: throw new System.InvalidOperationException("Unsupported value group " + valueGroup); } }
// ================================================================================================================ // CONSTRUCTOR ---------------------------------------------------------------------------------------------------- public ValueList(string key = "") { _key = key; ValueList.addInstance(this); root = new ValueGroup(); }
// ================================================================================================================ // CONSTRUCTOR ---------------------------------------------------------------------------------------------------- public ValueList(string name = "") { _name = name; ValueList.addInstance(this); root = new ValueGroup(); }
/// <summary> /// Method for creating of list of value groups and their corresponding special teasps. /// </summary> /// <param name="dc">user data category</param> /// <returns>List of Value Groups</returns> private (List <ValueGroup>, List <Teasp>) handleSplitContents(string dc, bool hasPicklist = false) { TBXContentMap cm = mappingDict.getTBXContentMap(dc); string[] tbx_keys = Methods.getKeyArray(tbx_picklists.Keys); List <ValueGroup> vgs = new List <ValueGroup>(); List <Teasp> teasps = new List <Teasp>(); foreach (string tbx_dc in mappingDict.getTBXMappingList(dc)) { if (Methods.inArray(ref tbx_keys, tbx_dc)) { Teasp teasp = new Teasp(); (string target, string eltAtt) = getEltTgtEltAtt(tbx_dc); if (hasPicklist) { teasp.setAll(target, eltAtt, mappingDict.getPicklistMap(dc)); } else { teasp.setAll(target, eltAtt); } ValueGroup vg = new ValueGroup(); foreach (string content in cm.Keys) { if (cm[content] == tbx_dc) { vg.Add(content); } } vgs.Add(vg); teasps.Add(teasp); } else { Teasp teasp = new Teasp(); (string target, string eltAtt) = getEltTgtEltAtt(tbx_dc); teasp.setAll(target, eltAtt); ValueGroup vg = new ValueGroup(); foreach (string content in cm.Keys) { if (cm[content] == tbx_dc) { vg.Add(content); } } vgs.Add(vg); teasps.Add(teasp); } } return(vgs, teasps); }
internal AbstractArrayType(ValueGroup valueGroup, sbyte typeId, ArrayElementComparator arrayElementComparator, ArrayElementValueFactory <T> valueFactory, ArrayElementWriter arrayElementWriter, ArrayElementReader arrayElementReader, System.Func <int, T[]> arrayCreator, Org.Neo4j.Values.Storable.ValueWriter_ArrayType arrayType) : base(valueGroup, typeId, null, null) { this._arrayElementComparator = arrayElementComparator; this._valueFactory = valueFactory; this.ArrayElementWriter = arrayElementWriter; this._arrayElementReader = arrayElementReader; this._arrayCreator = arrayCreator; this._arrayType = arrayType; }
public override bool HasFullValuePrecision(params IndexQuery[] predicates) { foreach (IndexQuery predicate in predicates) { ValueGroup valueGroup = predicate.ValueGroup(); if (valueGroup == ValueGroup.GEOMETRY_ARRAY || valueGroup == ValueGroup.GEOMETRY) { return(false); } } return(true); }
/*Gets the closest coord whose center is minimum distance away * from the target coordinate.Note that coordinate target doesn't * have to the coordinate of the AI's current target*/ Coordinate GetClosestCoordToTargetCoord(Coordinate target) { if (target == null) { return(null); } const float INTERVAL_THETA = 20; const float FULL_CIRCLE = 360; ValueGroup <Coordinate, float> v = GetMinimalDistStarterCoord(target); Coordinate goal = v.index; Coordinate current_coord = Map.Instance.GetPos(ptr.position); Vector3 ORIGINAL_POS = Map.Instance.GetCenter(goal); float dist = v.value; float goal_cost = 0; if (goal.isHazardous(ptr.gameObject.layer)) { goal_cost = goal.GetHazardCost(ptr.gameObject.layer); // Debug.Log("Hazardous"); } float goal_distance = Math.Abs( Vector3.Distance( Map.Instance.GetCenter(goal), Map.Instance.GetCenter(current_coord))); for (float degrees = 10; degrees < FULL_CIRCLE; degrees += INTERVAL_THETA) { Vector3 pos = Quaternion.AngleAxis(degrees, Vector3.up) * ORIGINAL_POS; Coordinate coord = Map.Instance.GetPos(pos); if (coord != null) { float cost = 0; if (coord.isHazardous(ptr.gameObject.layer)) { cost = coord.GetHazardCost(ptr.gameObject.layer); } float distance = Math.Abs( Vector3.Distance( Map.Instance.GetCenter(coord), Map.Instance.GetCenter(current_coord))); if (distance + cost < goal_distance + goal_cost) { goal = coord; goal_distance = distance; goal_cost = cost; } } } return(goal); }
private Org.Neo4j.Storageengine.Api.schema.IndexProgressor_NodeValueClient InjectFullValuePrecision(Org.Neo4j.Storageengine.Api.schema.IndexProgressor_NodeValueClient cursor, IndexQuery[] query, IndexReader reader) { Org.Neo4j.Storageengine.Api.schema.IndexProgressor_NodeValueClient target = cursor; if (!reader.HasFullValuePrecision(query)) { IndexQuery[] filters = new IndexQuery[query.Length]; int count = 0; for (int i = 0; i < query.Length; i++) { IndexQuery q = query[i]; switch (q.Type()) { case range: ValueGroup valueGroup = q.ValueGroup(); if ((valueGroup == NUMBER || valueGroup == GEOMETRY) && !reader.HasFullValuePrecision(q)) { filters[i] = q; count++; } break; case exact: Value value = ((IndexQuery.ExactPredicate)q).value(); if (value.ValueGroup() == ValueGroup.NUMBER || Values.isArrayValue(value) || value.ValueGroup() == ValueGroup.GEOMETRY) { if (!reader.HasFullValuePrecision(q)) { filters[i] = q; count++; } } break; default: break; } } if (count > 0) { // filters[] can contain null elements. The non-null elements are the filters and each sit in the designated slot // matching the values from the index. target = new NodeValueClientFilter(target, _cursors.allocateNodeCursor(), _cursors.allocatePropertyCursor(), this, filters); } } return(target); }
/// <summary> /// Serialize the <see cref="ValueGroup"/> /// </summary> /// <param name="valueGroup">The <see cref="ValueGroup"/> to serialize</param> /// <returns>The <see cref="JObject"/></returns> private JObject Serialize(ValueGroup valueGroup) { var jsonObject = new JObject(); jsonObject.Add("alias", this.PropertySerializerMap["alias"](valueGroup.Alias.OrderBy(x => x, this.guidComparer))); jsonObject.Add("category", this.PropertySerializerMap["category"](valueGroup.Category.OrderBy(x => x, this.guidComparer))); jsonObject.Add("classKind", this.PropertySerializerMap["classKind"](Enum.GetName(typeof(CDP4Common.CommonData.ClassKind), valueGroup.ClassKind))); jsonObject.Add("definition", this.PropertySerializerMap["definition"](valueGroup.Definition.OrderBy(x => x, this.guidComparer))); jsonObject.Add("excludedDomain", this.PropertySerializerMap["excludedDomain"](valueGroup.ExcludedDomain.OrderBy(x => x, this.guidComparer))); jsonObject.Add("excludedPerson", this.PropertySerializerMap["excludedPerson"](valueGroup.ExcludedPerson.OrderBy(x => x, this.guidComparer))); jsonObject.Add("hyperLink", this.PropertySerializerMap["hyperLink"](valueGroup.HyperLink.OrderBy(x => x, this.guidComparer))); jsonObject.Add("iid", this.PropertySerializerMap["iid"](valueGroup.Iid)); jsonObject.Add("modifiedOn", this.PropertySerializerMap["modifiedOn"](valueGroup.ModifiedOn)); jsonObject.Add("name", this.PropertySerializerMap["name"](valueGroup.Name)); jsonObject.Add("revisionNumber", this.PropertySerializerMap["revisionNumber"](valueGroup.RevisionNumber)); jsonObject.Add("shortName", this.PropertySerializerMap["shortName"](valueGroup.ShortName)); jsonObject.Add("thingPreference", this.PropertySerializerMap["thingPreference"](valueGroup.ThingPreference)); return(jsonObject); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void copyShouldCopyExtremeValues() internal virtual void CopyShouldCopyExtremeValues() { // Given GenericKey extreme = NewKeyState(); GenericKey copy = NewKeyState(); foreach (ValueGroup valueGroup in ValueGroup.values()) { if (valueGroup != ValueGroup.NO_VALUE) { extreme.InitValueAsLowest(valueGroup); copy.CopyFrom(extreme); assertEquals(0, extreme.CompareValueTo(copy), "states not equals after copy, valueGroup=" + valueGroup); extreme.InitValueAsHighest(valueGroup); copy.CopyFrom(extreme); assertEquals(0, extreme.CompareValueTo(copy), "states not equals after copy, valueGroup=" + valueGroup); } } }
private static List <ValueGroup> LoadValueGroups(XmlElement rootElement) { var valueGroups = new List <ValueGroup>(); foreach (XmlNode vg in rootElement.SelectNodes("//value-group")) { if (vg.NodeType != XmlNodeType.Element) { continue; } var valueGroup = new ValueGroup { Caption = vg.Value("caption"), Name = vg.Value("name"), Values = LoadValues(vg) }; valueGroups.Add(valueGroup); } return(valueGroups); }
public void UpdateDamageCounter(int damage, int layer) { if (layer == LayerMask.NameToLayer("Invincible")) { return; } int index = damage_counter_list.FindIndex(delegate(ValueGroup <int, int> v) { return(v.index == layer); }); if (index == -1) { damage_counter_list.Add(new ValueGroup <int, int>(layer, damage)); } else { damage_counter_list[index] = new ValueGroup <int, int>(layer, damage_counter_list[index].value + damage); } }
private void AssertAccessSingleProperty(long nodeId, object expectedValue, ValueGroup expectedValueType) { // given using (NodeCursor node = cursors.allocateNodeCursor(), PropertyCursor props = cursors.allocatePropertyCursor()) { // when read.singleNode(nodeId, node); assertTrue("node by reference", node.Next()); assertTrue("has properties", HasProperties(node, props)); node.Properties(props); assertTrue("has properties by direct method", props.Next()); assertEquals("correct value", expectedValue, props.PropertyValue()); assertEquals("correct value type ", expectedValueType, props.PropertyType()); assertFalse("single property", props.Next()); read.nodeProperties(node.NodeReference(), node.PropertiesReference(), props); assertTrue("has properties via property ref", props.Next()); assertEquals("correct value", expectedValue, props.PropertyValue()); assertFalse("single property", props.Next()); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public void add(java.util.Collection<? extends org.neo4j.kernel.api.index.IndexEntryUpdate<?>> updates) throws org.neo4j.kernel.api.exceptions.index.IndexEntryConflictException public override void Add <T1>(ICollection <T1> updates) where T1 : Org.Neo4j.Kernel.Api.Index.IndexEntryUpdate <T1> { //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: java.util.Map<org.neo4j.values.storable.ValueGroup,java.util.List<org.neo4j.kernel.api.index.IndexEntryUpdate<?>>> batchMap = new java.util.HashMap<>(); IDictionary <ValueGroup, IList <IndexEntryUpdate <object> > > batchMap = new Dictionary <ValueGroup, IList <IndexEntryUpdate <object> > >(); //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: for (org.neo4j.kernel.api.index.IndexEntryUpdate<?> update : updates) foreach (IndexEntryUpdate <object> update in updates) { ValueGroup valueGroup = update.Values()[0].valueGroup(); //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: java.util.List<org.neo4j.kernel.api.index.IndexEntryUpdate<?>> batch = batchMap.computeIfAbsent(valueGroup, k -> new java.util.ArrayList<>()); IList <IndexEntryUpdate <object> > batch = batchMap.computeIfAbsent(valueGroup, k => new List <IndexEntryUpdate <object> >()); batch.Add(update); } //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: for (java.util.Map.Entry<org.neo4j.values.storable.ValueGroup,java.util.List<org.neo4j.kernel.api.index.IndexEntryUpdate<?>>> entry : batchMap.entrySet()) foreach (KeyValuePair <ValueGroup, IList <IndexEntryUpdate <object> > > entry in batchMap.SetOfKeyValuePairs()) { Select(entry.Key).add(entry.Value); } }
public Coordinate GetPos(Vector3 pos) { /*The coordinate can be ascertained by dividing the * position float values by the length and width of * each rectangle*/ uint coord_x = (uint)((pos.x - min_x) / interval_x); uint coord_z = (uint)((pos.z - min_z) / interval_z); const uint NEGATIVE_OUTBOUND = 1000; if (coord_x > NEGATIVE_OUTBOUND) { coord_x = 0; } else if (coord_x > num_rects) { coord_x = num_rects; } if (coord_z > NEGATIVE_OUTBOUND) { coord_z = 0; } else if (coord_z > num_rects) { coord_z = num_rects; } ValueGroup <uint, uint> Key = new ValueGroup <uint, uint>(coord_x, coord_z); if (Coords.ContainsKey(Key)) { return(Coords[Key]); } else { return(null); } }
/// <summary> /// Select the part corresponding to the given ValueGroup, apply function to it and return the result. /// If the part isn't created yet return orElse. /// </summary> /// <param name="valueGroup"> target value group </param> /// <param name="function"> function to apply to part </param> /// <param name="orElse"> result to return if part isn't created yet </param> /// @param <RESULT> type of result </param> /// <returns> the result </returns> internal virtual RESULT SelectOrElse <RESULT>(ValueGroup valueGroup, System.Func <T, RESULT> function, RESULT orElse) { T cachedValue; switch (valueGroup.innerEnumValue) { case ValueGroup.InnerEnum.DATE: cachedValue = Cache[date]; break; case ValueGroup.InnerEnum.LOCAL_DATE_TIME: cachedValue = Cache[localDateTime]; break; case ValueGroup.InnerEnum.ZONED_DATE_TIME: cachedValue = Cache[zonedDateTime]; break; case ValueGroup.InnerEnum.LOCAL_TIME: cachedValue = Cache[localTime]; break; case ValueGroup.InnerEnum.ZONED_TIME: cachedValue = Cache[zonedTime]; break; case ValueGroup.InnerEnum.DURATION: cachedValue = Cache[duration]; break; default: throw new System.InvalidOperationException("Unsupported value group " + valueGroup); } return(cachedValue != default(T) ? function(cachedValue) : orElse); }
internal override void InitValueAsHighest(ValueGroup valueGroups) { Bytes = null; }
internal override void InitValueAsHighest(int stateSlot, ValueGroup valueGroup) { InitValueAsHighest(valueGroup); }
internal virtual void InitValueAsHighest(ValueGroup valueGroup) { Clear(); TypeConflict = valueGroup == ValueGroup.UNKNOWN ? HIGHEST_BY_VALUE_GROUP : Types.ByGroup[valueGroup.ordinal()]; TypeConflict.initializeAsHighest(this); }
/// <summary> /// Add an Value Group row view model to the list of <see cref="ValueGroup"/> /// </summary> /// <param name="valueGroup"> /// The <see cref="ValueGroup"/> that is to be added /// </param> private ValueGroupRowViewModel AddValueGroupRowViewModel(ValueGroup valueGroup) { return(new ValueGroupRowViewModel(valueGroup, this.Session, this)); }
internal FileLayout(File indexFile, IndexLayout <KEY, NativeIndexValue> layout, ValueGroup valueGroup) { this.IndexFile = indexFile; this.Layout = layout; this.ValueGroup = valueGroup; }
/// <summary> /// Select the part corresponding to the given ValueGroup. Creates the part if needed, /// in which case an exception of type E might be thrown. /// </summary> /// <param name="valueGroup"> target value group </param> /// <returns> selected part </returns> internal virtual T Select(ValueGroup valueGroup) { return(UncheckedSelect(valueGroup)); }
internal override void InitValueAsLowest(int stateSlot, ValueGroup valueGroup) { stateSlot(stateSlot).InitValueAsLowest(valueGroup); }
public void UpdateAggro(int damage = 0, NetworkInstanceId player_id = new NetworkInstanceId(), bool account_attack_dist = true) { if (damage != 0) { //Debug.Log("Aggro Called"); float dist_multiplier = 1; Transform playertr = NetworkServer.FindLocalObject(player_id).transform; if (account_attack_dist && Target) { /*The closer the player is to the enemy the more threat generated from * the respective attack done by the player*/ float dist_ratio = enemy_attack_detection.radius / Vector3.Distance(Target.transform.position, ptr.position); /*The distance only has 25% bearing on the threat,however.*/ dist_multiplier = .75f + .25f * (dist_ratio); } /*If the player is not currently on the enemy's hatelist... * (netIds are used as ValueGroup indeces)*/ if (!Array.Exists(HateList, delegate(ValueGroup g) { return(g.index == (int)(player_id.Value)); })) { /*Find the first empty slot to store threat info * in*/ int index = Array.FindIndex(HateList, delegate(ValueGroup g) { return(g.value == -1); }); //Debug.Log(index); HateList[index] = new ValueGroup((int)player_id.Value, dist_multiplier * (float)damage); } else { /*If the player is in the aggro list,then simply add to the threat * data stored into it*/ int index = Array.FindIndex(HateList, delegate(ValueGroup g) { return(g.index == (int)player_id.Value); }); HateList[index].value += (float)damage * dist_multiplier; } } /*There needs to be a .2 times more threat to move up one place. * This is to prevent rapid switching of targets constantly w/o huge * damage changes.*/ Array.Sort(HateList, delegate(ValueGroup lhs, ValueGroup rhs) { /*if (lhs.value == -1) * { * return 0; * } */ if (lhs.value * .9f > rhs.value) { return(-1); } else if (lhs.value * 1.1f < rhs.value) { return(1); } else { return(0); } }); if (HateList[0] != NOT_SET) { /*Assign target to one with most threat.The Gameobject's * existence is checked in event that a player disconnects.*/ GameObject g = NetworkServer.FindLocalObject(new NetworkInstanceId((uint)HateList[0].index)); if (g == null) { RemoveAggro(new NetworkInstanceId((uint)HateList[0].index)); } else { Target = g.GetComponent <HealthDefence>(); } } else { Target = null; } }
public void addGroup(string key, ValueGroup group) { groups[key] = group; }
internal abstract void InitValueAsHighest(int stateSlot, ValueGroup valueGroup);