public void Constructor_Member_CreatesNewRelationMembeAndSetsMember()
{
Node member = new Node(11);
RelationMember target = new RelationMember(member);
Assert.Same(member, target.Member);
Assert.True(string.IsNullOrEmpty(target.Role));
}
public void Constructor_Member_Role_CreatesRelationMemberAndSetsMemberAndRole()
{
Node member = new Node(11);
string role = "role";
RelationMember target = new RelationMember(member, role);
Assert.Same(member, target.Member);
Assert.Equal(role, target.Role);
}
public void Constructor_int_IEnumerable_CreatesRelationWithMembersAndInitializesProperties()
{
int id = 11;
var members = new RelationMember[] { new RelationMember(new Node(1)), new RelationMember(new Node(2)), new RelationMember(new Node(3)) };
Relation target = new Relation(id, members);
Assert.Equal(id, target.ID);
Assert.Equal(members.Length, target.Geometries.Count);
for (int i = 0; i < members.Length; i++) {
Assert.Same(members[i], target.Geometries[i]);
}
Assert.Empty(target.Tags);
}
public void Constructor_int_tags_CreatesRelationAndIntializesProperties()
{
int id = 11;
var members = new RelationMember[] { new RelationMember(new Node(1)), new RelationMember(new Node(2)), new RelationMember(new Node(3)) };
TagsCollection tags = new TagsCollection();
Relation target = new Relation(id, members, tags);
Assert.Equal(id, target.ID);
Assert.Equal(members.Length, target.Geometries.Count);
for (int i = 0; i < members.Length; i++) {
Assert.Same(members[i], target.Geometries[i]);
}
Assert.Same(tags, target.Tags);
}
/// <summary>
/// Initializes a new instance of the RelationMemberInfo structure with values from specific RelationMember.
/// </summary>
/// <param name="source">The RelationMember object to copy valyes from.</param>
public RelationMemberInfo(RelationMember source)
{
this.Reference = source.Member.ID;
this.MemberType = source.MemberType;
this.Role = source.Role;
}
/// <summary>
/// Creates a new instaance of the OsmDatabase class and loads data from specific IOsmReader into it.
/// </summary>
/// <param name="reader">The IOsmReader to read data from.</param>
/// <param name="ignoreReferentialErrors">A value indicatings whether Load function should skip geometries that reference miising geometries.</param>
/// <returns>New instance of the OsmDatabase class with data loaded from specified reader.</returns>
public static OsmGeometryDatabase Load(IOsmReader reader, bool ignoreReferentialErrors)
{
OsmGeometryDatabase db = new OsmGeometryDatabase();
List <RelationInfo> relations = new List <RelationInfo>();
IEntityInfo entityInfo = null;
while ((entityInfo = reader.Read()) != null)
{
switch (entityInfo.EntityType)
{
case EntityType.Node: db.Nodes.Add(Node.FromNodeInfo(entityInfo as NodeInfo)); break;
case EntityType.Way:
Way toAdd = Way.FromWayInfo(entityInfo as WayInfo, db, !ignoreReferentialErrors);
if (toAdd == null)
{
if (!ignoreReferentialErrors)
{
throw new ArgumentException(string.Format("Way (ID = {0}) references missing node.", entityInfo.ID));
}
}
else
{
db.Ways.Add(toAdd);
}
break;
case EntityType.Relation:
RelationInfo ri = entityInfo as RelationInfo;
db.Relations.Add(new Relation(ri.ID)
{
Tags = ri.Tags, Metadata = ri.Metadata
});
relations.Add(ri);
break;
}
}
foreach (var relationInfo in relations)
{
Relation relation = db.Relations[relationInfo.ID];
foreach (var memberInfo in relationInfo.Members)
{
RelationMember member = RelationMember.FromRelationMemberInfo(memberInfo, db, false);
if (member == null)
{
if (!ignoreReferentialErrors)
{
throw new ArgumentException(string.Format("Relation (ID = {0}) references missing OSM entity.", memberInfo.Reference));
}
db.Relations.Remove(relation);
}
else
{
relation.Geometries.Add(member);
}
}
}
return(db);
}
public void MemberType_ReturnsCorrectValueForWay()
{
RelationMember target = new RelationMember(new Way(11));
Assert.Equal(EntityType.Way, target.MemberType);
}
public void MemberType_ReturnsCorrectValueForNode()
{
RelationMember target = new RelationMember(new Node(11));
Assert.Equal(EntityType.Node, target.MemberType);
}
public void IsMeasured_GetsTrueForMeasuredMember()
{
Mock<Node> memberM = new Mock<Node>(11);
memberM.SetupGet(property => property.IsMeasured).Returns(true);
RelationMember target = new RelationMember(memberM.Object);
Assert.Equal(memberM.Object.IsMeasured, target.IsMeasured);
}
public void Is3D_GetsFalseFor2DMember()
{
Mock<Node> memberM = new Mock<Node>(11);
memberM.SetupGet(property => property.Is3D).Returns(false);
RelationMember target = new RelationMember(memberM.Object);
Assert.Equal(memberM.Object.Is3D, target.Is3D);
}
public void GetEnvelopeReturnsMembersEnvelope()
{
Envelope expectedEnvelope = new Envelope(new Coordinate(1.1, 2.2));
Mock<Way> member = new Mock<Way>(11);
member.Setup(function => function.GetEnvelope()).Returns(expectedEnvelope);
RelationMember target = new RelationMember(member.Object);
Assert.Same(expectedEnvelope, target.GetEnvelope());
}
/// <summary>
/// Creates a new instance of the RelationMember class based on the data from RelationInfo object.
/// </summary>
/// <param name="info">The RelationMemberInfo object that contains data about member.</param>
/// <param name="entities">The entities that can be referenced by RelationMember.</param>
/// <param name="throwOnMissing">bool value indicating whether references to the missing entity should cause exception.</param>
/// <returns>The RelationMember object created from RelationMemberInfo or null if referenced node is missing.</returns>
public static RelationMember FromRelationMemberInfo(RelationMemberInfo info, IEntityCollection<IOsmGeometry> entities, bool throwOnMissing)
{
if (info.MemberType == EntityType.Unknown) {
throw new ArgumentException("info.MemberType cannot be EntityType.Unknown");
}
if (entities.Contains(info.Reference, info.MemberType) == false) {
if (throwOnMissing) {
throw new ArgumentException(string.Format("Referenced Entity (ID = {0}, type = {1}) not found in entities collection.", info.Reference, info.MemberType), "info.Reference");
}
else {
return null;
}
}
RelationMember result = new RelationMember(entities[info.Reference, info.MemberType], info.Role) { MemberType = info.MemberType };
if (result.Member.EntityType != info.MemberType) {
throw new ArgumentException("Type of the referenced entity doesn't match type of the entity in the collection.");
}
return result;
}
