home *** CD-ROM | disk | FTP | other *** search
/ Power GUI Programming with VisualAge C++ / powergui.iso / trialva / ibmcppw / samples / visbuild / vbsample / ivbland.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1996-02-16  |  51.2 KB  |  1,127 lines
  1. /*******************************************************************************
  2. * FILE NAME: ivbland.cpp                                                       *
  3. *                                                                              *
  4. * DESCRIPTION:                                                                 *
  5. *   Class implementation of the class(es):                                     *
  6. *    IVBLogicalAndPart - VB Logical And Part.                                  *
  7. *                                                                              *
  8. * COPYRIGHT:                                                                   *
  9. *   IBM(R) VisualAge(TM) for C++                                               *
  10. *   (C) Copyright International Business Machines Corporation 1991, 1996       *
  11. *   Licensed Material - Program-Property of IBM - All Rights Reserved.         *
  12. *   US Government Users Restricted Rights - Use, duplication, or disclosure    *
  13. *   restricted by GSA ADP Schedule Contract with IBM Corp.                     *
  14. *                                                                              *
  15. *   This program will not run in DOS mode.                                     *
  16. *                                                                              *
  17. * DISCLAIMER OF WARRANTIES:                                                    *
  18. *   The following [enclosed] code is sample code created by IBM                *
  19. *   Corporation.  This sample code is not part of any standard IBM product     *
  20. *   and is provided to you solely for the purpose of assisting you in the      *
  21. *   development of your applications.  The code is provided "AS IS",           *
  22. *   without warranty of any kind.  IBM shall not be liable for any damages     *
  23. *   arising out of your use of the sample code, even if they have been         *
  24. *   advised of the possibility of such damages.                                *
  25. *******************************************************************************/
  26.  
  27. #ifndef _IVBLAND_
  28.   #include <ivbland.hpp>
  29. #endif
  30.  
  31. #ifndef _INOTIFEV_
  32.   #include <inotifev.hpp>
  33. #endif
  34.  
  35.  
  36. #pragma export (IVBLogicalAndPart::valueId,, 3100)
  37. const INotificationId IVBLogicalAndPart::valueId =
  38.                      "IVBLogicalAndPart::value";
  39. #pragma export (IVBLogicalAndPart::input1Id,, 3101)
  40. const INotificationId IVBLogicalAndPart::input1Id =
  41.                      "IVBLogicalAndPart::input1";
  42. #pragma export (IVBLogicalAndPart::input2Id,, 3102)
  43. const INotificationId IVBLogicalAndPart::input2Id =
  44.                      "IVBLogicalAndPart::input2";
  45. #pragma export (IVBLogicalAndPart::input3Id,, 3103)
  46. const INotificationId IVBLogicalAndPart::input3Id =
  47.                      "IVBLogicalAndPart::input3";
  48. #pragma export (IVBLogicalAndPart::input4Id,, 3104)
  49. const INotificationId IVBLogicalAndPart::input4Id =
  50.                      "IVBLogicalAndPart::input4";
  51. #pragma export (IVBLogicalAndPart::input5Id,, 3105)
  52. const INotificationId IVBLogicalAndPart::input5Id =
  53.                      "IVBLogicalAndPart::input5";
  54. #pragma export (IVBLogicalAndPart::input6Id,, 3106)
  55. const INotificationId IVBLogicalAndPart::input6Id =
  56.                      "IVBLogicalAndPart::input6";
  57. #pragma export (IVBLogicalAndPart::input7Id,, 3107)
  58. const INotificationId IVBLogicalAndPart::input7Id =
  59.                      "IVBLogicalAndPart::input7";
  60. #pragma export (IVBLogicalAndPart::input8Id,, 3108)
  61. const INotificationId IVBLogicalAndPart::input8Id =
  62.                      "IVBLogicalAndPart::input8";
  63. #pragma export (IVBLogicalAndPart::input9Id,, 3109)
  64. const INotificationId IVBLogicalAndPart::input9Id =
  65.                      "IVBLogicalAndPart::input9";
  66. #pragma export (IVBLogicalAndPart::input10Id,, 3110)
  67. const INotificationId IVBLogicalAndPart::input10Id =
  68.                      "IVBLogicalAndPart::input10";
  69.  
  70. /*------------------------------------------------------------------------------
  71. | IVBLogicalAndPart::IVBLogicalAndPart                                         |
  72. |                                                                              |
  73. | Standard constructor.                                                        |
  74. ------------------------------------------------------------------------------*/
  75. #pragma export (IVBLogicalAndPart::IVBLogicalAndPart(),, 3111)
  76. IVBLogicalAndPart::IVBLogicalAndPart() : IVBDataTypePart ()
  77.     ,iValue (defaultInput())
  78.     ,iInput1 (defaultInput())
  79.     ,iInput2 (defaultInput())
  80.     ,iInput3 (defaultInput())
  81.     ,iInput4 (defaultInput())
  82.     ,iInput5 (defaultInput())
  83.     ,iInput6 (defaultInput())
  84.     ,iInput7 (defaultInput())
  85.     ,iInput8 (defaultInput())
  86.     ,iInput9 (defaultInput())
  87.     ,iInput10 (defaultInput())
  88. {
  89.   enableNotification ();
  90. }
  91.  
  92. /*------------------------------------------------------------------------------
  93. | IVBLogicalAndPart::IVBLogicalAndPart                                         |
  94. |                                                                              |
  95. | Standard copy constructor.                                                   |
  96. ------------------------------------------------------------------------------*/
  97. #pragma export (IVBLogicalAndPart::IVBLogicalAndPart(const IVBLogicalAndPart&),, 3112)
  98. IVBLogicalAndPart::IVBLogicalAndPart (const IVBLogicalAndPart& partCopy)
  99.   : IVBDataTypePart (partCopy)
  100.     ,iInput1 (partCopy.input1 ())
  101.     ,iInput2 (partCopy.input2 ())
  102.     ,iInput3 (partCopy.input3 ())
  103.     ,iInput4 (partCopy.input4 ())
  104.     ,iInput5 (partCopy.input5 ())
  105.     ,iInput6 (partCopy.input6 ())
  106.     ,iInput7 (partCopy.input7 ())
  107.     ,iInput8 (partCopy.input8 ())
  108.     ,iInput9 (partCopy.input9 ())
  109.     ,iInput10 (partCopy.input10 ())
  110. {
  111.   enableNotification ();
  112. }
  113.  
  114. /*------------------------------------------------------------------------------
  115. | IVBLogicalAndPart::IVBLogicalAndPart                                         |
  116. |                                                                              |
  117. | Standard operator=                                                           |
  118. ------------------------------------------------------------------------------*/
  119. #pragma export (IVBLogicalAndPart::operator= (const IVBLogicalAndPart&),, 3113)
  120. IVBLogicalAndPart& IVBLogicalAndPart::operator= (const IVBLogicalAndPart& aIVBLogicalAndPart)
  121. {
  122.   if (this == &aIVBLogicalAndPart) {
  123.     return *this;
  124.   } /* endif */
  125.   Inherited::operator=(aIVBLogicalAndPart);
  126.   setInput1(aIVBLogicalAndPart.input1());
  127.   setInput2(aIVBLogicalAndPart.input2());
  128.   setInput3(aIVBLogicalAndPart.input3());
  129.   setInput4(aIVBLogicalAndPart.input4());
  130.   setInput5(aIVBLogicalAndPart.input5());
  131.   setInput6(aIVBLogicalAndPart.input6());
  132.   setInput7(aIVBLogicalAndPart.input7());
  133.   setInput8(aIVBLogicalAndPart.input8());
  134.   setInput9(aIVBLogicalAndPart.input9());
  135.   setInput10(aIVBLogicalAndPart.input10());
  136.   return *this;
  137. }
  138.  
  139. /*------------------------------------------------------------------------------
  140. | IVBLogicalAndPart::~IVBLogicalAndPart                                        |
  141. |                                                                              |
  142. | IVBLogicalAndPart destructor.                                                |
  143. ------------------------------------------------------------------------------*/
  144. #pragma export (IVBLogicalAndPart::~IVBLogicalAndPart(),, 3114)
  145. IVBLogicalAndPart::~IVBLogicalAndPart()
  146. {
  147. }
  148.  
  149. /*------------------------------------------------------------------------------
  150. | IVBLogicalAndPart::asString                                                  |
  151. |                                                                              |
  152. | Perform asString.                                                            |
  153. ------------------------------------------------------------------------------*/
  154. #pragma export (IVBLogicalAndPart::asString() const,, 3115)
  155. IString IVBLogicalAndPart::asString () const
  156. {
  157.   return valueAsText();
  158. }
  159.  
  160. /*------------------------------------------------------------------------------
  161. | IVBLogicalAndPart::value                                                     |
  162. |                                                                              |
  163. | Return the value attribute.                                                  |
  164. ------------------------------------------------------------------------------*/
  165. #pragma export (IVBLogicalAndPart::value() const,, 3116)
  166. Boolean IVBLogicalAndPart::value () const
  167. {
  168.   return iValue;
  169. }
  170.  
  171. /*------------------------------------------------------------------------------
  172. | IVBLogicalAndPart::notValue                                                  |
  173. |                                                                              |
  174. | Return the notValue attribute.                                               |
  175. ------------------------------------------------------------------------------*/
  176. #pragma export (IVBLogicalAndPart::notValue() const,, 3117)
  177. Boolean IVBLogicalAndPart::notValue () const
  178. {
  179.   return !value();
  180. }
  181.  
  182. /*------------------------------------------------------------------------------
  183. | IVBLogicalAndPart::valueAsText                                               |
  184. |                                                                              |
  185. | Return the valueAsText attribute.                                            |
  186. ------------------------------------------------------------------------------*/
  187. #pragma export (IVBLogicalAndPart::valueAsText() const,, 3118)
  188. IString IVBLogicalAndPart::valueAsText () const
  189. {
  190.   if (value()) {
  191.     return IString("1");
  192.   } ; /* endif */
  193.   return IString("0");
  194. }
  195.  
  196. /*------------------------------------------------------------------------------
  197. | IVBLogicalAndPart::input1                                                    |
  198. |                                                                              |
  199. | Return the input1 attribute.                                                 |
  200. ------------------------------------------------------------------------------*/
  201. #pragma export (IVBLogicalAndPart::input1() const,, 3119)
  202. Boolean IVBLogicalAndPart::input1 () const
  203. {
  204.   return iInput1;
  205. }
  206.  
  207. /*------------------------------------------------------------------------------
  208. | IVBLogicalAndPart::setInput1                                                 |
  209. |                                                                              |
  210. | Set the input1 attribute.                                                    |
  211. ------------------------------------------------------------------------------*/
  212. #pragma export (IVBLogicalAndPart::setInput1(const Boolean))
  213. IVBLogicalAndPart& IVBLogicalAndPart::setInput1 (Boolean aInput1)
  214. {
  215.   if (iInput1 != aInput1) {
  216.     iInput1 = aInput1;
  217.     compute ();
  218.     notifyObservers(INotificationEvent(input1Id, *this,
  219.                     true, (void*)iInput1));
  220.   } /* endif */
  221.   return *this;
  222. }
  223.  
  224. /*------------------------------------------------------------------------------
  225. | IVBLogicalAndPart::setInput1                                                 |
  226. |                                                                              |
  227. | Set the input1 attribute.                                                    |
  228. ------------------------------------------------------------------------------*/
  229. #pragma export (IVBLogicalAndPart::setInput1(),, 3121)
  230. IVBLogicalAndPart& IVBLogicalAndPart::setInput1 ()
  231. {
  232.   return setInput1 (defaultInput());
  233. }
  234.  
  235. /*------------------------------------------------------------------------------
  236. | IVBLogicalAndPart::input2                                                    |
  237. |                                                                              |
  238. | Return the input2 attribute.                                                 |
  239. ------------------------------------------------------------------------------*/
  240. #pragma export (IVBLogicalAndPart::input2() const,, 3122)
  241. Boolean IVBLogicalAndPart::input2 () const
  242. {
  243.   return iInput2;
  244. }
  245.  
  246. /*------------------------------------------------------------------------------
  247. | IVBLogicalAndPart::setInput2                                                 |
  248. |                                                                              |
  249. | Set the input2 attribute.                                                    |
  250. ------------------------------------------------------------------------------*/
  251. #pragma export (IVBLogicalAndPart::setInput2(const Boolean))
  252. IVBLogicalAndPart& IVBLogicalAndPart::setInput2 (Boolean aInput2)
  253. {
  254.   if (iInput2 != aInput2) {
  255.     iInput2 = aInput2;
  256.     compute ();
  257.     notifyObservers(INotificationEvent(input2Id, *this,
  258.                     true, (void*)iInput2));
  259.   } /* endif */
  260.   return *this;
  261. }
  262.  
  263. /*------------------------------------------------------------------------------
  264. | IVBLogicalAndPart::setInput2                                                 |
  265. |                                                                              |
  266. | Set the input2 attribute.                                                    |
  267. ------------------------------------------------------------------------------*/
  268. #pragma export (IVBLogicalAndPart::setInput2(),, 3124)
  269. IVBLogicalAndPart& IVBLogicalAndPart::setInput2 ()
  270. {
  271.   return setInput2 (defaultInput());
  272. }
  273.  
  274. /*------------------------------------------------------------------------------
  275. | IVBLogicalAndPart::input3                                                    |
  276. |                                                                              |
  277. | Return the input3 attribute.                                                 |
  278. ------------------------------------------------------------------------------*/
  279. #pragma export (IVBLogicalAndPart::input3() const,, 3125)
  280. Boolean IVBLogicalAndPart::input3 () const
  281. {
  282.   return iInput3;
  283. }
  284.  
  285. /*------------------------------------------------------------------------------
  286. | IVBLogicalAndPart::setInput3                                                 |
  287. |                                                                              |
  288. | Set the input3 attribute.                                                    |
  289. ------------------------------------------------------------------------------*/
  290. #pragma export (IVBLogicalAndPart::setInput3(const Boolean))
  291. IVBLogicalAndPart& IVBLogicalAndPart::setInput3 (Boolean aInput3)
  292. {
  293.   if (iInput3 != aInput3) {
  294.     iInput3 = aInput3;
  295.     compute ();
  296.     notifyObservers(INotificationEvent(input3Id, *this,
  297.                     true, (void*)iInput3));
  298.   } /* endif */
  299.   return *this;
  300. }
  301.  
  302. /*------------------------------------------------------------------------------
  303. | IVBLogicalAndPart::setInput3                                                 |
  304. |                                                                              |
  305. | Set the input3 attribute.                                                    |
  306. ------------------------------------------------------------------------------*/
  307. #pragma export (IVBLogicalAndPart::setInput3(),, 3127)
  308. IVBLogicalAndPart& IVBLogicalAndPart::setInput3 ()
  309. {
  310.   return setInput3 (defaultInput());
  311. }
  312.  
  313. /*------------------------------------------------------------------------------
  314. | IVBLogicalAndPart::input4                                                    |
  315. |                                                                              |
  316. | Return the input4 attribute.                                                 |
  317. ------------------------------------------------------------------------------*/
  318. #pragma export (IVBLogicalAndPart::input4() const,, 3128)
  319. Boolean IVBLogicalAndPart::input4 () const
  320. {
  321.   return iInput4;
  322. }
  323.  
  324. /*------------------------------------------------------------------------------
  325. | IVBLogicalAndPart::setInput4                                                 |
  326. |                                                                              |
  327. | Set the input4 attribute.                                                    |
  328. ------------------------------------------------------------------------------*/
  329. #pragma export (IVBLogicalAndPart::setInput4(const Boolean))
  330. IVBLogicalAndPart& IVBLogicalAndPart::setInput4 (Boolean aInput4)
  331. {
  332.   if (iInput4 != aInput4) {
  333.     iInput4 = aInput4;
  334.     compute ();
  335.     notifyObservers(INotificationEvent(input4Id, *this,
  336.                     true, (void*)iInput4));
  337.   } /* endif */
  338.   return *this;
  339. }
  340.  
  341. /*------------------------------------------------------------------------------
  342. | IVBLogicalAndPart::setInput4                                                 |
  343. |                                                                              |
  344. | Set the input4 attribute.                                                    |
  345. ------------------------------------------------------------------------------*/
  346. #pragma export (IVBLogicalAndPart::setInput4(),, 3130)
  347. IVBLogicalAndPart& IVBLogicalAndPart::setInput4 ()
  348. {
  349.   return setInput4 (defaultInput());
  350. }
  351.  
  352. /*------------------------------------------------------------------------------
  353. | IVBLogicalAndPart::input5                                                    |
  354. |                                                                              |
  355. | Return the input5 attribute.                                                 |
  356. ------------------------------------------------------------------------------*/
  357. #pragma export (IVBLogicalAndPart::input5() const,, 3131)
  358. Boolean IVBLogicalAndPart::input5 () const
  359. {
  360.   return iInput5;
  361. }
  362.  
  363. /*------------------------------------------------------------------------------
  364. | IVBLogicalAndPart::setInput5                                                 |
  365. |                                                                              |
  366. | Set the input5 attribute.                                                    |
  367. ------------------------------------------------------------------------------*/
  368. #pragma export (IVBLogicalAndPart::setInput5(const Boolean))
  369. IVBLogicalAndPart& IVBLogicalAndPart::setInput5 (Boolean aInput5)
  370. {
  371.   if (iInput5 != aInput5) {
  372.     iInput5 = aInput5;
  373.     compute ();
  374.     notifyObservers(INotificationEvent(input5Id, *this,
  375.                     true, (void*)iInput5));
  376.   } /* endif */
  377.   return *this;
  378. }
  379.  
  380. /*------------------------------------------------------------------------------
  381. | IVBLogicalAndPart::setInput5                                                 |
  382. |                                                                              |
  383. | Set the input5 attribute.                                                    |
  384. ------------------------------------------------------------------------------*/
  385. #pragma export (IVBLogicalAndPart::setInput5(),, 3133)
  386. IVBLogicalAndPart& IVBLogicalAndPart::setInput5 ()
  387. {
  388.   return setInput5 (defaultInput());
  389. }
  390.  
  391. /*------------------------------------------------------------------------------
  392. | IVBLogicalAndPart::input6                                                    |
  393. |                                                                              |
  394. | Return the input6 attribute.                                                 |
  395. ------------------------------------------------------------------------------*/
  396. #pragma export (IVBLogicalAndPart::input6() const,, 3134)
  397. Boolean IVBLogicalAndPart::input6 () const
  398. {
  399.   return iInput6;
  400. }
  401.  
  402. /*------------------------------------------------------------------------------
  403. | IVBLogicalAndPart::setInput6                                                 |
  404. |                                                                              |
  405. | Set the input6 attribute.                                                    |
  406. ------------------------------------------------------------------------------*/
  407. #pragma export (IVBLogicalAndPart::setInput6(const Boolean))
  408. IVBLogicalAndPart& IVBLogicalAndPart::setInput6 (Boolean aInput6)
  409. {
  410.   if (iInput6 != aInput6) {
  411.     iInput6 = aInput6;
  412.     compute ();
  413.     notifyObservers(INotificationEvent(input6Id, *this,
  414.                     true, (void*)iInput6));
  415.   } /* endif */
  416.   return *this;
  417. }
  418.  
  419. /*------------------------------------------------------------------------------
  420. | IVBLogicalAndPart::setInput6                                                 |
  421. |                                                                              |
  422. | Set the input6 attribute.                                                    |
  423. ------------------------------------------------------------------------------*/
  424. #pragma export (IVBLogicalAndPart::setInput6(),, 3136)
  425. IVBLogicalAndPart& IVBLogicalAndPart::setInput6 ()
  426. {
  427.   return setInput6 (defaultInput());
  428. }
  429.  
  430. /*------------------------------------------------------------------------------
  431. | IVBLogicalAndPart::input7                                                    |
  432. |                                                                              |
  433. | Return the input7 attribute.                                                 |
  434. ------------------------------------------------------------------------------*/
  435. #pragma export (IVBLogicalAndPart::input7() const,, 3137)
  436. Boolean IVBLogicalAndPart::input7 () const
  437. {
  438.   return iInput7;
  439. }
  440.  
  441. /*------------------------------------------------------------------------------
  442. | IVBLogicalAndPart::setInput7                                                 |
  443. |                                                                              |
  444. | Set the input7 attribute.                                                    |
  445. ------------------------------------------------------------------------------*/
  446. #pragma export (IVBLogicalAndPart::setInput7(const Boolean))
  447. IVBLogicalAndPart& IVBLogicalAndPart::setInput7 (Boolean aInput7)
  448. {
  449.   if (iInput7 != aInput7) {
  450.     iInput7 = aInput7;
  451.     compute ();
  452.     notifyObservers(INotificationEvent(input7Id, *this,
  453.                     true, (void*)iInput7));
  454.   } /* endif */
  455.   return *this;
  456. }
  457.  
  458. /*------------------------------------------------------------------------------
  459. | IVBLogicalAndPart::setInput7                                                 |
  460. |                                                                              |
  461. | Set the input7 attribute.                                                    |
  462. ------------------------------------------------------------------------------*/
  463. #pragma export (IVBLogicalAndPart::setInput7(),, 3139)
  464. IVBLogicalAndPart& IVBLogicalAndPart::setInput7 ()
  465. {
  466.   return setInput7 (defaultInput());
  467. }
  468.  
  469. /*------------------------------------------------------------------------------
  470. | IVBLogicalAndPart::input8                                                    |
  471. |                                                                              |
  472. | Return the input8 attribute.                                                 |
  473. ------------------------------------------------------------------------------*/
  474. #pragma export (IVBLogicalAndPart::input8() const,, 3140)
  475. Boolean IVBLogicalAndPart::input8 () const
  476. {
  477.   return iInput8;
  478. }
  479.  
  480. /*------------------------------------------------------------------------------
  481. | IVBLogicalAndPart::setInput8                                                 |
  482. |                                                                              |
  483. | Set the input8 attribute.                                                    |
  484. ------------------------------------------------------------------------------*/
  485. #pragma export (IVBLogicalAndPart::setInput8(const Boolean))
  486. IVBLogicalAndPart& IVBLogicalAndPart::setInput8 (Boolean aInput8)
  487. {
  488.   if (iInput8 != aInput8) {
  489.     iInput8 = aInput8;
  490.     compute ();
  491.     notifyObservers(INotificationEvent(input8Id, *this,
  492.                     true, (void*)iInput8));
  493.   } /* endif */
  494.   return *this;
  495. }
  496.  
  497. /*------------------------------------------------------------------------------
  498. | IVBLogicalAndPart::setInput8                                                 |
  499. |                                                                              |
  500. | Set the input8 attribute.                                                    |
  501. ------------------------------------------------------------------------------*/
  502. #pragma export (IVBLogicalAndPart::setInput8(),, 3142)
  503. IVBLogicalAndPart& IVBLogicalAndPart::setInput8 ()
  504. {
  505.   return setInput8 (defaultInput());
  506. }
  507.  
  508. /*------------------------------------------------------------------------------
  509. | IVBLogicalAndPart::input9                                                    |
  510. |                                                                              |
  511. | Return the input9 attribute.                                                 |
  512. ------------------------------------------------------------------------------*/
  513. #pragma export (IVBLogicalAndPart::input9() const,, 3143)
  514. Boolean IVBLogicalAndPart::input9 () const
  515. {
  516.   return iInput9;
  517. }
  518.  
  519. /*------------------------------------------------------------------------------
  520. | IVBLogicalAndPart::setInput9                                                 |
  521. |                                                                              |
  522. | Set the input9 attribute.                                                    |
  523. ------------------------------------------------------------------------------*/
  524. #pragma export (IVBLogicalAndPart::setInput9(const Boolean))
  525. IVBLogicalAndPart& IVBLogicalAndPart::setInput9 (Boolean aInput9)
  526. {
  527.   if (iInput9 != aInput9) {
  528.     iInput9 = aInput9;
  529.     compute ();
  530.     notifyObservers(INotificationEvent(input9Id, *this,
  531.                     true, (void*)iInput9));
  532.   } /* endif */
  533.   return *this;
  534. }
  535.  
  536. /*------------------------------------------------------------------------------
  537. | IVBLogicalAndPart::setInput9                                                 |
  538. |                                                                              |
  539. | Set the input9 attribute.                                                    |
  540. ------------------------------------------------------------------------------*/
  541. #pragma export (IVBLogicalAndPart::setInput9(),, 3145)
  542. IVBLogicalAndPart& IVBLogicalAndPart::setInput9 ()
  543. {
  544.   return setInput9 (defaultInput());
  545. }
  546.  
  547. /*------------------------------------------------------------------------------
  548. | IVBLogicalAndPart::input10                                                   |
  549. |                                                                              |
  550. | Return the input10 attribute.                                                |
  551. ------------------------------------------------------------------------------*/
  552. #pragma export (IVBLogicalAndPart::input10() const,, 3146)
  553. Boolean IVBLogicalAndPart::input10 () const
  554. {
  555.   return iInput10;
  556. }
  557.  
  558. /*------------------------------------------------------------------------------
  559. | IVBLogicalAndPart::setInput10                                                |
  560. |                                                                              |
  561. | Set the input10 attribute.                                                   |
  562. ------------------------------------------------------------------------------*/
  563. #pragma export (IVBLogicalAndPart::setInput10(const Boolean))
  564. IVBLogicalAndPart& IVBLogicalAndPart::setInput10 (Boolean aInput10)
  565. {
  566.   if (iInput10 != aInput10) {
  567.     iInput10 = aInput10;
  568.     compute ();
  569.     notifyObservers(INotificationEvent(input10Id, *this,
  570.                     true, (void*)iInput10));
  571.   } /* endif */
  572.   return *this;
  573. }
  574.  
  575. /*------------------------------------------------------------------------------
  576. | IVBLogicalAndPart::setInput10                                                |
  577. |                                                                              |
  578. | Set the input10 attribute.                                                   |
  579. ------------------------------------------------------------------------------*/
  580. #pragma export (IVBLogicalAndPart::setInput10(),, 3148)
  581. IVBLogicalAndPart& IVBLogicalAndPart::setInput10 ()
  582. {
  583.   return setInput10 (defaultInput());
  584. }
  585.  
  586. /*------------------------------------------------------------------------------
  587. | IVBLogicalAndPart::notInput1                                                 |
  588. |                                                                              |
  589. | Return the notInput1 attribute.                                              |
  590. ------------------------------------------------------------------------------*/
  591. #pragma export (IVBLogicalAndPart::notInput1() const,, 3149)
  592. Boolean IVBLogicalAndPart::notInput1 () const
  593. {
  594.   return !input1();
  595. }
  596.  
  597. /*------------------------------------------------------------------------------
  598. | IVBLogicalAndPart::setNotInput1                                              |
  599. |                                                                              |
  600. | Set the notInput1 attribute.                                                 |
  601. ------------------------------------------------------------------------------*/
  602. #pragma export (IVBLogicalAndPart::setNotInput1(const Boolean),, 3150)
  603. IVBLogicalAndPart& IVBLogicalAndPart::setNotInput1 (Boolean aNotInput1)
  604. {
  605.   return setInput1(!aNotInput1);
  606. }
  607.  
  608. /*------------------------------------------------------------------------------
  609. | IVBLogicalAndPart::setNotInput1                                              |
  610. |                                                                              |
  611. | Set the notInput1 attribute.                                                 |
  612. ------------------------------------------------------------------------------*/
  613. #pragma export (IVBLogicalAndPart::setNotInput1(),, 3151)
  614. IVBLogicalAndPart& IVBLogicalAndPart::setNotInput1 ()
  615. {
  616.   return setNotInput1 (!defaultInput());
  617. }
  618.  
  619. /*------------------------------------------------------------------------------
  620. | IVBLogicalAndPart::notInput2                                                 |
  621. |                                                                              |
  622. | Return the notInput2 attribute.                                              |
  623. ------------------------------------------------------------------------------*/
  624. #pragma export (IVBLogicalAndPart::notInput2() const,, 3152)
  625. Boolean IVBLogicalAndPart::notInput2 () const
  626. {
  627.   return !input2();
  628. }
  629.  
  630. /*------------------------------------------------------------------------------
  631. | IVBLogicalAndPart::setNotInput2                                              |
  632. |                                                                              |
  633. | Set the notInput2 attribute.                                                 |
  634. ------------------------------------------------------------------------------*/
  635. #pragma export (IVBLogicalAndPart::setNotInput2(const Boolean),, 3153)
  636. IVBLogicalAndPart& IVBLogicalAndPart::setNotInput2 (Boolean aNotInput2)
  637. {
  638.   return setInput2(!aNotInput2);
  639. }
  640.  
  641. /*------------------------------------------------------------------------------
  642. | IVBLogicalAndPart::setNotInput2                                              |
  643. |                                                                              |
  644. | Set the notInput2 attribute.                                                 |
  645. ------------------------------------------------------------------------------*/
  646. #pragma export (IVBLogicalAndPart::setNotInput2(),, 3154)
  647. IVBLogicalAndPart& IVBLogicalAndPart::setNotInput2 ()
  648. {
  649.   return setNotInput2 (!defaultInput());
  650. }
  651.  
  652. /*------------------------------------------------------------------------------
  653. | IVBLogicalAndPart::notInput3                                                 |
  654. |                                                                              |
  655. | Return the notInput3 attribute.                                              |
  656. ------------------------------------------------------------------------------*/
  657. #pragma export (IVBLogicalAndPart::notInput3() const,, 3155)
  658. Boolean IVBLogicalAndPart::notInput3 () const
  659. {
  660.   return !input3();
  661. }
  662.  
  663. /*------------------------------------------------------------------------------
  664. | IVBLogicalAndPart::setNotInput3                                              |
  665. |                                                                              |
  666. | Set the notInput3 attribute.                                                 |
  667. ------------------------------------------------------------------------------*/
  668. #pragma export (IVBLogicalAndPart::setNotInput3(const Boolean),, 3156)
  669. IVBLogicalAndPart& IVBLogicalAndPart::setNotInput3 (Boolean aNotInput3)
  670. {
  671.   return setInput3(!aNotInput3);
  672. }
  673.  
  674. /*------------------------------------------------------------------------------
  675. | IVBLogicalAndPart::setNotInput3                                              |
  676. |                                                                              |
  677. | Set the notInput3 attribute.                                                 |
  678. ------------------------------------------------------------------------------*/
  679. #pragma export (IVBLogicalAndPart::setNotInput3(),, 3157)
  680. IVBLogicalAndPart& IVBLogicalAndPart::setNotInput3 ()
  681. {
  682.   return setNotInput3 (!defaultInput());
  683. }
  684.  
  685. /*------------------------------------------------------------------------------
  686. | IVBLogicalAndPart::notInput4                                                 |
  687. |                                                                              |
  688. | Return the notInput4 attribute.                                              |
  689. ------------------------------------------------------------------------------*/
  690. #pragma export (IVBLogicalAndPart::notInput4() const,, 3158)
  691. Boolean IVBLogicalAndPart::notInput4 () const
  692. {
  693.   return !input4();
  694. }
  695.  
  696. /*------------------------------------------------------------------------------
  697. | IVBLogicalAndPart::setNotInput4                                              |
  698. |                                                                              |
  699. | Set the notInput4 attribute.                                                 |
  700. ------------------------------------------------------------------------------*/
  701. #pragma export (IVBLogicalAndPart::setNotInput4(const Boolean),, 3159)
  702. IVBLogicalAndPart& IVBLogicalAndPart::setNotInput4 (Boolean aNotInput4)
  703. {
  704.   return setInput4(!aNotInput4);
  705. }
  706.  
  707. /*------------------------------------------------------------------------------
  708. | IVBLogicalAndPart::setNotInput4                                              |
  709. |                                                                              |
  710. | Set the notInput4 attribute.                                                 |
  711. ------------------------------------------------------------------------------*/
  712. #pragma export (IVBLogicalAndPart::setNotInput4(),, 3160)
  713. IVBLogicalAndPart& IVBLogicalAndPart::setNotInput4 ()
  714. {
  715.   return setNotInput4 (!defaultInput());
  716. }
  717.  
  718. /*------------------------------------------------------------------------------
  719. | IVBLogicalAndPart::notInput5                                                 |
  720. |                                                                              |
  721. | Return the notInput5 attribute.                                              |
  722. ------------------------------------------------------------------------------*/
  723. #pragma export (IVBLogicalAndPart::notInput5() const,, 3161)
  724. Boolean IVBLogicalAndPart::notInput5 () const
  725. {
  726.   return !input5();
  727. }
  728.  
  729. /*------------------------------------------------------------------------------
  730. | IVBLogicalAndPart::setNotInput5                                              |
  731. |                                                                              |
  732. | Set the notInput5 attribute.                                                 |
  733. ------------------------------------------------------------------------------*/
  734. #pragma export (IVBLogicalAndPart::setNotInput5(const Boolean),, 3162)
  735. IVBLogicalAndPart& IVBLogicalAndPart::setNotInput5 (Boolean aNotInput5)
  736. {
  737.   return setInput5(!aNotInput5);
  738. }
  739.  
  740. /*------------------------------------------------------------------------------
  741. | IVBLogicalAndPart::setNotInput5                                              |
  742. |                                                                              |
  743. | Set the notInput5 attribute.                                                 |
  744. ------------------------------------------------------------------------------*/
  745. #pragma export (IVBLogicalAndPart::setNotInput5(),, 3163)
  746. IVBLogicalAndPart& IVBLogicalAndPart::setNotInput5 ()
  747. {
  748.   return setNotInput5 (!defaultInput());
  749. }
  750.  
  751. /*------------------------------------------------------------------------------
  752. | IVBLogicalAndPart::notInput6                                                 |
  753. |                                                                              |
  754. | Return the notInput6 attribute.                                              |
  755. ------------------------------------------------------------------------------*/
  756. #pragma export (IVBLogicalAndPart::notInput6() const,, 3164)
  757. Boolean IVBLogicalAndPart::notInput6 () const
  758. {
  759.   return !input6();
  760. }
  761.  
  762. /*------------------------------------------------------------------------------
  763. | IVBLogicalAndPart::setNotInput6                                              |
  764. |                                                                              |
  765. | Set the notInput6 attribute.                                                 |
  766. ------------------------------------------------------------------------------*/
  767. #pragma export (IVBLogicalAndPart::setNotInput6(const Boolean),, 3165)
  768. IVBLogicalAndPart& IVBLogicalAndPart::setNotInput6 (Boolean aNotInput6)
  769. {
  770.   return setInput6(!aNotInput6);
  771. }
  772.  
  773. /*------------------------------------------------------------------------------
  774. | IVBLogicalAndPart::setNotInput6                                              |
  775. |                                                                              |
  776. | Set the notInput6 attribute.                                                 |
  777. ------------------------------------------------------------------------------*/
  778. #pragma export (IVBLogicalAndPart::setNotInput6(),, 3166)
  779. IVBLogicalAndPart& IVBLogicalAndPart::setNotInput6 ()
  780. {
  781.   return setNotInput6 (!defaultInput());
  782. }
  783.  
  784. /*------------------------------------------------------------------------------
  785. | IVBLogicalAndPart::notInput7                                                 |
  786. |                                                                              |
  787. | Return the notInput7 attribute.                                              |
  788. ------------------------------------------------------------------------------*/
  789. #pragma export (IVBLogicalAndPart::notInput7() const,, 3167)
  790. Boolean IVBLogicalAndPart::notInput7 () const
  791. {
  792.   return !input7();
  793. }
  794.  
  795. /*------------------------------------------------------------------------------
  796. | IVBLogicalAndPart::setNotInput7                                              |
  797. |                                                                              |
  798. | Set the notInput7 attribute.                                                 |
  799. ------------------------------------------------------------------------------*/
  800. #pragma export (IVBLogicalAndPart::setNotInput7(const Boolean),, 3168)
  801. IVBLogicalAndPart& IVBLogicalAndPart::setNotInput7 (Boolean aNotInput7)
  802. {
  803.   return setInput7(!aNotInput7);
  804. }
  805.  
  806. /*------------------------------------------------------------------------------
  807. | IVBLogicalAndPart::setNotInput7                                              |
  808. |                                                                              |
  809. | Set the notInput7 attribute.                                                 |
  810. ------------------------------------------------------------------------------*/
  811. #pragma export (IVBLogicalAndPart::setNotInput7(),, 3169)
  812. IVBLogicalAndPart& IVBLogicalAndPart::setNotInput7 ()
  813. {
  814.   return setNotInput7 (!defaultInput());
  815. }
  816.  
  817. /*------------------------------------------------------------------------------
  818. | IVBLogicalAndPart::notInput8                                                 |
  819. |                                                                              |
  820. | Return the notInput8 attribute.                                              |
  821. ------------------------------------------------------------------------------*/
  822. #pragma export (IVBLogicalAndPart::notInput8() const,, 3170)
  823. Boolean IVBLogicalAndPart::notInput8 () const
  824. {
  825.   return !input8();
  826. }
  827.  
  828. /*------------------------------------------------------------------------------
  829. | IVBLogicalAndPart::setNotInput8                                              |
  830. |                                                                              |
  831. | Set the notInput8 attribute.                                                 |
  832. ------------------------------------------------------------------------------*/
  833. #pragma export (IVBLogicalAndPart::setNotInput8(const Boolean),, 3171)
  834. IVBLogicalAndPart& IVBLogicalAndPart::setNotInput8 (Boolean aNotInput8)
  835. {
  836.   return setInput8(!aNotInput8);
  837. }
  838.  
  839. /*------------------------------------------------------------------------------
  840. | IVBLogicalAndPart::setNotInput8                                              |
  841. |                                                                              |
  842. | Set the notInput8 attribute.                                                 |
  843. ------------------------------------------------------------------------------*/
  844. #pragma export (IVBLogicalAndPart::setNotInput8(),, 3172)
  845. IVBLogicalAndPart& IVBLogicalAndPart::setNotInput8 ()
  846. {
  847.   return setNotInput8 (!defaultInput());
  848. }
  849.  
  850. /*------------------------------------------------------------------------------
  851. | IVBLogicalAndPart::notInput9                                                 |
  852. |                                                                              |
  853. | Return the notInput9 attribute.                                              |
  854. ------------------------------------------------------------------------------*/
  855. #pragma export (IVBLogicalAndPart::notInput9() const,, 3173)
  856. Boolean IVBLogicalAndPart::notInput9 () const
  857. {
  858.   return !input9();
  859. }
  860.  
  861. /*------------------------------------------------------------------------------
  862. | IVBLogicalAndPart::setNotInput9                                              |
  863. |                                                                              |
  864. | Set the notInput9 attribute.                                                 |
  865. ------------------------------------------------------------------------------*/
  866. #pragma export (IVBLogicalAndPart::setNotInput9(const Boolean),, 3174)
  867. IVBLogicalAndPart& IVBLogicalAndPart::setNotInput9 (Boolean aNotInput9)
  868. {
  869.   return setInput9(!aNotInput9);
  870. }
  871.  
  872. /*------------------------------------------------------------------------------
  873. | IVBLogicalAndPart::setNotInput9                                              |
  874. |                                                                              |
  875. | Set the notInput9 attribute.                                                 |
  876. ------------------------------------------------------------------------------*/
  877. #pragma export (IVBLogicalAndPart::setNotInput9(),, 3175)
  878. IVBLogicalAndPart& IVBLogicalAndPart::setNotInput9 ()
  879. {
  880.   return setNotInput9 (!defaultInput());
  881. }
  882.  
  883. /*------------------------------------------------------------------------------
  884. | IVBLogicalAndPart::notInput10                                                |
  885. |                                                                              |
  886. | Return the notInput10 attribute.                                             |
  887. ------------------------------------------------------------------------------*/
  888. #pragma export (IVBLogicalAndPart::notInput10() const,, 3176)
  889. Boolean IVBLogicalAndPart::notInput10 () const
  890. {
  891.   return !input10();
  892. }
  893.  
  894. /*------------------------------------------------------------------------------
  895. | IVBLogicalAndPart::setNotInput10                                             |
  896. |                                                                              |
  897. | Set the notInput10 attribute.                                                |
  898. ------------------------------------------------------------------------------*/
  899. #pragma export (IVBLogicalAndPart::setNotInput10(const Boolean),, 3177)
  900. IVBLogicalAndPart& IVBLogicalAndPart::setNotInput10 (Boolean aNotInput10)
  901. {
  902.   return setInput10(!aNotInput10);
  903. }
  904.  
  905. /*------------------------------------------------------------------------------
  906. | IVBLogicalAndPart::setNotInput10                                             |
  907. |                                                                              |
  908. | Set the notInput10 attribute.                                                |
  909. ------------------------------------------------------------------------------*/
  910. #pragma export (IVBLogicalAndPart::setNotInput10(),, 3178)
  911. IVBLogicalAndPart& IVBLogicalAndPart::setNotInput10 ()
  912. {
  913.   return setNotInput10 (!defaultInput());
  914. }
  915.  
  916. /*------------------------------------------------------------------------------
  917. | IVBLogicalAndPart::defaultInput                                              |
  918. |                                                                              |
  919. | Return the defaultInput attribute.                                           |
  920. ------------------------------------------------------------------------------*/
  921. #pragma export (IVBLogicalAndPart::defaultInput() const,, 3179)
  922. Boolean IVBLogicalAndPart::defaultInput () const
  923. {
  924.   return true;
  925. }
  926.  
  927. /*------------------------------------------------------------------------------
  928. | IVBLogicalAndPart::compute                                                   |
  929. |                                                                              |
  930. | Perform the compute action.                                                  |
  931. ------------------------------------------------------------------------------*/
  932. #pragma export (IVBLogicalAndPart::compute(),, 3180)
  933. IVBLogicalAndPart& IVBLogicalAndPart::compute ()
  934. {
  935.   Boolean aValue = (iInput1 &&
  936.                     iInput2 &&
  937.                     iInput3 &&
  938.                     iInput4 &&
  939.                     iInput5 &&
  940.                     iInput6 &&
  941.                     iInput7 &&
  942.                     iInput9 &&
  943.                     iInput10);
  944.   if (iValue != aValue) {
  945.     iValue = aValue;
  946.     notifyObservers(INotificationEvent(valueId, *this,
  947.                       true, (void*)iValue));
  948.   } ; /* endif */
  949.   return *this;
  950. }
  951.  
  952. /*------------------------------------------------------------------------------
  953. | IVBLogicalAndPart::operator == (const IVBLogicalAndPart & aValue)            |
  954. |                                                                              |
  955. ------------------------------------------------------------------------------*/
  956. #pragma export (IVBLogicalAndPart::operator == (const IVBLogicalAndPart&) const,, 3181)
  957. Boolean IVBLogicalAndPart::
  958.   operator == (const IVBLogicalAndPart& aValue) const
  959. {
  960.   if (value() != aValue.value()) {
  961.     return false;
  962.   } /* endif */
  963.   if (input1() != aValue.input1()) {
  964.     return false;
  965.   } /* endif */
  966.   if (input2() != aValue.input2()) {
  967.     return false;
  968.   } /* endif */
  969.   if (input3() != aValue.input3()) {
  970.     return false;
  971.   } /* endif */
  972.   if (input4() != aValue.input4()) {
  973.     return false;
  974.   } /* endif */
  975.   if (input5() != aValue.input5()) {
  976.     return false;
  977.   } /* endif */
  978.   if (input6() != aValue.input6()) {
  979.     return false;
  980.   } /* endif */
  981.   if (input7() != aValue.input7()) {
  982.     return false;
  983.   } /* endif */
  984.   if (input8() != aValue.input8()) {
  985.     return false;
  986.   } /* endif */
  987.   if (input9() != aValue.input9()) {
  988.     return false;
  989.   } /* endif */
  990.   if (input10() != aValue.input10()) {
  991.     return false;
  992.   } /* endif */
  993.   return true;
  994. }
  995.  
  996. /*------------------------------------------------------------------------------
  997. | IVBLogicalAndPart::operator != (const IVBLogicalAndPart & aValue)            |
  998. |                                                                              |
  999. ------------------------------------------------------------------------------*/
  1000. #pragma export (IVBLogicalAndPart::operator != (const IVBLogicalAndPart&) const,, 3182)
  1001. Boolean IVBLogicalAndPart::
  1002.   operator != (const IVBLogicalAndPart& aValue) const
  1003. {
  1004.   if (value() != aValue.value()) {
  1005.     return true;
  1006.   } /* endif */
  1007.   if (input1() != aValue.input1()) {
  1008.     return true;
  1009.   } /* endif */
  1010.   if (input2() != aValue.input2()) {
  1011.     return true;
  1012.   } /* endif */
  1013.   if (input3() != aValue.input3()) {
  1014.     return true;
  1015.   } /* endif */
  1016.   if (input4() != aValue.input4()) {
  1017.     return true;
  1018.   } /* endif */
  1019.   if (input5() != aValue.input5()) {
  1020.     return true;
  1021.   } /* endif */
  1022.   if (input6() != aValue.input6()) {
  1023.     return true;
  1024.   } /* endif */
  1025.   if (input7() != aValue.input7()) {
  1026.     return true;
  1027.   } /* endif */
  1028.   if (input8() != aValue.input8()) {
  1029.     return true;
  1030.   } /* endif */
  1031.   if (input9() != aValue.input9()) {
  1032.     return true;
  1033.   } /* endif */
  1034.   if (input10() != aValue.input10()) {
  1035.     return true;
  1036.   } /* endif */
  1037.   return false;
  1038. }
  1039.  
  1040. /*------------------------------------------------------------------------------
  1041. | IVBLogicalAndPart::operator == (const IVBLogicalAndPart * aValue)            |
  1042. |                                                                              |
  1043. ------------------------------------------------------------------------------*/
  1044. #pragma export (IVBLogicalAndPart::operator == (const IVBLogicalAndPart*) const,, 3183)
  1045. Boolean IVBLogicalAndPart::
  1046.   operator == (const IVBLogicalAndPart* aValue) const
  1047. {
  1048.   if (value() != aValue->value()) {
  1049.     return false;
  1050.   } /* endif */
  1051.   if (input1() != aValue->input1()) {
  1052.     return false;
  1053.   } /* endif */
  1054.   if (input2() != aValue->input2()) {
  1055.     return false;
  1056.   } /* endif */
  1057.   if (input3() != aValue->input3()) {
  1058.     return false;
  1059.   } /* endif */
  1060.   if (input4() != aValue->input4()) {
  1061.     return false;
  1062.   } /* endif */
  1063.   if (input5() != aValue->input5()) {
  1064.     return false;
  1065.   } /* endif */
  1066.   if (input6() != aValue->input6()) {
  1067.     return false;
  1068.   } /* endif */
  1069.   if (input7() != aValue->input7()) {
  1070.     return false;
  1071.   } /* endif */
  1072.   if (input8() != aValue->input8()) {
  1073.     return false;
  1074.   } /* endif */
  1075.   if (input9() != aValue->input9()) {
  1076.     return false;
  1077.   } /* endif */
  1078.   if (input10() != aValue->input10()) {
  1079.     return false;
  1080.   } /* endif */
  1081.   return true;
  1082. }
  1083.  
  1084. /*------------------------------------------------------------------------------
  1085. | IVBLogicalAndPart::operator != (const IVBLogicalAndPart * aValue)            |
  1086. |                                                                              |
  1087. ------------------------------------------------------------------------------*/
  1088. #pragma export (IVBLogicalAndPart::operator != (const IVBLogicalAndPart*) const,, 3184)
  1089. Boolean IVBLogicalAndPart::
  1090.   operator != (const IVBLogicalAndPart* aValue) const
  1091. {
  1092.   if (value() != aValue->value()) {
  1093.     return true;
  1094.   } /* endif */
  1095.   if (input1() != aValue->input1()) {
  1096.     return true;
  1097.   } /* endif */
  1098.   if (input2() != aValue->input2()) {
  1099.     return true;
  1100.   } /* endif */
  1101.   if (input3() != aValue->input3()) {
  1102.     return true;
  1103.   } /* endif */
  1104.   if (input4() != aValue->input4()) {
  1105.     return true;
  1106.   } /* endif */
  1107.   if (input5() != aValue->input5()) {
  1108.     return true;
  1109.   } /* endif */
  1110.   if (input6() != aValue->input6()) {
  1111.     return true;
  1112.   } /* endif */
  1113.   if (input7() != aValue->input7()) {
  1114.     return true;
  1115.   } /* endif */
  1116.   if (input8() != aValue->input8()) {
  1117.     return true;
  1118.   } /* endif */
  1119.   if (input9() != aValue->input9()) {
  1120.     return true;
  1121.   } /* endif */
  1122.   if (input10() != aValue->input10()) {
  1123.     return true;
  1124.   } /* endif */
  1125.   return false;
  1126. }
  1127.