void check(const nscp_version &version, const Plugin::QueryRequestMessage::Request &request, Plugin::QueryResponseMessage::Response *response) {
		typedef filter filter_type;
		modern_filter::data_container data;
		modern_filter::cli_helper<filter_type> filter_helper(request, response, data);

		filter_type filter;
		filter_helper.add_options("", "", "", filter.get_filter_syntax(), "ignored");
		filter_helper.add_syntax("${status}: ${list}", filter.get_filter_syntax(), "${release}.${major}.${minor}.${build} (${date})", "version", "", "");

		if (!filter_helper.parse_options())
			return;

		if (!filter_helper.build_filter(filter))
			return;

		boost::shared_ptr<filter_obj> record(new filter_obj(version));
		filter.match(record);

		filter_helper.post_process(filter);
	}

void ESURegistrationTableManager::syncRecord(const QHostAddress &address)
{
    if( m_tableData.isEmpty() ) return;

    RegistrationPackageNET p(ESURegistrationEngine::SyncRegistrationTableMsg);
    p.records.enable = true;

    foreach( const RegistrationUserInfo& r, m_tableData ) {
        if( r.address == address ) {
            RegistrationPackageDataNET record(r);
            p.addRecord(record);
#ifdef ESU_NET_PROTO_SERVER
            esuNet.sendRegistrationMsg(p);
#else
            emit emitsendRegistrationMsg(p);
#endif
            break;
        }
    }
}

void AudioCaptureSession::setState(QMediaRecorder::State state)
{
    if (m_state == state)
        return;

    m_state = state;
    emit stateChanged(m_state);

    switch (m_state) {
    case QMediaRecorder::StoppedState:
        stop();
        break;
    case QMediaRecorder::PausedState:
        pause();
        break;
    case QMediaRecorder::RecordingState:
        record();
        break;
    }
}

void failure_detector::register_worker( ::dsn::rpc_address target, bool is_connected)
{
    uint64_t now = now_ms();

    /*
     * callers should use the fd::_lock necessarily
     */
    worker_record record(target, now);
    record.is_alive = is_connected ? true : false;

    auto ret = _workers.insert(std::make_pair(target, record));
    if ( ret.second )
    {
        dinfo("register worker[%s] successfully", target.to_string());
    }
    else
    {
        dinfo("worker[%s] already registered", target.to_string());
    }
}

QVariant MusicModel::data(const QModelIndex& item, int role) const{
  if(role == Qt::TextAlignmentRole){
    return QVariant(Qt::AlignLeft | Qt::AlignVCenter);
  }

  int durationColIndex = record().indexOf(DataStore::getLibDurationColName());
  QVariant actualData = QSqlQueryModel::data(item, role);
  if(item.column() == durationColIndex && role == Qt::DisplayRole){
    int seconds = actualData.toInt() % 60;
    int minutes = actualData.toInt() / 60;
    QString secondsString = seconds < 10 ? "0" + QString::number(seconds) :
      QString::number(seconds);
    return QString::number(minutes) + ":" + secondsString;
  }
  else{
    return actualData;
  }


}

void ZhscWidget::selectBookmark( QString bm )
{
  BookmarkList::Iterator it;

  for ( it = bml.begin(); it != bml.end(); ++it )
  {
    if ( (*it).content == bm )
    {
      sDynastyNo = (*it).dynastyno;
      sPoetNo = (*it).poetno;
      sPoemNo = (*it).poemno;

      setPoem();

      record();

      return;
    }
  }
}

void InspectorTimelineAgent::innerAddRecordToTimeline(PassRefPtr<InspectorObject> prpRecord, const String& type, const String& frameId)
{
    DEFINE_STATIC_LOCAL(String, program, (TimelineRecordType::Program));

    RefPtr<InspectorObject> record(prpRecord);
    record->setString("type", type);
    if (!frameId.isEmpty())
        record->setString("frameId", frameId);
    if (type != program)
        setHeapSizeStatistics(record.get());

    if (m_recordStack.isEmpty()) {
        // FIXME: runtimeCast is a hack. We do it because we can't build TimelineEvent directly now.
        RefPtr<TypeBuilder::Timeline::TimelineEvent> recordChecked = TypeBuilder::Timeline::TimelineEvent::runtimeCast(record.release());
        m_frontend->eventRecorded(recordChecked.release());
    } else {
        TimelineRecordEntry parent = m_recordStack.last();
        parent.children->pushObject(record.release());
    }
}

void db::add(const string & term_c, int doc_id, int freq)
{
	throw_if_reader();
	string term = term_c;
	fancy_term(term);
	auto descriptor = m_descriptors->find(term);
	if (descriptor == m_descriptors->end())
	{
		new_term(term);
	}
	descriptor = m_descriptors->find(term);
	uint cur = descriptor->second.cur;
	uint cur_in_clusters = cur - sizeof(file_header);
	//uint idx = cur_in_clusters % sizeof(cluster);
	cluster * added_cluster;
	cluster * cur_cluster = (cluster*)(((char*)m_cluster_space) + cur_in_clusters / sizeof(cluster) * sizeof(cluster));
	if (cur_cluster->cur_pos == CLUSTER_SIZE_RECORDS - 1)
	{
		//cluster is complete
		added_cluster = new_cluster();
		if (added_cluster == NULL)
		{
			add(term_c, doc_id, freq);
			return; //New file - new rules.
		}
		cur_cluster->next_cluster = ((char*)added_cluster) - m_work_file;
		//cur_in_clusters = ((char*)&(write_to->records)) - m_work_file;
	}
	term_record rec;
	rec.doc_id = doc_id;
	rec.freq = freq;
	record(cur, rec);
	descriptor->second.cur += sizeof(term_record);
	if (cur_cluster->next_cluster != (uint)(-1))
	{
		descriptor->second.cur = ((char*)&added_cluster->records) - m_work_file;
	}
	cur_cluster->cur_pos++;
	//cout << "[" << m_worker_id << "] Term " << term << " in doc " << doc_id
	//		<< " with freq " << freq << "\n";
}

void main(void) {
  char *entries[] = {"Replay", "Record", "From USB", "Halt", NULL};
  gui_text_menu_t menu;
  U8 res;

  /*
  U32 nulldata[EFC_PAGE_WORDS] = {0};
  for (res=128; res<140; res++)
    nx__efc_write_page(nulldata, res);
  */

  menu.entries = entries;
  menu.title = "Tag route";
  menu.active_mark = GUI_DEFAULT_TEXT_MARK;

  while (TRUE) {
    res = nx_gui_text_menu(menu);

    switch (res) {
      case 0:
        replay(ROUTE_FILE);
        break;
      case 1:
        record(ROUTE_FILE);
        break;
      case 2:
        usb_recv();
        break;
      case 3:
        return;
        break;
      default:
        continue;
        break;
    }

    nx_display_string("\nOk to go back");
    while (nx_avr_get_button() != BUTTON_OK);
    nx_systick_wait_ms(500);
  }
}

void FiPage::saveSplit()
{
  QString msg = "Split %5: Id=%1 Date=%2 Comment=%3 FI=%4";

  if(mSplitId > 0)
  {
    // FIXME Right now we have no fitting addSplit() function
    mFilu->updateField("sdate", mSplitDate->text(), "split", mSplitId);
    mFilu->updateField("sratio", mRatio->text(), "split", mSplitId);
    mFilu->updateField("scomment", mSplitComment->text(), "split", mSplitId);
    mFilu->updateField("quality", Filu::ePlatinum, "split", mSplitId);

    msg = msg.arg(mSplitId)
             .arg(mSplitDate->text())
             .arg(mSplitComment->text())
             .arg(mFi->name())
             .arg(tr("updated"));
  }
  else
  {
    mSplitId = mFilu->addSplit(mSymbol->text()
                             , mSplitDate->text()
                             , mRatio->text().toDouble()
                             , mSplitComment->text()
                             , Filu::ePlatinum);

    msg = msg.arg(mSplitId)
             .arg(mSplitDate->text())
             .arg(mSplitComment->text())
             .arg(mFi->name())
             .arg(tr("added"));
  }

  emitMessage(FUNC, msg);
  record(FUNC, msg);

  int id = mSplitId; // setSplitTable() will change mSplitId
  setSplitTable();
  mSplitView->selectRowWithValue(id, 3);
  loadBars();
}

int result(char fir[],int plus) //算出结果 
{
    char c,ch;
    int x,y,i = 0;
    count1 = 0;
    count2 = 0;
    push2('#');
    while( fir[i]!='#' || optr[count2-1]!='#')
    {
        c = fir[i];
        if( isdigit(c) )
        {
            push1(c-'0');
            i++;
            continue;
        }
        if( isalpha(c) )
        {
            push1(c-'a'+plus);
            i++;
            continue;
        }
        if(c == '+' || c== '-'||c=='*' || c=='('||c==')'||c=='#')
        {
            switch( record(optr[count2-1],c) )
            {
                
                case -1: push2(c); i++; break;
                case 0 : pop2(); i++; break;
                case 1 : ch = pop2();
                         y = pop1();
                         x = pop1(); 
                         push1(computer(x,y,ch));
                         break;
            }
        }
        else
            i++;
    }
return opnd[count1-1];
}

void plugin_finish_type (tree t, void *_)
{
  fprintf(code_outputfile, "finish_type(\"%s\",\n", tree_code_name[TREE_CODE(t)]);
  //  printf("check1 pointer %p\n",t);
  //  printf("check2 as long %ul\n",t);
#ifdef USE_GTK
  gtk_add_node(t,tree_code_name[TREE_CODE(t)]);
#endif
  //  printf ( "after tcname:%s\n", tree_code_name[TREE_CODE(t)]);
  //  generic_callback(t, "user_data");   
  if (t)
    {
      record(t);      
    }
  else
    {
      printf ( "no record\n");
    }
  fprintf(code_outputfile,"0),//finish_type\n");
  //gcc_report_tree_visit(t);
}

QVariant CustomSqlModel::data(const QModelIndex &item, int role) const
{



    if ( role == Qt::TextColorRole){
        if (!record(item.row()).value(2).toString().isEmpty())
          return Qt::black;
        else return Qt::lightGray;


    }

    if ( role == Qt::DecorationRole)
        return mIcon;




    return QSqlQueryModel::data(item,role);
}

    int
    process(const tendrils& inputs, const tendrils& outputs)
    {
      // Only start when we do have a frame
      if (frame->empty())
        return ecto::OK;

      switch (*command)
      {
        case Record::START:
        case Record::RESUME:
          record();
          break;
        case Record::PAUSE:
          break;
        case Record::STOP:
          stop();
          break;
      }
      return ecto::OK;
    }

JNIEXPORT void JNICALL  Java_com_syouquan_script_ScriptEngine_nativeEventStartRecord
  (JNIEnv * env, jobject thiz )
{
	LOGI("---call native method---");

	if (in_record == 1)
	{
		LOGI("is in recoding");
		in_record = 0;
		return;
	}

	if (init() != 0)
	{
		printf("Init failed");
		return;
	}

	record();

}

void ASTDumper::walk(VariableDeclaration *vDecl) {
    int parent = parent_id;

    parent_id = node("var_decl " + vDecl->name);
    edge(parent, parent_id);

    child("modifiers");
    edge(parent_id, record({ "extern: " + std::to_string(vDecl->extern_mod), "static: " + std::to_string(vDecl->static_mod) }));

    if (vDecl->type) {
        child("type");
        vDecl->type->accept(*this);
    }

    if (vDecl->init_expr) {
        child("init_expr");
        vDecl->init_expr->accept(*this);
    }

    parent_id = parent;
}

    void MULTREGTScanner::addKeyword( const DeckKeyword& deckKeyword , const std::string& defaultRegion) {
        assertKeywordSupported( deckKeyword , defaultRegion );

        for (auto iter = deckKeyword.begin(); iter != deckKeyword.end(); ++iter) {
            MULTREGTRecord record( *iter , defaultRegion );
            /*
              The default value for the region item is to use the
              region item on the previous record, or alternatively
              'MULTNUM' for the first record.
            */
            if (!record.m_region.hasValue()) {
                if (m_records.size() > 0) {
                    auto previousRecord = m_records.back();
                    record.m_region.setValue( previousRecord.m_region.getValue() );
                } else
                    record.m_region.setValue( "MULTNUM" );
            }
            m_records.push_back( record );
        }

    }

void BonjourBrowser::bonjourBrowseReply(DNSServiceRef, DNSServiceFlags flags,
                                        quint32, DNSServiceErrorType error_code,
                                        const char *service_name, const char *reg_type,
                                        const char *reply_domain, void *context) {
    BonjourBrowser *browser = static_cast<BonjourBrowser *>(context);
    if (error_code != kDNSServiceErr_NoError) {
        emit browser->error(error_code);
    } else {
        BonjourRecord record(service_name, reg_type, reply_domain);
        if (flags & kDNSServiceFlagsAdd) {
            if (!browser->bonjour_records_.contains(record))
                browser->bonjour_records_.append(record);
        } else {
            browser->bonjour_records_.removeAll(record);
        }

        if (!(flags & kDNSServiceFlagsMoreComing)) {
            emit browser->currentRecordsChanged(browser->bonjour_records_);
        }
    }
}

static int record_host(const abl_args *args, abl_info *info, time_t tm) {
    if (NULL != args->host_db) {
        const void *rhost;
        int err;

        if (err = pam_get_item(args->pamh, PAM_RHOST, &rhost), PAM_SUCCESS != err) {
            log_pam_error(args, err, "getting PAM_RHOST");
            return err;
        }
        if (NULL != rhost) {
            info->subject = HOST;
            info->host = rhost;
            return record(args, info, tm, args->host_purge);
        } else {
            log_debug(args, "PAM_RHOST is NULL");
            return 0;
        }
    } else {
        return 0;
    }
}

void ZhscWidget::recordNumber()
{
  bool ok = FALSE;

  int res = QInputDialog::getInteger(
                Unicode( "中华诗词 Qt版" ),
                Unicode( "请输入你要看的作品编号：" ), nPoemIndex, nPoemMin, nPoemMax, 1, &ok, this );
  if ( ok )
  {
    ok = FALSE;
    if ( bConStatus )
    {
      QString number;
      number.setNum( res );

      QString sq = "select id, dynastyno, poetno, poemno from tsc where id = " + number;
      QSqlQuery query( sq );

      if ( query.size() > 0 )
      {
        if ( query.next() )
        {
          nPoemIndex = query.value(0).toInt( &ok );
          sDynastyNo = query.value(1).toString();
          sPoetNo = query.value(2).toString();
          sPoemNo = query.value(3).toString();

          setPoem();
          record();
        }
      }
    }

    return;
  }
  else
  {
    return;
  }
}