internal void SerializeStateEntries(StreamMarshaler streamBuffer, bool tagsCannotSpanOverMultipleArcs, float[] pWeights, ref uint iArcOffset, ref int iOffset) { List <Arc> list = _outArcs.ToList(); list.Sort(); Arc arc = (list.Count > 0) ? list[list.Count - 1] : null; IEnumerator <Arc> enumerator = ((IEnumerable <Arc>)list).GetEnumerator(); enumerator.MoveNext(); uint num = (uint)(list.Count + (int)iArcOffset); uint num2 = num; foreach (Arc item in list) { int semanticTagCount = item.SemanticTagCount; if (semanticTagCount > 0) { item.SetArcIndexForTag(0, iArcOffset, tagsCannotSpanOverMultipleArcs); } if (semanticTagCount <= 1) { pWeights[iOffset++] = item.Serialize(streamBuffer, arc == item, iArcOffset++); } else { iArcOffset++; pWeights[iOffset++] = Arc.SerializeExtraEpsilonWithTag(streamBuffer, item, arc == item, num); num = (uint)((int)num + (semanticTagCount - 1)); } } enumerator = ((IEnumerable <Arc>)list).GetEnumerator(); enumerator.MoveNext(); num = num2; foreach (Arc item2 in list) { int semanticTagCount2 = item2.SemanticTagCount; if (semanticTagCount2 > 1) { for (int i = 1; i < semanticTagCount2 - 1; i++) { item2.SetArcIndexForTag(i, iArcOffset, tagsCannotSpanOverMultipleArcs); num++; pWeights[iOffset++] = Arc.SerializeExtraEpsilonWithTag(streamBuffer, item2, true, num); iArcOffset++; } item2.SetArcIndexForTag(semanticTagCount2 - 1, iArcOffset, tagsCannotSpanOverMultipleArcs); pWeights[iOffset++] = item2.Serialize(streamBuffer, true, iArcOffset++); num++; } } }
internal void SerializeStateEntries(StreamMarshaler streamBuffer, bool tagsCannotSpanOverMultipleArcs, float[] pWeights, ref uint iArcOffset, ref int iOffset) { // The arcs must be sorted before being written to disk. List <Arc> outArcs = _outArcs.ToList(); outArcs.Sort(); Arc lastArc = outArcs.Count > 0 ? outArcs[outArcs.Count - 1] : null; IEnumerator <Arc> enumArcs = ((IEnumerable <Arc>)outArcs).GetEnumerator(); enumArcs.MoveNext(); uint nextAvailableArc = (uint)outArcs.Count + iArcOffset; uint saveNextAvailableArc = nextAvailableArc; // Write the arc of the first epsilon arc with an arc has more than one semantic tag foreach (Arc arc in outArcs) { // Create the first arc. int cSemantics = arc.SemanticTagCount; // Set the semantic property reference for the first arc if (cSemantics > 0) { arc.SetArcIndexForTag(0, iArcOffset, tagsCannotSpanOverMultipleArcs); } // Serialize the arc if (cSemantics <= 1) { pWeights[iOffset++] = arc.Serialize(streamBuffer, lastArc == arc, iArcOffset++); } else { // update the position of the current arc ++iArcOffset; // more than one arc, create an epsilon transition pWeights[iOffset++] = Arc.SerializeExtraEpsilonWithTag(streamBuffer, arc, lastArc == arc, nextAvailableArc); // reset the position of the next available slop for an arc nextAvailableArc += (uint)cSemantics - 1; } } enumArcs = ((IEnumerable <Arc>)outArcs).GetEnumerator(); enumArcs.MoveNext(); // revert the position for the new arc nextAvailableArc = saveNextAvailableArc; // write the additional arcs if we have more than one semantic tag foreach (Arc arc in outArcs) { int cSemantics = arc.SemanticTagCount; if (cSemantics > 1) { // If more than 2 arcs insert extra new epsilon states, one per semantic tag for (int i = 1; i < cSemantics - 1; i++) { // Set the semantic property reference arc.SetArcIndexForTag(i, iArcOffset, tagsCannotSpanOverMultipleArcs); // reset the position of the next available slop for an arc nextAvailableArc++; // create an epsilon transition pWeights[iOffset++] = Arc.SerializeExtraEpsilonWithTag(streamBuffer, arc, true, nextAvailableArc); // update the position of the current arc ++iArcOffset; } // Set the semantic property reference arc.SetArcIndexForTag(cSemantics - 1, iArcOffset, tagsCannotSpanOverMultipleArcs); // Add the real arc at the end pWeights[iOffset++] = arc.Serialize(streamBuffer, true, iArcOffset++); // reset the position of the next available slop for an arc nextAvailableArc++; } } }