Курсовой проект [6] [программа] / Main

#include <vcl.h>
#pragma hdrstop
#include "Main.h"
#include "QSheme.cpp"
#include <stdlib.h>
#include <time.h>
#pragma package(smart_init)
#pragma resource "*.dfm"
class Request
{
public:
    unsigned long int State;
        //0 - не обработаная деталь
        //1 - И1
        //2 - И1 И2
        //3 - И1 И2 И2
        //4 - И1 И2 И1 И2
    unsigned long int MakeTime;
    unsigned long int ProcessingTime;


    Request(unsigned long int Time)
    {
        State = 0;
        ProcessingTime = 0;
        MakeTime = Time;
    }
};
class Executor
{
public:
    unsigned long int IsFree;
    unsigned long int EndTime;
    Request *ProcessingRequest;
    Executor(unsigned long int Time, int Mistake)
    {
        ExecTime = Time;
        MistakeTime = Mistake;
        IsFree = 1;
        ProcessingRequest = NULL;
        EndTime = 0;
    }
    void Load(Request *req, unsigned long int current_t)
    {
        EndTime = ExecTime+current_t+random(2*MistakeTime+1)-MistakeTime;
        ProcessingRequest = req;
        ProcessingRequest->ProcessingTime = ProcessingRequest->ProcessingTime+ EndTime-current_t;
        IsFree = 0;
        ProcessingRequest->State++;
    }
    Request *Extract()
    {   IsFree=1;
        return ProcessingRequest;
    }
private:

    unsigned long int ExecTime;
    unsigned long int MistakeTime;
};
class Storage{
private:
    Request **m_storage;
public:
    unsigned long int MaxVolume;
    unsigned long int Volume;
    unsigned long int IsFull;
    Storage(unsigned long int maximum_volume)
    {
        Volume = maximum_volume;
        MaxVolume = maximum_volume;
        IsFull = 0;
        m_storage = new Request *[maximum_volume];
        for (int i=0;i<maximum_volume;i++) m_storage[i]=NULL;
    }
    int Add(Request *req)
    {
        if(Volume){
            m_storage[MaxVolume-Volume]=req;
            Volume--;
            if (Volume==0) IsFull = 1;
            else IsFull =0;
            return 1;
        }
        return 0;
    }
    Request *Extract()
    {
        if(Volume!=MaxVolume)
        {
            Volume++;
            Request *tmp;
            tmp = m_storage[MaxVolume-Volume];
            m_storage[MaxVolume-Volume] = NULL;
            if (Volume==0) IsFull = 1;
            else IsFull =0;
            return tmp;
        }
        if (Volume==0) IsFull = 1;
        else IsFull =0; 
        return NULL;    
    }
};
class Generator
{
public:
    Request *CurrentRequest;
    Generator(unsigned long int Time, unsigned long int Mistake)
    {
        GenTime = Time;
        MistakeTime = Mistake;
        NextTime=1;
    }
    unsigned long int Generate(unsigned long int t)
    {
        if (t==NextTime)
        {
            CurrentRequest = new Request(t);

            unsigned long int RndMstk  = random(2*MistakeTime+1)-MistakeTime;
            NextTime = NextTime+GenTime+RndMstk;
            return 1;
        }
        else
        {
            return 0;
        }
    }
private:
    unsigned long int NextTime;
    unsigned long int GenTime;
    unsigned long int MistakeTime;

};

TfrmMain *frmMain;
__fastcall TfrmMain::TfrmMain(TComponent* Owner): TForm(Owner)
{
}
void __fastcall TfrmMain::btnStartClick(TObject *Sender)
{
    unsigned long int RequestTime        = StrToInt(edtRequestTime->Text);
    unsigned long int RequestMistake     = StrToInt(edtRequestMistake->Text);
    unsigned long int CementationTime    = StrToInt(edtCementationTime->Text);
    unsigned long int CementationMistake = StrToInt(edtCementationMistake->Text);
    unsigned long int TemperingTime      = StrToInt(edtTemperingTime->Text);
    unsigned long int TemperingMistake   = StrToInt(edtTemperingMistake->Text);
    unsigned long int RequestQuantity    = StrToInt(edtRequestQuantity->Text);
    unsigned long int StorageVolume      = StrToInt(edtStorageVolume->Text);
    unsigned long int Denied  =0;
    unsigned long int FstSort =0;
    unsigned long int SecSort =0;
    unsigned long int MaxTime =2*(CementationTime + CementationMistake+
                               TemperingTime + TemperingMistake+1);

    Generator    *G; G  = new Generator(RequestTime,RequestMistake);
    Storage     *S1; S1 = new Storage(StorageVolume);
    Storage     *S2; S2 = new Storage(StorageVolume);
    Executor    *E1; E1 = new Executor(CementationTime,CementationMistake);
    Executor    *E2; E2 = new Executor(TemperingTime,TemperingMistake);
    unsigned long int t=1;
    int *data; data = new int[MaxTime+1];
    for (int i=0;i<MaxTime;i++) data[i]=0;

    Series1->Clear();
    randomize();
    while (Denied+FstSort+SecSort<RequestQuantity){

        if ((E2->EndTime==t)&&(E2->ProcessingRequest!=NULL))
        {
            Request *tmp = E2->ProcessingRequest;
            if ((tmp->ProcessingTime>=25)&&(tmp->State==2))
            {
            //Заявка с t>25 Второй класс. На выход первый сорт
                FstSort++;
                data[tmp->ProcessingTime]++;
                E2->Extract();
//                delete tmp;
            }
            if ((tmp->State>2)&&(tmp->ProcessingTime<20))
            {
            //Заявка с t<20. На выход второй сорт
                SecSort++;
                data[tmp->ProcessingTime]++;
                E2->Extract();
//                delete tmp;
            }
            if ((tmp->State>2)&&(tmp->ProcessingTime>=20))
            {
            //Заявка с t>=20. На выход первый сорт
                FstSort++;
                data[tmp->ProcessingTime]++;
                E2->Extract();
//                delete tmp;
             }
            if ((tmp->ProcessingTime<20)&&(tmp->State==2))
            {
                //Заявка с t<20 второго класса. Отправить на S1
                if (!S1->IsFull)
                S1->Add(E2->Extract());
            }
            if ((tmp->ProcessingTime <25)&&
                (tmp->ProcessingTime>=20)&&
                (tmp->State==2))
            {
                //Заявка 20<=t<25 второго класса. Отправить на S2
                if (!S2->IsFull) S2->Add(E2->Extract());
            }

        }
        if ((E2->IsFree)&&(S2->Volume!=S2->MaxVolume)) E2->Load(S2->Extract(),t);
        if ((E1->EndTime==t)&&(E1->ProcessingRequest!=NULL)) if (!S2->IsFull) S2->Add(E1->Extract());
        if ((E1->IsFree)&&((S1->Volume)!=(S1->MaxVolume))) E1->Load(S1->Extract(),t);
        if (G->Generate(t)){
            if (!S1->IsFull) S1->Add(G->CurrentRequest);
            else
            {
                Denied++;
                data[0]++;
                data[1]=1;
            }
        }
       t++;
    }

    for (int i =0;i<MaxTime;i++)
    {
//        if(data[i])
         {
            Series1->AddXY(i,data[i],"",clBlue);
         }
    }

    double tmp = FstSort;
    tmp = tmp/RequestQuantity;

    edtFstSortPossibility->Text = FloatToStr((double)FstSort/(double)RequestQuantity);
    edtSecSortPossibility->Text = FloatToStr((double)SecSort/(double)RequestQuantity);
    edtDeniedPossibility->Text = FloatToStr((double)Denied/(double)RequestQuantity);
    edtSecSort->Text = IntToStr(SecSort);
    edtFstSort->Text = IntToStr(FstSort);
    edtDenied ->Text = IntToStr(Denied);
    delete G;
    delete E1;
    delete E2;
    delete S1;
    delete S2;

}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::btnCloseClick(TObject *Sender)
{
    Close();    
}


void __fastcall TfrmMain::btnQShemeClick(TObject *Sender)
{
    frmQSheme->Show();
}
//---------------------------------------------------------------------------



void __fastcall TfrmMain::edtRequestMistakeChange(TObject *Sender)
{
    if (StrToInt(edtRequestMistake->Text)>=StrToInt(edtRequestTime->Text)){
    edtRequestMistake->Text = "0";
    }
}

//---------------------------------------------------------------------------

void __fastcall TfrmMain::edtTemperingMistakeChange(TObject *Sender)
{
if (StrToInt(edtTemperingMistake->Text)>=StrToInt(edtTemperingTime->Text)){
    edtTemperingMistake->Text = "0";
    }
}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::edtCementationMistakeChange(TObject *Sender)
{
if (StrToInt(edtCementationMistake->Text)>=StrToInt(edtCementationTime->Text)){
    edtCementationMistake->Text = "0";
    }
}
//---------------------------------------------------------------------------