C++ Hashtable::contains方法代码示例

		void Room::cacheProperties(const Hashtable& properties)
		{
			if(properties.contains(static_cast<nByte>(Properties::Room::MAX_PLAYERS)))
				mMaxPlayers = ValueObject<nByte>(properties.getValue(static_cast<nByte>(Properties::Room::MAX_PLAYERS))).getDataCopy();

			if(properties.contains(static_cast<nByte>(Properties::Room::IS_OPEN)))
				mIsOpen = ValueObject<bool>(properties.getValue(static_cast<nByte>(Properties::Room::IS_OPEN))).getDataCopy();

			if(properties.contains(static_cast<nByte>(Properties::Room::PLAYER_COUNT)))
				mPlayerCount = ValueObject<nByte>(properties.getValue(static_cast<nByte>(Properties::Room::PLAYER_COUNT))).getDataCopy();

			mCustomProperties.put(Utils::stripToCustomProperties(properties));
			mCustomProperties = Utils::stripKeysWithNullValues(mCustomProperties);
		}

static void clean_evaluate(bool aggressive, int depth, board_t board) {
  check_board(board);
  symmetry_t symmetry;
  superstandardize(board).get(board,symmetry);
  if (known.contains(tuple(depth,board)))
    return;
  cout << "clean evaluate: depth "<<depth<<", board "<<board<<endl;
  clear_supertable();
  const super_t all = ~super_t(0);
  const side_t side0 = unpack(board,0), side1 = unpack(board,1);
  auto data = super_shallow_evaluate(aggressive,depth,side0,side1,all);
  superinfo_t info = data.lookup.info;
  if (depth>=1)
    info = super_evaluate_recurse<false>(aggressive,depth,side0,side1,data,all);
  GEODE_ASSERT(info.known==all);
  known.set(tuple(depth,board),info);
}

void LoadBalancingListener::afterRoomJoined(int localPlayerNr)
{
	mpView->info( "afterRoomJoined: localPlayerNr=", localPlayerNr );
	this->mLcalPlayerNr = localPlayerNr;
	MutableRoom& myRoom = mpLbc->getCurrentlyJoinedRoom();
	Hashtable props = myRoom.getCustomProperties();
	updateGridSize(props);
	if(props.contains("m"))
		mMap = ((ValueObject<JString>*)props.getValue("m"))->getDataCopy();

	mpView->initPlayers();
	mpView->setupScene(mGridSize);

	const JVector<Player*>& players = myRoom.getPlayers();
	for(unsigned int i=0; i<players.getSize(); ++i)
	{
		const Player* p = players[i];
		mpView->addPlayer(p->getNumber(), p->getName().UTF8Representation().cstr(), p->getNumber() == mpLbc->getLocalPlayer().getNumber());
	}
	mpView->changePlayerColor(localPlayerNr, mLocalPlayer.color);
	raiseColorEvent();
}

GEODE_COLD static void assert_delaunay(const char* prefix,
                                       const TriangleTopology& mesh, RawField<const Perturbed2,VertexId> X,
                                       const Hashtable<Vector<VertexId,2>>& constrained=Tuple<>(),
                                       const bool oriented_only=false,
                                       const bool check_boundary=true) {
  // Verify that all faces are correctly oriented
  for (const auto f : mesh.faces()) {
    const auto v = mesh.vertices(f);
    GEODE_ASSERT(triangle_oriented(X,v.x,v.y,v.z));
  }
  if (oriented_only)
    return;
  // Verify that all internal edges are Delaunay
  if (!constrained.size()) {
    for (const auto e : mesh.interior_halfedges())
      if (!mesh.is_boundary(mesh.reverse(e)) && mesh.src(e)<mesh.dst(e))
        if (!is_delaunay(mesh,X,e))
          throw RuntimeError(format("%snon delaunay edge: e%d, v%d v%d",prefix,e.id,mesh.src(e).id,mesh.dst(e).id));
  } else {
    for (const auto v : constrained)
      if (!mesh.halfedge(v.x,v.y).valid())
        throw RuntimeError(format("%smissing constraint edge: v%d v%d",prefix,v.x.id,v.y.id));
    for (const auto e : mesh.interior_halfedges()) {
      const auto s = mesh.src(e), d = mesh.dst(e);
      if (!mesh.is_boundary(mesh.reverse(e)) && s<d && !constrained.contains(vec(s,d)))
        if (!is_delaunay(mesh,X,e))
          throw RuntimeError(format("%snon delaunay edge: e%d, v%d v%d",prefix,e.id,mesh.src(e).id,mesh.dst(e).id));
    }
  }
  // Verify that all boundary vertices are convex
  if (check_boundary)
    for (const auto e : mesh.boundary_edges()) {
      const auto v0 = mesh.src(mesh.prev(e)),
                 v1 = mesh.src(e),
                 v2 = mesh.dst(e);
      GEODE_ASSERT(triangle_oriented(X,v2,v1,v0));
    }
}

bool traced(bool aggressive, board_t board) {
  return board_flags.contains(superstandardize(board).x|(uint64_t)aggressive<<aggressive_bit);
}

GEODE_NEVER_INLINE static void add_constraint_edges(MutableTriangleTopology& mesh, RawField<const EV,VertexId> X,
                                                    RawArray<const Vector<int,2>> edges, const bool validate) {
  if (!edges.size())
    return;
  IntervalScope scope;
  Hashtable<Vector<VertexId,2>> constrained;
  Array<VertexId> left_cavity, right_cavity; // List of vertices for both cavities
  const auto random = new_<Random>(key+7);
  for (int i=0;i<edges.size();i++) {
    // Randomly choose an edge to ensure optimal time complexity
    const auto edge = edges[int(random_permute(edges.size(),key+5,i))].sorted();
    auto v0 = VertexId(edge.x),
         v1 = VertexId(edge.y);
    const auto vs = vec(v0,v1);
    GEODE_ASSERT(mesh.valid(v0) && mesh.valid(v1));

    {
      // Check if the edge already exists in the triangulation.  To ensure optimal complexity,
      // we loop around both vertices interleaved so that our time is O(min(degree(v0),degree(v1))).
      const auto s0 = mesh.halfedge(v0),
                 s1 = mesh.halfedge(v1);
      {
        auto e0 = s0,
             e1 = s1;
        do {
          if (mesh.dst(e0)==v1 || mesh.dst(e1)==v0)
            goto success; // The edge already exists, so there's nothing to be done.
          e0 = mesh.left(e0);
          e1 = mesh.left(e1);
        } while (e0!=s0 && e1!=s1);
      }

      // Find a triangle touching v0 or v1 containing part of the v0-v1 segment.
      // As above, we loop around both vertices interleaved.
      auto e0 = s0;
      {
        auto e1 = s1;
        if (mesh.is_boundary(e0)) e0 = mesh.left(e0);
        if (mesh.is_boundary(e1)) e1 = mesh.left(e1);
        const auto x0 = Perturbed2(v0.id,X[v0]),
                   x1 = Perturbed2(v1.id,X[v1]);
        const auto e0d = mesh.dst(e0),
                   e1d = mesh.dst(e1);
        bool e0o = triangle_oriented(x0,Perturbed2(e0d.id,X[e0d]),x1),
             e1o = triangle_oriented(x1,Perturbed2(e1d.id,X[e1d]),x0);
        for (;;) { // No need to check for an end condition, since we're guaranteed to terminate
          const auto n0 = mesh.left(e0),
                     n1 = mesh.left(e1);
          const auto n0d = mesh.dst(n0),
                     n1d = mesh.dst(n1);
          const bool n0o = triangle_oriented(x0,Perturbed2(n0d.id,X[n0d]),x1),
                     n1o = triangle_oriented(x1,Perturbed2(n1d.id,X[n1d]),x0);
          if (e0o && !n0o)
            break;
          if (e1o && !n1o) {
            // Swap v0 with v1 and e0 with e1 so that our ray starts at v0
            swap(v0,v1);
            swap(e0,e1);
            break;
          }
          e0 = n0;
          e1 = n1;
          e0o = n0o;
          e1o = n1o;
        }
      }

      // If we only need to walk one step, the retriangulation is a single edge flip
      auto cut = mesh.reverse(mesh.next(e0));
      if (mesh.dst(mesh.next(cut))==v1) {
        if (constrained.contains(vec(mesh.src(cut),mesh.dst(cut)).sorted()))
          throw DelaunayConstraintConflict(vec(v0.id,v1.id),vec(mesh.src(cut).id,mesh.dst(cut).id));
        cut = mesh.flip_edge(cut);
        goto success;
      }

      // Walk from v0 to v1, collecting the two cavities.
      const auto x0 = Perturbed2(v0.id,X[v0]),
                 x1 = Perturbed2(v1.id,X[v1]);
      right_cavity.copy(vec(v0,mesh.dst(cut)));
      left_cavity .copy(vec(v0,mesh.src(cut)));
      mesh.erase(mesh.face(e0));
      for (;;) {
        if (constrained.contains(vec(mesh.src(cut),mesh.dst(cut)).sorted()))
          throw DelaunayConstraintConflict(vec(v0.id,v1.id),vec(mesh.src(cut).id,mesh.dst(cut).id));
        const auto n = mesh.reverse(mesh.next(cut)),
                   p = mesh.reverse(mesh.prev(cut));
        const auto v = mesh.src(n);
        mesh.erase(mesh.face(cut));
        if (v == v1) {
          left_cavity.append(v);
          right_cavity.append(v);
          break;
        } else if (triangle_oriented(x0,x1,Perturbed2(v.id,X[v]))) {
          left_cavity.append(v);
          cut = n;
        } else {
          right_cavity.append(v);
          cut = p;
        }
//.........这里部分代码省略.........

		void MutableRoom::cacheProperties(const Hashtable& properties)
		{
			if(properties.contains(static_cast<nByte>(Properties::Room::IS_VISIBLE)))
				mIsVisible = ValueObject<bool>(properties.getValue(static_cast<nByte>(Properties::Room::IS_VISIBLE))).getDataCopy();
			super::cacheProperties(properties);
		}