Структура библиотеки должна обеспечивать удобство ее использования при построении проектов пользователем. При этом она должна предоставлять возможность внедрения кода пользователя в контекст сущностей библиотеки с целью обеспечения открытости и гибкости. Так, необходима возможность добавления определенных пользователем классов генераторов случайных чисел для реализации специальных законов распределения генераторов заявок и каналов, введения новых функций управления клапанами и дисциплин обслуживания в очередях. Это же касается и обобщенных массовых контроллеров, которые по определению должны включать код пользователя, представляющий закон управления клапанами.

Состав модулей и заголовочных файлов библиотеки вместе с описанием их назначения представлены в табл.4.

Таблица 4

Рисунок 2. Структура библиотеки

Структура библиотеки представлена диаграммой на рис.2

Листинги модулей библиотеки представлены в приложении 2.

Заключение

Листинг программы.

class QShema; // предварительное объявление Q-схемы

// глобально уникальный идентификатор заявок

extern unsigned __int64 req_enumerator;

class structelem

{public:

// конструктор и деструктор

explicit __fastcall structelem(const std::string & name):

_psvyazi(0), __name(name), __id(0)

{

;

}

virtual ~structelem() = 0;

// общая информация об элементе (для класса CQChart::CStatManager)

const std::string & GetName() const { return __name; }

int GetID() const { return __id; }

protected:

SxemaElem_t * _psvyazi;

// указатель на элемент структуры Q-схемы с описанием связей

private:

std::string __name; // символическое имя элемента

int __id; // числовой идентификатор элемента

};

class obyavZayav: virtual public structelem

{ public: public:

// конструктор и деструктор

explicit __fastcall obyavZayav(const std::string & name):

structelem(name)

virtual ~obyavZayav() { }

// установка признака пометки обработанных заявок

void SetMarksObrZayav() { _marksObrZayav = true; }

// получение состояния

virtual state_t GetState() const = 0;

protected:

class Zayavka { // класс "заявка"

//моделирует ассоциацию элементов с заявками методов вложения

public:

// конструктор

explicit __fastcall Zayavka {

__VremPoyav = __TekVrem = 0;

__obrabot = false;

__psoderg = NULL;

__cntrazmer = 0;

}

Zayavka() {

if ( __psoderg ) free( __psoderg );

}

// информация

size_t TekVrem() const { // время пребывания заявки в системе

return __TekVrem;

}

size_t GetVremPoyav() const { // время появления заявки в системе

return __VremPoyav;

}

bool GetObrabot() const { // признак обработки заявки

return __obrabot;

}

// счет времени пребывания заявки в системе

void __fastcall SetTekVrem(size_t vrem) { __TekVrem = vrem; }

void __fastcall SetVremPoyav(size_t vrem) { __VremPoyav = vrem; }

// пометка обработанной заявки

void SetObrabot() { __Obrabot = true; }

// получение идентификатора текущей заявки

unsigned __int64 GetID() const { return __id; }

// задание идентификатора текущей заявки генератором

void SetID(unsigned __int64 id) { __id = id; }

// получение содержимого заявки

void GetSoderg(void * psoderg, size_t & cntrazmer);

// изменение содержимого заявки

void SetSoderg(const void * psoderg, size_t cntrazmer);

private:

//уникальный идентификатор данной заявки

unsigned __int64 __id;

size_t __VremPoyav; // время появления заявки в системе

size_t __TekVrem; // текущая временная метка

// используется для подсчета времени пребывания заявки в системе

void * __psoderg; // указатель на определенное пользователем

//содержимое заявки

size_t __cntrazmer; // размер содержимого в байтах

};

bool _marksObrZayav; // признак пометки обработанных заявок

private:

// избыточные функции

obyavZayav(const obyavZayav &);

obyavZayav & operator = (const obyavZayav &);

template <class uprfunction> class objectupr: virtual public structelem

{ public:

// конструктор и деструктор

explicit __fastcall objectupr

(const std::string & name, ctrlfunc_t pctrlfunc): structelem(name)

{

try {

_UprElemmap = new IDUprElemmap_t();

}

_pfuncupr = pfuncupr;

_ctrlcount = 0;

}

~objectupr() { delete _uprelemmap; }

protected:

// разрешающие управляющие сигналы

IDUprElemmap_t * _UprElemmap;

// первая компонента map - идентификатор управляющего элемента

// вторая - указатель на управляющий элемент + разрешающее состояние этого элемента

// функция формирования общего сигнала управления

funcupr_t * _pfuncupr;

// число элементов, управляющих элементом

size_t _KolichUprElem;

// индикация состояния объекта управления (разрешенное или запрещенное)

bool _Razresh() const;

private:

// добавление разрешающего сигнала

void __DobavRazreshSignal(structelem *, state_t, float,

structelem *, state_t);

// удаление разрешающего сигнала

void __fastcall __UdalitRazreshSignal(structelem * pcontroller);}

class priemnik: virtual public obrabotzayavok

{ public:

// конструктор и деструктор

explicit __fastcall priemnik(const std::string & name):

structelem(name), obyavZayav(name)

{

;

}

~priemnik() { }

protected:

virtual void __fastcall _Priem(Zayavka *) = 0; // прием заявки

virtual bool _GotovKPriem() const = 0; // готовность к приему заявки

private:

};

class peredatchik: virtual public obrabotzayavok

{ public:

// конструктор и деструктор

explicit __fastcall peredatchik(const std::string & name):

structelem(name), obyavZayav(name)

{

;

}

~ peredatchik() { }

protected:

virtual Zayavka * __fastcall _Peredacha(Zayavka * req = 0) = 0; // выдача заявки

// информация

virtual bool _GotovKPeredache() const = 0; // готовность к выдаче заявки

private:

};

template <class randomgenerator> class peredatchikszader: public peredatchik

{ public:

// конструктор и деструктор

explicit __fastcall peredatchikszader(const std::string & name):

structelem(name), obyavZayav(name), peredatchik(name),

_ObrZayav(0), _VremyaVidachi(0), _OprVremyaVidachi(false)

{

;

}

~peredatchikszader()

// информация

virtual state_t GetState() const { // проверка состояния

return _ObrZayav == 0 ? pusto : zanyat;

}

protected:

// поведение

virtual void _VremyaSozdZayav() = 0; // время выхода заявки

Zayavka * _ObrZayav; // заявка, находящаяся на обработке

size_t _VremyaVidachi; // время выдачи заявки

bool _OprVremyaVidachi; // признак определенности времени выдачи

private:

};

template <class randomgenerator>

class GeneratorZayavok: public peredatchikszader {

// генератор заявок (элемент, который выдает заявки через случайное время)

// конструктор и деструктор

explicit __fastcall GeneratorZayavok(const std::string & name):

structelem(name), obyavZayav(name), peredatchikszader(name)

{

;

}

~GeneratorZayavok() { }

protected:

// поведение

virtual Zayavka * __fastcall _Peredacha(Zayavka *) { // выдача (генерация) заявки

_OprVremyaVidachi = false;

Zayavka * tmObrZayav = _ObrZayav; _ObrZayav = 0;

// задание момента появления заявки

tmObrZayav->SetVremPoyav;

tmObrZayav->SetTekVrem;

}

return tmObrZayav;

}

virtual void _GenerateVremyaVidachi() { // время выхода заявки

try {

_VremyaVidachi = randomgenerator::GetValue();

}

if (_VremyaVidachi < 1) _VremyaVidachi = 1;

_OprVremyaVidachi = true;

try {

__VidachaZayavki();

}

// информация

virtual bool _GotovKPeredache() const { // готовность к выдаче заявки

return _OprVremyaVidachi && _VremyaVidachi == 0;

}

private:

void __VidachaZayavki() throw(std::bad_alloc);

// избыточные функции

virtual state_t GetState() const { // получение состояния

return zanyat;

}

};

template <class randomgenerator>

class kanal: public obrabotzayavok

// "канал (устройство)" (принимает, обрабатывает и выдает заявки

// через время, определяемое заданным законом распределения)

public:

// конструктор и деструктор

explicit __fastcall kanal(const std::string & name):

structelem(name), obyavZayav(name), obrabotzayavok(name)

{

__DlinObslujZayav= 0;

}

~kanal() { }

protected:

// поведение

virtual void _GenerateVremyaVidachi() { // время выхода заявки

if(_ObrZayavka != 0) {

try { // контроль средств пользователя

__DlinObslujZayav= _VremyaVidachi = randomgenerator::Poluchznach();

}

}

virtual Zayavka * __fastcall _Peredacha(Zayavka *) { // выдача обслуженной заявки

Zayavka* tmpObrZayavka = _ObrZayavka;

_ObrZayavka = 0;

if (tmpObrZayavka != NULL && this->_marksObrZayav)

tmpObrZayavka->SetObrabot(); // заявка обработана

return tmpObrZayavka;

}

virtual void __fastcall _Priemnik(Zayavka * req) { // прием заявки

_OprVremyaVidachi = false;

if (_ObrZayavka != 0)

_ObrZayavka = req;

}

private:

size_t __DlinObslujZayav; // хранит длительность обслуживания заявки

// для расчета загрузки канала

};

template <class uprfunction> class klapan: public peredatchik, public priemnik, public objectupr <uprfunction>

{ public:

// конструктор и деструктор

explicit __fastcall klapan(const std::string & name, funcupr_t pfuncupr NachFuncUpr):

structelem(name), objectupr(name, pfuncupr), obyavZayav(name),

priemnik(name), peredatchik(name)

{

__tmpObrZayav = 0;

}

~klapan() { }

protected:

// поведение

virtual void __fastcall _Priem(Zayavka * ObrZayavka) //принять заявку

{__tmpObrZayav = ObrZayav;

}

virtual Zayavka * __fastcall _Peredacha(Zayavka *)//передать заявку

{ Zayavka * tmObrZayav = __tmObrZayav; __tmpObrZayav = 0;

if (this->_marksObrZayav) tmObrZayav->SetObrabot();

// клапаны тоже могут помечать заявки как обработанные

return tmObrZayav;

}

// информация

virtual bool _GotovKPriem() const { // готовность к приему заявки

return _Razresh();

}

virtual bool _GotovKPeredache() const { // готовность к выдаче заявки

return __tmObrZayav != 0;

}

Zayavka * __tmObrZayav; // заявка хранится один такт, пока клапан не выдаст её дальше

private:

virtual state_t GetState() const { // получение состояния

return pusto; // клапан никогда не содержит заявок

};

typedef struct ListZayav_t {

obrabotzayavok::Zayav * ObrZayav; // указатель на заявку

ListZayav_t * SledZayav; // указатель на следующую заявку

ListZayav_t * PredZayav; // указатель на предыдущую заявку

} ListZayav_tag;

class ochered: public peredatchik, public priemnik

{ public:

// конструктор

explicit __fastcall ochered(const std::string & name):

structelem(name), obyavZayav(name), priemnik(name), peredatchik(name)

{

_dlina = 0; _NachaloListZayav = 0; _KonetsListZayav = 0;

}

// деструктор

~ochered() { ; }

// получение состояния

virtual state_t GetState() const {

return _length != 0 ? zanyat : pusto;

}

// получение текущей длины

size_t GetDlina() const { return _dlina; }

// выдача времени генерации наиболее старой хранимой заявки

bool __fastcall GetMinTekVrem(size_t & TekVrem) const;

protected:

// информация

virtual bool _GotovKPeredache() const { // готовность к выдаче заявки

return _dlina > 0;

}

// готовность к приему зависит от наличия ограничения для длину очереди

size_t _dlina; // текущая длина очереди заявок

ListZayav_t * _NachaloListZayav; // указатель на голову списка заявок

ListZayav_t * _KonetsListZayav; // указатель на хвост списка заявок

private:

};

template <class obsdiscipl>

class discochered: public ochered {

// абстрактный накопитель заявок с дисциплиной обслуживания

public:

// конструктор

explicit __fastcall discochered(const std::string & name):

structelem(name), obyavZayav(name), ochered(name)

{

;

}

// деструктор

~discochered() { }

protected:

// поведение

// ------------------------------------------------ прием заявки

virtual void __fastcall _Priem(Zayavka * req) {

ListZayav_t * SohrListZayav = _KonetsListZayav;

// создание элемента списка под заявку

try {

_KonetsListZayav = new ListZayav_t;

}

catch (std::bad_alloc &)

THROW_ERROR(ERegisterError, REG_ERROR_ID,

"Description: queue cell object creation failed",

std::string("Details: out of memory while adding a cell to queue ") +

this->GetName())

_KonetsListZayav -> ObrZayav = req;

_KonetsListZayav -> SledZayav = 0;

_dlina++;

if(SohrListZayav == 0) {

// очередь пуста

_KonetsListZayav -> PredZayav = 0;

__NachaloListZayav = _KonetsListZayav;

return;

}

// очередь не пуста

_KonetsListZayav -> PredZayav = SohrListZayav;

ohrListZayav -> SledZayav = _KonetsListZayav;

}

// ------------------------- выдача заявки согласно заданной дисциплине

virtual Zayavka * __fastcall _Peredacha(Zayavka *) {

const ListZayav_t * preqentry;

try { // контроль средств пользователя

preqentry =

obsdiscipl::GetSledZayav(__NachaloListZayav, _KonetsListZayav);

}

Zayavka * preadreq = preqentry -> ObrZayav;

__UdalitElement ( &___NachaloListZayav, &_KonetsListZayav,

const_cast<ListZayav_t*>(preqentry) );

--_dlina;

if (this->_marksObrZayav)

preadreq->SetObrabot(); // заявка считается обработанной

return preadreq;

}

private:

// --------------------------------- удаление элемента очереди

void __fastcall __UdalitElem(ListZayav_t ** NachaloListZayav,

ListZayav_t ** KonetsListZayav, ListZayav_t * udalitzayav)

{

ListZayav_t * tmpliszayav;

if (udalitzayav == *NachaloListZayav) // удаление головы

{

tmpliszayav = *NachaloListZayav;

(*NachaloListZayav) = (*pNachaloListZayav) -> SledZayav;

(*KonetsListZayav) = (*NachaloListZayav) == 0 ? 0 : (*KonetsListZayav);

if (*NachaloListZayav != 0) (*NachaloListZayav) -> PredZayav = 0;

}

else

if (udalitzayav == *KonetsListZayav) // удаление хвоста

{

tmpliszayav = *KonetsListZayav;

(*KonetsListZayav) = (*KonetsListZayav) -> PredZayav;

(*NachaloListZayav) = (*KonetsListZayav) == 0 ? 0 : (*NachaloListZayav);

if (*KonetsListZayav != 0) (*preqKonetsListZayav) -> SledZayav = 0;

}

else

{ // удаление из "середины" очереди

tmpliszayav = udalitzayav;

udalitzayav -> SledZayav -> PredZayav = udalitzayav -> PredZayav;

udalitzayav -> PredZayav -> SledZayav = udalitzayav -> SledZayav;

}

delete tmpliszayav;

}

};

template <class obsdiscipl> class bezkonochered: public ochered <obsdiscipl>

{ public:

// бесконечный накопитель заявок

explicit __fastcall bezkonochered(const std::string & name):

structelem(name), obyavZayav(name), ochered(name),

peredatchik (name), priemnik(name)

;

}

~bezkonochered() { }

virtual bool _GotovKPriem() const { // готовность к приему заявки

return true;

}

private:

};

template <class obsdiscipl> class konochered: public ochered <obsdiscipl>

{ public:

// ограниченный накопитель заявок

explicit __fastcall konochered(const std::string & name, size_t maxDlina):

structelem(name), obyavZayav(name), ochered(name),

peredatchik (name), priemnik(name)

_maxDlina(maxDlina > 0 ? maxDlina : 1)

{

;

}

~konochered() { }

// получение состояния

virtual state_t GetState() const {

return _Dlina != 0 ? (_maxDlina > _Dlina ? busy : full) : empty;

}

// максимальная длина

size_t GetMaxDlina() const { return _maxDlina; }

virtual bool _GotovKPriem() const { // aioiaiinou e i?eaio cayaee

return _maxDlina > _Dlina;

}

const size_t _maxDlina; // максимальная длина очереди

private:

};

class masskontrol: virtual public structelem {

protected:

// карта дескрипторов управляемых клапанов

typedef

map <int, pair< pair<float,int>, pair<structelem *, state_t> > >

klapandescriptormap_t;

{ public:

// конструктор

explicit __fastcall masskontrol(const std::string & name):

structelem(name)

{

__KolichKlapan = 0;

try {

__pklapandescriptormap = new klapandescriptormap_t();

}

// деструктор

~masskontrol() { delete __pklapandescriptormap; }

protected:

size_t __KolichKlapan; // число управляемых клапанов в группе

klapandescriptormap_t * __pklapandescriptormap;

// добавление клапана для случайного управления

virtual void _DobavKlapan(int klapanid, float reserved) { ++__KolichKlapan; }

// удаление управляемого клапана

// (вызывается только из qchart::UnregisterElement/Link)

void __fastcall _UdalitKlapan(const structelem * pklapan);

// определение состояния заданного управляемого клапана

int __fastcall _GetSostUpr(int klapanid) const {

return (__pklapandescriptormap -> operator [] (klapanid)).first.second;

}

// вычисление состояний клапанов в текущем такте

virtual void _VichislSostUprKlapana() = 0;

private:

};

class prostrandomcontrol: public masskontrol {

// элемент случайного управления клапанами

public:

// конструктор

explicit __fastcall prostrandomcontrol(const std::string & name):

masskontrol(name)

{

;

}

// деструктор

~prostrandomcontrol() { }

protected:

// карта текущего состояния управляемых клапанов наследуется

// добавление клапана для случайного управления (переопределение)

virtual void _DobavKlapan(int klapanid, float veroyatnost);

// вычисление состояний клапанов в текущем такте (реализация)

virtual void _VichislSostUprKlapana();

private:

static const float __proberror; // погрешность расчета вероятностей

// суммирование вероятностей и контроль равенства суммы единице

bool __SummirVeroyat() const;

};

class adaptcontrol: public prostrandomcontrol {

// элемент случайного управления клапанами, позволяющий динамически

// исключать заблокированные клапаны с соответствующим пересчетом

// вероятностей открытия клапанов

public:

// конструктор

explicit __fastcall adaptcontrol (const std::string & name):

prostrandomcontrol (name)

{

try {

__pustanklapandescriptormap = new klapandescriptormap_t();

}

__srcprobmapsaved = false;

}

// деструктор

~adaptcontrol () { delete __pustanklapandescriptormap; }

protected:

// карта текущего состояния управляемых клапанов наследуется

// добавление ассоциированного элемента для управляемого клапана

void __fastcall

_DobavKlapanAssocCtrl(int klapanid, structelem * passocelem, state_t assocelemstate);

// пересчет вероятностей открытия клапанов

virtual void _PereschetVeroyat();

private:

// исходная карта дескрипторов управляемых клапанов

Klapandescriptormap_t * __pustanklapandescriptormap;

// карта из prostrandomcontrol динамически изменяется и используется для

// расчета состояний клапанов, а эта карта хранит исходные вероятности и

// не пересчитывается

// признак сохранения исходной карты вероятностей

bool __srcprobmapsaved;

// фиксация исходной карты дескрипторов

// вызывается после регистрации всех управляемых клапанов

void __SaveSrcProbMap() {

*__pustanklapandescriptormap = *__pklapandescriptormap;

__srcprobmapsaved = true;

}

// восстановление исходной карты дескрипторов клапанов

void __VosstVeroyatKlapanov() {

*__pklapandescriptormap = *__pustanklapandescriptormap;

}

class Polzovatcontrol: public masskontrol{

public:

// вектор ассоциированных контроллеров

typedef vector < const structelem * > assoccontr_t;

// карта состояний управляемых клапанов

typedef map < int, int > klapanstatemap_t;

// компонента 1 - уникальный идентификатор клапана;

// компонента 2 - вычисленное состояние клапана

protected:

// ZakonUpr-функция для реализации пользовательского закона управления

typedef

void (* pcustomfuncupr_t)

(const assoccontr_t & assoccontr, klapanstatemap_t & klapanstatemap);

/*

assoccontr - вектор указателей на ассоциированные контроллеры,

состояние которых можно учитывать при формировании сигналов управления

клапанами;

klapanstatemap - карта состояний (0 или 1) управляемых клапанов,

вычисляемая callback-функцией (ее размер определяется размером вектора)

*/

public:

// конструктор

__fastcall obobmasscontrol(

const std::string & name,

const assoccontr_t & assoccontr,

pcustomfuncupr_t pcustomfuncupr

);

// деструктор

~Polzovatcontrol() { }

protected:

// добавление клапана для случайного управления (реализация)

virtual void _DobavKlapan(int klapanid, float reserved);

// вычисление состояний клапанов в текущем такте

virtual void _VichislSostUprKlapana();

private:

// связь с ассоциированными контроллерами

assoccontr_t __assoccontr;

// указатель на функцию управления пользователя

pcustomfuncupr_t __pcustomfuncupr;};

template<class randomgenerator>class uprgeneratorzayavok: public generatorzayavok<randomgenerator>, public objectupr

{

public:

// конструктор и деструктор

explicit __fastcall uprgeneratorzayavok

(const std::string & name, funcupr_t pfuncupr = NachFuncUpr):

structelem(name), obyavZayav(name),

generatorzayavok<randomgenerator>(name), objectupr(name, pfuncupr)

{

;

}

~uprgeneratorzayavok() { }

protected:

// поведение

// готовность к выдаче заявки

virtual bool _GotovKPeredache() const {

if (!_Razresh())

const_cast< generatorzayavok<randomgenerator> * >(this)->__OprVremyaVidachi = false;

return

__OprVremyaVidachi && this->generatorzayavok<randomgenerator>::_GotovKPeredache();

}

private:

};

template <class RandomGenerator>

class KanalSPrerObslug: public kanal<RandomGenerator>, public ObjectOfControl

{

// управляемый канал (элемент, который обслуживает заявки случайное время

public:

// конструктор и деструктор

explicit __fastcall KanalSPrerObslug

(const std::string & name, funcupr_t pfuncupr = NachFunсUpr):

structelem(name), ObyavZayav(name),

kanal<RandomGenerator>(name), ObjectOfControl(name, pfuncupr)

~KanalSPrerObslug() { }

protected:

// готовность к выдаче заявки

virtual bool _GotovKPeredache() const {

// при запрещающем управляющем сигнале заявка выдается сразу

if (!_Razresh()) return _ObrZayavka != NULL;

return this-> kanal<RandomGenerator>::_GotovKPeredache();

}

private:

};

class razvetvitel: public peredatchik, public priemnik, public objectupr <uprfunction>

public: explicit __fastcall razvetvitel(const std::string & name):

structelem(name), objectupr(name, pfuncupr), obyavZayav(name),

priemnik(name), peredatchik(name) {}

~razvetvitel() {}

private:

};

};

Размещено на Allbest.ru