Implementação da Cadeia de Notificações do PON

A concepção de aplicações do PON é realizada através da criação de Rules. Ao passo em que a execução de uma aplicação PON propriamente dita, é realizada pela cadeia de notificações, a qual é orquestrada através de notificações pontuais e precisas entre todas as entidades pertinentes a esta cadeia de notificação (Figura 12). Tais entidades pertencentes à cadeia de notificação do PON são comportadas por estruturas de dados de alto nível, especificamente sobre estruturas das classes

list e vector da STL. A título de exemplificação, o Algoritmo 10, apresenta a

implementação do método addPremise( ... ) da classe Rule. Assim, no momento da adição de uma Premise da respectiva Rule, os elementos PON pertinentes a eles são instanciados e conectados.

1 2 3 4 5 6 7 8

void Rule::addPremise(Attribute* attributeA, Attribute* attributeB, int

operattor, bool exclusive, int attributesToSave){

Premise* premiseTmp = new Premise(attributeA, attributeB,

operattor, exclusive);

this->condition->addPremise(premiseTmp); ...

}

Deste modo, após a chamada do método addPremise( ... ), a Premise é instanciada, conforme apresenta a linha 4 do Algoritmo 10. Na sequência, a Premise em questão é adicionada ao objeto condition da classe Condition na linha 6. Assim, após a mudança de estado desta Premise, a mesma notifica pontualmente sua

Condition relacionada. Ainda, o Algoritmo 11, apresenta a implementação do

construtor da classe Premise.

1 2 3 4 5 6 7 8 9 10 11 12 13 14

Premise::Premise(char* name, Attribute* attributeA, Attribute*

attributeB, int operattor, bool exclusive){

this->attributeA = attributeA;

this->attributeB = attributeB;

this->operattor = operattor;

this->exclusive = exclusive;

setInit(true);

setLogicValue( this->logicCalculus() );

this->attributeA->addPremise(this);

this->attributeB->addPremise(this); setActive(true);

setName(name);

conditionExclusive = 0;

}

Algoritmo 11 – Construtor da classe Premise

Observa-se, que no construtor da classe Premise, os objetos da classe

Attribute descritos nas linhas 9 e 10 relacionados a ela, se conectam a sua

respectiva Premise através da execução do método addPremise. Neste caso, após a alteração de estado de um destes Attributes referenciados, os memos notificarão pontualmente sua(s) Premise(s) relacionada(s). Ainda, é importante salientar que todo elemento PON agrega em seu escopo uma estrutura de dados da classe list e

vector da STL. Assim, conforme esboçado no Algoritmo 12, o método addPremise( ... ) da classe Attribute, adiciona um elemento Premise à lista de Premises denotado

pelo objeto premisesList da classe list da STL, através da chamada do método

push_back, conforme observado na linha 2.

1 2 3

void Attribute::addPremise(Premise* premise){

premisesList.push_back(premise); }

Neste âmbito, toda cadeia de notificações do PON é suportada por objetos da

STL, especificamente sobre objetos da classe list e vector da STL. Assim, cada

elemento (Attribute, Premise, Condition e Instigation) responsável pelo fluxo de notificações do PON, agrega em seu escopo uma lista de elementos a serem notificados. A título de exemplificação, o Algoritmo 13 apresenta a classe Attribute, a qual agrega um objeto da classe list da STL denominada premisesList. Importante salientar que os demais métodos e atributos da classe foram suprimidos de modo a facilitar a leitura e compreensão da respectiva classe.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 class Attribute { ... private: Attribute* value;

list<Premise*> premisesList;

list<Premise*>::iterator it;

public:

const static int RENOTITY = 1;

public:

Attribute(); ...

}

Algoritmo 13 – Objeto premisesList da Classe List da STL

Conforme observado, a linha 5 contém o objeto premisesList da classe list da

STL. Ainda, a linha 6 define seu respectivo objeto iterador it. Desta forma, após a

mudança de estado de um Attribute relacionado a um respectivo FBE, a cadeia de notificações é iniciada. Neste caso, o Attribute em questão, itera sobre os elementos

Premises adicionados a sua lista de Premises “premisesList”, conforme esboçado

pelo Algoritmo 14. 1 2 3 4 5 6 7 8 9 10 11 12 13

void Attribute::renotifyPremises(){

Premise* premiseTmp = 0; list<Premise>::iterator it;

for( it = premisesList.begin(); it != premisesList.end(); ++it ) { premiseTmp = (Premise*)(*it); if(premiseTmp->isExclusive()) premiseTmp->renotifyConditionsAboutPremiseExclusive(); else premiseTmp->renotifyConditions(); } }

Neste contexto, todas as Premises as quais o respectivo Attribute se relaciona são iteradas. Da mesma maneira, cada elemento PON Premise, notifica seu conjunto de elementos PON Condition, através da chamada do método

notifyConditionsAboutPremiseExclusive() da linha 8 ou notifyConditions() da linha

11. Estes dois métodos supracitados, também iteram sobre seus respectivos elementos PON, especificamente sobre elementos Conditions, por meio de objetos da classe list ou vector da STL.

Outrossim, uma vez aprovada, a Rule seria executada via escalonador pré- definido pelo desenvolvedor da aplicação PON. Para tanto, conforme a política de escalonamento adotada, a Rule executaria conforme descrito na seção 2.3.2. Para exemplificar, a resolução de conflitos denominada BREADTH é descrita no Algoritmo 15. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

void SchedulerStrategyBreadth::execute(){

Rule* ruleTmp = 0;

isInferenceExecuting = true;

while(!listRules.empty()){

ruleTmp = listRules.front();

if(ruleTmp->isDerived()){

ruleTmp->setExecuting(true);

ruleTmp->executeRule();

ruleTmp->setExecuting(false);

ruleTmp->reproved();

}

else{

ruleTmp->setExecuting(true);

ruleTmp->execute();

ruleTmp->setExecuting(false);

ruleTmp->reproved();

}

}

isInferenceExecuting = false; }

Algoritmo 15 – Resolução de Conflitos BREADTH

A resolução de conflitos BREADTH, se baseia no escalonamento First In, First

Out (FIFO), ou seja, refere-se à execução de entidades Rules, seguindo uma

estrutura de dados do tipo fila. Para isto, a classe SchedulerStrategyBreadth agrega um objeto denominado listRules da classe queue da STL. Este objeto tem por referência objetos da classe Rule e a iteração é realizada conforme Algoritmo 15. Neste âmbito, enquanto a fila não for vazia (linha 5), a primeira Rule da fila é obtida (linha 6). Caso a Rule em questão for uma Rule derivada, ou seja, da classe

Caso contrário, o método a ser executado será o método execute() da linha 15. Por fim, após sua execução, a Rule é reprovada (linhas 11 ou 17). Sendo assim, todo o orquestramento da cadeia de notificações é realizado a partir de iterações ou percorrimentos sobre contêineres da STL, que correspondem a estruturas de dados de alto nível.