public void SetCompositeRole(IRelationType relationType, IObject role)
{
this.AssertNotDeleted();
if (role == null)
{
this.RemoveCompositeRole(relationType);
return;
}
RoleAssertions.CompositeRoleChecks(this, relationType.RoleType, role);
switch (relationType.Multiplicity)
{
case Multiplicity.OneToOne:
this.session.SetCompositeRoleOneToOne(this.objectId, relationType.RoleType, role.Id);
return;
case Multiplicity.ManyToOne:
this.session.SetCompositeRoleManyToOne(this.objectId, relationType.RoleType, role.Id);
return;
default:
throw new Exception("Unsupported multiplicity " + relationType.Multiplicity);
}
}
public void SetCompositeRoles(IRelationType relationType, Extent roles)
{
if (roles == null || roles.Count == 0)
{
this.RemoveCompositeRoles(relationType);
return;
}
this.AssertNotDeleted();
var roleObjectIds = new List <long>();
foreach (IObject role in roles)
{
if (role != null)
{
RoleAssertions.CompositeRolesChecks(this, relationType.RoleType, role);
roleObjectIds.Add(role.Id);
}
}
switch (relationType.Multiplicity)
{
case Multiplicity.OneToMany:
this.session.SetCompositeRoleOneToMany(this.objectId, relationType.RoleType, roleObjectIds.ToArray());
return;
case Multiplicity.ManyToMany:
this.session.SetCompositeRoleManyToMany(this.objectId, relationType.RoleType, roleObjectIds.ToArray());
return;
default:
throw new Exception("Unsupported multiplicity " + relationType.Multiplicity);
}
}
public virtual void RemoveCompositeRole(IRelationType relationType)
{
this.AssertExist();
RoleAssertions.CompositeRoleChecks(this, relationType.RoleType);
this.Roles.RemoveCompositeRole(relationType.RoleType);
}
public virtual void RemoveCompositeRole(IRelationType relationType, IObject roleObject)
{
this.AssertExist();
if (roleObject != null)
{
RoleAssertions.CompositeRolesChecks(this, relationType.RoleType, roleObject);
var role = (Strategy)roleObject.Strategy;
this.Roles.RemoveCompositeRole(relationType.RoleType, role);
}
}
public virtual void RemoveCompositeRoles(IRelationType relationType)
{
this.AssertExist();
RoleAssertions.CompositeRoleChecks(this, relationType.RoleType);
var previousRoles = this.Roles.GetCompositesRole(relationType.RoleType);
foreach (var previousRole in previousRoles)
{
this.Roles.RemoveCompositeRole(relationType.RoleType, this.Session.State.GetOrCreateReferenceForExistingObject(previousRole, this.Session).Strategy);
}
}
public void SetUnitRole(IRelationType relationType, object unit)
{
if (unit == null)
{
this.RemoveUnitRole(relationType);
return;
}
this.AssertNotDeleted();
RoleAssertions.UnitRoleChecks(this, relationType.RoleType);
unit = relationType.RoleType.Normalize(unit);
this.session.SetUnitRole(this.objectId, relationType.RoleType, unit);
}
public virtual void RemoveCompositeRoles(IRelationType relationType)
{
this.AssertExist();
var roleType = relationType.RoleType;
RoleAssertions.CompositeRoleChecks(this, roleType);
var previousRoles = this.Roles.GetCompositeRoles(roleType);
foreach (var previousRole in previousRoles)
{
this.Roles.RemoveCompositeRole(roleType, this.SqlSession.GetOrCreateAssociationForExistingObject(previousRole).Strategy);
}
}
public virtual void SetCompositeRole(IRelationType relationType, IObject newRoleObject)
{
if (newRoleObject == null)
{
this.RemoveCompositeRole(relationType);
return;
}
this.AssertExist();
RoleAssertions.CompositeRoleChecks(this, relationType.RoleType, newRoleObject);
var newRoleObjectId = (Strategy)newRoleObject.Strategy;
this.Roles.SetCompositeRole(relationType.RoleType, newRoleObjectId);
}
public virtual void SetUnitRole(IRelationType relationType, object role)
{
this.AssertExist();
RoleAssertions.UnitRoleChecks(this, relationType.RoleType);
if (role != null)
{
role = relationType.RoleType.Normalize(role);
}
var oldUnit = this.GetUnitRole(relationType);
if (!Equals(oldUnit, role))
{
this.Roles.SetUnitRole(relationType.RoleType, role);
}
}
public void RemoveCompositeRoles(IRelationType relationType)
{
this.AssertNotDeleted();
RoleAssertions.CompositeRolesChecks(this, relationType.RoleType);
switch (relationType.Multiplicity)
{
case Multiplicity.OneToMany:
this.session.RemoveCompositeRolesOneToMany(this.objectId, relationType.RoleType);
return;
case Multiplicity.ManyToMany:
this.session.RemoveCompositeRolesManyToMany(this.objectId, relationType.RoleType);
return;
default:
throw new Exception("Unsupported multiplicity " + relationType.Multiplicity);
}
}
public virtual void SetCompositeRoles(IRelationType relationType, Allors.Extent roleObjects)
{
if (roleObjects == null || roleObjects.Count == 0)
{
this.RemoveCompositeRoles(relationType);
}
else
{
this.AssertExist();
var roleType = relationType.RoleType;
// TODO: use CompositeRoles
var previousRoles = new List <long>(this.Roles.GetCompositeRoles(roleType));
var newRoles = new HashSet <long>();
foreach (IObject roleObject in roleObjects)
{
if (roleObject != null)
{
RoleAssertions.CompositeRolesChecks(this, roleType, roleObject);
var role = (Strategy)roleObject.Strategy;
if (!previousRoles.Contains(role.ObjectId))
{
this.Roles.AddCompositeRole(roleType, role);
}
newRoles.Add(role.ObjectId);
}
}
foreach (var previousRole in previousRoles)
{
if (!newRoles.Contains(previousRole))
{
this.Roles.RemoveCompositeRole(roleType, this.SqlSession.GetOrCreateAssociationForExistingObject(previousRole).Strategy);
}
}
}
}
public void AddCompositeRole(IRoleType roleType, IObject role)
{
if (role == null)
{
return;
}
this.AssertNotDeleted();
RoleAssertions.CompositeRolesChecks(this, roleType, role);
switch (roleType.RelationType.Multiplicity)
{
case Multiplicity.OneToMany:
this.session.AddCompositeRoleOneToMany(this.objectId, roleType, role.Id);
return;
case Multiplicity.ManyToMany:
this.session.AddCompositeRoleManyToMany(this.objectId, roleType, role.Id);
return;
default:
throw new Exception("Unsupported multiplicity " + roleType.RelationType.Multiplicity);
}
}
