private void DropReferences(object instance) { IPersistentObject managed = (IPersistentObject)instance; this.uow.Objects.Remove(managed.Id); IList references = managed.GetReferences(); ArrayList tmp = new ArrayList(references); foreach (ObjectReference reference in tmp) { if (!IsLoaded(reference.ObjectId)) { continue; } IPersistentObject referencedObject = (IPersistentObject)this.Get(reference.ObjectId); referencedObject.SetUnloaded(reference.Property, true); Type referencedObjectType = referencedObject.GetType(); PropertyInfo pi = referencedObjectType.GetProperty(reference.Property); bool stackMute = referencedObject.Mute; referencedObject.Mute = true; pi.SetValue(referencedObject, null, null); referencedObject.Mute = stackMute; } }
public string GetExpression(Dictionary <string, object> parameters, string variable) { object obj = parameters["Handle"]; Array handles = null; if (obj.GetType().IsArray) { handles = obj as Array; } else { handles = new Object[] { obj } }; List <IGeometryEntity> geometry = new List <IGeometryEntity>(); foreach (var item in handles) { IPersistentObject persitentObject = HostFactory.PersistenceManager.GetPersistentObjectFromHandle(item); if (null != persitentObject) { geometry.Add(persitentObject.Geometry); } } return(GeometryExpressionBuilder.GetExpression(geometry.ToArray(), variable)); } }
public int ExecuteInsert(IPersistentObject persistentObject, DbConnection connection, DbTransaction transaction, string sql, params DbParameter[] parameters) { bool close = connection == null; int result = 0; try { connection = Db.Get.Connection(connection); using (DbCommand command = Db.Get.Command(sql, connection, transaction)) { foreach (DbParameter parameter in parameters) { command.Parameters.Add(parameter); } result = command.ExecuteNonQuery(); int id = Db.Get.Identity(command); if (id > -1) { persistentObject.Id = id; } } } finally { if (close && connection != null) { connection.Close(); } } return(result); }
public bool HasSamePersistenceId(IPersistentObject other) { return other == null ? false : other.PersistenceId == null || PersistenceId == null ? false : PersistenceId.Value == other.PersistenceId.Value; }
public static Geometry FromObject(long ptr) { IPersistentObject obj = HostFactory.PersistenceManager.FromObject(ptr); Geometry geom = Geometry.ToGeometry(obj.Geometry); geom.mPersistent = obj; return(geom); }
public virtual void RemoveFromNewObjects(IPersistentObject newObject) { lock (_lock) { if (_newObjects.Contains(newObject)) _newObjects.Remove(newObject); } }
private void Load(IPersistentObject obj) { var data = persistenceManager.PersistenceStrategy.TryLoad(CompositeKey.CollectionId, CompositeKey.Key); if (!string.IsNullOrWhiteSpace(data)) { persistenceManager.SerializationStrategy.PopulateFromSerialized(obj, data); } }
private object Create <T>(string id, object[] args) { IPersistentObject instance = (IPersistentObject)engine.CreateProxyWithState <T>(this, args); uow.NewObjects.Add(instance); ((IPersistentObject)instance).Id = id; RegisterObject(instance); return(instance); }
private static void InjectInterceptableList(IPersistentObject target, PropertyInfo property, Type propertyType) { Type subType = propertyType.GetGenericArguments()[0]; Type genericType = typeof(PersistentList<>).MakeGenericType(subType); Object instance = Activator.CreateInstance(genericType); property.SetValue(target, instance, null); IPersistentList persistentList = (IPersistentList)instance; persistentList.Owner = target; }
public void CommitObject(object instance) { IPersistentObject managed = (IPersistentObject)instance; string serializedData = managed.Serialize(); System.IO.StreamWriter sw = new System.IO.StreamWriter(GetObjectFile(managed), false); sw.WriteLine(serializedData); sw.Close(); this.uow.DirtyObjects.Remove(managed.Id); }
void CustomerPositionChanged(object sender, EventArgs e) { IPersistentObject pc = SelectedCustomer; if (pc != null) { this.orderList = SelectedCustomer.Orders; orderBindingSource.DataSource = this.orderList; } }
void OrderPositionChanged(object sender, EventArgs e) { IPersistentObject pc = SelectedOrder as IPersistentObject; if (pc != null) { this.orderDetailList = SelectedOrder.OrderDetails; orderDetailBindingSource.DataSource = this.orderDetailList; } }
public static void SaveTemporary(IPersistentObject obj) { using (var stream = new FileStream(GetTempLocation().FullName, FileMode.Create)) using (var writer = new BinaryWriter(stream)) { writer.Write(KTempVersion); writer.Write((byte)SaveType.Temporary); BackEnd.Persist(stream, obj.EnumeratePersistedObjects()); } }
void EmployeePositionChanged(object sender, EventArgs e) { IPersistentObject pc = SelectedEmployee as IPersistentObject; if (pc != null) { this.orderList = SelectedEmployee.Orders; orderBindingSource.DataSource = this.orderList; } }
private static void InjectInterceptableList(IPersistentObject target, PropertyInfo property, Type propertyType) { Type subType = propertyType.GetGenericArguments()[0]; Type genericType = typeof(PersistentList <>).MakeGenericType(subType); Object instance = Activator.CreateInstance(genericType); property.SetValue(target, instance, null); IPersistentList persistentList = (IPersistentList)instance; persistentList.Owner = target; }
/// <summary> /// Helper Method for Linq queries. /// </summary> /// <param name="o"></param> /// <returns></returns> public static ObjectId Oid(this object o) { // If Oid() is used at the right side of a comparison // we try to return the NDOObjectId. IPersistentObject po = o as IPersistentObject; if (po == null) { return(default(ObjectId)); } return(po.NDOObjectId); }
/// <summary> /// Helper Method for Linq queries. Used to query for columns of multikey oids. /// </summary> /// <param name="o"></param> /// <param name="index">The index of the Multikey value to compare with</param> /// <returns></returns> public static object Oid(this object o, int index) { // If Oid() is used at the right side of a comparison // we try to return the NDOObjectId. IPersistentObject po = o as IPersistentObject; if (po == null) { return(null); } return(po.NDOObjectId.Id.Values[index]); }
/// <summary> Commits any changes to a specified object to the database. </summary> /// <param name="instance"> the object instance to create/update. </param> public virtual void CommitChanges(IPersistentObject instance) { if (_session is null) { using (var session = SessionFactory.OpenSession()) CommitChanges(session, instance); } else { CommitChanges(_session, instance); } }
public IPersistentObject Create(IPersistentObject po) { Task task = po as Task; if (task != null) { // Make sure that IsTransient contract check will not fail... po.PersistenceId = 0; m_Tasks.Add(task); } return(task); }
/// <summary> /// Returns the extension for the given persistent object /// </summary> /// <param name="obj"></param> /// <returns></returns> /// <exception cref="NotSupportedException"></exception> public static string GetFileExtension(IPersistentObject obj) { if (obj is UTinyProject) { return(ProjectFileExtension); } if (obj is UTinyModule) { return(ModuleFileExtension); } throw new NotSupportedException($"Persitent object of type {obj.GetType()} has no known file extension"); }
public static string GetLocation(IPersistentObject p) { var guid = p.PersistenceId; if (string.IsNullOrEmpty(guid)) { return(null); } var path = AssetDatabase.GUIDToAssetPath(guid); return(string.IsNullOrEmpty(path) ? null : path); }
public static string PersistObject(IPersistentObject obj) { var path = GetLocation(obj); // No persistent path exists for this object // Default to `Assets/{NAME}` if (string.IsNullOrEmpty(path)) { path = Path.Combine(Application.dataPath, GetFileName(obj)); } return(PersistObjectAs(obj, path)); }
public void ReadPacketStream(NetDataReader stream) { ushort repObjId = stream.GetUShort(); while (repObjId != 0) { Log.Debug($"Reading ghost with id: {repObjId}"); // first read if there is a status change if (stream.GetByte() == 1) { // read the status change if (stream.GetByte() == 1) { Log.Debug("status changed: ADDED"); // added so read the persistent obj id byte objRepId = stream.GetByte(); // Create new instance of the object IPersistentObject obj = PersistentObjectManager.CreatePersistentObject(objRepId); // unpack stream data obj.Deserialize(stream); ReplicatedObjects[repObjId] = new ReplicationRecord { Id = repObjId, Entity = obj as ReplicatableObject }; } else { Log.Debug("status changed: REMOVED"); // remove the record but also need to destroy game object or queue it to be destroyed.. if (ReplicatedObjects.TryGetValue(repObjId, out ReplicationRecord record)) { Log.Debug($"Removing record: {record.Id}"); //GameObject.Destroy(record.Entity); ReplicatedObjects.Remove(repObjId); } } } else { Log.Debug("State update"); // no status change just new state information so unpack into existing replicated obj ReplicatedObjects[repObjId].Entity.Deserialize(stream); } repObjId = stream.GetUShort(); } }
public static string PersistObjectAs(IPersistentObject obj, string path) { path = PersistObjectsAs(obj.EnumeratePersistedObjects(), path); var assetPath = FullPathToAssetPath(path); AssetDatabase.ImportAsset(assetPath, ImportAssetOptions.ForceSynchronousImport); s_ChangedAssetPaths.Remove(assetPath); var assetGuid = AssetDatabase.AssetPathToGUID(assetPath); obj.PersistenceId = assetGuid; return(path); }
public void Delete(object instance) { IPersistentObject managed = (IPersistentObject)instance; uow.DeletedObjects[managed.Id] = managed; DropReferences(instance); uow.DirtyObjects[managed.Id] = null; //clear object from dirty list string filePath = dbPath + @"\" + managed.Id.ToString() + ".txt"; if (System.IO.File.Exists(filePath)) { System.IO.File.Delete(filePath); } }
/// <summary> /// Get or create an entity for a business object /// </summary> /// <param name="unitOfWork">An open database unit of work</param> /// <param name="obj">The business object</param> /// <typeparam name="TEntity">The entity type to use</typeparam> public static TEntity GetEntity <TEntity>(this IUnitOfWork unitOfWork, IPersistentObject obj) where TEntity : class, IEntity { var repository = unitOfWork.GetRepository <IRepository <TEntity> >(); var entity = repository.GetByKey(obj.Id); if (entity == null) { entity = repository.Create(); EntityIdListener.Listen(entity, obj); } return(entity); }
public object HandleCall(Puzzle.NAspect.Framework.MethodInvocation call) { if (call.Method.DeclaringType == typeof(IPersistentObject)) { return(call.Proceed()); } string property = GetPropertyName(call); IPersistentObject managed = (IPersistentObject)call.Target; object res = managed.GetPropertyValue(property); call.Proceed(); return(res); }
/// <summary> Commits any changes to a specified object to the database. </summary> /// <param name="session"> The session in whose scope to commit. </param> /// <param name="instance"> The object instance to create/update. </param> protected void CommitChanges(ISession session, IPersistentObject instance) { LogDebug(EDatabaseLogMessage.CommittingChangesTo.Format(instance.ToString())); lock (_lock) { using (var transaction = session.BeginTransaction()) { session.Save(instance); transaction.Commit(); } RemoveFromNewObjects(instance); } LogDebug(EDatabaseLogMessage.ChangesCommitted); }
protected static void AssetNameField(IPersistentObject obj) { using (new EditorGUILayout.VerticalScope()) { EditorGUILayout.LabelField("Project Name", obj.Name); var path = AssetDatabase.GUIDToAssetPath(obj.PersistenceId); using (new EditorGUILayout.HorizontalScope()) { GUI.enabled = false; EditorGUILayout.ObjectField("Project Asset", AssetDatabase.LoadAssetAtPath(path, typeof(UnityEngine.Object)), typeof(UnityEngine.Object), false); GUI.enabled = true; } } }
/// <summary> /// Get or create an entity for a business object /// </summary> /// <param name="dbSet">An open database set</param> /// <param name="obj">The business object</param> /// <typeparam name="TEntity">The entity type to use</typeparam> public static TEntity GetEntity <TEntity>(this IDbSet <TEntity> dbSet, IPersistentObject obj) where TEntity : class, IEntity { var entity = dbSet.FirstOrDefault(e => e.Id == obj.Id); if (entity != null) { return(entity); } entity = dbSet.Create(); dbSet.Add(entity); EntityIdListener.Listen(entity, obj); return(entity); }
private IPersistentObject UpdateTask(IPersistentObject po) { Contract.Requires(po != null); Contract.Requires(po is Task); Contract.Ensures(Contract.Result <IPersistentObject>() != null); CheckObjectAlreadyDisposed(); Task task = po as Task; CheckTask(task); if (s_Logger.IsDebugEnabled) { s_Logger.Debug(string.Format("{0}({1})", MethodBase.GetCurrentMethod().Name, task)); } return(BaseUpdate(task)); }
private void Initialize(IPersistentObject target) { Type type = target.GetType().BaseType; PropertyInfo[] properties = type.GetProperties(); target.Initializing = true; foreach (PropertyInfo property in properties) { Type propertyType = property.PropertyType; if (propertyType.IsGenericType && propertyType.IsInterface) { InjectInterceptableList(target, property, propertyType); } } target.Initializing = false; }
/// <summary> /// /// </summary> /// <param name="disposing"></param> protected override void Dispose(bool disposing) { if (disposing) { if (null != mPersistent && !Object.ReferenceEquals(mPersistent, base.HostImpl)) { mPersistent.Dispose(); } DSGeometryExtension.DisposeObject(ref mContext); DSGeometryExtension.DisposeObject(ref mContextCS); } mPersistent = null; mDisplayAttributes = null; base.Dispose(disposing); //allow base class to release it's resources }
public ICollection<IPersistentObject> GetChildren(IPersistentObject po, string propertyName) { // NOP return null; }
public IPersistentObject Delete(IPersistentObject po) { Contract.Requires(Transaction.Current != null); Contract.Requires(Transaction.Current.TransactionInformation.DistributedIdentifier == Guid.Empty); //Contract.Requires(IsOperational); Contract.Requires(po != null); Contract.Requires(po.PersistenceId.HasValue); Contract.Ensures(Contract.Result<IPersistentObject>() != null); Contract.Ensures(Contract.Result<IPersistentObject>().GetType() == po.GetType()); Contract.Ensures(!Contract.Result<IPersistentObject>().PersistenceId.HasValue); return default(IPersistentObject); }
private IPersistentObject UpdateTask(IPersistentObject po) { Contract.Requires(po != null); Contract.Requires(po is Task); Contract.Ensures(Contract.Result<IPersistentObject>() != null); CheckObjectAlreadyDisposed(); Task task = po as Task; CheckTask(task); if (s_Logger.IsDebugEnabled) { s_Logger.Debug(string.Format("{0}({1})", MethodBase.GetCurrentMethod().Name, task)); } return BaseUpdate(task); }
public IPersistentObject Update(IPersistentObject po) { // NOP return null; }
public IPersistentObject Delete(IPersistentObject po) { Contract.Requires(Transaction.Current != null); //Contract.Requires(IsOperational); Contract.Requires(po != null); Contract.Requires(po.PersistenceId.HasValue); Contract.Ensures(Contract.Result<IPersistentObject>() != null); Contract.Ensures(Contract.Result<IPersistentObject>().GetType() == po.GetType()); Contract.Ensures(!Contract.Result<IPersistentObject>().PersistenceId.HasValue); return default(IPersistentObject); }
public object GetPropertyValue(IPersistentObject po, string PropertyName) { Contract.Requires(Transaction.Current != null); Contract.Requires(!string.IsNullOrEmpty(PropertyName)); //Contract.Requires(IsOperational); //Contract.Ensures(Contract.Result<ICollection<IPersistentObject>>() != null); //// TODO: Tests if ICollection<IPersistenObject> contains elements of type described by the PropertyName //// (This PropertyName should point in the first version to an ICollection). //Contract.Ensures(Contract.ForAll<IPersistentObject>( // Contract.Result<ICollection<IPersistentObject>>(), // a => Contract.Result<ICollection<IPersistentObject>>() // .Where(b => Type.ReferenceEquals(a, b)) // .Count() == 1)); //Contract.Ensures(Contract.ForAll<IPersistentObject>( // Contract.Result<ICollection<IPersistentObject>>(), // a => Contract.Result<ICollection<IPersistentObject>>() // .Where(b => b.HasSamePersistenceId(a)) // .Count() == 1)); return default(object); }
private IPersistentObject UpdateTask(IPersistentObject po) { Contract.Requires(typeof(Task).IsAssignableFrom(po.GetType())); const string MethodName = "UpdateTask"; CheckObjectAlreadyDisposed(); Task task = po as Task; CheckTask(task); if (s_Logger.IsDebugEnabled) { s_Logger.Debug(string.Format("{0}({1})", MethodName, task)); } return BaseUpdate(task); }
public abstract bool HasSamePersistenceId(IPersistentObject other);
public abstract IPersistentObject Create(IPersistentObject po);
public abstract IPersistentObject Update(IPersistentObject po);
public abstract IPersistentObject Delete(IPersistentObject po);
public object GetPropertyValue(IPersistentObject po, string propertyName) { // NOP return null; }
public ICollection<IPersistentObject> GetChildren(IPersistentObject po, string PropertyName) { Contract.Requires(Transaction.Current != null); Contract.Requires(!string.IsNullOrEmpty(PropertyName)); //Contract.Requires(IsOperational); return default(ICollection<IPersistentObject>); }
public IPersistentObject Delete(IPersistentObject po) { // NOP return null; }
public void SetProxy(IAopProxy target) { this.target = (IPersistentObject)target; }
public bool HasSamePersistenceId(IPersistentObject other) { Contract.Ensures(Contract.Result<bool>() == (other == null ? false : !other.PersistenceId.HasValue || !PersistenceId.HasValue ? false : PersistenceId.Value == other.PersistenceId.Value)); return default(bool); }
public IPersistentObject Create(IPersistentObject po) { Task task = po as Task; if (task != null) { // Make sure that IsTransient contract check will not fail... po.PersistenceId = 0; m_Tasks.Add(task); } return task; }
public abstract object GetPropertyValue(IPersistentObject po, string PropertyName);
public abstract ICollection<IPersistentObject> GetChildren(IPersistentObject po, string PropertyName);