Exemplo n.º 1
0
        protected List <ErroPosicao> CompararObjeto(ObjetoComparacaoLista pOutro)
        {
            List <ErroPosicao> diferencas = new List <ErroPosicao>();

            double deltaComprimento = Math.Abs(this.Comprimento - pOutro.Comprimento);

            if (deltaComprimento > 0.1)
            {
                bool ncMelhoria = deltaComprimento > 2;

                diferencas.Add(new DivergenciaComprimento(this.Comprimento, pOutro.Comprimento));
            }

            if (this.SiglaMaterial != pOutro.SiglaMaterial)
            {
                diferencas.Add(new DivergenciaMaterial());
            }

            if (this.QuantidadePecasNoComponente != pOutro.QuantidadePecasNoComponente)
            {
                diferencas.Add(new DivergenciaQuantidadePecas(this.QuantidadePecasNoComponente, pOutro.QuantidadePecasNoComponente));
            }

            if (this.QuantidadeRecortes != pOutro.QuantidadeRecortes)
            {
                diferencas.Add(new DivergenciaQuantidadeRecortes(this.QuantidadeRecortes, pOutro.QuantidadeRecortes));
            }

            if (this.QuantidadeDobras != pOutro.QuantidadeDobras)
            {
                diferencas.Add(new DivergenciaQuantidadeDobras(this.QuantidadeDobras, pOutro.QuantidadeDobras));
            }

            if (this.QuantidadeChanfros != pOutro.QuantidadeChanfros)
            {
                diferencas.Add(new DivergenciaQuantidadeChanfros(this.QuantidadeChanfros, pOutro.QuantidadeChanfros));
            }

            if (this.TemDegrau != pOutro.TemDegrau)
            {
                diferencas.Add(new DivergenciaDegrau(this.TemDegrau, pOutro.TemDegrau));
            }

            if (this.NumeracaoDireitaComSigla != pOutro.NumeracaoDireitaComSigla)
            {
                diferencas.Add(new DivergenciaEsquerda(this.NumeracaoDireitaComSigla, pOutro.NumeracaoDireitaComSigla));
            }

            if (this.NumeracaoConjuntoSoldado != pOutro.NumeracaoConjuntoSoldado)
            {
                diferencas.Add(new DivergenciaConjuntoSoldado(this.NumeracaoConjuntoSoldado, pOutro.NumeracaoConjuntoSoldado));
            }

            return(diferencas);
        }
        /// <summary>
        /// Compara o objeto com o outro
        /// </summary>
        /// <param name="pOutro"></param>
        /// <returns></returns>
        public override List <ErroPosicao> CompararComObjeto(ObjetoComparacaoLista pOutro)
        {
            List <ErroPosicao> diferencas = new List <ErroPosicao>();

            if (pOutro is CantoneiraComparacaoLista)
            {
                diferencas.Add(new DivergenciaPecasTipo());
            }
            else
            {
                diferencas.AddRange(this.CompararObjeto(pOutro));

                ChapaComparacaoLista outraChapaComparacao = pOutro as ChapaComparacaoLista;

                if (this.Calota)
                {
                    if (Math.Abs(this.DiametroCalota - outraChapaComparacao.DiametroCalota) > 0.1)
                    {
                        diferencas.Add(new DivergenciaDiametroCalota(this.DiametroCalota, outraChapaComparacao.DiametroCalota));
                    }

                    if (Math.Abs(this.DiametroFuroCalota - outraChapaComparacao.DiametroFuroCalota) > 0.1)
                    {
                        diferencas.Add(new DivergenciaFuroCalota(this.DiametroFuroCalota, outraChapaComparacao.DiametroFuroCalota));
                    }

                    if (Math.Abs(this.RaioUsinagemCalota - outraChapaComparacao.RaioUsinagemCalota) > 0.1)
                    {
                        diferencas.Add(new DivergenciaRaioUsinagemCalota(this.RaioUsinagemCalota, outraChapaComparacao.RaioUsinagemCalota));
                    }
                }

                else
                {
                    if (Math.Abs(this.Largura - outraChapaComparacao.Largura) > 0.1)
                    {
                        diferencas.Add(new DivergenciaLargura(this.Largura, outraChapaComparacao.Largura));
                    }

                    if (Math.Abs(this.Espessura - pOutro.Espessura) > 0.1)
                    {
                        diferencas.Add(new DivergenciaEspessura(this.Espessura, outraChapaComparacao.Espessura));
                    }
                }
            }

            return(diferencas);
        }
        public override List <ErroPosicao> CompararComObjeto(ObjetoComparacaoLista pOutro)
        {
            List <ErroPosicao> diferencas = new List <ErroPosicao>();

            if (pOutro is ChapaComparacaoLista)
            {
                diferencas.Add(new DivergenciaPecasTipo());
            }
            else
            {
                diferencas.AddRange(this.CompararObjeto(pOutro));

                CantoneiraComparacaoLista outraCantoneiraComparacao = pOutro as CantoneiraComparacaoLista;

                if (Math.Abs(this.Aba - outraCantoneiraComparacao.Aba) > 0.1 || Math.Abs(this.Espessura - pOutro.Espessura) > 0.1)
                {
                    diferencas.Add(new DivergenciaPerfilCantoneira(this.PerfilSimples, outraCantoneiraComparacao.PerfilSimples));
                }
            }

            return(diferencas);
        }
Exemplo n.º 4
0
 public abstract List <ErroPosicao> CompararComObjeto(ObjetoComparacaoLista pOutro);