youmuliu/stgsharp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

daily update on 20250109 by nitload youmu, building STEP file reader

Browse Source
This commit is contained in:
Nitload
2025-01-09 07:28:07 +08:00
parent 63c3cd17e2
commit 6cfaa42ff3
84 changed files with 6688 additions and 922 deletions
Download Patch File Download Diff File Expand all files Collapse all files
内核源代码/StgSharp.Modeling/STEP/STEP.cs
+47
View File
@@ -0,0 +1,47 @@
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
// file="STEP.cs"
// Project: StgSharp
// AuthorGroup: Nitload Space
// Copyright (c) Nitload Space. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the “Software”), to deal in the Software without restriction,
// including without limitation the rights to use, copy, modify, merge,
// publish, distribute, sublicense, and/or sell copies of the Software,
// and to permit persons to whom the Software is furnished to do so,
// subject to the following conditions:
//
// The above copyright notice and
// this permission notice shall be included in all copies
// or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED “AS IS”,
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
// ARISING FROM, OUT OF OR IN CONNECTION WITH
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Text;
namespace StgSharp.Modeling.STEP
{
public class STEP
{
private ConcurrentDictionary<int, STEPExpression> _node = new ConcurrentDictionary<int, STEPExpression>(
);
private STEPInfo
_header;
}
}
内核源代码/StgSharp.Modeling/STEP/STEPDataNode.cs
+77
View File
@@ -0,0 +1,77 @@
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
// file="STEPDataNode.cs"
// Project: StgSharp
// AuthorGroup: Nitload Space
// Copyright (c) Nitload Space. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the “Software”), to deal in the Software without restriction,
// including without limitation the rights to use, copy, modify, merge,
// publish, distribute, sublicense, and/or sell copies of the Software,
// and to permit persons to whom the Software is furnished to do so,
// subject to the following conditions:
//
// The above copyright notice and
// this permission notice shall be included in all copies
// or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED “AS IS”,
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
// ARISING FROM, OUT OF OR IN CONNECTION WITH
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;
namespace StgSharp.Modeling.STEP
{
public static class STEPDataParser
{
private static Regex _stringParser = new Regex(
@"(\(\s?'|')\s*(?<value>.+)\s*('\s*\)|')", RegexOptions.Compiled );
public static DateTime ToDateTime( string source )
{
Match match = _stringParser.Match( source );
if( match.Success ) {
return DateTime.Parse( match.Groups[ "value" ].Value );
}
throw new InvalidCastException();
}
public static string ToString( string source )
{
Match match = _stringParser.Match( source );
if( match.Success ) {
return match.Groups[ "value" ].Value;
}
return string.Empty;
}
public static (int, int?) ToVersion( string source )
{
Match match = _stringParser.Match( source );
if( match.Success ) {
string data = match.Groups[ "value" ].Value;
if( data.Contains( ';' ) ) {
string[] subdata = data.Split( ';' );
return (int.Parse( subdata[ 0 ] ), int.Parse( subdata[ 1 ] ));
}
return (int.Parse( data ), null);
}
return (-1,-1);
}
}
}
内核源代码/StgSharp.Modeling/STEP/STEPDataReader.cs
+153
View File
@@ -0,0 +1,153 @@
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
// file="STEPDataReader.cs"
// Project: StgSharp
// AuthorGroup: Nitload Space
// Copyright (c) Nitload Space. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the “Software”), to deal in the Software without restriction,
// including without limitation the rights to use, copy, modify, merge,
// publish, distribute, sublicense, and/or sell copies of the Software,
// and to permit persons to whom the Software is furnished to do so,
// subject to the following conditions:
//
// The above copyright notice and
// this permission notice shall be included in all copies
// or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED “AS IS”,
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
// ARISING FROM, OUT OF OR IN CONNECTION WITH
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.IO.MemoryMappedFiles;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
namespace StgSharp.Modeling.STEP
{
public partial class STEPReader
{
private static Regex _expressionSplitterWithID = new Regex(
@"^#(?<ID>[0-9]+)\s*=\s*(?<CALLER>[A-Z_]+)\s?\(\s?(?<PARAMS>.+?)\s*\)\s*;",
RegexOptions.Compiled );
private ConcurrentDictionary<int, STEPExpression> cache = new ConcurrentDictionary<int, STEPExpression>(
);
private int _readCount = 0, _analyseCount = 0;
public Task AnalyseDataSection( ConcurrentQueue<STEPExpression> index )
{
return Task.Run(
() => {
if( _analyseCount == 1 ) {
throw new InvalidOperationException(
"Cannot read a STEP file while an other thread is reading" );
}
Interlocked.Exchange( ref _analyseCount, 1 );
STEPExpression exp = null;
while( exp != null && exp.Caller != "ENDSEC" ) {
if( index.TryDequeue( out exp ) ) {
//TODO 写一个Token向几何构造器的转换方法
}
}
;
Interlocked.Exchange( ref _analyseCount, 0 );
} );
}
public Task ReadDataSection( out ConcurrentQueue<STEPExpression> queue )
{
ConcurrentQueue<STEPExpression> expressionQueue = new ConcurrentQueue<STEPExpression>(
);
queue = expressionQueue;
return Task.Run(
() => {
if( _readCount == 1 ) {
throw new InvalidOperationException(
"Cannot read a STEP file while an other thread is reading" );
}
Interlocked.Exchange( ref _readCount, 1 );
using( MemoryMappedViewStream ms = _memoryFile.CreateViewStream(
0, _size, MemoryMappedFileAccess.Read ) ) {
using( StreamReader reader = new StreamReader( ms ) ) {
string line = string.Empty;
long pos = _dataStart;
reader.BaseStream.Seek( pos, SeekOrigin.Begin );
do {
line = ReadToken( reader, ref pos );
if( line == "DATA;" ) {
continue;
}
if( line == "ENDSEC;" ) {
expressionQueue.Enqueue(
new STEPExpression(
-1, "ENDSEC", string.Empty ) );
break;
}
Match match = _expressionSplitterWithID.Match(
line );
if( match.Success ) {
int id = int.Parse(
match.Groups[ "ID" ].Value );
STEPExpression exp = new STEPExpression(
id, match.Groups[ "CALLER" ].Value,
match.Groups[ "PARAMS" ].Value );
AddExpressionToCache(id, exp);
expressionQueue.Enqueue( exp );
}
} while (true);
}
}
Interlocked.Exchange( ref _readCount, 0 );
} );
}
private void AddExpressionToCache( int id, STEPExpression expression )
{
if( expression == null ) {
throw new ArgumentNullException( nameof( expression ) );
}
if( cache.TryGetValue( id,
out STEPExpression exp ) && exp.Caller !=
STEPExpression.TempCallerName ) {
throw new InvalidOperationException(
"Cannot add an expression to cache with the same id" );
}
cache.AddOrUpdate( id, expression, ( _, _ ) => expression );
}
private STEPExpression GetExpressionFromCache( int id )
{
if( cache.TryGetValue( id, out STEPExpression expression ) ) {
return expression;
}
STEPExpression tempCaller = STEPExpression.CreateTempExpression(id);
cache.AddOrUpdate(id, tempCaller, (_, newExpression) =>
{
tempCaller = newExpression;
return newExpression;
});
return tempCaller;
}
}
}
内核源代码/StgSharp.Modeling/STEP/STEPExpression.cs
+102
View File
@@ -0,0 +1,102 @@
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
// file="STEPExpression.cs"
// Project: StgSharp
// AuthorGroup: Nitload Space
// Copyright (c) Nitload Space. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the “Software”), to deal in the Software without restriction,
// including without limitation the rights to use, copy, modify, merge,
// publish, distribute, sublicense, and/or sell copies of the Software,
// and to permit persons to whom the Software is furnished to do so,
// subject to the following conditions:
//
// The above copyright notice and
// this permission notice shall be included in all copies
// or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED “AS IS”,
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
// ARISING FROM, OUT OF OR IN CONNECTION WITH
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
using StgSharp;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Runtime.CompilerServices;
using System.Text;
using System.Text.RegularExpressions;
namespace StgSharp.Modeling.STEP
{
public class STEPExpression
{
private static Regex regex = new Regex(
@"(?<param1>.+?(\)|'\s?\)|'))\s?(?<sepcomma>,)\s?(?<other>(.|\(|\(\s?').+)",
RegexOptions.Compiled );
private readonly int _id;
private readonly List<string> _paramList;
private string _caller;
public static string TempCallerName
{
get => "TEMPCALLER";
}
public STEPExpression( int id, string caller, string parameters )
{
_caller = caller;
_paramList = new List<string>();
SplitParameter( parameters );
}
public string this[ int paramIndex ]
{
get => _paramList[ paramIndex ];
}
public ReadOnlyCollection<string> ParamList
{
get => _paramList.AsReadOnly();
}
public string Caller
{
get => _caller;
internal set => _caller = value;
}
public static STEPExpression CreateTempExpression( int id )
{
return new STEPExpression( id, "TEMPCALLER", string.Empty );
}
private void SplitParameter( string parameters )
{
if( string.IsNullOrEmpty( parameters ) || string.IsNullOrWhiteSpace(
parameters ) ) {
return;
}
Match match = regex.Match( parameters );
while( match.Success ) {
_paramList.Add( match.Groups[ "param1" ].Value );
parameters = match.Groups[ "other" ].Value;
match = regex.Match( parameters );
}
_paramList.Add( parameters );
}
}
}
内核源代码/StgSharp.Modeling/STEP/STEPHeadReader.cs
+116
View File
@@ -0,0 +1,116 @@
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
// file="STEPHeadReader.cs"
// Project: StgSharp
// AuthorGroup: Nitload Space
// Copyright (c) Nitload Space. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the ¡°Software¡±), to deal in the Software without restriction,
// including without limitation the rights to use, copy, modify, merge,
// publish, distribute, sublicense, and/or sell copies of the Software,
// and to permit persons to whom the Software is furnished to do so,
// subject to the following conditions:
//
// The above copyright notice and
// this permission notice shall be included in all copies
// or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED ¡°AS IS¡±,
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
// ARISING FROM, OUT OF OR IN CONNECTION WITH
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.IO;
using System.IO.MemoryMappedFiles;
using System.Runtime.Serialization;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
namespace StgSharp.Modeling.STEP
{
public partial class STEPReader
{
/**/
private static Regex expressionSplitter = new Regex(
@"^(?<CALLER>[A-Z_]+)\s?\((?<PARAM>.+)\)\;",
RegexOptions.Compiled );
public Task<STEPInfo> GetInfo()
{
return Task<STEPInfo>.Run<STEPInfo>(
() => {
STEPInfo info = new STEPInfo();
List<STEPExpression> expressionList = new List<STEPExpression>(
);
using( MemoryMappedViewStream ms = _memoryFile.CreateViewStream(
0, _size, MemoryMappedFileAccess.Read ) ) {
using( StreamReader sr = new StreamReader( ms ) ) {
long pos = _headStart;
ms.Seek( _headStart, SeekOrigin.Begin );
while( pos <= _headEnd ) {
string token = ReadToken( sr, ref pos );
if( token == "HEADER;" ) {
continue;
}
if( token == "ENDSEC;" ) {
break;
}
GroupCollection match = expressionSplitter.Match(
token )
.Groups;
expressionList.Add(
new STEPExpression(
0, match[ "CALLER" ].ToString(),
match[ "PARAM" ].ToString() ) );
}
foreach( STEPExpression expression in expressionList ) {
switch( expression.Caller ) {
case "FILE_DESCRIPTION":
info.Description = STEPDataParser.ToString(
expression[ 0 ] );
info.Level = STEPDataParser.ToVersion(
expression[ 1 ] );
break;
case "FILE_NAME":
info.Name = STEPDataParser.ToString(
expression[ 0 ] );
info.TimeStamp = STEPDataParser.ToDateTime(
expression[ 1 ] );
info.Author = STEPDataParser.ToString(
expression[ 2 ] );
info.Organization = STEPDataParser.ToString(
expression[ 3 ] );
info.PreprocessorVersion = STEPDataParser.ToString(
expression[ 4 ] );
info.OriginatingSystem = STEPDataParser.ToString(
expression[ 5 ] );
info.Authorization = STEPDataParser.ToString(
expression[ 6 ] );
break;
default:
break;
}
}
}
}
return info;
} );
}
/**/
}
}
内核源代码/StgSharp.Modeling/STEP/STEPHeader.cs
+227
View File
@@ -0,0 +1,227 @@
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
// file="STEPHeader.cs"
// Project: StgSharp
// AuthorGroup: Nitload Space
// Copyright (c) Nitload Space. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the “Software”), to deal in the Software without restriction,
// including without limitation the rights to use, copy, modify, merge,
// publish, distribute, sublicense, and/or sell copies of the Software,
// and to permit persons to whom the Software is furnished to do so,
// subject to the following conditions:
//
// The above copyright notice and
// this permission notice shall be included in all copies
// or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED “AS IS”,
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
// ARISING FROM, OUT OF OR IN CONNECTION WITH
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.Text;
namespace StgSharp.Modeling.STEP
{
/// <summary>
/// C# implementation of HEADER part in STEP file.
/// </summary>
public struct STEPInfo
{
private STEPFileDescriptor _header;
private STEPFileName _name;
private STEPSchema _schema;
public (int mainLevel, int? subLevel) Level
{
get => _header.Level;
internal set => _header.Level = value;
}
public DateTime TimeStamp
{
get => _name.TimeStamp;
internal set => _name.TimeStamp = value;
}
public STEPFileDescriptor Descriptor
{
get => _header;
internal set => _header = value;
}
public STEPFileName FileName
{
get => _name;
internal set => _name = value;
}
public STEPSchema Schema
{
get => _schema;
internal set => _schema = value;
}
public string Description
{
get => _header.Description;
internal set => _header.Description = value;
}
public string Name
{
get => _name.Name;
internal set => _name.Name = value;
}
public string Author
{
get => _name.Author;
internal set => _name.Author = value;
}
public string Organization
{
get => _name.Organization;
internal set => _name.Organization = value;
}
public string OriginatingSystem
{
get => _name.OriginatingSystem;
internal set => _name.OriginatingSystem = value;
}
public string Authorization
{
get => _name.Authorization;
internal set => _name.Authorization = value;
}
public string PreprocessorVersion
{
get => _name.PreprocessorVersion;
internal set => _name.PreprocessorVersion = value;
}
public string Version
{
get => _name.Version;
internal set => _name.Version = value;
}
public string SchemaString
{
get => _schema.Data;
internal set => _schema.Data = value;
}
}
/// <summary>
/// C# implementation of FILE_NAME part in header of STEP file.
/// </summary>
public struct STEPFileName
{
public DateTime TimeStamp
{
get;
internal set;
}
public string Name
{
get;
internal set;
}
public string Author
{
get;
internal set;
}
public string Description
{
get;
internal set;
}
public string PreprocessorVersion
{
get;
internal set;
}
public string Version
{
get;
internal set;
}
public string Organization
{
get;
internal set;
}
public string OriginatingSystem
{
get;
internal set;
}
public string Authorization
{
get;
internal set;
}
}
public struct STEPSchema
{
private List<string> _schema;
public string Data
{
get;
internal set;
}
}
/// <summary>
/// C# implementation of FILE_NAME part in header of STEP file.
/// </summary>
public struct STEPFileDescriptor
{
public (int mainLevel,int? subLevel) Level
{
get;
internal set;
}
public string Description
{
get;
internal set;
}
}
}
内核源代码/StgSharp.Modeling/STEP/STEPReader.cs
+158
View File
@@ -0,0 +1,158 @@
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
// file="STEPReader.cs"
// Project: StgSharp
// AuthorGroup: Nitload Space
// Copyright (c) Nitload Space. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the “Software”), to deal in the Software without restriction,
// including without limitation the rights to use, copy, modify, merge,
// publish, distribute, sublicense, and/or sell copies of the Software,
// and to permit persons to whom the Software is furnished to do so,
// subject to the following conditions:
//
// The above copyright notice and
// this permission notice shall be included in all copies
// or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED “AS IS”,
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
// ARISING FROM, OUT OF OR IN CONNECTION WITH
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
using StgSharp;
using System;
using System.Collections.Generic;
using System.IO;
using System.IO.MemoryMappedFiles;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
namespace StgSharp.Modeling.STEP
{
public partial class STEPReader : IDisposable
{
private const string fileLabel = "ISO-10303-21;";
private bool disposedValue;
private FileStream _fileStream;
private long _headStart = -1, _headEnd = -1, _dataStart = -1, _size;
private MemoryMappedFile _memoryFile;
private STEPReader() { }
private STEPReader( FileStream stream, long size )
{
_fileStream = stream;
_size = size;
_memoryFile = MemoryMappedFile.CreateFromFile(
stream, mapName: null, size, MemoryMappedFileAccess.Read,
HandleInheritability.None, leaveOpen: true );
}
// ~STEPReader()
// {
// Dispose(disposing: false);
// }
public void Dispose()
{
Dispose( disposing: true );
GC.SuppressFinalize( this );
}
public static bool FromFile( string path, out STEPReader reader )
{
FileInfo info = new FileInfo( path );
if( !info.Exists ) {
reader = null!;
return false;
}
FileStream stream = new FileStream(
path, FileMode.Open, FileAccess.Read, FileShare.Read,
bufferSize: 4096, useAsync: true );
byte[] fileHead = new byte[40];
stream.Read( fileHead, 0, fileLabel.Length );
if( !Encoding.UTF8.GetString( fileHead ).Contains( fileLabel ) ) {
throw new InvalidDataException(
"The given file is not a STEP file" );
}
reader = new STEPReader( stream, info.Length );
reader.LocateSection();
return reader != null;
}
private void LocateSection()
{
long startPos = 0;
byte[] buffer = new byte[1024];
Span<byte> bufferSpan = buffer,
headerSec = Encoding.UTF8.GetBytes( "HEADER;" ),
endsecSec = Encoding.UTF8.GetBytes( "ENDSEC;" ),
dataSec = Encoding.UTF8.GetBytes( "DATA;" );
_fileStream.Position = 0;
for( ; startPos < _size; startPos += 1000 ) {
_fileStream.Read( buffer );
if( _headStart == -1 ) {
long pos = bufferSpan.IndexOf( headerSec );
if( pos >= 0 ) {
_headStart = startPos + pos;
}
}
if( _headEnd == -1 ) {
long pos = bufferSpan.IndexOf( endsecSec );
if( pos >= 0 ) {
_headEnd = startPos + pos;
}
}
if( _dataStart == -1 ) {
long pos = bufferSpan.IndexOf( dataSec );
if( pos >= 0 ) {
_dataStart = startPos + pos;
}
} else {
break;
}
_fileStream.Seek( 1000, SeekOrigin.Current );
}
}
private string ReadToken( StreamReader reader, ref long posCache )
{
StringBuilder token = new StringBuilder( 100 );
while( token.Length == 0 || token[ token.Length - 1 ] != ';' ) {
string subString = reader.ReadLine();
if( subString == null ) {
break;
}
token.Append( subString.TrimStart() );
}
posCache += token.Length;
return token.ToString();
}
private protected virtual void Dispose( bool disposing )
{
if( !disposedValue ) {
if( disposing ) {
_fileStream.Dispose();
_memoryFile.Dispose();
}
disposedValue = true;
}
}
}
}