コード例 #1
0
ファイル: flags.hpp プロジェクト: Califax/mesos
inline Try<Warnings> FlagsBase::load(
    const Option<std::string>& prefix,
    int argc,
    const char* const *argv,
    bool unknowns,
    bool duplicates)
{
  Multimap<std::string, Option<std::string>> values;

  // Grab the program name from argv[0].
  programName_ = argc > 0 ? Path(argv[0]).basename() : "";

  // Read flags from the command line.
  for (int i = 1; i < argc; i++) {
    const std::string arg(strings::trim(argv[i]));

    // Stop parsing flags after '--' is encountered.
    if (arg == "--") {
      break;
    }

    // Skip anything that doesn't look like a flag.
    if (arg.find("--") != 0) {
      continue;
    }

    std::string name;
    Option<std::string> value = None();

    size_t eq = arg.find_first_of("=");
    if (eq == std::string::npos && arg.find("--no-") == 0) { // --no-name
      name = arg.substr(2);
    } else if (eq == std::string::npos) {                    // --name
      name = arg.substr(2);
    } else {                                                 // --name=value
      name = arg.substr(2, eq - 2);
      value = arg.substr(eq + 1);
    }

    name = strings::lower(name);

    values.put(name, value);
  }

  if (prefix.isSome()) {
    // Merge in flags from the environment. Command-line
    // flags take precedence over environment flags.
    foreachpair (const std::string& name,
                 const Option<std::string>& value,
                 extract(prefix.get())) {
      if (!values.contains(name)) {
        values.put(name, value);
      }
    }
  }
コード例 #2
0
ファイル: flags.hpp プロジェクト: SStar1314/mesos
inline Try<Warnings> FlagsBase::load(
    const Option<std::string>& prefix,
    int argc,
    const char* const *argv,
    bool unknowns,
    bool duplicates)
{
  Multimap<std::string, Option<std::string>> values;

  // Grab the program name from argv[0].
  programName_ = argc > 0 ? Path(argv[0]).basename() : "";

  // Read flags from the command line.
  for (int i = 1; i < argc; i++) {
    const std::string arg(strings::trim(argv[i]));

    // Stop parsing flags after '--' is encountered.
    if (arg == "--") {
      break;
    }

    // Skip anything that doesn't look like a flag.
    if (arg.find("--") != 0) {
      continue;
    }

    std::string name;
    Option<std::string> value = None();

    size_t eq = arg.find_first_of("=");
    if (eq == std::string::npos && arg.find("--no-") == 0) { // --no-name
      name = arg.substr(2);
    } else if (eq == std::string::npos) {                    // --name
      name = arg.substr(2);
    } else {                                                 // --name=value
      name = arg.substr(2, eq - 2);
      value = arg.substr(eq + 1);
    }

    name = strings::lower(name);

    values.put(name, value);
  }

  return load(values, unknowns, duplicates, prefix);
}
コード例 #3
0
inline void test_multimap_insert(std::multimap<int, int> c)
{
    using phx::arg_names::arg1;
    using phx::arg_names::arg2;
    using phx::arg_names::arg3;

    typedef std::multimap<int, int> Multimap;

    Multimap::value_type const value = *c.begin();
    Multimap::iterator c_begin = c.begin();
    // wrapper for
    // iterator insert(iterator where, const value_type& val);
    Multimap::iterator it =
        phx::insert(arg1, arg2, arg3)(c, c_begin, value);

    if (test(it != c.begin() || *it != *(++it))) {
        cerr << "Failed " << typeid(Multimap).name()
             << " test_multimap_insert 1\n";
        return;
    }

    // wrapper for
    // iterator insert(const value_type& val);
    Multimap::value_type const value2(1400, 2200);
    it = phx::insert(arg1, arg2)(c, value2);
    if (test(it == c.end())) {
        cerr << "Failed " << typeid(Multimap).name()
             << " test_multimap_insert 2\n";
        return;
    }

    // wrapper for
    // template<class InIt>
    // void insert(InIt first, InIt last);
    Multimap const const_c = build_multimap();
    Multimap::size_type size = c.size();
    phx::insert(arg1, const_c.begin(), const_c.end())(c);
    if (test(c.size() != size + const_c.size())) {
        cerr << "Failed " << typeid(Multimap).name()
             << " test_multimap_insert 3\n";
        return;
    }
}
コード例 #4
0
ファイル: flags.hpp プロジェクト: SStar1314/mesos
inline Try<Warnings> FlagsBase::load(
    const Option<std::string>& prefix,
    int* argc,
    char*** argv,
    bool unknowns,
    bool duplicates)
{
  Multimap<std::string, Option<std::string>> values;

  // Grab the program name from argv, without removing it.
  programName_ = *argc > 0 ? Path(*(argv[0])).basename() : "";

  // Keep the arguments that are not being processed as flags.
  std::vector<char*> args;

  // Read flags from the command line.
  for (int i = 1; i < *argc; i++) {
    const std::string arg(strings::trim((*argv)[i]));

    // Stop parsing flags after '--' is encountered.
    if (arg == "--") {
      // Save the rest of the arguments.
      for (int j = i + 1; j < *argc; j++) {
        args.push_back((*argv)[j]);
      }
      break;
    }

    // Skip anything that doesn't look like a flag.
    if (arg.find("--") != 0) {
      args.push_back((*argv)[i]);
      continue;
    }

    std::string name;
    Option<std::string> value = None();

    size_t eq = arg.find_first_of("=");
    if (eq == std::string::npos && arg.find("--no-") == 0) { // --no-name
      name = arg.substr(2);
    } else if (eq == std::string::npos) {                    // --name
      name = arg.substr(2);
    } else {                                                 // --name=value
      name = arg.substr(2, eq - 2);
      value = arg.substr(eq + 1);
    }

    name = strings::lower(name);

    values.put(name, value);
  }

  Try<Warnings> result = load(values, unknowns, duplicates, prefix);

  // Update 'argc' and 'argv' if we successfully loaded the flags.
  if (!result.isError()) {
    CHECK_LE(args.size(), (size_t) *argc);
    int i = 1; // Start at '1' to skip argv[0].
    foreach (char* arg, args) {
      (*argv)[i++] = arg;
    }

    *argc = i;

    // Now null terminate the array. Note that we'll "leak" the
    // arguments that were processed here but it's not like they would
    // have gotten deleted in normal operations anyway.
    (*argv)[i++] = nullptr;
  }
コード例 #5
0
		Automaton::Ref NfaToDfa(Automaton::Ref source, Multimap<State*, State*>& dfaStateMap)
		{
			Automaton::Ref target = shared_ptr<Automaton>(new Automaton);
			Multimap<Transition*, Transition*> nfaTransitions;
			vector<Transition*> transitionClasses;//保证转换先后顺序不被nfaTransitions.Keys破坏

			State* startState = target->NewState();
			target->startState = startState;
			dfaStateMap.insert(startState, source->startState);

			vector<State*> transitionTargets;
			vector<State*> relativeStates;


			for (int i = 0;i < target->states.size();i++)
			{
				// dfa中的待处理的结点
				State* currentState = target->states[i].get();
				nfaTransitions.clear();
				transitionClasses.clear();

				// 获得dfa结点对应的nfa的那个结点
				// 对该DFA状态的所有等价NFA状态进行遍历
				vector<State*> &nfaStates = dfaStateMap[currentState];
				for (int j = 0;j < nfaStates.size();j++)
				{
					State* nfaState = nfaStates[j];
					//对每一个NFA状态的所有转换进行遍历
					for (int k = 0;k < nfaState->transitions.size();k++)
					{
						Transition* nfaTransition = nfaState->transitions[k];
						//检查该NFA转换类型是否已经具有已经被记录
						Transition* transitionClass = 0;
						for (auto it = nfaTransitions.begin();it != nfaTransitions.end();it++)
						{
							Transition* key = (*it).first;
							if (isTransitionEqual(key, nfaTransition))
							{
								transitionClass = key;
								break;
							}
						}
						//不存在则创建一个转换类型
						if (transitionClass == 0)
						{
							transitionClass = nfaTransition;
							transitionClasses.push_back(transitionClass);
						}
						//注册转换,一对多的结构
						nfaTransitions.insert(transitionClass, nfaTransition);
					}
				}

				// 遍历上面获得的转换,transitionClasses就是将来可能会成为
				// 某个dfa结点的边的结构,它的key是任意取的其中的一条边
				for (int j = 0;j < transitionClasses.size();j++)
				{
					// 获得一条边对应的那些边
					const vector<Transition*>& transitionSet = 
											nfaTransitions[transitionClasses[j]];
					// 获得那些边指向的结点集合
					transitionTargets.clear();
					for (int l = 0;l < transitionSet.size();l++)
					{
						State* nfaState = transitionSet[l]->target;
						if (!isElementExist(transitionTargets, nfaState))
						{
							transitionTargets.push_back(nfaState);
						}
					}
					// 判断转换类的所有转换的NFA目标状态组成的集合是否已经有一个对应的DFA状态
					State* dfaState = 0;
					for (auto it = dfaStateMap.begin();it != dfaStateMap.end();it++)
					{
						// 将DFA的等价NFA状态集合进行排序(不然不能compare对吧)
						// 话说我记得我当初也是这么写的 hh
						// dfaStateMap.CopyValuesToCollection(k, relativeStates);
						relativeStates.clear(); // 忘记清空了,debug了一年
						for (auto i = 0;i < (*it).second.size();i++)
						{
							relativeStates.push_back((*it).second[i]);
						}
						// 先排下序,才能比较
						sort(relativeStates.begin(),relativeStates.end());
						sort(transitionTargets.begin(), transitionTargets.end());
						// 比较两者是否相等
						if (relativeStates.size() == transitionTargets.size())
						{
							bool equal = true;
							for (int l = 0;l < relativeStates.size();l++)
							{
								if (relativeStates[l] != transitionTargets[l])
								{
									equal = false;
									break;
								}
							}
							if (equal)
							{
								dfaState = (*it).first;
								break;
							}
						}
					}
					//不存在这个DFA状态则创建一个
					if (!dfaState)
					{
						dfaState = target->NewState();
						// 把刚刚得到的那些结点加进去
						for (int k = 0;k < transitionTargets.size();k++)
						{
							dfaStateMap.insert(dfaState, transitionTargets[k]);
							if (transitionTargets[k]->finalState)
							{
								dfaState->finalState = true;
							}
						}
					}
					//将该转换复制到新状态机里
					Transition* transitionClass = transitionClasses[j];
					Transition* newTransition = target->NewTransition(currentState, dfaState);
					newTransition->range = transitionClass->range;
					newTransition->type = transitionClass->type;
				}
			}
			return target;
		}