C++ IOHandler类代码示例

TCPProtocol::~TCPProtocol() {
	if (_pCarrier != NULL) {
		IOHandler *pCarrier = _pCarrier;
		_pCarrier = NULL;
		pCarrier->SetProtocol(NULL);
		delete pCarrier;
	}
}

bool protocolManagerNetworkedProtocolsFilter(BaseProtocol *pProtocol) {
  IOHandler *pIOHandler = pProtocol->GetIOHandler();
  if ((pIOHandler == NULL)
      || ((pIOHandler->GetType() != IOHT_TCP_CARRIER)
      && (pIOHandler->GetType() != IOHT_UDP_CARRIER)))
    return false;
  return true;
}

void REPL::IOHandlerActivated(IOHandler &io_handler) {
  lldb::ProcessSP process_sp = m_target.GetProcessSP();
  if (process_sp && process_sp->IsAlive())
    return;
  lldb::StreamFileSP error_sp(io_handler.GetErrorStreamFile());
  error_sp->Printf("REPL requires a running target process.\n");
  io_handler.SetIsDone(true);
}

int
REPL::IOHandlerFixIndentation (IOHandler &io_handler,
                               const StringList &lines,
                               int cursor_position)
{
    if (!m_enable_auto_indent) return 0;
    
    if (!lines.GetSize())
    {
        return 0;
    }
    
    int tab_size = io_handler.GetDebugger().GetTabSize();

    lldb::offset_t desired_indent = GetDesiredIndentation(lines,
                                                          cursor_position,
                                                          tab_size);
    
    int actual_indent = REPL::CalculateActualIndentation(lines);
    
    if (desired_indent == LLDB_INVALID_OFFSET)
        return 0;
    
    return (int)desired_indent - actual_indent;
}

void getCount(IOHandler& io)
{
    cout<<endl;
    cout<<"\nPART 2 TESTING FUNCTION: getCount()"<<endl;

    cout<<"Total comparisons and assignments: "<<io.getCount()<<endl;

}

    virtual void
    IOHandlerInputComplete (IOHandler &io_handler, std::string &line)
    {
        io_handler.SetIsDone(true);

        // The WatchpointOptions object is owned by the watchpoint or watchpoint location
        WatchpointOptions *wp_options = (WatchpointOptions *) io_handler.GetUserData();
        if (wp_options)
        {
            std::unique_ptr<WatchpointOptions::CommandData> data_ap(new WatchpointOptions::CommandData());
            if (data_ap.get())
            {
                data_ap->user_source.SplitIntoLines(line);
                BatonSP baton_sp (new WatchpointOptions::CommandBaton (data_ap.release()));
                wp_options->SetCallback (WatchpointOptionsCallbackFunction, baton_sp);
            }
        }
    }

 void
 IOHandlerActivated (IOHandler &io_handler) override
 {
     StreamFileSP output_sp(io_handler.GetOutputStreamFile());
     if (output_sp)
     {
         output_sp->PutCString(g_reader_instructions);
         output_sp->Flush();
     }
 }

void deleteMin(IOHandler& io)
{
    cout<<endl<<endl;
    cout<<"\nPART 3 TESTING FUNCTION: deleteMin()"<<endl;

    for(int i = 1; i<11; i++)
    {
        cout<<i<<"] \""<<io.getMinString()<<"\""<<endl;
        cout<<"    LINES: ";
        list<int> outputList = io.deleteMin();
        for (std::list<int>::iterator it = outputList.begin(); it != outputList.end(); it++)
        {
            if (*it!= outputList.back())
                cout << *it << ",";
            else cout<<*it<<" ";
        }

        cout<< endl;
        cout<< endl;

    }
}

void fastInsert(IOHandler& io)
{
    cout<<"\nPART 6 TESTING FUNCTION: fastInsert(string word)"<<endl;
    cout<<"Original Vector Indices:"<<endl;
    io.outputScannedIndices();
    cout<<endl;
    string ans;
    string word;
    do
    {
        cout<<"Please enter a string for fast insert:"<<endl;
        cin>>word;
        io.fastInsert(word);
//cout<<"New indices after fast insert: \n";
      //  io.outputScannedIndices();


        cout<<"To search again enter 'y' else hit any key: ";
        cin>>ans;
        cout<<endl<<endl;

    }while(ans=="y");
}

void removeString(IOHandler& io)
{
      cout<<"\nPART 5 TESTING FUNCTION: removeString(string word)//non-min-delete: "<<endl;

    string input;
    for(int i = 0; i<5; i++)
    {
        cout<<i+1<<"] Please enter a key for removal: ";
        cin>>input;
        if (io.removeKey(input) == 0)
        {
            cout<<"KEY : \""<<input<<"\" unfound"<<endl;
        }
        else
            cout<<"KEY : \""<<input<<"\": checked & successfully deleted"<<endl;
    }
}

 void
 IOHandlerInputComplete (IOHandler &io_handler, std::string &line) override
 {
     io_handler.SetIsDone(true);
     
     std::vector<BreakpointOptions *> *bp_options_vec = (std::vector<BreakpointOptions *> *)io_handler.GetUserData();
     for (BreakpointOptions *bp_options : *bp_options_vec)
     {
         if (!bp_options)
             continue;
                 
         std::unique_ptr<BreakpointOptions::CommandData> data_ap(new BreakpointOptions::CommandData());
         if (data_ap.get())
         {
             data_ap->user_source.SplitIntoLines (line.c_str(), line.size());
             BatonSP baton_sp (new BreakpointOptions::CommandBaton (data_ap.release()));
             bp_options->SetCallback (BreakpointOptionsCallbackFunction, baton_sp);
         }
     }
 }

void find(IOHandler& io)
{

    cout<<endl<<endl;
    cout<<"\nPART 4 TESTING FUNCTION: find()"<<endl;

    string ans;

    do
    {
        string searchKey;
        cout<<"Please enter a key to find: ";
        cin>>searchKey;
        cout<<"KEY:     \""<< searchKey <<"\""<<endl;
        list<int> outputList = io.find(searchKey);

        if (outputList.front() == -1)
            cout<<"STATUS:"<< "    NULL"<<endl;
        else
        {
            cout<<"STATUS:   "<<"found. "<<endl;
            cout<<"LINES: ";

            for (std::list<int>::iterator it = outputList.begin(); it != outputList.end(); it++)
            {
                if (*it!= outputList.back())
                    cout << *it << ",";
                else cout<<*it<<" ";
            }
            cout<<endl;
        }
        cout<<"To search again enter 'y' else hit any key: ";
        cin>>ans;
        cout<<endl;

    }
    while (ans == "y");
}

void REPL::IOHandlerInputComplete(IOHandler &io_handler, std::string &code) {
  lldb::StreamFileSP output_sp(io_handler.GetOutputStreamFile());
  lldb::StreamFileSP error_sp(io_handler.GetErrorStreamFile());
  bool extra_line = false;
  bool did_quit = false;

  if (code.empty()) {
    m_code.AppendString("");
    static_cast<IOHandlerEditline &>(io_handler)
        .SetBaseLineNumber(m_code.GetSize() + 1);
  } else {
    Debugger &debugger = m_target.GetDebugger();
    CommandInterpreter &ci = debugger.GetCommandInterpreter();
    extra_line = ci.GetSpaceReplPrompts();

    ExecutionContext exe_ctx(m_target.GetProcessSP()
                                 ->GetThreadList()
                                 .GetSelectedThread()
                                 ->GetSelectedFrame()
                                 .get());

    lldb::ProcessSP process_sp(exe_ctx.GetProcessSP());

    if (code[0] == ':') {
      // Meta command
      // Strip the ':'
      code.erase(0, 1);
      if (Args::StripSpaces(code)) {
        // "lldb" was followed by arguments, so just execute the command dump
        // the results

        // Turn off prompt on quit in case the user types ":quit"
        const bool saved_prompt_on_quit = ci.GetPromptOnQuit();
        if (saved_prompt_on_quit)
          ci.SetPromptOnQuit(false);

        // Execute the command
        CommandReturnObject result;
        result.SetImmediateOutputStream(output_sp);
        result.SetImmediateErrorStream(error_sp);
        ci.HandleCommand(code.c_str(), eLazyBoolNo, result);

        if (saved_prompt_on_quit)
          ci.SetPromptOnQuit(true);

        if (result.GetStatus() == lldb::eReturnStatusQuit) {
          did_quit = true;
          io_handler.SetIsDone(true);
          if (debugger.CheckTopIOHandlerTypes(
                  IOHandler::Type::REPL, IOHandler::Type::CommandInterpreter)) {
            // We typed "quit" or an alias to quit so we need to check if the
            // command interpreter is above us and tell it that it is done as
            // well
            // so we don't drop back into the command interpreter if we have
            // already
            // quit
            lldb::IOHandlerSP io_handler_sp(ci.GetIOHandler());
            if (io_handler_sp)
              io_handler_sp->SetIsDone(true);
          }
        }
      } else {
        // ":" was followed by no arguments, so push the LLDB command prompt
        if (debugger.CheckTopIOHandlerTypes(
                IOHandler::Type::REPL, IOHandler::Type::CommandInterpreter)) {
          // If the user wants to get back to the command interpreter and the
          // command interpreter is what launched the REPL, then just let the
          // REPL exit and fall back to the command interpreter.
          io_handler.SetIsDone(true);
        } else {
          // The REPL wasn't launched the by the command interpreter, it is the
          // base IOHandler, so we need to get the command interpreter and
          lldb::IOHandlerSP io_handler_sp(ci.GetIOHandler());
          if (io_handler_sp) {
            io_handler_sp->SetIsDone(false);
            debugger.PushIOHandler(ci.GetIOHandler());
          }
        }
      }
    } else {
      // Unwind any expression we might have been running in case our REPL
      // expression crashed and the user was looking around
      if (m_dedicated_repl_mode) {
        Thread *thread = exe_ctx.GetThreadPtr();
        if (thread && thread->UnwindInnermostExpression().Success()) {
          thread->SetSelectedFrameByIndex(0, false);
          exe_ctx.SetFrameSP(thread->GetSelectedFrame());
        }
      }

      const bool colorize_err = error_sp->GetFile().GetIsTerminalWithColors();

      EvaluateExpressionOptions expr_options;
      expr_options.SetCoerceToId(m_varobj_options.use_objc);
      expr_options.SetUnwindOnError(m_command_options.unwind_on_error);
      expr_options.SetIgnoreBreakpoints(m_command_options.ignore_breakpoints);
      expr_options.SetKeepInMemory(true);
      expr_options.SetUseDynamic(m_varobj_options.use_dynamic);
      expr_options.SetTryAllThreads(m_command_options.try_all_threads);
      expr_options.SetGenerateDebugInfo(true);
//.........这里部分代码省略.........

	int IOSelect::handleIO( ssize_t ms )
	{
		int maxfd = 0;
		int numfd, ret, active;

		if( _handlers.empty() )
			return 0;


		FD_ZERO( &_readfds );
		FD_ZERO( &_writefds );
		FD_ZERO( &_execeptfds );

		for( std::list<IOHandler*>::iterator it = _handlers.begin(), end = _handlers.end(); it != end; ++it ) {
			IOHandler* ioh = *it;
			if( ioh->_read || ioh->_write || ioh->_except ) {
				maxfd = Math::max( maxfd, ioh->_fd );
				if( ioh->_read )
					FD_SET( ioh->_fd, &_readfds );
				if( ioh->_write )
					FD_SET( ioh->_fd, &_writefds );
				if( ioh->_except )
					FD_SET( ioh->_fd, &_execeptfds );
			}
		}

		if( ms < 0 ) {
			ret = pselect( maxfd + 1, &_readfds, &_writefds, &_execeptfds, NULL, NULL );
		} else {
			msToTimespec( ms, _timeout );
			ret = pselect( maxfd + 1, &_readfds, &_writefds, &_execeptfds, &_timeout, NULL );
		}
		/* FIXME: do error handling */
		if( ret <= 0 )
			return ret;

		numfd = ret;

		for( std::list<IOHandler*>::iterator it = _handlers.begin(), end = _handlers.end(); it != end; ++it ) {
			IOHandler* ioh = *it;
			if( ioh->_read || ioh->_write || ioh->_except ) {
				active = 0;
				if( ioh->_read && FD_ISSET( ioh->_fd, &_readfds ) ) {
					ioh->onDataReadable();
					active = 1;
				}
				if( ioh->_write && FD_ISSET( ioh->_fd, &_writefds ) ) {
					ioh->onDataWriteable();
					active = 1;
				}
				if( ioh->_except && FD_ISSET( ioh->_fd, &_execeptfds ) ) {
					ioh->onException();
					active = 1;
				}
				numfd -= active;
				if( !numfd )
					break;
			}
		}

		return ret;
	}

	virtual bool keyDownEvent(unsigned char asKey){return m_IOHandler.KeyDownEvent(asKey);}