/// <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); }