/// <summary> /// Writes the content of this instance to a persistent storage area. /// </summary> /// <param name="es">The mechanism for storing content.</param> public override void WriteData(EditSerializer es) { base.WriteData(es); es.WriteString(DataField.UserName, this.UserName); es.WriteString(DataField.MachineName, this.MachineName); }
/// <summary> /// Writes the content of this instance to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> public override void WriteData(EditSerializer editSerializer) { base.WriteData(editSerializer); // Nothing to do - the relevant info should have come out via the geometry object attached // to the created line feature Debug.Assert(base.Line.LineGeometry is SegmentGeometry); }
/// <summary> /// Writes the content of this instance to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> public override void WriteData(EditSerializer editSerializer) { base.WriteData(editSerializer); // Let the base class do it // ArcFeature arc = (ArcFeature)base.Line; // editSerializer.WritePersistent<ArcFeature>("Line", arc); }
/// <summary> /// Writes the content of this instance to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> public override void WriteData(EditSerializer editSerializer) { // Do nothing - line features that are represented by simple line segments // do not need to be written out (see comment in LineFeature.WriteData). // This method should therefore never get called (I am virtually certain // that it would not be used in any other context). throw new ApplicationException("Unexpected call to SegmentGeometry.WriteData"); }
/// <summary> /// Writes the content of this instance to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> public override void WriteData(EditSerializer editSerializer) { editSerializer.WriteDouble(DataField.Value, ObservedValue); editSerializer.WriteByte(DataField.Unit, (byte)m_EnteredUnit.UnitType); if (m_IsFixed) { editSerializer.WriteBool(DataField.Fixed, true); } if (IsAnnotationFlipped) { editSerializer.WriteBool(DataField.Flipped, true); } }
/// <summary> /// Writes the content of this instance to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> public override void WriteData(EditSerializer editSerializer) { base.WriteData(editSerializer); editSerializer.WriteFeatureRef <LineFeature>(DataField.Line, m_Line); editSerializer.WritePersistent <LineSubdivisionFace>(DataField.Face, m_Face); // When we initially write the primary face, this will always be undefined. Only the // alternate face will write out the reference to the other side. if (OtherSide != null) { editSerializer.WriteInternalId(DataField.OtherSide, OtherSide.InternalId); } editSerializer.WriteEntity(DataField.PointType, EditingController.Current.Project.DefaultPointType); editSerializer.WriteIdMappings(DataField.Ids, this.Features); }
/// <summary> /// Writes the content of this instance to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> public override void WriteData(EditSerializer editSerializer) { base.WriteData(editSerializer); editSerializer.WritePersistent <Direction>(DataField.Direction1, m_Direction1); editSerializer.WritePersistent <Direction>(DataField.Direction2, m_Direction2); editSerializer.WritePersistent <FeatureStub>(DataField.To, new FeatureStub(m_To)); if (m_Line1 != null) { editSerializer.WritePersistent <FeatureStub>(DataField.Line1, new FeatureStub(m_Line1)); } if (m_Line2 != null) { editSerializer.WritePersistent <FeatureStub>(DataField.Line2, new FeatureStub(m_Line2)); } }
/// <summary> /// Writes the content of this instance to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> public override void WriteData(EditSerializer editSerializer) { base.WriteData(editSerializer); editSerializer.WritePersistent <Direction>(DataField.Direction, m_Direction); editSerializer.WritePersistent <Observation>(DataField.Distance, m_Distance); editSerializer.WriteFeatureRef <PointFeature>(DataField.From, m_From); editSerializer.WriteBool(DataField.Default, m_Default); editSerializer.WritePersistent <FeatureStub>(DataField.To, new FeatureStub(m_To)); if (m_DirLine != null) { editSerializer.WritePersistent <FeatureStub>(DataField.DirLine, new FeatureStub(m_DirLine)); } if (m_DistLine != null) { editSerializer.WritePersistent <FeatureStub>(DataField.DistLine, new FeatureStub(m_DistLine)); } }
/// <summary> /// Writes the content of this instance to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> public override void WriteData(EditSerializer editSerializer) { base.WriteData(editSerializer); editSerializer.WritePersistent <Observation>(DataField.Distance1, m_Distance1); editSerializer.WriteFeatureRef <PointFeature>(DataField.From1, m_From1); editSerializer.WritePersistent <Observation>(DataField.Distance2, m_Distance2); editSerializer.WriteFeatureRef <PointFeature>(DataField.From2, m_From2); editSerializer.WriteBool(DataField.Default, m_Default); editSerializer.WritePersistent <FeatureStub>(DataField.To, new FeatureStub(m_To)); if (m_Line1 != null) { editSerializer.WritePersistent <FeatureStub>(DataField.Line1, new FeatureStub(m_Line1)); } if (m_Line2 != null) { editSerializer.WritePersistent <FeatureStub>(DataField.Line2, new FeatureStub(m_Line2)); } }
/// <summary> /// Writes the content of this instance to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> public override void WriteData(EditSerializer editSerializer) { base.WriteData(editSerializer); editSerializer.WriteFeatureRef <PointFeature>(DataField.Center, m_Center); editSerializer.WritePersistent <Observation>(DataField.Radius, m_Radius); // Record a closing point only if it was created by this edit -- in that case, the radius must // be a plain Distance (if the radius is defined using an OffsetPoint observation, the closing // point will coincide with the offset point itself -- we don't have to write anything further, // because the reference to the offset point is part of the observation object written above). if (Line.StartPoint.Creator == this) { Debug.Assert(m_Radius is Distance); editSerializer.WritePersistent <FeatureStub>(DataField.ClosingPoint, new FeatureStub(Line.StartPoint)); } else { Debug.Assert(m_Radius is OffsetPoint); } editSerializer.WritePersistent <FeatureStub>(DataField.Arc, new FeatureStub(Line)); }
/// <summary> /// Writes the content of this instance to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> public override void WriteData(EditSerializer editSerializer) { base.WriteData(editSerializer); editSerializer.WritePersistent <Direction>(DataField.Direction, m_Direction); editSerializer.WriteFeatureRef <LineFeature>(DataField.Line, m_Line); editSerializer.WriteFeatureRef <PointFeature>(DataField.CloseTo, m_CloseTo); editSerializer.WritePersistent <FeatureStub>(DataField.To, new FeatureStub(m_Intersection)); if (m_DirLine != null) { editSerializer.WritePersistent <FeatureStub>(DataField.DirLine, new FeatureStub(m_DirLine)); } if (m_LineA != null) { editSerializer.WriteInternalId(DataField.SplitBefore, m_LineA.InternalId); } if (m_LineB != null) { editSerializer.WriteInternalId(DataField.SplitAfter, m_LineB.InternalId); } }
/// <summary> /// Writes the content of this instance to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> public void WriteData(EditSerializer editSerializer) { editSerializer.WriteInternalId(DataField.Id, m_InternalId); editSerializer.WriteUInt32(DataField.Key, m_RawId); }
/// <summary> /// Writes updates for an editing operation to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> /// <param name="data">The collection of changes to write</param> public void WriteUpdateItems(EditSerializer editSerializer, UpdateItemCollection data) { data.WriteItem<double>(editSerializer, DataField.X); data.WriteItem<double>(editSerializer, DataField.Y); }
/// <summary> /// Writes updates for an editing operation to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> /// <param name="data">The collection of changes to write</param> public void WriteUpdateItems(EditSerializer editSerializer, UpdateItemCollection data) { throw new NotImplementedException(); }
/// <summary> /// Writes the content of this instance to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> public override void WriteData(EditSerializer editSerializer) { base.WriteData(editSerializer); if (m_Revisions.Length == 1) m_Revisions[0].WriteData(editSerializer); else editSerializer.WritePersistentArray<RevisedEdit>(DataField.RevisedEdits, m_Revisions); }
/// <summary> /// Writes the content of this instance to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> public abstract void WriteData(EditSerializer editSerializer);
/// <summary> /// Writes the content of this instance to a persistent storage area. /// </summary> /// <param name="es">The mechanism for storing content.</param> public override void WriteData(EditSerializer es) { base.WriteData(es); es.WriteString(DataField.ProjectId, this.ProjectId.ToString().ToUpper()); es.WriteString(DataField.ProjectName, this.ProjectName); es.WriteInt32(DataField.LayerId, this.LayerId); es.WriteString(DataField.CoordinateSystem, this.DefaultSystem); es.WriteString(DataField.UserName, this.UserName); es.WriteString(DataField.MachineName, this.MachineName); }
/// <summary> /// Writes the content of this instance to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> public override void WriteData(EditSerializer editSerializer) { base.WriteData(editSerializer); editSerializer.WriteFeatureRefArray <Feature>(DataField.Delete, m_Deletions.ToArray()); }
/// <summary> /// Writes the content of this instance to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> public override void WriteData(EditSerializer editSerializer) { base.WriteData(editSerializer); editSerializer.WriteFeatureRef<LineFeature>(DataField.Line, m_Line); editSerializer.WriteUInt32(DataField.PositionRatio, m_PositionRatio); editSerializer.WritePersistent<FeatureStub>(DataField.Point, new FeatureStub(m_Point)); }
/// <summary> /// Writes updates for an editing operation to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> /// <param name="data">The collection of changes to write</param> public void WriteUpdateItems(EditSerializer editSerializer, UpdateItemCollection data) { data.WriteObservation<Distance>(editSerializer, DataField.Distance); data.WriteItem<bool>(editSerializer, DataField.EntryFromEnd); }
/// <summary> /// Writes the content of this instance to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> public override void WriteData(EditSerializer editSerializer) { base.WriteData(editSerializer); editSerializer.WriteFeatureRef<LineFeature>(DataField.Line, m_Line); editSerializer.WritePersistent<Distance>(DataField.Distance, m_Distance); editSerializer.WriteBool(DataField.EntryFromEnd, m_IsFromEnd); editSerializer.WritePersistent<FeatureStub>(DataField.NewPoint, new FeatureStub(m_NewPoint)); editSerializer.WriteInternalId(DataField.NewLine1, m_NewLine1.InternalId); editSerializer.WriteInternalId(DataField.NewLine2, m_NewLine2.InternalId); }
/// <summary> /// Writes the content of this instance to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> public virtual void WriteData(EditSerializer editSerializer) { if (m_Font != null) editSerializer.WriteInt32(DataField.Font, m_Font.Id); editSerializer.WritePointGeometry(DataField.X, DataField.Y, m_Position); editSerializer.WriteDouble(DataField.Width, Math.Round((double)m_Width, 2)); editSerializer.WriteDouble(DataField.Height, Math.Round((double)m_Height, 2)); // TODO: May want to cover indirect rotations editSerializer.WriteRadians(DataField.Rotation, new RadianValue(m_Rotation.Radians)); }
/// <summary> /// Writes the content of this instance to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> public override void WriteData(EditSerializer editSerializer) { base.WriteData(editSerializer); editSerializer.WriteFeatureRefArray<LineFeature>(DataField.Lines, m_Lines); editSerializer.WriteFeatureRefArray<PointFeature>(DataField.Points, m_Points); }
/// <summary> /// Writes updates for an editing operation to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> /// <param name="data">The collection of changes to write</param> public void WriteUpdateItems(EditSerializer editSerializer, UpdateItemCollection data) { data.WriteFeature <PointFeature>(editSerializer, DataField.UpdatedPoint); data.WriteItem <double>(editSerializer, DataField.X); data.WriteItem <double>(editSerializer, DataField.Y); }
/// <summary> /// Writes the content of this instance to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> public void WriteData(EditSerializer editSerializer) { editSerializer.WriteInternalId(DataField.RevisedEdit, m_Edit.InternalId); (m_Edit as IRevisable).WriteUpdateItems(editSerializer, m_Changes); }
/// <summary> /// Writes the content of this instance to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> public override void WriteData(EditSerializer editSerializer) { base.WriteData(editSerializer); editSerializer.WriteRadians(DataField.Value, new RadianValue(m_Rotation)); }
/// <summary> /// Writes the content of this instance to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> public override void WriteData(EditSerializer editSerializer) { base.WriteData(editSerializer); editSerializer.WriteString(DataField.Source, m_Source); editSerializer.WritePersistentArray <Feature>(DataField.Features, this.Features); }
/// <summary> /// Writes the content of this instance to a persistent storage area. /// </summary> /// <param name="es">The mechanism for storing content.</param> public override void WriteData(EditSerializer es) { base.WriteData(es); es.WriteInt32(DataField.GroupId, this.GroupId); es.WriteInt32(DataField.LowestId, this.LowestId); es.WriteInt32(DataField.HighestId, this.HighestId); }
/// <summary> /// Writes the content of this instance to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> public virtual void WriteData(EditSerializer editSerializer) { editSerializer.WriteUInt32(DataField.Id, m_Sequence); editSerializer.WriteDateTime(DataField.When, m_When); }
/// <summary> /// Writes the content of this instance to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> public override void WriteData(EditSerializer editSerializer) { editSerializer.WriteFeatureRef <PointFeature>(DataField.Point, m_Point); }
/// <summary> /// Writes the content of this instance to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> public void WriteData(EditSerializer editSerializer) { editSerializer.WriteInternalId(DataField.Id, m_InternalId); editSerializer.WriteEntity(DataField.Entity, m_What); editSerializer.WriteFeatureId(m_Id); }
/// <summary> /// Writes the content of this instance to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> public override void WriteData(EditSerializer editSerializer) { base.WriteData(editSerializer); editSerializer.WritePersistent <PointFeature>(DataField.Point, m_NewPoint); }
/// <summary> /// Writes updates for an editing operation to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> /// <param name="data">The collection of changes to write</param> public void WriteUpdateItems(EditSerializer editSerializer, UpdateItemCollection data) { data.WriteObservation <Direction>(editSerializer, DataField.Direction1); data.WriteObservation <Direction>(editSerializer, DataField.Direction2); }
/// <summary> /// Writes the content of this instance to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> public override void WriteData(EditSerializer editSerializer) { base.WriteData(editSerializer); editSerializer.WriteFeatureRefArray<Feature>(DataField.Delete, m_Deletions.ToArray()); }
/// <summary> /// Writes the content of this instance to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> public override void WriteData(EditSerializer editSerializer) { base.WriteData(editSerializer); editSerializer.WritePersistent<PointFeature>(DataField.Point, m_NewPoint); }
/// <summary> /// Writes the content of this instance to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> public override void WriteData(EditSerializer editSerializer) { base.WriteData(editSerializer); }
/// <summary> /// Writes updates for an editing operation to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> /// <param name="data">The collection of changes to write</param> public void WriteUpdateItems(EditSerializer editSerializer, UpdateItemCollection data) { data.WriteItem <bool>(editSerializer, DataField.ExtendFromEnd); data.WriteObservation <Distance>(editSerializer, DataField.Distance); }
/// <summary> /// Writes the content of this instance to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> public void WriteData(EditSerializer editSerializer) { editSerializer.WriteInternalId(DataField.Id, this.Sequence); if (Leg.PrimaryFace != this) editSerializer.WriteInternalId(DataField.PrimaryFaceId, Leg.PrimaryFace.Sequence); editSerializer.WriteString(DataField.EntryString, GetEntryString(null)); }
/// <summary> /// Writes the content of this instance to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> public override void WriteData(EditSerializer editSerializer) { editSerializer.WriteFeatureRef<LineFeature>(DataField.Base, m_Base); }
/// <summary> /// Writes the content of this instance to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> public override void WriteData(EditSerializer editSerializer) { base.WriteData(editSerializer); editSerializer.WriteFeatureRef<PointFeature>(DataField.Center, m_Center); editSerializer.WritePersistent<Observation>(DataField.Radius, m_Radius); // Record a closing point only if it was created by this edit -- in that case, the radius must // be a plain Distance (if the radius is defined using an OffsetPoint observation, the closing // point will coincide with the offset point itself -- we don't have to write anything further, // because the reference to the offset point is part of the observation object written above). if (Line.StartPoint.Creator == this) { Debug.Assert(m_Radius is Distance); editSerializer.WritePersistent<FeatureStub>(DataField.ClosingPoint, new FeatureStub(Line.StartPoint)); } else { Debug.Assert(m_Radius is OffsetPoint); } editSerializer.WritePersistent<FeatureStub>(DataField.Arc, new FeatureStub(Line)); }
/// <summary> /// Writes the content of this instance to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> public override void WriteData(EditSerializer editSerializer) { base.WriteData(editSerializer); editSerializer.WritePersistentArray <PointFeature>(DataField.Points, m_Features.ToArray()); }
/// <summary> /// Writes the content of this instance to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> public override void WriteData(EditSerializer editSerializer) { base.WriteData(editSerializer); editSerializer.WriteFeatureRefArray <LineFeature>(DataField.Lines, m_Lines); editSerializer.WriteFeatureRefArray <PointFeature>(DataField.Points, m_Points); }
/// <summary> /// Writes the content of this instance to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> public override void WriteData(EditSerializer editSerializer) { base.WriteData(editSerializer); editSerializer.WriteFeatureRef<PointFeature>(DataField.From, m_From); editSerializer.WriteFeatureRef<PointFeature>(DataField.To, m_To); editSerializer.WriteString(DataField.EntryString, m_EntryString); editSerializer.WriteDistanceUnit(DataField.DefaultEntryUnit, m_DefaultEntryUnit); editSerializer.WriteEntity(DataField.PointType, EditingController.Current.Project.DefaultPointType); editSerializer.WriteEntity(DataField.LineType, EditingController.Current.Project.DefaultLineType); editSerializer.WriteIdMappings(DataField.Ids, this.Features); }
/// <summary> /// Writes the content of this instance to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> public override void WriteData(EditSerializer editSerializer) { base.WriteData(editSerializer); editSerializer.WriteFeatureRef <LineFeature>(DataField.Line, m_Line); editSerializer.WriteBool(DataField.Topological, m_Topological); }
/// <summary> /// Writes the content of this instance to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> public override void WriteData(EditSerializer editSerializer) { editSerializer.WritePersistent <Distance>(DataField.Offset, m_Offset); editSerializer.WriteBool(DataField.Left, m_IsLeft); }
/// <summary> /// Writes the content of this instance to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> public override void WriteData(EditSerializer editSerializer) { base.WriteData(editSerializer); editSerializer.WriteFeatureRef<LineFeature>(DataField.Line, m_Line); editSerializer.WriteBool(DataField.Topological, m_Topological); }
/// <summary> /// Represents this editing operation as a text string. /// </summary> /// <returns>A string that can be used to save a persistent version of this edit.</returns> internal string GetEditString() { EditSerializer es = new EditSerializer(); es.WritePersistent<Operation>(DataField.Edit, this); return es.ToSerializedString(); }
/// <summary> /// Writes the content of this instance to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> public void WriteData(EditSerializer editSerializer) { editSerializer.WriteBool(DataField.EntryFromEnd, m_IsEntryFromEnd); editSerializer.WritePersistentArray <Distance>(DataField.Sections, m_Distances); }
/// <summary> /// Writes the content of this instance to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> public override void WriteData(EditSerializer editSerializer) { base.WriteData(editSerializer); editSerializer.WriteFeatureRef<PointFeature>(DataField.From, m_From); editSerializer.WriteFeatureRef<PointFeature>(DataField.To, m_To); editSerializer.WriteBool(DataField.Topological, IsTopological); // For simple line segments (perhaps 80% of the case when dealing with cadastral // data), we already have what we need with the from & to points. if (!(m_Geom is SegmentGeometry)) editSerializer.WritePersistent<LineGeometry>(DataField.Type, m_Geom); }
/// <summary> /// Writes updates for an editing operation to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> /// <param name="data">The collection of changes to write</param> public void WriteUpdateItems(EditSerializer editSerializer, UpdateItemCollection data) { data.WriteObservation <Direction>(editSerializer, DataField.Direction); data.WriteFeature <LineFeature>(editSerializer, DataField.Line); data.WriteFeature <PointFeature>(editSerializer, DataField.CloseTo); }
/// <summary> /// Writes the content of this instance to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> public override void WriteData(EditSerializer editSerializer) { base.WriteData(editSerializer); editSerializer.WriteFeatureRef<PointFeature>(DataField.Backsight, m_Backsight); editSerializer.WriteFeatureRef<PointFeature>(DataField.From, m_From); editSerializer.WriteRadians(DataField.Value, m_Observation); }