home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 5 Edit / 05-Edit.zip / edispm11.zip / EDisPM / SRC / Server / edserv.c < prev    next >
Text File  |  1996-05-07  |  17KB  |  572 lines
  1. /* EDServ.C   : DSOM-Klasse : EDisServ.DLL V 1.1 */
  2. /* Editorservice-Klasse                          */
  3. /*                                               */
  4. /* (C) 1995 M.Schwarz, FoPra TU-Muenchen SS1995  */
  5. /* (C) 1996 M.Schwarz, SOMObjects-Programmierung */
  6. /*                     OS/2 Inside 7/96          */
  7.  
  8. /*
  9.  *  This file was generated by the SOM Compiler.
  10.  *  Generated using:
  11.  *     SOM incremental update: 2.43
  12.  */
  13.  
  14.  
  15. #ifndef SOM_Module_edserv_Source
  16. #define SOM_Module_edserv_Source
  17. #endif
  18. #define EDService_Class_Source
  19.  
  20. #include <time.h>
  21. #include <stdio.h>
  22. #include "edserv.ih"
  23. #include "edline.h"
  24.  
  25.  
  26.  
  27. /*
  28.  * get_edline (OK):
  29.  */
  30.  
  31. SOM_Scope long  SOMLINK get_edline(EDService *somSelf,  Environment *ev,
  32.                                    long lnr, EDLine** ed_line,
  33.                                    string user)
  34. {
  35.     EDServiceData *somThis = EDServiceGetData(somSelf);
  36.     long rc=0;
  37.     EDServiceMethodDebug("EDService","get_edline");
  38.  
  39.     /* Hole Zeile aus Text */
  40.     rc =_getLine(somSelf, ev, lnr, ed_line);
  41.  
  42.     return(rc);
  43. }
  44.  
  45. /*
  46.  * put_edline (OK):
  47.  */
  48.  
  49.  
  50. /*
  51.  * SOM_Scope long  SOMLINK put_edline(EDService *somSelf,  Environment *ev,
  52.  *                                    long lnr, EDLine* ed_line,
  53.  *                                    string user)
  54.  */
  55.  
  56. /*
  57.  * The prototype for put_edline was replaced by the following prototype:
  58.  */
  59. SOM_Scope long  SOMLINK put_edline(EDService *somSelf,  Environment *ev,
  60.                                    long lnr, string line, long vnr,
  61.                                    string user)
  62. {
  63.     EDServiceData *somThis = EDServiceGetData(somSelf);
  64.     long rc=0;
  65.     EDLine* tmpline;
  66.     EDServiceMethodDebug("EDService","put_edline");
  67.  
  68.     if (_getLine(somSelf, ev, lnr, &tmpline))
  69.        return(-1);  /* Zeile nicht gefunden */
  70.  
  71.     if (_locked(somSelf, ev, lnr, user))
  72.        return(-2);  /* Zeile gesperrt */
  73.  
  74.     if (__get_vnr(tmpline, ev) > vnr)
  75.        return(-3);  /* Zeile veraltet */
  76.  
  77.     /* Neue Zeile gültig */
  78.     _set(tmpline, ev, lnr, line, __get_lock(tmpline, ev), vnr, time(NULL));
  79.  
  80.     /* Änderung in Eventliste speichern: */
  81.     _events._buffer = (long*) SOMRealloc(_events._buffer, sizeof(long) * (sequenceLength(_events)+1));
  82.     sequenceElement(_events, sequenceLength(_events)) = lnr;
  83.     sequenceLength(_events)++;
  84.     /* EventCounter erhöhen: */
  85.     _eventcnt++;
  86.  
  87.     return(rc);
  88. }
  89.  
  90. /*
  91.  * ins_edline (OK):
  92.  */
  93.  
  94. /*
  95.  * SOM_Scope long  SOMLINK ins_edline(EDService *somSelf,  Environment *ev,
  96.  *                                    long prelnr, long aftlnr,
  97.  *                                    EDLine** ed_line, string user)
  98.  */
  99.  
  100. /*
  101.  * The prototype for ins_edline was replaced by the following prototype:
  102.  */
  103. SOM_Scope long  SOMLINK ins_edline(EDService *somSelf,  Environment *ev,
  104.                                    long prelnr, EDLine** ed_line,
  105.                                    string user)
  106. {
  107.     EDServiceData *somThis = EDServiceGetData(somSelf);
  108.     long rc = 0;
  109.     EDLine    *tmpline;
  110.     EDServiceMethodDebug("EDService","ins_edline");
  111.  
  112.     /* Füge neue Zeile ein, gib EDLine und lid zurück */
  113.     rc =_insLine(somSelf, ev, prelnr, ed_line);
  114.     if (rc >= 0) {
  115.        /* Setze User-Sperre auf neue Zeile */
  116.        _set(*ed_line, ev, __get_lnr(*ed_line, ev), "", user, 0,0);
  117.  
  118.        /* Änderung in Eventliste speichern: */
  119.        _events._buffer = (long*) SOMRealloc(_events._buffer, sizeof(long) * (sequenceLength(_events)+2));
  120.        sequenceElement(_events, sequenceLength(_events)) = -2;
  121.        sequenceLength(_events)++;
  122.        sequenceElement(_events, sequenceLength(_events)) = rc;
  123.        sequenceLength(_events)++;
  124.        /* EventCounter um 2 erhöhen: */
  125.        _eventcnt+=2;
  126.     } /* endif */
  127.  
  128.     return(rc);
  129. }
  130.  
  131. /*
  132.  * del_edline (OK):
  133.  */
  134.  
  135.  
  136. /*
  137.  * SOM_Scope long  SOMLINK del_edline(EDService *somSelf,  Environment *ev,
  138.  *                                    long lnr, long prelnr, long aftlnr,
  139.  *                                    long vnr, string user)
  140.  */
  141.  
  142. /*
  143.  * The prototype for del_edline was replaced by the following prototype:
  144.  */
  145. SOM_Scope long  SOMLINK del_edline(EDService *somSelf,  Environment *ev,
  146.                                    long lnr, long vnr, string user)
  147. {
  148.     EDServiceData *somThis = EDServiceGetData(somSelf);
  149.     long rc = 0;
  150.     EDLine* tmpline;
  151.     EDServiceMethodDebug("EDService","del_edline");
  152.  
  153.     if (_getLine(somSelf, ev, lnr, &tmpline))
  154.        return(-1);  /* Zeile nicht gefunden */
  155.  
  156.     if (_locked(somSelf, ev, lnr, user))
  157.        return(-2);  /* Zeile gesperrt */
  158.  
  159.     if (__get_vnr(tmpline, ev) > vnr)
  160.        return(-3);  /* Zeile veraltet */
  161.  
  162.     /* Lösche Zeile lid */
  163.     rc =_delLine(somSelf, ev, lnr);
  164.     if (rc >= 0) {
  165.        /* Änderung in Eventliste speichern: */
  166.        _events._buffer = (long*) SOMRealloc(_events._buffer, sizeof(long) * (sequenceLength(_events)+1));
  167.        sequenceElement(_events, sequenceLength(_events)) = -2;
  168.        sequenceLength(_events)++;
  169.        /* EventCounter erhöhen: */
  170.        _eventcnt++;
  171.     } /* endif */
  172.  
  173.     return(rc);
  174. }
  175.  
  176. /*
  177.  * getlock (OK):
  178.  */
  179.  
  180.  
  181. /*
  182.  * SOM_Scope long  SOMLINK getlock(EDService *somSelf,  Environment *ev,
  183.  *                                 long lnr, EDLine* ed_line, string user)
  184.  */
  185.  
  186. /*
  187.  * The prototype for getlock was replaced by the following prototype:
  188.  */
  189. SOM_Scope long  SOMLINK getlock(EDService *somSelf,  Environment *ev,
  190.                                 long lnr, long vnr, string user)
  191. {
  192.     EDServiceData *somThis = EDServiceGetData(somSelf);
  193.     long rc=0;
  194.     EDLine* tmpline;
  195.     EDServiceMethodDebug("EDService","getlock");
  196.  
  197.     if (_getLine(somSelf, ev, lnr, &tmpline))
  198.        return(-1);  /* Zeile nicht gefunden */
  199.  
  200.     if (_locked(somSelf, ev, lnr, user))
  201.        return(-2);  /* Zeile gesperrt */
  202.  
  203.     if (__get_vnr(tmpline, ev) > vnr)
  204.        return(-3);  /* Zeile veraltet */
  205.  
  206.     /* Neue Sperre gültig */
  207.     _set(tmpline, ev, lnr, __get_line(tmpline, ev), user, __get_vnr(tmpline, ev), time(NULL));
  208.  
  209.     /* Änderung in Eventliste speichern: */
  210.     _events._buffer = (long*) SOMRealloc(_events._buffer, sizeof(long) * (sequenceLength(_events)+1));
  211.     sequenceElement(_events, sequenceLength(_events)) = lnr;
  212.     sequenceLength(_events)++;
  213.     /* EventCounter erhöhen: */
  214.     _eventcnt++;
  215.  
  216.     return(rc);
  217. }
  218.  
  219.  
  220. /*
  221.  * rellock (OK)
  222.  */
  223.  
  224. /*
  225.  * SOM_Scope long  SOMLINK rellock(EDService somSelf,  Environment *ev,
  226.  *                                 long lnr, string user)
  227.  */
  228.  
  229. /*
  230.  * The prototype for rellock was replaced by the following prototype:
  231.  */
  232. SOM_Scope long  SOMLINK rellock(EDService *somSelf,  Environment *ev,
  233.                                 long lnr, string user)
  234. {
  235.     EDServiceData *somThis = EDServiceGetData(somSelf);
  236.     long rc=0;
  237.     EDLine* tmpline;
  238.     EDServiceMethodDebug("EDService","rellock");
  239.  
  240.     tmpline = EDLineNew();
  241.  
  242.     if (_getLine(somSelf, ev, lnr, &tmpline))
  243.        return(-1);  /* Zeile nicht gefunden */
  244.  
  245.     if (_locked(somSelf, ev, lnr, user))
  246.        return(-2);  /* Zeile gesperrt */
  247.  
  248.     /* Sperre aufheben */
  249.     _set(tmpline, ev, lnr, __get_line(tmpline, ev), "", __get_vnr(tmpline, ev), 0);
  250.  
  251.     /* Änderung in Eventliste speichern: */
  252.     _events._buffer = (long*) SOMRealloc(_events._buffer, sizeof(long) * (sequenceLength(_events)+1));
  253.     sequenceElement(_events, sequenceLength(_events)) = lnr;
  254.     sequenceLength(_events)++;
  255.     /* EventCounter erhöhen: */
  256.     _eventcnt++;
  257.  
  258.     return(rc);
  259. }
  260.  
  261.  
  262. /*
  263.  * appendline (OK)
  264.  */
  265.  
  266. /*
  267.  * SOM_Scope long  SOMLINK appendline(EDService somSelf,  Environment *ev,
  268.  *                                    long lnr, long vnr, string user)
  269.  */
  270.  
  271. /*
  272.  * The prototype for appendline was replaced by the following prototype:
  273.  */
  274. SOM_Scope long  SOMLINK appendline(EDService *somSelf,  Environment *ev,
  275.                                    long lnr, long vnr, string user)
  276. {
  277.     EDServiceData *somThis = EDServiceGetData(somSelf);
  278.     long rc=0;
  279.     EDLine* tmpline;
  280.     EDServiceMethodDebug("EDService","appendline");
  281.  
  282.     if (!(_getLine(somSelf, ev, lnr, &tmpline)))
  283.        return(-4);  /* Zeile schon vorhanden */
  284.  
  285. //    if (__get_nlines(somSelf, ev) != lnr-1)
  286. //       return(-1);
  287.  
  288.     tmpline = EDLineNew();
  289.  
  290.     /* leere neue Zeile erstellen */
  291.     __set_lnr (tmpline, ev, lnr);
  292.     __set_line(tmpline, ev, "");
  293.     __set_lock(tmpline, ev, "");
  294.     __set_vnr (tmpline, ev, vnr);
  295.     __set_ltime(tmpline, ev, 0);
  296.  
  297.     _addLine(somSelf, ev, lnr, tmpline);
  298.  
  299.     /* Änderung in Eventliste speichern: */
  300.     _events._buffer = (long*) SOMRealloc(_events._buffer, sizeof(long) * (sequenceLength(_events)+1));
  301.     sequenceElement(_events, sequenceLength(_events)) = lnr;
  302.     sequenceLength(_events)++;
  303.     /* EventCounter erhöhen: */
  304.     _eventcnt++;
  305.  
  306.     return(rc);
  307. }
  308.  
  309.  
  310. /*
  311.  * getinfo ()
  312.  */
  313.  
  314. /*
  315.  * SOM_Scope long  SOMLINK getinfo(EDService *somSelf,  Environment *ev,
  316.  *                                 long* nlines, string* docname,
  317.  *                                 long* evcnt, string user)
  318.  */
  319.  
  320. /*
  321.  * The prototype for getinfo was replaced by the following prototype:
  322.  */
  323. SOM_Scope long  SOMLINK getinfo(EDService *somSelf,  Environment *ev,
  324.                                 long* nlines, long* evcnt, string user)
  325. {
  326.     EDServiceData *somThis = EDServiceGetData(somSelf);
  327.     EDServiceMethodDebug("EDService","getinfo");
  328.  
  329.     *nlines = __get_nLines(somSelf, ev);
  330.     *evcnt = _eventcnt;
  331.  
  332.     return(0);
  333. }
  334.  
  335.  
  336. /*
  337.  * getevents (OK)
  338.  */
  339.  
  340. SOM_Scope long  SOMLINK getevents(EDService *somSelf,  Environment *ev,
  341.                                   long* evcnt, _IDL_SEQUENCE_long* events,
  342.                                   string user)
  343. {
  344.     EDServiceData *somThis = EDServiceGetData(somSelf);
  345.     long i, j = 0;
  346.  
  347.     EDServiceMethodDebug("EDService","getevents");
  348.  
  349.     /* Speicher für Eventsliste anmelden */
  350.     events->_length = _eventcnt - *evcnt+2;
  351.     events->_buffer = (long*) SOMMalloc(sizeof(long) * (events->_length));
  352.     events->_buffer[0] = -3; /* Dummy */
  353.     events->_buffer[1] = -3; /* Dummy */
  354.     for (i=*evcnt; i<_eventcnt ; i++) {
  355.        if (sequenceElement(_events, i) < 0) {
  356.           if (sequenceElement(_events, i) == -1) {
  357.              events->_buffer[0] = -1; /* Neue Userliste */
  358.              j++;
  359.              events->_length--;
  360.           } else if (sequenceElement(_events, i) == -2) {
  361.              events->_buffer[1] = -2; /* Neue Textliste */
  362.              j++;
  363.              events->_length--;
  364.           } /* endif */
  365.        } else {
  366.           events->_buffer[i-*evcnt+2-j] = sequenceElement(_events, i);
  367.        } /* endif */
  368.     } /* endfor */
  369.     *evcnt = _eventcnt;
  370.  
  371.     return(0);
  372. }
  373.  
  374.  
  375. /*
  376.  * joinsession (OK)
  377.  */
  378.  
  379. SOM_Scope long  SOMLINK joinsession(EDService *somSelf,  Environment *ev,
  380.                                     string user)
  381. {
  382.     EDServiceData *somThis = EDServiceGetData(somSelf);
  383.     long rc = 0;
  384.     long i;
  385.     string tmpUser;
  386.     EDServiceMethodDebug("EDService","joinsession");
  387.  
  388.    // implementation
  389.     tmpUser = (string) SOMMalloc(strlen(user)+1);
  390.     strcpy(tmpUser, user);
  391.  
  392.    // check if name already in userlist
  393.     if (sequenceLength(_users) > 0) {
  394.       long  countName = 0;
  395.       short loop;
  396.       do {
  397.          loop = 0;
  398.          for (i = 0; i<sequenceLength(_users); i++ ) {
  399.             if (!strcmp(tmpUser, sequenceElement(_users, i))) {
  400.                char ucount[35];
  401.                SOMFree(tmpUser);
  402.                tmpUser = (string) SOMMalloc(strlen(user)+strlen(_ltoa(++countName, ucount, 10))+2);
  403.                sprintf(tmpUser, "%s:%s", user, ucount);
  404.                rc = countName;
  405.                loop = 1;
  406.             } /* endif */
  407.          } /* endfor */
  408.       } while (loop);
  409.     }  /* endif */
  410.  
  411.    // put new user into userlist
  412.     _users._buffer = (string*) SOMRealloc(_users._buffer, sizeof(string) * (sequenceLength(_users)+1));
  413.     sequenceElement(_users, sequenceLength(_users)) = tmpUser;
  414.     sequenceLength(_users)++;
  415.  
  416.    // save changes in eventlist
  417.     _events._buffer = (long*) SOMRealloc(_events._buffer, sizeof(long) * ++(sequenceLength(_events)));
  418.     sequenceElement(_events, _eventcnt) = -1;
  419.    // rise event counter
  420.     _eventcnt++;
  421.  
  422.    // rc  < 0 -> error
  423.    // rc == 0 -> registered by userName
  424.    // rc  > 0 -> registered by userName:rc
  425.  
  426.     return(rc);
  427. }
  428.  
  429.  
  430.  
  431. /*
  432.  * leavesession (OK)
  433.  */
  434.  
  435. SOM_Scope long  SOMLINK leavesession(EDService *somSelf,  Environment *ev,
  436.                                      string user)
  437. {
  438.     EDServiceData *somThis = EDServiceGetData(somSelf);
  439.     long  rc=0;
  440.     long  i;
  441.     string item;
  442.     EDServiceMethodDebug("EDService","leavesession");
  443.  
  444.     /* Implementation */
  445.     /* User in Userliste löschen: */
  446.     for (i=0; i < sequenceLength(_users) ; i++ ) {
  447.        item = sequenceElement(_users, i);
  448.        if (!strcmp(item, user)) {
  449.           if (item) SOMFree(item);
  450.           sequenceLength(_users)--;
  451.           for (i; i < sequenceLength(_users); i++) {
  452.              sequenceElement(_users, i) = sequenceElement(_users, i+1);
  453.           } /* endfor */
  454.           _users._buffer = (string*) SOMRealloc(_users._buffer, sizeof(string) * (sequenceLength(_users)+1));
  455.  
  456.           /* Änderung in Eventliste speichern: */
  457.           _events._buffer = (long*) SOMRealloc(_events._buffer, sizeof(long) * ++(sequenceLength(_events)));
  458.           sequenceElement(_events, _eventcnt) = -1;
  459.           /* EventCounter erhöhen: */
  460.           _eventcnt++;
  461.  
  462.           return(rc);
  463.        } /* endif */
  464.     } /* endfor */
  465.  
  466.     rc = -1L;   /* User nicht in Liste eingetragen */
  467.     return(rc);
  468. }
  469.  
  470.  
  471.  
  472. /*
  473.  * getusers (OK)
  474.  */
  475.  
  476. SOM_Scope long  SOMLINK getusers(EDService *somSelf,  Environment *ev,
  477.                                  _IDL_SEQUENCE_string* userlist)
  478. {
  479.     EDServiceData *somThis = EDServiceGetData(somSelf);
  480.     EDServiceMethodDebug("EDService","getusers");
  481.  
  482.     *userlist = _users;
  483.  
  484.     return(0);
  485. }
  486.  
  487.  
  488. /*
  489.  * locked (OK)
  490.  */
  491.  
  492. /*
  493.  * SOM_Scope long  SOMLINK locked(EDService somSelf,  Environment *ev,
  494.  *                                long lnr, string user)
  495.  */
  496.  
  497. /*
  498.  * The prototype for locked was replaced by the following prototype:
  499.  */
  500. SOM_Scope long  SOMLINK locked(EDService *somSelf,  Environment *ev,
  501.                                long lnr, string user)
  502. {
  503.     EDServiceData *somThis = EDServiceGetData(somSelf);
  504.     long rc=0;
  505.     EDLine* tmpline;
  506.     EDServiceMethodDebug("EDService","locked");
  507.  
  508.     if (_getLine(somSelf, ev, lnr, &tmpline))
  509.        return(-1);  /* Zeile nicht gefunden */
  510.  
  511.     if (strlen(__get_lock(tmpline, ev))>0) {
  512.        if (difftime(time(NULL), (time_t) __get_ltime(tmpline, ev)) > 120)
  513.           return(0);   /* Sperrzeit von 2 Minuten abgelaufen! */
  514.        if (strcmp(__get_lock(tmpline, ev), user))
  515.           return(-2);  /* Zeile gesperrt */
  516.     } /* endif */
  517.  
  518.     return(rc);
  519. }
  520.  
  521.  
  522.  
  523. SOM_Scope void SOMLINK somDefaultInit(EDService *somSelf, som3InitCtrl* ctrl)
  524. {
  525.     EDServiceData *somThis; /* set in BeginInitializer */
  526.     somInitCtrl globalCtrl;
  527.     somBooleanVector myMask;
  528.     EDServiceMethodDebug("EDService","somDefaultInit");
  529.     EDService_BeginInitializer_somDefaultInit;
  530.  
  531.     EDService_Init_EDText_somDefaultInit(somSelf, ctrl);
  532.  
  533.     /* Userliste Initialisieren */
  534.     sequenceLength(_users) = 0;
  535.     _users._buffer = (string*) SOMMalloc(sizeof(string));
  536.  
  537.     /* Eventliste Initialisieren */
  538.     sequenceLength(_events) = 0;
  539.     _events._buffer = (long*) SOMMalloc(sizeof(long));
  540.     _eventcnt = 0;
  541.  
  542. }
  543.  
  544.  
  545. SOM_Scope void SOMLINK somDestruct(EDService *somSelf, octet doFree,
  546.                                    som3DestructCtrl* ctrl)
  547. {
  548.     EDServiceData *somThis; /* set in BeginDestructor */
  549.     somDestructCtrl globalCtrl;
  550.     somBooleanVector myMask;
  551.  
  552.     long  i;
  553.     string item;
  554.  
  555.     EDServiceMethodDebug("EDService","somDestruct");
  556.     EDService_BeginDestructor;
  557.  
  558.     /* Speicher für Userliste freigeben */
  559.     for (i=0; i < sequenceLength(_users) ; i++ ) {
  560.        item = sequenceElement(_users, i);
  561.        if (item) SOMFree(item);
  562.     }
  563.     SOMFree(_users._buffer);
  564.  
  565.     /* Speicher für Eventliste freigeben */
  566.     SOMFree(_events._buffer);
  567.  
  568.     EDService_EndDestructor;
  569. }
  570.  
  571.  
  572.