/// <summary>
/// Método responsável por verificar se intervalo está contido na lista de semáforos com intervalos já existentes.
/// </summary>
/// <param name="inicio">Início do intervalo</param>
/// <param name="final">Final do intervalo</param>
/// <param name="semaforos">Lista de Semáforos já existentes</param>
/// <returns>Confirmação se irá ou não impactar</returns>
public static bool RnVerificarIntervaloImpactara(short inicio, short final, List <SemaforoPorIntervalo> semaforos)
{
SemaforoPorIntervalo semaforo = null;
if (semaforos.Count > 0)
{
semaforo = semaforos.Where(o => inicio >= o.inicio && inicio <= o.final).FirstOrDefault();
if (semaforo != null)
{
return(true);
}
semaforo = semaforos.Where(o => final >= o.inicio && final <= o.final).FirstOrDefault();
if (semaforo != null)
{
return(true);
}
semaforo = semaforos.Where(o => inicio <= o.inicio && final >= o.final).FirstOrDefault();
if (semaforo != null)
{
return(true);
}
else
{
return(false);
}
}
return(false);
}
/// <summary>
/// Método responsável por verificar se intervalo está contido no semáforo com intervalo já existente.
/// </summary>
/// <param name="inicio">Início do intervalo</param>
/// <param name="final">Final do intervalo</param>
/// <param name="semaforo">Semáforo já existente</param>
/// <returns>Confirmação se irá ou não impactar</returns>
public static bool RnVerificarIntervaloImpactara(short inicio, short final, SemaforoPorIntervalo semaforo)
{
if (semaforo != null)
{
if (inicio >= semaforo.inicio && inicio <= semaforo.final)
{
return(true);
}
if (final >= semaforo.inicio && final <= semaforo.final)
{
return(true);
}
if (inicio <= semaforo.inicio && final >= semaforo.final)
{
return(true);
}
if (inicio >= semaforo.inicio && final <= semaforo.inicio)
{
return(true);
}
else
{
return(false);
}
}
return(false);
}
/// <summary>
/// Método responsável por liberar os semáforos a partir do índice atual dos semáforos.
/// </summary>
/// <param name="semaforosPorIntervalo">Lista de semáforos</param>
/// <param name="indice">Indice da posicao do semáforo</param>
public static void LiberarSemaforo(List <SemaforoPorIntervalo> semaforosPorIntervalo, int indice)
{
for (int i = indice; i < semaforosPorIntervalo.Count; i++)
{
SemaforoPorIntervalo.LiberarSemaforo(semaforosPorIntervalo[i]);
}
}
/// <summary>
/// Método responsável por validar a necessidade de criar novos semáforos de acordo com os novos intervalos,
/// ou se apenas deve-se reaproveitar o semáforo existentes.
/// </summary>
/// <param name="semaforoPorIntervalo">Semáforo que deseja comparar para verificar se há necessidade de criar novos semáforos</param>
/// <param name="inicio">ponto mínimo do intervalo atual</param>
/// <param name="final">ponto máximo do intervalo atual</param>
/// <returns>Lista de semáforos que se deve esperar</returns>
public static void VerificarSemaforosImpactados(ref List <SemaforoPorIntervalo> semaforosImpactadosAguardar,
ref List <SemaforoPorIntervalo> semaforosImpactadosNovos,
ref List <SemaforoPorIntervalo> semaforosExistentes,
SemaforoPorIntervalo semaforoPorIntervalo, short inicio, short final)
{
if (!(inicio <= final))
{
return;
}
//Verifica se o intervalo está contido no intervalo em verificação atual.
if (RnVerificarInicioFinalIntervaloEstaContidoEmOutroIntervalo(inicio, final, semaforoPorIntervalo))
{
if (RnValidarAdicionarSemaforoParaAguarde(semaforosImpactadosAguardar, semaforosImpactadosNovos, semaforoPorIntervalo))
{
SemaforoPorIntervalo.IncrementarContadorSemaforoEmEspera(semaforoPorIntervalo);
semaforosImpactadosAguardar.Add(semaforoPorIntervalo);
}
return;
}
//verifica se intervalo irá impactar no intervalo já existente
//Se não impactar irá querer criar um novo semáforo.
if (!(RnVerificarIntervaloImpactara(inicio, final, semaforoPorIntervalo)))
{
//Verifica se intervalo não irá impactar nos intervalos já existentes ou nos novos intervalos já existentes
if (!(RnVerificarIntervaloImpactara(inicio, final, semaforosImpactadosNovos) ||
RnVerificarIntervaloImpactara(inicio, final, semaforosImpactadosAguardar) ||
RnVerificarIntervaloImpactara(inicio, final, semaforosExistentes)))
{
semaforosImpactadosNovos.Add(new SemaforoPorIntervalo(inicio, final, 1));
semaforosExistentes.Add(new SemaforoPorIntervalo(inicio, final, 1));
}
}
//Se impactar vai adicionar o semáforo atual na lista de aguarde
//e verifica onde irá impactar para realizar as validações para então decidir se irá criar outro semáforo ou não.
else
{
if (RnValidarAdicionarSemaforoParaAguarde(semaforosImpactadosAguardar, semaforosImpactadosNovos, semaforoPorIntervalo))
{
SemaforoPorIntervalo.IncrementarContadorSemaforoEmEspera(semaforoPorIntervalo);
semaforosImpactadosAguardar.Add(semaforoPorIntervalo);
}
//Verifica se o intervalo incorpora outro intervalo dentro dele (o intervalo que está sendo verificado)
if (RnVerificarInicioFinalCobremIntervaloAtual(inicio, final, semaforoPorIntervalo))
{
RnConstruirSemaforoQueAbrangeSemaforoAtual(inicio, final, semaforoPorIntervalo, ref semaforosExistentes, ref semaforosImpactadosNovos);
}
//Se não quer dizer que ou o início ou final estão impactando em algum semáforo.
else
{
RnConstruirSemaforoQueAbrangeInicioOuFinalSemaforoAtual(inicio, final, semaforoPorIntervalo, ref semaforosExistentes, ref semaforosImpactadosNovos);
}
}
}
/// <summary>
/// Método responsável por atualizar o contador que indica se há um thread esperando em determinado semáforo.
/// </summary>
/// <param name="semaforoPorIntervalo">Objeto que contém os dados do semáforo</param>
public static void DecrementarContadorSemaforoEmEspera(SemaforoPorIntervalo semaforoPorIntervalo)
{
semaforoPorIntervalo.semaforoEmEspera.WaitOne();
semaforoPorIntervalo.emEspera -= 1;
semaforoPorIntervalo.semaforoEmEspera.Release();
}
/// <summary>
/// Método responsável por excluir os semáforos inutilizados da lista de semáforos existentes.
/// </summary>
/// <param name="semaforosParaExcluir">Lista de semáforos que deverão ser excluídos</param>
/// <param name="semaforosExistentes">Lista de semáforos existentes atualmente</param>
public static void ExcluirSemaforosInativos(ref List <SemaforoPorIntervalo> semaforosParaExcluir, ref List <SemaforoPorIntervalo> semaforosExistentes)
{
//excluindo semáforos da lista de semaforos por cronograma
for (int i = 0; i < semaforosParaExcluir.Count; i++)
{
SemaforoPorIntervalo.DestruirSemaforo(semaforosParaExcluir[i]);
semaforosExistentes.Remove(semaforosParaExcluir[i]);
}
}
/// <summary>
/// Método responsável por liberar recursos do semáforo criado que não possua mais ninguém em espera.
/// </summary>
/// <param name="semaforoIntervalo">Objeto SemaforoPorIntevalo</param>
public static void DestruirSemaforo(SemaforoPorIntervalo semaforoIntervalo)
{
if (semaforoIntervalo.emEspera == 0)
{
semaforoIntervalo.semaforo.Dispose();
semaforoIntervalo.semaforo = null;
semaforoIntervalo = null;
}
}
/// <summary>
/// Método responsável por verificar se o semaforoPorIntervalo1 é diferente do semaforoPorIntervalo2
/// </summary>
/// <param name="semaforoPorIntervalo1">Objeto semáforo 1</param>
/// <param name="semaforoPorIntervalo2">Objeto semáforo 2</param>
/// <returns>True (Se forem iguais), False (Se não forem iguais)</returns>
public static bool VerificarSemaforosSaoIguais(SemaforoPorIntervalo semaforoPorIntervalo1, SemaforoPorIntervalo semaforoPorIntervalo2)
{
if (semaforoPorIntervalo1.Oid != semaforoPorIntervalo2.Oid)
{
return(false);
}
return(true);
}
/// <summary>
/// Método que verifica se o intervalo atual é o mesmo que está sendo comparado, verifica se são iguais.
/// </summary>
/// <param name="inicio">Início do intervalo atual</param>
/// <param name="final">Final do intervalo atual</param>
/// <param name="semaforoPorIntervalo">Semáforo existente que está sendo comparado no momento</param>
/// <returns>Confirmação se são ou não iguais</returns>
public static bool RnValidarIntervalosIguais(short inicio, short final, SemaforoPorIntervalo semaforoPorIntervalo)
{
if (inicio == semaforoPorIntervalo.inicio && final == semaforoPorIntervalo.final)
{
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// Método responsável por verificar se final do intervalo está contido no semáforo atual.
/// </summary>
/// <param name="final">Final do intervalo</param>
/// <param name="semaforo">Semáforo já existente</param>
/// <returns>Confirmação se está ou não contido</returns>
public static bool RnVerificarFinalEstaContido(short final, SemaforoPorIntervalo semaforo)
{
if (semaforo != null)
{
if (final >= semaforo.inicio && final <= semaforo.final)
{
return(true);
}
}
return(false);
}
/// <summary>
/// Método responsável por verificar se início do intervalo está contido no semáforo atual.
/// </summary>
/// <param name="inicio">Início do intervalo</param>
/// <param name="semaforo">Semáforo já existente</param>
/// <returns>Confirmação se está ou não contido</returns>
public static bool RnVerificarInicioEstaContido(short inicio, SemaforoPorIntervalo semaforo)
{
if (semaforo != null)
{
if (inicio >= semaforo.inicio && inicio <= semaforo.final)
{
return(true);
}
}
return(false);
}
/// <summary>
/// Método responsável por gerar um intervalo
/// </summary>
/// <param name="inicio">Início do intervalo</param>
/// <param name="final">Final do intervalo</param>
/// <returns></returns>
public static List <short> CriarIntervalo(short inicio, short final)
{
List <short> novoIntervalo = new List <short>();
SemaforoPorIntervalo.ValidarParametrosCriarIntervalo(ref inicio, ref final);
int contador = final - inicio;
for (int i = 0; i <= contador; i++)
{
novoIntervalo.Add(inicio);
inicio++;
}
return(novoIntervalo);
}
/// <summary>
/// Método responsável por verificar se final do intervalo está contido na lista de semáforos já existentes.
/// </summary>
/// <param name="final">Final do intervalo</param>
/// <param name="semaforos">Semáforos já existentes</param>
/// <returns>Confirmação se está ou não contido</returns>
public static bool RnVerificarFinalEstaContido(short final, List <SemaforoPorIntervalo> semaforos)
{
SemaforoPorIntervalo semaforo = null;
if (semaforos.Count > 0)
{
semaforo = semaforos.Where(o => final >= o.inicio && final <= o.final).FirstOrDefault();
if (semaforo != null)
{
return(true);
}
}
return(false);
}
/// <summary>
/// Método que verifica se um intervalo pode ser adicionado na lista de aguarde ou não.
/// Caso ele não exista em nenhuma lista, então poderá adicionar.
/// </summary>
/// <param name="inicio">Início do intervalo atual</param>
/// <param name="final">Final do intervalo atual</param>
/// <param name="semaforosImpactadosAguardar">Lista de semáforos que irá aguardar</param>
/// <param name="semaforosImpactadosNovos">Lista de semáforos que irá criar</param>
/// <param name="semaforoPorIntervalo">Semáforo existente que está sendo comparado no momento</param>
/// <returns>Confirmação se pode adicionar ou não o semáforo na lista de aguarde</returns>
public static bool RnValidarAdicionarSemaforoParaAguarde(List <SemaforoPorIntervalo> semaforosImpactadosAguardar,
List <SemaforoPorIntervalo> semaforosImpactadosNovos,
SemaforoPorIntervalo semaforoPorIntervalo)
{
bool adicionar;
if (!RnValidarSemaforosIguaisPorLista(semaforosImpactadosAguardar, semaforosImpactadosNovos, semaforoPorIntervalo))
{
adicionar = true;
}
else
{
adicionar = false;
}
return(adicionar);
}
/// <summary>
/// Método que verifica se o intervalo atual se já está adicionado em alguma lista de aguarde ou de novos semáforos para criar.
/// </summary>
/// <param name="semaforosImpactadosAguardar">Lista de semáforos que irá aguardar</param>
/// <param name="semaforosImpactadosNovos">Lista de semáforos que irá criar</param>
/// <param name="semaforoPorIntervalo">Intervalo que está sendo verificado</param>
/// <returns>Confirmação se já está adicionado ou não.</returns>
public static bool RnValidarSemaforosIguaisPorLista(List <SemaforoPorIntervalo> semaforosImpactadosAguardar,
List <SemaforoPorIntervalo> semaforosImpactadosNovos,
SemaforoPorIntervalo semaforoPorIntervalo)
{
bool adicionado;
SemaforoPorIntervalo semaforoExistente = semaforosImpactadosAguardar.Where(o => semaforoPorIntervalo.inicio == o.inicio && semaforoPorIntervalo.final == o.final).FirstOrDefault();
SemaforoPorIntervalo semaforoNovo = semaforosImpactadosNovos.Where(o => semaforoPorIntervalo.inicio == o.inicio && semaforoPorIntervalo.final == o.final).FirstOrDefault();
if (semaforoExistente == null && semaforoNovo == null)
{
adicionado = false;
}
else
{
adicionado = true;
}
return(adicionado);
}
/// <summary>
/// Método responsável controlar o acesso de threads simultaneamente enquanto leem e escrevem tanto no dicionário de cronogramas quanto na lista de semáforos de cada cronograma.
/// Valida o acesso por cronograma e intervalo.
/// </summary>
/// <param name="oidCronograma">Oid cronograma</param>
/// <param name="inicio">Início do intervalo</param>
/// <param name="final">Final do intervalo</param>
public virtual Hashtable ControlarSemaforos(Guid oidCronograma, short inicio, short final)
{
Hashtable semaforos = new Hashtable();
ControlarIncrementacaoContadorAcessoPorCronograma(oidCronograma);
ControlarExclusaoSemaforosInativosPorCronograma(oidCronograma);
if (ValidarCronograma(oidCronograma))
{
semaforos = ConsultarSemaforosImpactadosPorCronograma(oidCronograma, inicio, final, semaforos);
ControlarExclusaoCronogramasInexistentes();
}
else
{
EsperarEscritaCronogramas();
if (semaforosPorCronograma.ContainsKey(oidCronograma))
{
LiberarEscritaCronogramas();
semaforos = ConsultarSemaforosImpactadosPorCronograma(oidCronograma, inicio, final, semaforos);
ControlarExclusaoCronogramasInexistentes();
ControlarDecrementacaoContadorAcessoPorCronograma(oidCronograma);
return(semaforos);
}
else
{
//cria um objeto SemaforoPorCronograma que armazena um semáforo e a lista de semáforos de um cronograma
SemaforosControle semaforosControle = new SemaforosControle()
{
lockerSemaforos = new ReaderWriterLockSlim(), semaforos = new List <SemaforoPorIntervalo>()
};
//cria um semáforo
SemaforoPorIntervalo novoSemaforo = new SemaforoPorIntervalo(inicio, final);
//cria uma lista para retornar na Hash
List <SemaforoPorIntervalo> semaforosNovos = new List <SemaforoPorIntervalo>();
semaforosNovos.Add(novoSemaforo);
//Adiciona o semáforo novo criado para retornar na hash
semaforos.Add(SEMAFOROS_NOVOS, semaforosNovos);
//adiciona o semáforo à lista de semáforo por cronograma.
semaforosControle.semaforos.Add(novoSemaforo);
//adiciona o cronograma e sua lista ao dicionário de cronogramas ativos.
semaforosPorCronograma.Add(oidCronograma, semaforosControle);
}
ControlarExclusaoCronogramasInexistentes();
LiberarEscritaCronogramas();
}
ControlarDecrementacaoContadorAcessoPorCronograma(oidCronograma);
return(semaforos);
}
/// <summary>
/// Método responsável por Liberar um semáforo e decrementar o contador, que indica se um semáforo está em espera, dos demais semáforos da lista que seria usada.
/// </summary>
/// <param name="semaforoPorIntervalo">Semáforo para liberar</param>
/// <param name="semaforosPorIntervalo">Lista de semáforos para decrementar o contador em espera</param>
/// <param name="indice">índice em que a lista irá começar a decrementar</param>
public static void LiberarSemaforoEDecrementarContadoresEmEsperaDosDemaisSemaforos(SemaforoPorIntervalo semaforoPorIntervalo, List <SemaforoPorIntervalo> semaforosPorIntervalo, int indice = 0)
{
SemaforoPorIntervalo.LiberarSemaforo(semaforoPorIntervalo);
SemaforoPorIntervalo.DecrementarContadorSemaforoEmEspera(semaforosPorIntervalo, indice);
}
/// <summary>
/// Método responsável por liberar um semáforo que está em espera e diminuir o atributo que indicar que ele está em espera.
/// </summary>
/// <param name="semaforoPorIntervalo">Semáforo para ser liberado</param>
public static void LiberarSemaforoEDecrementarContadorSemaforoEmEspera(SemaforoPorIntervalo semaforoPorIntervalo)
{
SemaforoPorIntervalo.LiberarSemaforo(semaforoPorIntervalo);
SemaforoPorIntervalo.DecrementarContadorSemaforoEmEspera(semaforoPorIntervalo);
}
/// <summary>
/// Método responsável por analisar a possibilidade de construir um semáforo e construí-lo quando início ou final de um intervalo não estiverem incorporados em outro.
/// </summary>
/// <param name="inicio">Início do intervalo</param>
/// <param name="final">Final do intervalo</param>
/// <param name="semaforoPorIntervalo">Semáforo atual</param>
/// <param name="semaforosExistentes">Lista de semáforos existentes</param>
/// <param name="semaforosImpactadosNovos">Lista de semáforos criados recentemente</param>
public static void RnConstruirSemaforoQueAbrangeInicioOuFinalSemaforoAtual(short inicio, short final, SemaforoPorIntervalo semaforoPorIntervalo,
ref List <SemaforoPorIntervalo> semaforosExistentes,
ref List <SemaforoPorIntervalo> semaforosImpactadosNovos)
{
//Verifica se o início está contido no semáforo em comparação, mas o final não está.
if (RnVerificarInicioEstaContido(inicio, semaforoPorIntervalo) && final > semaforoPorIntervalo.final)
{
int novoInicioIntervalo = semaforoPorIntervalo.final + 1;
List <short> novoIntervalo = CriarIntervalo(short.Parse(novoInicioIntervalo.ToString()), final);
RnCriarIntervaloNaoAbrangente(novoIntervalo, ref semaforosExistentes, ref semaforosImpactadosNovos);
}
//Verifica se o final está contido no semáforo em comparação, mas o início não está.
else if (inicio < semaforoPorIntervalo.inicio && RnVerificarFinalEstaContido(final, semaforoPorIntervalo))
{
int novoFinalIntervalo = semaforoPorIntervalo.inicio - 1;
List <short> novoIntervalo = CriarIntervalo(inicio, short.Parse(novoFinalIntervalo.ToString()));
RnCriarIntervaloNaoAbrangente(novoIntervalo, ref semaforosExistentes, ref semaforosImpactadosNovos);
}
}
/// <summary>
/// Verificar se um determinado intervalo incorpora outro intervalo, mas ainda contém pontos do intervalo não abrangidos.
/// </summary>
/// <param name="inicio">Início do intervalo</param>
/// <param name="final">Final do intervalo</param>
/// <param name="SemaforoPorIntervalo">semáforo para validar</param>
/// <returns>Confirmação se está ou não contido</returns>
public static bool RnVerificarInicioFinalCobremIntervaloAtual(short inicio, short final, SemaforoPorIntervalo semaforo)
{
if (semaforo != null)
{
if (inicio < semaforo.inicio && final > semaforo.final)
{
return(true);
}
}
return(false);
}
/// <summary>
/// Método responsável por consultar os semáforos que uma determinada thread de reordenação deverá esperar para então executar sua própria reordenação.
/// </summary>
/// <param name="oidCronograma">Oid do cronograma (índice do dicionário de cronogramas)</param>
/// <param name="inicio">Início do intervalo</param>
/// <param name="final">Final do intervalo</param>
/// <returns>Retorna uma lista contendo os semáforos que deve-se esperar</returns>
public Hashtable ConsultarSemaforosImpactadosPorCronograma(Guid oidCronograma, short inicio, short final, Hashtable semaforos)
{
List <SemaforoPorIntervalo> semaforosImpactadosAguardar = new List <SemaforoPorIntervalo>();
List <SemaforoPorIntervalo> semaforosImpactadosNovos = new List <SemaforoPorIntervalo>();
lock (semaforosPorCronograma[oidCronograma].semaforos)
{
EsperarLeituraSemaforos(oidCronograma);
if (semaforosPorCronograma[oidCronograma].semaforos.Count == 0)
{
semaforosImpactadosNovos.Add(new SemaforoPorIntervalo(inicio, final));
}
else
{
for (int i = 0; i < semaforosPorCronograma[oidCronograma].semaforos.Count; i++)
{
SemaforoPorIntervalo.VerificarSemaforosImpactados(ref semaforosImpactadosAguardar, ref semaforosImpactadosNovos, ref semaforosImpactadosNovos,
semaforosPorCronograma[oidCronograma].semaforos[i], inicio, final);
if (semaforosImpactadosNovos.Count > 0)
{
if (semaforosImpactadosAguardar.Count > 0)
{
for (int indice = 0; indice < semaforosImpactadosAguardar.Count; indice++)
{
SemaforoPorIntervalo.DecrementarContadorSemaforoEmEspera(semaforosImpactadosAguardar[indice]);
}
}
break;
}
}
}
LiberarLeituraSemaforos(oidCronograma);
if (semaforosImpactadosNovos.Count > 0)
{
EsperarEscritaSemaforos(oidCronograma);
semaforosImpactadosAguardar.Clear();
semaforosImpactadosNovos.Clear();
List <SemaforoPorIntervalo> semaforosExistentes = semaforosPorCronograma[oidCronograma].semaforos;
if (semaforosPorCronograma[oidCronograma].semaforos.Count == 0)
{
SemaforoPorIntervalo novoSemaforo = new SemaforoPorIntervalo(inicio, final);
semaforosPorCronograma[oidCronograma].semaforos.Add(novoSemaforo);
semaforosImpactadosNovos.Add(novoSemaforo);
}
else
{
for (int i = 0; i < semaforosPorCronograma[oidCronograma].semaforos.Count; i++)
{
if (semaforosPorCronograma[oidCronograma].semaforos[i].semaforo != null)
{
SemaforoPorIntervalo.IncrementarContadorSemaforoEmEspera(semaforosPorCronograma[oidCronograma].semaforos[i]);
SemaforoPorIntervalo.VerificarSemaforosImpactados(ref semaforosImpactadosAguardar, ref semaforosImpactadosNovos, ref semaforosExistentes,
semaforosPorCronograma[oidCronograma].semaforos[i], inicio, final);
SemaforoPorIntervalo.DecrementarContadorSemaforoEmEspera(semaforosPorCronograma[oidCronograma].semaforos[i]);
}
else
{
semaforosPorCronograma[oidCronograma] = new SemaforosControle()
{
lockerSemaforos = new ReaderWriterLockSlim(), semaforos = new List <SemaforoPorIntervalo>()
};
//cria um semáforo
SemaforoPorIntervalo novoSemaforo = new SemaforoPorIntervalo(inicio, final);
semaforosImpactadosNovos.Add(novoSemaforo);
semaforosPorCronograma[oidCronograma].semaforos.Add(novoSemaforo);
}
}
}
LiberarEscritaSemaforos(oidCronograma);
}
}
semaforos.Add(SEMAFOROS_AGUARDAR, semaforosImpactadosAguardar);
semaforos.Add(SEMAFOROS_NOVOS, semaforosImpactadosNovos);
return(semaforos);
}
/// <summary>
/// Método responsável por liberar o semáforo.
/// </summary>
/// <param name="semaforo">Semáforo que deseja efeturar a liberação (release)</param>
/// <param name="posicoesLiberadas">Quantidade de posições que serão liberadas no semáforo</param>
public static void LiberarSemaforo(SemaforoPorIntervalo semaforoPorIntervalo)
{
semaforoPorIntervalo.semaforo.Release();
}
/// <summary>
/// Método responsável por analisar a possibilidade de construir um semáforo e construí-lo quando um intervalo abrangir
/// outro semáforo por completo, mas ainda assim existir intervalo não incorporados em outro.
/// </summary>
/// <param name="inicio">Início do intervalo</param>
/// <param name="final">Final do intervalo</param>
/// <param name="semaforoPorIntervalo">Semáforo atual</param>
/// <param name="semaforosExistentes">Lista de semáforos existentes</param>
/// <param name="semaforosImpactadosNovos">Lista de semáforos criados recentemente</param>
public static void RnConstruirSemaforoQueAbrangeSemaforoAtual(short inicio, short final, SemaforoPorIntervalo semaforoPorIntervalo,
ref List <SemaforoPorIntervalo> semaforosExistentes,
ref List <SemaforoPorIntervalo> semaforosImpactadosNovos)
{
//Criando início
int novoFinalIntervalo = semaforoPorIntervalo.inicio - 1;
List <short> novoIntervalo = CriarIntervalo(inicio, short.Parse(novoFinalIntervalo.ToString()));
RnCriarIntervaloNaoAbrangente(novoIntervalo, ref semaforosExistentes, ref semaforosImpactadosNovos);
//Criando final
int novoInicioIntervalo = semaforoPorIntervalo.final + 1;
novoIntervalo = CriarIntervalo(short.Parse(novoInicioIntervalo.ToString()), final);
RnCriarIntervaloNaoAbrangente(novoIntervalo, ref semaforosExistentes, ref semaforosImpactadosNovos);
}
/// <summary>
/// Método responsável por verificar se um intervalo está totalmente contido num semáforo já existente.
/// </summary>
/// <param name="inicio">Início do intervalo</param>
/// <param name="final">Final do intervalo</param>
/// <param name="semaforo">Semáforo já existente, o qual desejasse comparar se está contido</param>
/// <returns>Confirmação se está ou não contido</returns>
public static bool RnVerificarInicioFinalIntervaloEstaContidoEmOutroIntervalo(short inicio, short final, SemaforoPorIntervalo semaforo)
{
if (semaforo != null)
{
if (inicio >= semaforo.inicio && final <= semaforo.final)
{
return(true);
}
}
return(false);
}