示例#1
0
 // Close connection when things have gone wrong...
 void  close()
 {
     // System.out.println("Closing Connection...");
     try {
         sendTime = -1L;
         if (output != null)
         {
             output.close();
             output = null;
         }
         if (input != null)
         {
             input.Close();
             input = null;
         }
         if (connection != null)
         {
             connection.Close();
             connection = null;
         }
     } catch (Exception e) {
         if (PrologSession.debugging())
         {
             PrologSession.WriteStackTrace(e, Console.Error);
         }
     }
 }
示例#2
0
        PBTerm sendAtom(string commandName, string argument)
        {
            lock (this) {
                if (parentSession != null)
                {
                    return(parentSession.sendAtom(commandName, argument));
                }

                try {
                    initSend();

                    // Write a fastrw term
                    output.writeCompound(commandName, 1);
                    output.writeAtom(argument);
                    output.commit();
                    return(parser.parseProlog(input));
                } catch (System.IO.IOException e) {
                    if (PrologSession.debugging())
                    {
                        PrologSession.WriteStackTrace(e, Console.Error);
                    }
                    close();
                    return(null);
                } finally {
                    finishSend();
                }
            }
        }
示例#3
0
 /// <summary> Returns <code>true</code> if this {@link se.sics.prologbeans.PBTerm} is a
 /// proper list and all of its elements are character codes or one character
 /// atoms. Returns <code>false</code> otherwise.
 /// </summary>
 /// <returns> whether the argument is a string
 /// </returns>
 public virtual bool isString()
 {
     if (PrologSession.debugging())
     {
         Console.Error.WriteLine("Entering PBTerm.isString()");
     }
     return(false);
 }
示例#4
0
 internal virtual void  queryStarted(PrologSession session)
 {
     lock (this) {
         if (activeCount == sessions.Length)
         {
             PrologSession[] tmp = new PrologSession[activeCount + 10];
             Array.Copy(sessions, 0, tmp, 0, activeCount);
             // [PM] 4.1.3 SPRM 11845, 11819
             sessions = tmp;
         }
         sessions [activeCount++] = session;
     }
 }
示例#5
0
 internal virtual void  queryFinished(PrologSession session)
 {
     lock (this) {
         for (int i = 0; i < activeCount; i++)
         {
             if (sessions [i] == session)
             {
                 activeCount--;
                 sessions [i]           = sessions [activeCount];
                 sessions [activeCount] = null;
                 break;
             }
         }
     }
 }
示例#6
0
        // Note: may only be called within the timeout thread
        void  checkQueries()
        {
            long currentTime = (DateTime.Now.Ticks - 621355968000000000) / 10000;

            lock (this) {
                if (cancelList.Length < activeCount)
                {
                    cancelList = new PrologSession[activeCount];
                }
                // [PM] 4.1.3 FIXME: assert cancelCount == 0;
                for (int i = 0; i < activeCount; i++)
                {
                    PrologSession sess      = sessions [i];
                    int           timeout   = sess.Timeout;
                    long          startTime = sess.QueryStartTime;
                    if (currentTime > (startTime + timeout))
                    {
                        activeCount--;
                        sessions [i]           = sessions [activeCount];
                        sessions [activeCount] = null;
                        if (startTime > 0L && timeout > 0)
                        {
                            // The query has taken too long and need to be cancelled
                            cancelList [cancelCount++] = sess;
                        }
                        // Since we might have moved one session to this index it
                        // will need to be rechecked again.
                        i--;
                    }
                }
            }

            if (cancelCount > 0)
            {
                // Notify all sessions that need to be cancelled. This should
                // not be done synchronized in case the cancellation takes time
                // and we do not want new queries to be blocked.
                for (int i = 0; i < cancelCount; i++)
                {
                    Console.Error.WriteLine("PBMonitor: need to interrupt read/write!");
                    cancelList [i].cancelQuery();
                    cancelList [i] = null;
                }
                cancelCount = 0;
            }
        }
示例#7
0
        public void  Run()
        {
            do
            {
                try {
                    Thread.Sleep(oneSecond);

                    checkQueries();
                } catch (Exception e) {
                    if (PrologSession.debugging())
                    {
                        Console.Error.WriteLine("PBMonitor: monitor caught an exception:");
                        PrologSession.WriteStackTrace(e, Console.Error);
                    }
                }
            } while (true);
        }
示例#8
0
        // PrologSession constructor

        PrologSession(PrologSession parent, string sessionID)
        {
            parentSession   = parent;
            prologSessionID = sessionID;
        }