namespace GMW_data.Type
{
    public class elenchi
    {
        public elenchi()
        {
        }

        #region area tipo dichiarazione

        protected TipoDichiarazione[] _elencoTipoDichiaraz;

        /// <summary>
        /// legge una tab di tipo AnagTipoDichiaraz e la converte ad un array di tipo TipoDichiarazione[]
        /// </summary>
        /// <param name="tabTipoDichiaraz"></param>
        public void caricaTipoDichiarazioni(DS_Applicazione.AnagTipoDichiarazDataTable tabTipoDichiaraz)
        {
            // conto quanti elementi ha la tab x inizializzare l'array...
            int numRighe = tabTipoDichiaraz.Rows.Count;
            _elencoTipoDichiaraz = new TipoDichiarazione[numRighe];
            // prendo un obj impianto da valorizzare di volta in volta...
            TipoDichiarazione obj;
            for (int i = 0; i < numRighe; i++)
            {
                obj = new TipoDichiarazione(tabTipoDichiaraz[i]);
                _elencoTipoDichiaraz[i] = obj;
            }
        }
        /// <summary>
        /// Elenco tipo di dichiarazioni ammesse
        /// </summary>
        public TipoDichiarazione[] elencoTipoDichiaraz
        {
            get
            {
                return _elencoTipoDichiaraz;
            }
        }

        #endregion

        #region area stato prodotti

        protected StatiProdotto[] _elencoStatiProdotto;

        /// <summary>
        /// legge una tab di tipo AnagStatiProdotto e la converte ad un array di tipo StatiProdotto[]
        /// </summary>
        /// <param name="tabTipoDichiaraz"></param>
        public void caricaStatiProdotto(DS_Applicazione.AnagStatiProdottoDataTable tabStatiProd)
        {
            // conto quanti elementi ha la tab x inizializzare l'array...
            int numRighe = tabStatiProd.Rows.Count;
            _elencoStatiProdotto = new StatiProdotto[numRighe];
            // prendo un obj impianto da valorizzare di volta in volta...
            StatiProdotto obj;
            for (int i = 0; i < numRighe; i++)
            {
                obj = new StatiProdotto(tabStatiProd[i]);
                _elencoStatiProdotto[i] = obj;
            }
        }
        /// <summary>
        /// Elenco degli stati del prodotto ammessi
        /// </summary>
        public StatiProdotto[] elencoStatiProdotto
        {
            get
            {
                return _elencoStatiProdotto;
            }
        }

        #endregion

        #region area Company Sito


        protected CompanySito[] _elencoCompanySito;

        /// <summary>
        /// legge una tab di tipo AnagArticoli e la converte ad un array di tipo Articolo[]
        /// </summary>
        /// <param name="tabArticoli"></param>
        public void caricaCompanySito(DS_Applicazione.AnagCompanySitoDataTable tabCS)
        {
            // conto quanti elementi ha la tab x inizializzare l'array...
            int numRighe = tabCS.Rows.Count;
            _elencoCompanySito = new CompanySito[numRighe];
            // prendo un obj impianto da valorizzare di volta in volta...
            CompanySito obj;
            for (int i = 0; i < numRighe; i++)
            {
                obj = new CompanySito(tabCS[i]);
                _elencoCompanySito[i] = obj;
            }
        }
        /// <summary>
        /// Elenco Company/Sito
        /// </summary>
        public CompanySito[] elencoCompanySito
        {
            get
            {
                return _elencoCompanySito;
            }
        }

        #endregion

        #region area impianti

        protected Impianto[] _elencoImpianti;

        /// <summary>
        /// legge una tab di tipo AnagImpianti e la converte ad un array di tipo Impianto[]
        /// </summary>
        /// <param name="tabImpianti"></param>
        public void caricaImpianti(DS_Applicazione.AnagImpiantiDataTable tabImpianti)
        {
            // conto quanti elementi ha la tab x inizializzare l'array...
            int numRighe = tabImpianti.Rows.Count;
            _elencoImpianti = new Impianto[numRighe];
            // prendo un obj impianto da valorizzare di volta in volta...
            Impianto obj;
            for (int i = 0; i < numRighe; i++)
            {
                obj = new Impianto(tabImpianti[i]);
                _elencoImpianti[i] = obj;
            }
        }
        /// <summary>
        /// Elenco Impianti
        /// </summary>
        public Impianto[] elencoImpianti
        {
            get
            {
                return _elencoImpianti;
            }
        }

        #endregion

        #region area imballi

        protected Imballo[] _elencoImballi;

        /// <summary>
        /// legge una tab di tipo AnagImballi e la converte ad un array di tipo Imballo[]
        /// </summary>
        /// <param name="tabImpianti"></param>
        public void caricaImballi(DS_Applicazione.AnagImballiDataTable tabImballi)
        {
            // conto quanti elementi ha la tab x inizializzare l'array...
            int numRighe = tabImballi.Rows.Count;
            _elencoImballi = new Imballo[numRighe];
            // prendo un obj impianto da valorizzare di volta in volta...
            Imballo obj;
            for (int i = 0; i < numRighe; i++)
            {
                obj = new Imballo(tabImballi[i]);
                _elencoImballi[i] = obj;
            }
        }
        /// <summary>
        /// Elenco Imballi
        /// </summary>
        public Imballo[] elencoImballi
        {
            get
            {
                return _elencoImballi;
            }
        }

        #endregion

        #region area bilance

        protected Bilancia[] _elencoBilance;

        /// <summary>
        /// legge una tab di tipo AnagBilance e la converte ad un array di tipo Bilancia[]
        /// </summary>
        /// <param name="tabImpianti"></param>
        public void caricaBilance(DS_Applicazione.AnagBilanceDataTable tabBilance)
        {
            // conto quanti elementi ha la tab x inizializzare l'array...
            int numRighe = tabBilance.Rows.Count;
            _elencoBilance = new Bilancia[numRighe];
            // prendo un obj impianto da valorizzare di volta in volta...
            Bilancia obj;
            for (int i = 0; i < numRighe; i++)
            {
                obj = new Bilancia(tabBilance[i]);
                _elencoBilance[i] = obj;
            }
        }
        /// <summary>
        /// Elenco Bilance
        /// </summary>
        public Bilancia[] elencoBilance
        {
            get
            {
                return _elencoBilance;
            }
        }

        #endregion

        #region area articoli in prod

        protected ArtInProd[] _elencoArtInProd;

        /// <summary>
        /// legge una tab di tipo Impianti2Articoli e la converte ad un array di tipo ArtInProd[]
        /// </summary>
        /// <param name="tabArt2Imp"></param>
        public void caricaArtInProd(DS_Applicazione.v_ArtInProdDataTable tabArtInProd)
        {
            // conto quanti elementi ha la tab x inizializzare l'array...
            int numRighe = tabArtInProd.Rows.Count;
            _elencoArtInProd = new ArtInProd[numRighe];
            // prendo un obj impianto da valorizzare di volta in volta...
            ArtInProd obj;
            for (int i = 0; i < numRighe; i++)
            {
                obj = new ArtInProd(tabArtInProd[i]);
                _elencoArtInProd[i] = obj;
            }
        }
        /// <summary>
        /// Elenco Articoli in produzione
        /// </summary>
        public ArtInProd[] elencoArtInProd
        {
            get
            {
                return _elencoArtInProd;
            }
        }

        #endregion

        #region area Cartellino

        protected Cartellino[] _ElencoCartellini;

        /// <summary>
        /// legge una tab di tipo ElencoCartellini e la converte ad un array di tipo cartellini[]
        /// </summary>
        /// <param name="tabArt2Imp"></param>
        public void caricaCartellini(DS_Applicazione.ElencoCartelliniDataTable tabArt2Imp)
        {
            // conto quanti elementi ha la tab x inizializzare l'array...
            int numRighe = tabArt2Imp.Rows.Count;
            _ElencoCartellini = new Cartellino[numRighe];
            // prendo un obj impianto da valorizzare di volta in volta...
            Cartellino obj;
            for (int i = 0; i < numRighe; i++)
            {
                obj = new Cartellino(tabArt2Imp[i]);
                _ElencoCartellini[i] = obj;
            }
        }
        /// <summary>
        /// Elenco cartellini
        /// </summary>
        public Cartellino[] ElencoCartellini
        {
            get
            {
                return _ElencoCartellini;
            }
        }

        #endregion

        #region area Clienti

        protected Cliente[] _elencoClienti;

        /// <summary>
        /// legge una tab di tipo anagClienti e la converte ad un array di tipo clienti[]
        /// </summary>
        /// <param name="tabArt2Imp"></param>
        public void caricaClienti(DS_Applicazione.AnagClientiDataTable tabArt2Imp)
        {
            // conto quanti elementi ha la tab x inizializzare l'array...
            int numRighe = tabArt2Imp.Rows.Count;
            _elencoClienti = new Cliente[numRighe];
            // prendo un obj impianto da valorizzare di volta in volta...
            Cliente obj;
            for (int i = 0; i < numRighe; i++)
            {
                obj = new Cliente(tabArt2Imp[i]);
                _elencoClienti[i] = obj;
            }
        }
        /// <summary>
        /// Elenco clienti
        /// </summary>
        public Cliente[] elencoClienti
        {
            get
            {
                return _elencoClienti;
            }
        }

        #endregion

        #region area Operatori

        protected Operatore[] _elencoOperatori;

        /// <summary>
        /// legge una tab di tipo anagOperatori e la converte ad un array di tipo operatori[]
        /// </summary>
        /// <param name="tabArt2Imp"></param>
        public void caricaOperatori(DS_Applicazione.AnagOperatoriDataTable tabArt2Imp)
        {
            // conto quanti elementi ha la tab x inizializzare l'array...
            int numRighe = tabArt2Imp.Rows.Count;
            _elencoOperatori = new Operatore[numRighe];
            // prendo un obj impianto da valorizzare di volta in volta...
            Operatore obj;
            for (int i = 0; i < numRighe; i++)
            {
                obj = new Operatore(tabArt2Imp[i]);
                _elencoOperatori[i] = obj;
            }
        }
        /// <summary>
        /// Elenco Operatori
        /// </summary>
        public Operatore[] elencoOperatori
        {
            get
            {
                return _elencoOperatori;
            }
        }

        #endregion


        #region area specifiche particolari

        protected SpecParticolare[] _elencoSpecPart;

        /// <summary>
        /// legge una tab di tipo SpecPart e la converte ad un array di tipo SpecParticolare[]
        /// </summary>
        /// <param name="tabArt2Imp"></param>
        public void caricaSpecPart(DS_Applicazione.v_specParticolariDataTable tab2imp)
        {
            // conto quanti elementi ha la tab x inizializzare l'array...
            int numRighe = tab2imp.Rows.Count;
            _elencoSpecPart = new SpecParticolare[numRighe];
            // prendo un obj impianto da valorizzare di volta in volta...
            SpecParticolare obj;
            for (int i = 0; i < numRighe; i++)
            {
                obj = new SpecParticolare(tab2imp[i]);
                _elencoSpecPart[i] = obj;
            }
        }
        /// <summary>
        /// Elenco specifiche particolari
        /// </summary>
        public SpecParticolare[] elencoSpecPart
        {
            get
            {
                return _elencoSpecPart;
            }
        }

        #endregion

    }
}
