public override void Persist(IModel model, string fileName, ReportProgressDelegate progDelegate = null) { if (model is EsentModel esentModel) { var fullSourcePath = Path.GetFullPath(esentModel.DatabaseName); var fullTargetPath = Path.GetFullPath(fileName); if (string.Compare(fullSourcePath, fullTargetPath, StringComparison.OrdinalIgnoreCase) == 0) { return; // do nothing - don't save on top of self } } else { throw new ArgumentOutOfRangeException("EsentModelProvider only supports EsentModel"); } // Create a new Esent model for this Model => Model copy var factory = GetFactory(model.SchemaVersion); using (var esentDb = new EsentModel(factory)) { esentDb.CreateFrom(model, fileName, progDelegate); esentDb.Close(); } }
/// <summary> /// Creates and opens a new Xbim Database /// </summary> /// <param name="factory">Entity factory to be used for deserialization</param> /// <param name="dbFileName">Name of the Xbim file</param> /// <param name="access"></param> /// <returns></returns> static public EsentModel CreateModel(IEntityFactory factory, string dbFileName, XbimDBAccess access = XbimDBAccess.ReadWrite) { try { if (string.IsNullOrWhiteSpace(Path.GetExtension(dbFileName))) { dbFileName += ".xBIM"; } var model = new EsentModel(factory); model.CreateDatabase(dbFileName); model.Open(dbFileName, access); model.Header = new StepFileHeader(StepFileHeader.HeaderCreationMode.InitWithXbimDefaults, model) { FileName = { Name = dbFileName } }; foreach (var schemasId in factory.SchemasIds) { model.Header.FileSchema.Schemas.Add(schemasId); } return(model); } catch (Exception e) { throw new XbimException("Failed to create and open xBIM file \'" + dbFileName + "\'\n" + e.Message, e); } }
public EsentGeometryStoreReader(EsentModel esentModel) { _esentModel = esentModel; _shapeGeometryCursor = _esentModel.GetShapeGeometryTable(); _shapeInstanceCursor = _esentModel.GetShapeInstanceTable(); _shapeGeometryTransaction = _shapeGeometryCursor.BeginReadOnlyTransaction(); _shapeInstanceTransaction = _shapeInstanceCursor.BeginReadOnlyTransaction(); _regionsList = new XbimContextRegionCollection(); IXbimShapeGeometryData regions = new XbimRegionCollection(); if (_shapeGeometryCursor.TryMoveFirstRegion(ref regions)) { do { _regionsList.Add((XbimRegionCollection)regions); regions = new XbimRegionCollection(); } while (_shapeGeometryCursor.TryMoveNextRegion(ref regions)); } if (!_regionsList.Any()) //we might have an old xbim database regions were stored in the geometry table { var legacyCursor = _esentModel.GetGeometryTable(); using (var txn = legacyCursor.BeginReadOnlyTransaction()) { foreach (var regionData in legacyCursor.GetGeometryData(Xbim.Common.Geometry.XbimGeometryType.Region)) { _regionsList.Add(XbimRegionCollection.FromArray(regionData.ShapeData)); } } _esentModel.FreeTable(legacyCursor); } _contextIds = new HashSet <int>(ContextIds); }
//public static IStepFileHeader GetFileHeader(string fileName) //{ //} public static IStepFileHeader GetStepFileHeader(string fileName) { //create a temporary model var esentModel = new EsentModel(); esentModel.InstanceCache = new PersistedEntityInstanceCache(esentModel, null); esentModel.InstanceCache.DatabaseName = fileName; IStepFileHeader header; var entTable = esentModel.InstanceCache.GetEntityTable(); try { using (entTable.BeginReadOnlyTransaction()) { header = entTable.ReadHeader(); } } catch (Exception e) { throw new XbimException("Failed to open " + fileName, e); } finally { esentModel.InstanceCache.FreeTable(entTable); esentModel.Dispose(); } return(header); }
public XbimGeometryCursor(EsentModel model, string database, OpenDatabaseGrbit mode) : base(model, database, mode) { Api.JetOpenTable(Sesid, DbId, GeometryTableName, null, 0, mode == OpenDatabaseGrbit.ReadOnly ? OpenTableGrbit.ReadOnly : mode == OpenDatabaseGrbit.Exclusive ? OpenTableGrbit.DenyWrite : OpenTableGrbit.None, out Table); InitColumns(); }
public EsentShapeInstanceCursor(EsentModel model, string database, OpenDatabaseGrbit mode) : base(model, database, mode) { Api.JetOpenTable(this.Sesid, this.DbId, InstanceTableName, null, 0, mode == OpenDatabaseGrbit.ReadOnly ? OpenTableGrbit.ReadOnly : mode == OpenDatabaseGrbit.Exclusive ? OpenTableGrbit.DenyWrite : OpenTableGrbit.None, out this.Table); InitColumns(); }
public T SurfaceStyle <T>(EsentModel model) where T : class, IPersistEntity { if (IsIfcSurfaceStyle) { return((T)model.Instances[_styleId]); } return(null); }
internal XbimReadWriteTransaction(EsentModel model, EsentLazyDBTransaction txn, string name = null) { Name = name; Model = model; _readWriteTransaction = txn; InTransaction = true; _pulseCount = 0; _transactionBatchSize = 100; }
public override IModel Create(XbimSchemaVersion ifcVersion, XbimStoreType storageType) { var factory = GetFactory(ifcVersion); if (storageType == XbimStoreType.EsentDatabase) { return(EsentModel.CreateTemporaryModel(factory)); } throw new NotSupportedException($"{storageType} is not a supported Storage Type"); }
private EsentModel CreateEsentModel(XbimSchemaVersion schema, int codePageOverride) { var factory = GetFactory(schema); var model = new EsentModel(factory) { CodePageOverride = codePageOverride }; return(model); }
/// <summary> /// Constructs a table and opens it /// </summary> /// <param name="instance"></param> /// <param name="database"></param> public EsentEntityCursor(EsentModel model, string database, OpenDatabaseGrbit mode) : base(model, database, mode) { Api.JetOpenTable(Sesid, DbId, ifcEntityTableName, null, 0, mode == OpenDatabaseGrbit.ReadOnly ? OpenTableGrbit.ReadOnly : mode == OpenDatabaseGrbit.Exclusive ? OpenTableGrbit.DenyWrite : OpenTableGrbit.None, out Table); Api.JetOpenTable(Sesid, DbId, ifcEntityIndexTableName, null, 0, mode == OpenDatabaseGrbit.ReadOnly ? OpenTableGrbit.ReadOnly : mode == OpenDatabaseGrbit.Exclusive ? OpenTableGrbit.DenyWrite : OpenTableGrbit.None, out _indexTable); InitColumns(); }
protected EsentCursor(EsentModel model, string database, OpenDatabaseGrbit mode) { LockObject = new Object(); Model = model; Instance = model.Cache.JetInstance; Sesid = new Session(Instance); Api.JetOpenDatabase(Sesid, database, String.Empty, out DbId, mode); Api.JetOpenTable(Sesid, DbId, GlobalsTableName, null, 0, mode == OpenDatabaseGrbit.ReadOnly ? OpenTableGrbit.ReadOnly : mode == OpenDatabaseGrbit.Exclusive ? OpenTableGrbit.DenyWrite : OpenTableGrbit.None, out GlobalsTable); EntityCountColumn = Api.GetTableColumnid(Sesid, GlobalsTable, EntityCountColumnName); GeometryCountColumn = Api.GetTableColumnid(Sesid, GlobalsTable, GeometryCountColumnName); FlushColumn = Api.GetTableColumnid(Sesid, GlobalsTable, FlushColumnName); IfcHeaderColumn = Api.GetTableColumnid(Sesid, GlobalsTable, ifcHeaderColumnName); ReadOnly = (mode == OpenDatabaseGrbit.ReadOnly); }
/// <summary> /// Creates an empty model using a temporary filename, the model will be deleted on close, unless SaveAs is called /// It will be returned open for read write operations /// </summary> /// <returns></returns> static public EsentModel CreateTemporaryModel(IEntityFactory factory) { var tmpFileName = Path.GetTempFileName(); try { var model = new EsentModel(factory); model.CreateDatabase(tmpFileName); model.Open(tmpFileName, XbimDBAccess.ReadWrite, true); model.Header = new StepFileHeader(StepFileHeader.HeaderCreationMode.InitWithXbimDefaults, model); foreach (var schemasId in factory.SchemasIds) { model.Header.FileSchema.Schemas.Add(schemasId); } return(model); } catch (Exception e) { throw new XbimException("Failed to create and open temporary xBIM file \'" + tmpFileName + "\'\n" + e.Message, e); } }
public override XbimSchemaVersion GetXbimSchemaVersion(string modelPath) { var storageType = modelPath.StorageType(); if (storageType == StorageType.Invalid) { return(XbimSchemaVersion.Unsupported); } if (storageType != StorageType.Xbim) { return(Memory.MemoryModel.GetSchemaVersion(modelPath)); } var stepHeader = EsentModel.GetStepFileHeader(modelPath); IList <string> schemas = stepHeader.FileSchema.Schemas; var schemaIdentifier = string.Join(", ", schemas); foreach (var schema in schemas) { if (string.Compare(schema, "Ifc4", StringComparison.OrdinalIgnoreCase) == 0 || schema.StartsWith("Ifc4RC", StringComparison.OrdinalIgnoreCase)) { return(XbimSchemaVersion.Ifc4); } if (string.Compare(schema, "Ifc4x1", StringComparison.OrdinalIgnoreCase) == 0) { return(XbimSchemaVersion.Ifc4x1); } if (string.Compare(schema, "Ifc2x3", StringComparison.OrdinalIgnoreCase) == 0) { return(XbimSchemaVersion.Ifc2X3); } if (schema.StartsWith("Ifc2x", StringComparison.OrdinalIgnoreCase)) //return this as 2x3 { return(XbimSchemaVersion.Ifc2X3); } } return(XbimSchemaVersion.Unsupported); }
public EsentEntityCursor(EsentModel model, string database) : this(model, database, OpenDatabaseGrbit.None) { }
public override IModel Create(XbimSchemaVersion ifcVersion, string dbPath) { var factory = GetFactory(ifcVersion); return(EsentModel.CreateModel(factory, dbPath)); }
internal XbimReadTransaction(EsentModel theModel, EsentReadOnlyTransaction txn) { Model = theModel; _readTransaction = txn; InTransaction = true; }
public EsentShapeInstanceCursor(EsentModel model, string database) : this(model, database, OpenDatabaseGrbit.None) { }
public EsentGeometryStore(EsentModel esentModel) { _esentModel = esentModel; }
internal XbimInstanceCollection(EsentModel esentModel) { Cache = esentModel.Cache; _model = esentModel; }
public XbimGeometryCursor(EsentModel model, string database) : this(model, database, OpenDatabaseGrbit.None) { }