-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathRegla.cpp
executable file
·162 lines (148 loc) · 7.94 KB
/
Regla.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
/*---------------------------------------------------------------------------*\
| Archivo : Regla.cpp |
| Proyecto : Prolog.bpr |
| Programado por: Patricio Merino - Héctor Díaz. |
| Descripción : Clase que representa a una regla en Prolog. Se constituye |
| de un predicado consecuente y de dos o un predicado |
| antecedente. |
| Usado por : Interprete.cpp, Regla.cpp |
\*---------------------------------------------------------------------------*/
#include <vcl.h>
#pragma hdrstop
#include "Regla.h"
#pragma package(smart_init)
#define SINTIPO 0
#define UNANTEC 1
#define DOSANTE 2
/*---------------------------------------------------------------------------*\
| Nombre : Regla() |
| Programado por: Patricio Merino - Héctor Díaz. |
| Entradas : No tiene. |
| Salidas : No tiene. |
| Descripción : Método constructor en el cual se inicializan los valores |
| de las variables. |
| Se asigna memoria a los objeto y se inicializan. |
\*---------------------------------------------------------------------------*/
Regla::Regla()
{
consecuente = Predicado();
antecedente1 = Predicado();
antecedente2 = Predicado();
tipo = SINTIPO;
conflicto = 0;
}
/*---------------------------------------------------------------------------*\
| Nombre : void ingresaConsecuente(Predicado predicado) |
| Programado por: Patricio Merino - Héctor Díaz. |
| Entradas : El predicado consecuente de la regla. |
| Salidas : No tiene. |
| Descripción : Método en el cual se setea el predicado <consecuente>. |
\*---------------------------------------------------------------------------*/
void Regla::ingresaConsecuente(Predicado predicado)
{
consecuente = predicado;
}
/*---------------------------------------------------------------------------*\
| Nombre : void ingresaAntecedente1(Predicado predicado) |
| Programado por: Patricio Merino - Héctor Díaz. |
| Entradas : El predicado antecedente1 de la regla. |
| Salidas : No tiene. |
| Descripción : Método en el cual se setea el predicado <antecedente1>. |
\*---------------------------------------------------------------------------*/
void Regla::ingresaAntecedente1(Predicado predicado)
{
antecedente1 = predicado;
}
/*---------------------------------------------------------------------------*\
| Nombre : void ingresaAntecedente2(Predicado predicado) |
| Programado por: Patricio Merino - Héctor Díaz. |
| Entradas : El predicado antecedente2 de la regla. |
| Salidas : No tiene. |
| Descripción : Método en el cual se setea el predicado <antecedente2>. |
\*---------------------------------------------------------------------------*/
void Regla::ingresaAntecedente2(Predicado predicado)
{
antecedente2 = predicado;
}
/*---------------------------------------------------------------------------*\
| Nombre : Predicado obtieneConsecuente() |
| Programado por: Patricio Merino - Héctor Díaz. |
| Entradas : No tiene. |
| Salidas : El predicado consecuente de la regla. |
| Descripción : Método en el cual se retorna el predicado consecuente de |
| la regla. |
\*---------------------------------------------------------------------------*/
Predicado Regla::obtieneConsecuente()
{
return (consecuente);
}
/*---------------------------------------------------------------------------*\
| Nombre : Predicado obtieneAntecedente1() |
| Programado por: Patricio Merino - Héctor Díaz. |
| Entradas : No tiene. |
| Salidas : El predicado antecedente1 de la regla. |
| Descripción : Método en el cual se retorna el predicado antecedente1 de |
| la regla. |
\*---------------------------------------------------------------------------*/
Predicado Regla::obtieneAntecedente1()
{
return (antecedente1);
}
/*---------------------------------------------------------------------------*\
| Nombre : Predicado obtieneAntecedente2() |
| Programado por: Patricio Merino - Héctor Díaz. |
| Entradas : No tiene. |
| Salidas : El predicado antecedente1 de la regla. |
| Descripción : Método en el cual se retorna el predicado antecedente2 de |
| la regla. |
\*---------------------------------------------------------------------------*/
Predicado Regla::obtieneAntecedente2()
{
return (antecedente2);
}
/*---------------------------------------------------------------------------*\
| Nombre : int obtieneTipo() |
| Programado por: Patricio Merino - Héctor Díaz. |
| Entradas : No tiene. |
| Salidas : El tipo de regla. |
| 0. Sin tipo. |
| 1. Un antecedente. |
| 2. Dos antecedentes. |
| Descripción : En este método se setea el valor de <tipo>. Se preguntan |
| por los casos posibles de existencia y no existencia de |
| los antecedentes que tiene la regla. |
\*---------------------------------------------------------------------------*/
int Regla::obtieneTipo()
{
char c1 = antecedente1.capturaNombre().obtiene(0);
char c2 = antecedente2.capturaNombre().obtiene(0);
tipo = SINTIPO;
if ((c1 != NULL) && (c2 == NULL))
tipo = UNANTEC;
else if ((c1 != NULL) && (c2 != NULL))
tipo = DOSANTE;
return (tipo);
}
/*---------------------------------------------------------------------------*\
| Nombre : void limpia() |
| Programado por: Patricio Merino - Héctor Díaz. |
| Entradas : No tiene. |
| Salidas : No tiene. |
| Descripción : En este método se llama a los metodos de los objetos que |
| limpian los predicados <consecuente>, <antecedente1> y |
| <antecedente2>. |
\*---------------------------------------------------------------------------*/
void Regla::limpia()
{
consecuente.limpia();
antecedente1.limpia();
antecedente2.limpia();
}
int Regla::obtieneConflicto()
{
return (conflicto);
}
void Regla::ingresaConflicto(int cantidad)
{
conflicto = cantidad;
}