/// <summary>
 /// Returns true if the vehicle is allowed on the way represented by these tags
 /// </summary>
 /// <param name="tags"></param>
 /// <param name="highwayType"></param>
 /// <returns></returns>
 protected override bool IsVehicleAllowed(TagsCollectionBase tags, string highwayType)
 {
     // do the designated tags.
     if (tags.ContainsKey("bicycle"))
     {
         if (tags["bicycle"] == "designated")
         {
             return true; // designated bicycle
         }
         if (tags["bicycle"] == "yes")
         {
             return true; // yes for bicycle
         }
         if (tags["bicycle"] == "no")
         {
             return false; //  no for bicycle
         }
     }
     if (tags.ContainsKey("foot"))
     {
         if (tags["foot"] == "designated")
         {
             return false; // designated foot
         }
     }
     return AccessibleTags.ContainsKey(highwayType);
 }

 /// <summary>
 /// Compares two tags collections.
 /// </summary>
 public static void CompareTags(TagsCollectionBase expected, TagsCollectionBase actual)
 {
     if (expected == null)
     {
         Assert.IsNull(actual);
     }
     else
     {
         if (expected.Count == 0)
         {
             Assert.IsTrue(actual == null || actual.Count == 0);
         }
         else
         {
             Assert.IsNotNull(actual);
             Assert.AreEqual(expected.Count, actual.Count);
             foreach (Tag tag in expected)
             {
                 Assert.IsTrue(actual.ContainsKeyValue(tag.Key, tag.Value));
             }
             foreach (Tag tag in actual)
             {
                 Assert.IsTrue(expected.ContainsKeyValue(tag.Key, tag.Value));
             }
         }
     }
 }

        public override TagsCollectionBase Evaluate(TagsCollectionBase tags, OsmGeoType type)
        {
            var a_result = _a.Evaluate(tags, type);
            var b_result = _b.Evaluate(tags, type);

            return a_result.Union(b_result);
        }

 /// <summary>
 /// Creates a new way.
 /// </summary>
 /// <param name="id"></param>
 /// <param name="nodes"></param>
 /// <param name="tags"></param>
 /// <returns></returns>
 public static Way Create(long id, TagsCollectionBase tags, params long[] nodes)
 {
     Way way = new Way();
     way.Id = id;
     way.Nodes = new List<long>(nodes);
     way.Tags = tags;
     return way;
 }

 /// <summary>
 /// Returns a label for different categories of highways.
 /// </summary>
 /// <param name="tags"></param>
 /// <returns></returns>
 public RoutingLabel GetLabelFor(TagsCollectionBase tags)
 {
     if (_edge_intepreter.IsOnlyLocalAccessible(tags))
     {
         return new RoutingLabel('L', "OnlyLocalAccessible"); // local
     }
     return new RoutingLabel('R', "GeneralAccessible"); // regular.
 }

 /// <summary>
 ///     Returns true if the edge with the given tags is routable.
 /// </summary>
 /// <param name="tags"></param>
 /// <returns></returns>
 public bool IsRoutable(TagsCollectionBase tags)
 {
     if (tags != null && tags.Count > 0)
     {
         return tags.ContainsKey("highway");
     }
     return false;
 }

 /// <summary>
 /// Creates a new relation.
 /// </summary>
 /// <param name="id"></param>
 /// <param name="tags"></param>
 /// <param name="members"></param>
 /// <returns></returns>
 public static Relation Create(long id, TagsCollectionBase tags, params RelationMember[] members)
 {
     Relation relation = new Relation();
     relation.Id = id;
     relation.Members = new List<RelationMember>(members);
     relation.Tags = tags;
     return relation;
 }

        /// <summary>
        /// Serializes a tags collection to a byte array and addes the size in the first 4 bytes.
        /// </summary>
        /// <param name="collection"></param>
        /// <param name="stream"></param>
        /// <returns></returns>
        public void SerializeWithSize(TagsCollectionBase collection, Stream stream)
        {
            RuntimeTypeModel typeModel = TypeModel.Create();
            typeModel.Add(typeof(Tag), true);

            var tagsList = new List<Tag>(collection);
            typeModel.SerializeWithSize(stream, tagsList);
        }

        public override TagsCollectionBase Evaluate(TagsCollectionBase tags, OsmGeoType type)
        {
            if (tags == null)
            {
                throw new ArgumentNullException("tags");
            }

            return tags;
        }

 /// <summary>
 ///     Returns the name of a given way.
 /// </summary>
 /// <param name="tags"></param>
 /// <returns></returns>
 public string GetName(TagsCollectionBase tags)
 {
     var name = string.Empty;
     if (tags.ContainsKey("name"))
     {
         name = tags["name"];
     }
     return name;
 }

 private IAttributesTable ConvertTags(TagsCollectionBase tags, long id)
 {
     var properties = tags.ToStringObjectDictionary();
     properties.Add("osm_id", id);
     var table = new AttributesTable();
     foreach (var key in properties.Keys)
     {
         table.AddAttribute(key, properties[key]);
     }
     return table;
 }

 /// <summary>
 /// Returns true if the vehicle is allowed on the way represented by these tags
 /// </summary>
 /// <param name="tags"></param>
 /// <param name="highwayType"></param>
 /// <returns></returns>
 protected override bool IsVehicleAllowed(TagsCollectionBase tags, string highwayType)
 {
     if (tags.ContainsKey("motor_vehicle"))
     {
         if (tags["motor_vehicle"] == "no")
         {
             return false;
         }
     }
     return AccessibleTags.ContainsKey(highwayType);
 }

 /// <summary>
 /// Generates an instruction for a direct turn.
 /// </summary>
 /// <param name="countBefore"></param>
 /// <param name="street"></param>
 /// <param name="direction"></param>
 /// <param name="pois"></param>
 /// <returns></returns>
 protected override string GenerateDirectTurn(int countBefore, TagsCollectionBase street, RelativeDirection direction, List<PointPoi> pois)
 {
     countBefore++;
     if (countBefore == 1)
     {
         return string.Format("Neem de 1ste afslag {0}, de {1} op.", TurnDirection(direction), this.GetName("nl", street));
     }
     else
     {
         return string.Format("Neem de {0}de afslag {1}, de {2} op.", countBefore, TurnDirection(direction), this.GetName("nl", street));
     }
 }

 /// <summary>
 ///     Returns all the names in all languages and alternatives.
 /// </summary>
 /// <param name="tags"></param>
 /// <returns></returns>
 public Dictionary<string, string> GetNamesInAllLanguages(TagsCollectionBase tags)
 {
     var names = new Dictionary<string, string>();
     //if (tags != null)
     //{
     //    foreach (var pair in tags)
     //    {
     //        var m = Regex.Match(pair.Key, "name:[a-zA-Z]");
     //        if (m.Success)
     //        {
     //            //throw new NotImplementedException();
     //        }
     //    }
     //}
     return names;
 }

        public override TagsCollectionBase Evaluate(TagsCollectionBase tags, OsmGeoType type)
        {
            if (tags == null)
            {
                throw new ArgumentNullException("tags");
            }

            var result = tags;

            if (type == _type)
            {
                result = TagsCollectionBase.Empty;
            }

            return result;
        }

        /// <summary>
        /// Direct turn instruction.
        /// </summary>
        /// <param name="instruction"></param>
        /// <param name="streetCountBeforeTurn"></param>
        /// <param name="streetTo"></param>
        /// <param name="direction"></param>
        /// <param name="list"></param>
        /// <returns></returns>
        public Instruction GenerateDirectTurn(Instruction instruction,
            int streetCountBeforeTurn,
            TagsCollectionBase streetTo,
            RelativeDirectionEnum direction,
            List<PointPoi> list)
        {
            instruction.Text = string.Format("GenerateDirectTurn:{0}_{1}_{2}",
                                             streetCountBeforeTurn, direction.ToString(), list.Count);

            instruction.Extras = new Dictionary<string, object>();
            instruction.Extras.Add("streetCountBeforeTurn", streetCountBeforeTurn);
            instruction.Extras.Add("streetTo", streetTo);
            instruction.Extras.Add("direction", direction);
            instruction.Extras.Add("list", list);

            return instruction;
        }

 /// <summary>
 ///     Returns true if the edge with the given tags is only accessible locally.
 /// </summary>
 /// <param name="tags"></param>
 /// <returns></returns>
 public bool IsOnlyLocalAccessible(TagsCollectionBase tags)
 {
     string tag;
     if (tags.TryGetValue("highway", out tag))
     {
         if (tag == "service")
         {
             return true;
         }
     }
     if (tags.TryGetValue("access", out tag))
     {
         if (tag == "private" || tag == "official")
         {
             return true;
         }
     }
     return false;
 }

 /// <summary>
 /// Generates an instruction for an immidiate turn.
 /// </summary>
 /// <param name="countBefore"></param>
 /// <param name="firstStreet"></param>
 /// <param name="firstDirection"></param>
 /// <param name="secondStreet"></param>
 /// <param name="secondDirection"></param>
 /// <param name="pois"></param>
 /// <returns></returns>
 protected override string GenerateImmidiateTurn(int countBefore, TagsCollectionBase firstStreet, RelativeDirection firstDirection, TagsCollectionBase secondStreet, RelativeDirection secondDirection, List<PointPoi> pois)
 {
     countBefore++;
     if (countBefore == 1)
     {
         return string.Format("Take the first turn {0}, on the {1}, and turn immidiately {2} on the {3}.",
             TurnDirection(firstDirection),
             this.GetName("en", firstStreet),
             TurnDirection(secondDirection),
             this.GetName("en", secondStreet));
     }
     else
     {
         return string.Format("Take the {4}d turn {0}, on the {1}, and turn immidiately {2} on the {3}.",
             TurnDirection(firstDirection),
             this.GetName("en", firstStreet),
             TurnDirection(secondDirection),
             this.GetName("en", secondStreet),
             countBefore);
     }
 }

        /// <summary>
        /// Generates an instruction for a direct turn.
        /// </summary>
        /// <param name="instruction"></param>
        /// <param name="street_count_before_turn"></param>
        /// <param name="street_to"></param>
        /// <param name="direction"></param>
        /// <param name="list"></param>
        /// <returns></returns>
        public Instruction GenerateDirectTurn(Instruction instruction, int street_count_before_turn,
            TagsCollectionBase street_to, RelativeDirectionEnum direction, List<PointPoi> list)
        {
            //            if (street_count_before_turn == 1)
            //            {
            //                instruction.Text = string.Format("Neem de 1ste afslag {0}, de {1} op.",
            //                    TurnDirection(direction),
            //                    this.GetName("nl", street_to));
            //            }
            //            else
            //            {
            //                instruction.Text = string.Format("Neem de {0}de afslag {1}, de {2} op.",
            //                    street_count_before_turn,
            //                    TurnDirection(direction),
            //                    this.GetName("nl", street_to));
            //            }
            instruction.Text = string.Format ("Draai {0}", TurnDirection (direction));

            // returns the instruction with text.
            return instruction;
        }

        /// <summary>
        /// Returns true if the edge is a suitable candidate as a target for a point to be resolved on.
        /// </summary>
        /// <param name="vehicle"></param>
        /// <param name="pointTags"></param>
        /// <param name="edgeTags"></param>
        /// <returns></returns>
        public bool MatchWithEdge(Vehicle vehicle,
            TagsCollectionBase pointTags, TagsCollectionBase edgeTags)
        {
            if (pointTags == null || pointTags.Count == 0)
            { // when the point has no tags it has no requirements.
                return true;
            }

            if (edgeTags == null || edgeTags.Count == 0)
            { // when the edge has no tags, no way to verify.
                return false;
            }

            string pointName, edgeName;
            if (pointTags.TryGetValue("name", out pointName) &&
                edgeTags.TryGetValue("name", out edgeName))
            { // both have names.
                return (pointName == edgeName);
            }
            return false;
        }