Ejemplo n.º 1
0
        public override void Wykonaj()
        {
            foreach (KlocekPionowy klocekPionowy in Zawartość)
            {
                if (SkokPętli)
                {
                    break;
                }
                else
                {
                    if (klocekPionowy.PunktPrzerwania)
                    {
                        KlocekPionowyZZawartością klocekPionowyZZawartością = this;

                        while (!(klocekPionowyZZawartością is RozpoczęcieProgramu))
                        {
                            klocekPionowyZZawartością = klocekPionowyZZawartością.Rodzic;
                        }

                        klocekPionowyZZawartością.Debugowanie = true;
                    }

                    klocekPionowy.AktualnieWykonywany = true;

                    if (klocekPionowy.PunktPrzerwania || klocekPionowy.KrokPoKroku)
                    {
                        Semafor.Opuść();
                    }

                    klocekPionowy.Wykonaj();

                    klocekPionowy.AktualnieWykonywany = false;
                }
            }
        }
Ejemplo n.º 2
0
        private void COmpress(long streamStartPosition, int blockLength, int blockOrder)
        {
            //читаем часть из файла
            byte[] Buffer = new byte[blockLength]; // размер буфера
            using (var FS = File.OpenRead(inputPath))
            {
                FS.Seek(streamStartPosition, SeekOrigin.Begin);// устанавливаем позицию в потоке со смещением
                FS.Read(Buffer, 0, blockLength);
            }

            // сжимаем эту часть

            byte[] compresBuffer;

            using (var ms = new MemoryStream())
            {
                using (var GZ = new GZipStream(ms, CompressionMode.Compress, true))
                {
                    GZ.Write(Buffer, 0, Buffer.Length);
                }

                compresBuffer = ms.ToArray();
            }

            // отправляем на запись в очередь
            Semafor.Wait();
            buffer_Queue.Enqueue(blockOrder, compresBuffer);
            Console.Write("*"); // визуально показывает что операция идет
        }
Ejemplo n.º 3
0
        private void WykonajNastępnyKrok()
        {
            if (WPunkciePrzerwania)
            {
                RozpoczęcieProgramu.KrokPoKroku = true;

                Semafor.Podnieś();
            }
        }
Ejemplo n.º 4
0
        private void KontynuujWykonywanie()
        {
            if (WPunkciePrzerwania)
            {
                WPunkciePrzerwania = false;
                RozpoczęcieProgramu.KrokPoKroku = false;

                Semafor.Podnieś();
            }
        }
Ejemplo n.º 5
0
        public override void Wykonaj()
        {
            SprawdźPoprawnośćKlockówKonfigurujących();

            bool warunek = (Wartość[0] != null) && Wartość.Zwróć <bool>(false) && !Błąd;

            if (warunek)
            {
                base.Wykonaj();
            }
            else
            {
                foreach (KlocekPionowy klocekPionowy in AlternatywnaZawartość)
                {
                    if (SkokPętli)
                    {
                        break;
                    }
                    else
                    {
                        if (klocekPionowy.PunktPrzerwania)
                        {
                            KlocekPionowyZZawartością klocekPionowyZZawartością = this;

                            while (!(klocekPionowyZZawartością is RozpoczęcieProgramu))
                            {
                                klocekPionowyZZawartością = klocekPionowyZZawartością.Rodzic;
                            }

                            klocekPionowyZZawartością.Debugowanie = true;
                        }

                        klocekPionowy.AktualnieWykonywany = true;

                        if (klocekPionowy.PunktPrzerwania || klocekPionowy.KrokPoKroku)
                        {
                            Semafor.Opuść();
                        }

                        klocekPionowy.Wykonaj();

                        klocekPionowy.AktualnieWykonywany = false;
                    }
                }
            }
        }
Ejemplo n.º 6
0
        /// <summary>
        /// Распаковываю  отдельный блок данных из исходного файла
        /// </summary>
        /// <param name="Position_in_stream">Смещение блока данных от начала файла</param>
        /// <param name="blockOrder">Порядок блока</param>
        private void DecompressBlock(long Position_in_stream, int blockOrder)
        {
            using (var inputStream = File.OpenRead(inputPath))
            {
                inputStream.Seek(Position_in_stream, SeekOrigin.Begin);

                using (var compressStream = new GZipStream(inputStream, CompressionMode.Decompress, true))
                {
                    int bufferNumber = 0;

                    byte[] buffer    = new byte[BlockSize];
                    int    bytesRead = compressStream.Read(buffer, 0, buffer.Length);
                    if (bytesRead < BlockSize)
                    {
                        Array.Resize(ref buffer, bytesRead);
                    }

                    byte[] nextBuffer = new byte[BlockSize];
                    while (bytesRead > 0)
                    {
                        bytesRead = compressStream.Read(nextBuffer, 0, nextBuffer.Length);

                        if (bytesRead < BlockSize)
                        {
                            Array.Resize(ref nextBuffer, bytesRead);
                        }

                        Semafor.Wait();
                        buffer_Queue.Enqueue(blockOrder, bufferNumber, buffer, nextBuffer.Length == 0);

                        buffer     = nextBuffer;
                        nextBuffer = new byte[BlockSize];

                        bufferNumber++;
                    }
                }
            }
        }
Ejemplo n.º 7
0
        public void PrzeczytajZXml(XElement elementXml, Konsola konsola, Semafor semafor, ObservableCollection <Zmienna> zmienne)
        {
            foreach (PropertyInfo właściwość in GetType().GetProperties())
            {
                Type     typWłaściwości   = właściwość.PropertyType;
                XElement węzełWłaściwości = elementXml.Element(właściwość.Name);

                if ((węzełWłaściwości != null) && !węzełWłaściwości.IsEmpty)
                {
                    if (właściwość.GetSetMethod() == null)
                    {
                        if (typWłaściwości == typeof(WartośćWewnętrznegoKlockaZwracającegoWartość))
                        {
                            XElement węzełWartości = węzełWłaściwości.Elements().Single();
                            Type     typKlockaZwracającegoWartość = Type.GetType(węzełWartości.Name.LocalName);

                            if (typKlockaZwracającegoWartość != null)
                            {
                                KlocekZwracającyWartość klocekZwracającyWartość      = (KlocekZwracającyWartość)Activator.CreateInstance(typKlockaZwracającegoWartość);
                                WartośćWewnętrznegoKlockaZwracającegoWartość wartość = (WartośćWewnętrznegoKlockaZwracającegoWartość)właściwość.GetValue(this);
                                klocekZwracającyWartość.MiejsceUmieszczenia = wartość;
                                wartość[0] = klocekZwracającyWartość;

                                klocekZwracającyWartość.PrzeczytajZXml(węzełWartości, konsola, semafor, zmienne);
                            }
                        }
                        else if (typWłaściwości == typeof(ZawartośćKlockaPionowegoZZawartością))
                        {
                            foreach (XElement węzełKlockaPionowego in węzełWłaściwości.Elements())
                            {
                                Type typKlockaPionowego = Type.GetType(węzełKlockaPionowego.Name.LocalName);

                                if (typKlockaPionowego != null)
                                {
                                    KlocekPionowy klocekPionowy = (KlocekPionowy)Activator.CreateInstance(typKlockaPionowego);
                                    klocekPionowy.Rodzic = (KlocekPionowyZZawartością)this;
                                    ZawartośćKlockaPionowegoZZawartością zawartość = (ZawartośćKlockaPionowegoZZawartością)właściwość.GetValue(this);

                                    klocekPionowy.PrzeczytajZXml(węzełKlockaPionowego, konsola, semafor, zmienne);
                                    zawartość.Add(klocekPionowy);
                                }
                            }
                        }
                    }
                    else
                    {
                        if (typWłaściwości == typeof(KlocekPionowyZZawartością))
                        {
                        }
                        else if (typWłaściwości == typeof(Konsola))
                        {
                            właściwość.SetValue(this, konsola);
                        }
                        else if (typWłaściwości == typeof(Semafor))
                        {
                            właściwość.SetValue(this, semafor);
                        }
                        else if (typWłaściwości == typeof(WartośćWewnętrznegoKlockaZwracającegoWartość))
                        {
                        }
                        else if (typWłaściwości == typeof(Zmienna))
                        {
                            właściwość.SetValue(this, zmienne.Single(z => z.Nazwa == węzełWłaściwości.Value));
                        }
                        else if ((typWłaściwości == typeof(bool)) || (typWłaściwości == typeof(double)) || (typWłaściwości == typeof(string)))
                        {
                            właściwość.SetValue(this, Convert.ChangeType(węzełWłaściwości.Value, typWłaściwości));
                        }
                        else
                        {
                            Type typOpcji = Type.GetType(węzełWłaściwości.Value);

                            if (typOpcji != null)
                            {
                                właściwość.SetValue(this, Activator.CreateInstance(typOpcji));
                            }
                        }
                    }
                }
            }
        }
Ejemplo n.º 8
0
        private void WyłączEdytowalność()
        {
            Edytowalna = false;

            Semafor?.Set();
        }
Ejemplo n.º 9
0
        public Główny()
        {
            Semafor      = new Semafor();
            MagazynZmian = new MagazynZmian();
            Konsola      = new Konsola();
            KomendaCofnięciaStanuAplikacji          = new Komenda(CofnijStanAplikacji);
            KomendaDodaniaUsunięciaPunktuPrzerwania = new Komenda(DodajUsuńPunktPrzerwania);
            KomendaDodaniaZmiennej                            = new Komenda(DodajZmienną);
            KomendaKontynuacjiWykonywania                     = new Komenda(KontynuujWykonywanie);
            KomendaKopiowaniaKlocka                           = new Komenda(KopiujKlocek);
            KomendaPrzejęciaSkupienia                         = new Komenda(PrzejmijSkupienie);
            KomendaPrzywróceniaStanuAplikacji                 = new Komenda(PrzywróćStanAplikacji);
            KomendaStartuProgramu                             = new Komenda(RozpocznijWykonywanieProgramu);
            KomendaUsunięciaKlockaPionowego                   = new Komenda(UsuńKlocekPionowy);
            KomendaUsunięciaKlockaZwracającegoWartość         = new Komenda(UsuńKlocekZwracającyWartość);
            KomendaUsunięciaZmiennej                          = new Komenda(UsuńZmienną);
            KomendaWycięciaKlocka                             = new Komenda(WytnijKlocek);
            KomendaWykonaniaNastępnegoKroku                   = new Komenda(WykonajNastępnyKrok);
            KomendaZamknięciaOkna                             = new Komenda(ZamknijOkno);
            KomendaZatrzymaniaDebugowania                     = new Komenda(ZatrzymajDebugowanie);
            KomendaZwinięciaRozwinięciaKlockaZZawartością     = new Komenda(ZwińRozwińKlocekZZawartością);
            ObsługującyPrzeciąganieZPrzybornika               = new ObsługującyPrzeciąganieZPrzybornika();
            ObsługującyPrzenoszenieKlockówPionowych           = new ObsługującyPrzenoszenieKlockówPionowych();
            ObsługującyPrzenoszenieKlockówZwracającychWartość = new ObsługującyPrzenoszenieKlockówZwracającychWartość();
            ObsługującyUpuszczanieKlockówPionowych            = new ObsługującyUpuszczanieKlockówPionowych(DodajDziałanie);
            ObsługującyUpuszczanieKlockówZwracającychWartość  = new ObsługującyUpuszczanieKlockówZwracającychWartość(DodajDziałanie);
            Powiększenie        = 1;
            RozpoczęcieProgramu = new RozpoczęcieProgramu {
                Semafor = Semafor
            };
            Schowek = new ObservableCollection <Klocek> {
                null
            };
            Zmienne = new ObservableCollection <Zmienna>();
            Semafor.SemaforOpuszczony += _semafor_SemaforOpuszczony;

            CechyLiczby = new OpcjaZwracającaWartośćNaPodstawieParametru <bool, double>[]
            {
                new Parzystość(),
                new Nieparzystość(),
                new Całkowitość(),
                new Dodatniość(),
                new Ujemność()
            };

            DziałaniaLogiczne = new OpcjaZwracającaWartośćNaPodstawieDwóchParametrów <bool, bool, bool>[]
            {
                new Koniunkcja(),
                new Alternatywa()
            };

            DziałaniaMatematyczne = new OpcjaZwracającaWartośćNaPodstawieDwóchParametrów <double, double, double>[]
            {
                new Dodawanie(),
                new Odejmowanie(),
                new Mnożenie(),
                new Dzielenie(),
                new Potęgowanie(),
                new Modulo()
            };

            DziałaniaMatematyczneNaLiście = new OpcjaZwracającaWartośćNaPodstawieParametru <double, ZmiennaTypuListowego>[]
            {
                new SumaListy(),
                new MinimumListy(),
                new MaksimumListy(),
                new ŚredniaListy()
            };

            FunkcjeMatematyczne = new OpcjaZwracającaWartośćNaPodstawieParametru <double, double>[]
            {
                new PierwiastekKwadratowy(),
                new WartośćBezwzględna(),
                new WartośćOdwrotna(),
                new LogarytmNaturalny(),
                new LogarytmOPodstawie10(),
                new FunkcjaEksponencjalna(),
                new PotęgaOPodstawie10()
            };

            FunkcjeTrygonometryczne = new OpcjaZwracającaWartośćNaPodstawieParametru <double, double>[]
            {
                new Sinus(),
                new Cosinus(),
                new Tangens(),
                new ArcusSinus(),
                new ArcusCosinus(),
                new ArcusTangens()
            };

            ModyfikacjeElementuListy = new TypUstawieniaElementuListy[]
            {
                new UstawienieElementu(),
                new WstawienieElementu()
            };

            ObcinaniaSpacji = new OpcjaZwracającaWartośćNaPodstawieParametru <object, object>[]
            {
                new ObcinanieSpacjiZObuStron(),
                new ObcinanieSpacjiZLewejStrony(),
                new ObcinanieSpacjiZPrawejStrony()
            };

            PobieraniaTekstu = new PobieranieTekstu[]
            {
                new PobieranieTekstuTekstowego(),
                new PobieranieTekstuLiczbowego()
            };

            PorządkiSortowania = new PorządekSortowania[]
            {
                new SortowanieRosnąco(),
                new SortowanieMalejąco()
            };

            SortowaniaListy = new SposóbSortowaniaListy[]
            {
                new SortowanieLiczbowe(),
                new SortowanieAlfabetyczne()
            };

            StałeLogiczne = new OpcjaZwracającaWartość <bool>[]
            {
                new Prawda(),
                new Fałsz()
            };

            StałeMatematyczne = new OpcjaZwracającaWartość <double>[]
            {
                new Pi(),
                new LiczbaE(),
                new LiczbaPhi(),
                new PierwiastekZDwóch(),
                new PierwiastekZJednejDrugiej(),
                new Nieskończoność()
            };

            SzukaniaTekstuWTekście = new OpcjaZwracającaWartośćNaPodstawieDwóchParametrów <double, object, object>[]
            {
                new PierwszeWystąpienieTekstuWTekście(),
                new OstatnieWystąpienieTekstuWTekście()
            };

            WielkościLiter = new OpcjaZwracającaWartośćNaPodstawieParametru <object, object>[]
            {
                new WielkieLitery(),
                new MałeLitery()
            };

            WystąpieniaElementuNaLiście = new OpcjaZwracającaWartośćNaPodstawieDwóchParametrów <double, ZmiennaTypuListowego, object>[]
            {
                new PierwszeWystąpienie(),
                new OstatnieWystąpienie()
            };

            ZaokrąglaniaLiczby = new OpcjaZwracającaWartośćNaPodstawieParametru <double, double>[]
            {
                new Zaokrąglanie(),
                new ZaokrąglanieWGórę(),
                new ZaokrąglanieWDół()
            };

            ZnakiPorównania = new OpcjaZwracającaWartośćNaPodstawieDwóchParametrów <bool, object, object>[]
            {
                new Równy(),
                new Nierówny(),
                new Mniejszy(),
                new MniejszyRówny(),
                new Większy(),
                new WiększyRówny()
            };

            KlockiDotycząceList = new Klocek[]
            {
                new DodajDoListy(),
                new UsuńElementZListy(),
                new ModyfikujElementListy {
                    WybranyTypModyfikacjiListy = ModyfikacjeElementuListy.First()
                },

                new ElementListyOIndeksie(),
                new IndeksElementuNaLiście {
                    WybranaOpcja = WystąpieniaElementuNaLiście.First()
                },
                new LiczbaElementówNaLiście(),
                new ListaPowtórzonegoElementu(),
                new ListaZElementów(),
                new Podlista(),
                new PosortowanaLista
                {
                    WybranyPorządekSortowania = PorządkiSortowania.First(),
                    WybranySposóbSortowania   = SortowaniaListy.First()
                },
                new PustaLista(),
                new PustośćListy()
            };

            KlockiDotyczącePętli = new Klocek[]
            {
                new WykonajDlaKażdegoElementu(),
                new WykonujDopóki(),
                new WykonujOdliczając(),
                new PomińIterację(),
                new PrzerwijPętlę()
            };

            KlockiDotycząceZmiennych = new Klocek[]
            {
                new UstawZmienną(),
                new WartośćZmiennej()
            };

            KlockiLogiczne = new Klocek[]
            {
                new WykonajJeżeli(),
                new Negacja(),
                new Porównanie {
                    WybranaOpcja = ZnakiPorównania.First()
                },
                new StałaLogiczna {
                    WybranaOpcja = StałeLogiczne.First()
                },
                new WarunekZłożony {
                    WybranaOpcja = DziałaniaLogiczne.First()
                }
            };

            KlockiMatematyczne = new Klocek[]
            {
                new ZmieńWartośćZmiennejOLiczbę(),

                new FunkcjaMatematyczna {
                    WybranaOpcja = FunkcjeMatematyczne.First()
                },
                new FunkcjaTrygonometryczna {
                    WybranaOpcja = FunkcjeTrygonometryczne.First()
                },
                new LosowaLiczbaCałkowitaZZakresu(),
                new LosowyUłamek(),
                new PodzielnośćLiczbyPrzezLiczbę(),
                new StałaLiczbowa(),
                new StałaMatematyczna {
                    WybranaOpcja = StałeMatematyczne.First()
                },
                new WynikDziałania {
                    WybranaOpcja = DziałaniaMatematyczne.First()
                },
                new WynikDziałaniaMatematycznegoNaLiście {
                    WybranaOpcja = DziałaniaMatematyczneNaLiście.First()
                },
                new WystępowanieCechyLiczby {
                    WybranaOpcja = CechyLiczby.First()
                },
                new ZaokrąglonaLiczba {
                    WybranaOpcja = ZaokrąglaniaLiczby.First()
                },
            };

            KlockiTekstowe = new Klocek[]
            {
                new DodajTekst(),
                new Wyświetl {
                    Konsola = Konsola
                },

                new DługośćTekstu(),
                new IndeksTekstuWTekście {
                    WybranaOpcja = SzukaniaTekstuWTekście.First()
                },
                new LiteraTekstu(),
                new Napis(),
                new PobranyTekst
                {
                    Konsola      = Konsola,
                    WybranaOpcja = PobieraniaTekstu.First()
                },
                new Podciąg(),
                new PustośćTekstu(),
                new TekstOWielkościLiter {
                    WybranaOpcja = WielkościLiter.First()
                },
                new TekstZObciętymiSpacjami {
                    WybranaOpcja = ObcinaniaSpacji.First()
                }
            };
        }