public completeLink getNewLink(lineClass master, lineClass slave, e_TskLim limitType)
{
completeLink cLink = new completeLink();
cLink.slave = slave;
cLink.master = master;
cLink.reinitLink(limitType);
return cLink;
}
public link_2(IConnectible precursor, IConnectible follower, e_TskLim limit, double delay)
{
if(delay < DELAY_MINIMUM_VALUE) throw new ArgumentException(nameof(delay));
init_Identity();
init_Limit(limit);
init_Storage(follower, precursor);
init_PrecursorDate(storage.precursor, storage.dotPrecursor);
}
public ILink_2 createLink(IConnectible precursor, IConnectible follower, e_TskLim limit, double delay)
{
if(delay < link_2.DELAY_MINIMUM_VALUE) throw new ArgumentException(nameof(delay));
if(!Enum.IsDefined(typeof(e_TskLim), limit)) throw new ArgumentException(nameof(limit));
if (!checkMembers(precursor, follower)) return null;
link_2 newLink = new link_2(precursor, follower, limit, delay);
vault.addLink(newLink);
return newLink;
}
public linkClass(IId MasterID, ILine MasterLine, IId SlaveID, ILine SlaveLine, e_TskLim limit)
{
if(!Enum.IsDefined(typeof(e_TskLim),limit)) throw new ArgumentNullException();
this.limit = limit;
_ident = new Identity(e_Entity.Link);
delay = 0;
init_master(MasterID, MasterLine);
Console.WriteLine("Master initialized");
init_slave(SlaveID, SlaveLine);
Console.WriteLine("Slave initialized");
init_dependence();
Console.WriteLine("Dependence initialized");
}
public bool SetLimit(e_TskLim limitType)
{
e_TskLim Old = limit;
limit = limitType;
event_LimitChanged?.Invoke(this, new ea_ValueChange<e_TskLim>(Old, limit));
return true;
}
public simpleLink(IId idMaster, ILine lMaster, IId idSlave, ILine lSlave, e_TskLim limit)
{
id = new Identity(e_Entity.Link);
this.limit = limit;
master = new simpleLMember(this, idMaster, lMaster, e_DependType.Master);
depend = new simpleDepend(lMaster, Hlp.GetPrecursor(limit));
slave = new simpleLMember(this, idSlave, lSlave, e_DependType.Slave);
depend.sender = this;
}
public void reinitLink(e_TskLim linkDependType)
{
link = new simpleLink(master, master, slave, slave, linkDependType);
}
/// <summary>
/// Метод основной инициализации (запускается первым)
/// </summary>
/// <param name="limit">Вид связи</param>
/// <param name="delay">Задержка связи</param>
protected void init_default(e_TskLim limit, double delay = 0)
{
//Запускать первым из инитов
if (!Enum.IsDefined(typeof(e_TskLim), limit)) throw new ArgumentException("Wrong e_TskLim value");
_identity = new Identity(e_Entity.Link);
_limit = limit;
_delay = delay;
_state = e_LnkState.InTime;
_master = new linkMember(this, e_DependType.Master);
_slave = new linkMember(this, e_DependType.Slave);
}
/// <summary>
/// Конструктор экземпляра связи
/// </summary>
/// <param name="master">Интерфейс управляющего члена связи</param>
/// <param name="slave">Интерфейс подчиеннного члена связи</param>
/// <param name="limitType">Вид связи</param>
/// <param name="delay">Задержка связи</param>
public link(IDock master, IDock slave, e_TskLim limitType, double delay)
{
init_default(limitType, delay);
init_master(master, master);
init_slave(slave, slave);
init_slaveDependence();
master.connect(this);
slave.connect(this);
}
public void limitChanged(e_TskLim limit)
{
_follower.updateDependDot(limit);
_precursor.updateDependDot(limit);
}
public memberStorage(IConnectible precursor, IConnectible follower, e_TskLim limit)
{
if(precursor == null || follower == null) throw new ArgumentNullException();
if(!Enum.IsDefined(typeof(e_TskLim), limit)) throw new ArgumentException(nameof(limit));
_follower = new memberData(follower, e_DependType.Slave, limit);
_precursor = new memberData(precursor, e_DependType.Master, limit);
follower.event_ObjectDeleted += memberRemovedHandler;
precursor.event_ObjectDeleted += memberRemovedHandler;
unsubscribeFollower = () => follower.event_ObjectDeleted -= memberRemovedHandler;
unsubscribePrecursor = () => precursor.event_ObjectDeleted -= memberRemovedHandler;
}
public void updateDependDot(e_TskLim limit)
{
dependDot = depend == e_DependType.Master ? Hlp.GetPrecursor(limit) : Hlp.GetFollower(limit);
}
public memberData(IConnectible member, e_DependType type, e_TskLim limit)
{
this.member = member;
depend = type;
dependDot = depend == e_DependType.Master ?
Hlp.GetPrecursor(limit) : Hlp.GetFollower(limit);
}
public bool SetLimit(e_TskLim limitType)
{
return _limit.SetLimit(limitType);
}
protected void init_Limit(e_TskLim limit)
{
_limit = new cLimit<e_TskLim>(this, limit);
_limit.event_LimitChanged += limitChangedHandler;
unsubscribeLimit = () => _limit.event_LimitChanged -= limitChangedHandler;
}
public bool SetLimit(e_TskLim limitType)
{
if (_limit == limitType) return false;
e_TskLim Old = _limit;
_limit = limitType;
event_LimitChanged?.Invoke(this, new ea_ValueChange<e_TskLim>(Old, _limit));
return true;
}
public link_2(IConnectible precursor, IConnectible follower, e_TskLim limit)
:this(precursor, follower, limit, DELAY_MINIMUM_VALUE)
{ }
/// <summary>
/// Инициализирует класс зависимости <seealso cref="Dependence"/>
/// </summary>
/// <param name="dependDate">Дата зависимости</param>
/// <param name="limitType">Тип зависимости</param>
/// <exception cref="objectAlreadyExistException">Выбрасывает исключение если класс <seealso cref="Dependence"/> уже был инициализирован</exception>
public void init_Dependence(ILink parent, DateTime dependDate, e_TskLim limitType)
{
if(depend != null) throw new objectAlreadyExistException();
date = dependDate;
depend = new Dependence(date, cDirection, Hlp.GetDepenDot(limitType, dependType));
depend.setSender(parent);
}
/// <summary>
/// Конструктор экземпляра связи
/// </summary>
/// <param name="master">Интерфейс управляющего члена связи</param>
/// <param name="slave">Интерфейс подчиеннного члена связи</param>
/// <param name="limitType">Вид связи</param>
public link(IDock master, IDock slave, e_TskLim limitType)
:this(master, slave, limitType, 0)
{ }
public completeLink(DateTime masterStart, double masterDuration, DateTime slaveStart, double slaveDuration,
e_TskLim linkDependType)
{
master = new lineClass(masterStart, masterDuration);
slave = new lineClass(slaveStart, slaveDuration);
link = new simpleLink(master, master, slave, slave, linkDependType);
}
/// <summary>
/// Метод установки значения вида связи
/// </summary>
/// <param name="limitType">вид связи</param>
/// <returns>Истина если новый вид связи установлен</returns>
/// <exception cref="ArgumentException">Если значение не подходит под <seealso cref="e_TskLim"/></exception>
public bool SetLimit(e_TskLim limitType)
{
if(!Enum.IsDefined(typeof(e_TskLim), limitType )) throw new ArgumentException("Wrong argument value of e_TskLim type");
if (limitType == _limit) return false;
e_TskLim Old = _limit;
_limit = limitType;
event_LimitChanged?.Invoke(this, new ea_ValueChange<e_TskLim>(Old, _limit));
return true;
}
public bool SetLimit(e_TskLim limitType)
{
throw new NotImplementedException();
}
