Java 类com.mongodb.TagSet 实例源码

private static List<TagSet> parseArgs(String args) {
    args = args.trim();
    if (args.length() == 0) {
        return null;
    } else {
        try {
            return parseArgs(JsonUtils.json(args));
        } catch (InvalidReadPreferenceArgs x) {
            throw x;
        } catch (Exception e) {
            throw new InvalidReadPreferenceArgs(args);
        }
    }
}

private static List<TagSet> parseArgs(JsonNode args) {
    List<TagSet> list = new ArrayList<>();
    if (args instanceof ObjectNode) {
        list.add(parseArg((ObjectNode) args));
    } else if (args instanceof ArrayNode) {
        ArrayNode array = (ArrayNode) args;
        for (Iterator<JsonNode> itr = array.elements(); itr.hasNext();) {
            list.add(parseArg((ObjectNode) itr.next()));
        }
    } else {
        throw new InvalidReadPreferenceArgs(args.toString());
    }
    return list;
}

private static TagSet parseArg(ObjectNode arg) {
    List<Tag> tags = new ArrayList<>();
    for (Iterator<Map.Entry<String, JsonNode>> itr = arg.fields(); itr.hasNext();) {
        Map.Entry<String, JsonNode> entry = itr.next();
        tags.add(new Tag(entry.getKey(), entry.getValue().asText()));
    }
    return new TagSet(tags);
}

ReadPreferenceParser(ConnectionString connectionString, JsonObject config) {
  ReadPreference connStringReadPreference = connectionString != null ? connectionString.getReadPreference() : null;
  if (connStringReadPreference != null) {
    // Prefer connection string's read preference
    readPreference = connStringReadPreference;
  } else {
    ReadPreference rp;
    String rps = config.getString("readPreference");
    if (rps != null) {
      JsonArray readPreferenceTags = config.getJsonArray("readPreferenceTags");
      if (readPreferenceTags == null) {
        rp = ReadPreference.valueOf(rps);
        if (rp == null) throw new IllegalArgumentException("Invalid ReadPreference " + rps);
      } else {
        // Support advanced ReadPreference Tags
        List<TagSet> tagSet = new ArrayList<>();
        readPreferenceTags.forEach(o -> {
          String tagString = (String) o;
          List<Tag> tags = Stream.of(tagString.trim().split(","))
              .map(s -> s.split(":"))
              .filter(array -> {
                if (array.length != 2) {
                  throw new IllegalArgumentException("Invalid readPreferenceTags value '" + tagString + "'");
                }
                return true;
              }).map(array -> new Tag(array[0], array[1])).collect(Collectors.toList());

          tagSet.add(new TagSet(tags));
        });
        rp = ReadPreference.valueOf(rps, tagSet);
      }
    } else {
      rp = null;
    }

    readPreference = rp;
  }
}

private static TagSet toTags( DBObject tagsDocument )
{
    List<Tag> tagList = new ArrayList<Tag>( );
    for ( String key : tagsDocument.keySet( ) )
    {
        tagList.add( new Tag( key, tagsDocument.get( key ).toString( ) ) );
    }
    return new TagSet( tagList );
}

public static ReadPreference parse(String value) {
    value = value.trim();
    int paren = value.indexOf('(');
    String pref;
    List<TagSet> tags;
    if (paren != -1) {
        pref = value.substring(0, paren).trim();
        String argsStr = value.substring(paren + 1).trim();
        if (!argsStr.endsWith(")")) {
            throw new InvalidReadPreference(value);
        }
        tags = parseArgs(argsStr.substring(0, argsStr.length() - 1));
    } else {
        pref = value;
        tags = null;
    }
    switch (pref) {
        case READ_PREFERENCE_NEAREST:
            if (tags == null) {
                return ReadPreference.nearest();
            } else {
                return ReadPreference.nearest(tags);
            }
        case READ_PREFERENCE_PRIMARY:
            return ReadPreference.primary();
        case READ_PREFERENCE_PRIMARY_PREFERRED:
            if (tags == null) {
                return ReadPreference.primaryPreferred();
            } else {
                return ReadPreference.primaryPreferred(tags);
            }
        case READ_PREFERENCE_SECONDARY:
            if (tags == null) {
                return ReadPreference.secondary();
            } else {
                return ReadPreference.secondary(tags);
            }
        case READ_PREFERENCE_SECONDARY_PREFERRED:
            if (tags == null) {
                return ReadPreference.secondaryPreferred();
            } else {
                return ReadPreference.secondaryPreferred(tags);
            }
        default:
            throw new InvalidReadPreference(value);
    }
}

@Test
public void testNearestArgs() {
    TaggableReadPreference pref = (TaggableReadPreference) MongoReadPreference.parse("nearest ( {\"x\":1} )");
    Assert.assertTrue(pref.equals(ReadPreference.nearest(new TagSet(Arrays.asList(new Tag("x", "1"))))));
}

@Test
public void testNearestArgs2() {
    TaggableReadPreference pref = (TaggableReadPreference) MongoReadPreference.parse("nearest ( [ {\"x\":1}, {\"y\":\"a\"}] )");
    Assert.assertTrue(pref.equals(ReadPreference.nearest(Arrays.asList(new TagSet(Arrays.asList(new Tag("x", "1"))),
            new TagSet(Arrays.asList(new Tag("y", "a")))))));
}

@Test
public void testNearestArgs3() {
    TaggableReadPreference pref = (TaggableReadPreference) MongoReadPreference.parse("nearest([ {\"x\":1}, {\"y\":\"a\"}])");
    Assert.assertTrue(pref.equals(ReadPreference.nearest(Arrays.asList(new TagSet(Arrays.asList(new Tag("x", "1"))),
            new TagSet(Arrays.asList(new Tag("y", "a")))))));
}

ReadPreference getTaggableReadPreference()
  {
      ReadPreference readPref = getQueryReadPreference();
      if( readPref == ReadPreference.primary() )
          return readPref;    // primary read preference mode does not apply tags

      DBObject tagObjects = getReadPreferenceTagsAsParsedObject();

      if( tagObjects == null )
          return readPref;    // no tags in read preference

List<TagSet> tagsList = new ArrayList<TagSet>( );
if ( tagObjects instanceof BasicDBList )
{
    BasicDBList tagObjectList = (BasicDBList) tagObjects;
    for ( Object obj : tagObjectList )
    {
        if ( obj instanceof DBObject )
        {
            tagsList.add( toTags( (DBObject) obj ) );
        }
        else
        { // ignore elements that are not DBObject
            logInvalidTagValue( obj );
        }
    }
}
else
{
    tagsList.add( toTags( tagObjects ) );
}
if ( tagsList.size( ) == 0 )
{
    return readPref;
}

      try
      {
          return ReadPreference.valueOf( readPref.getName( ), tagsList );
      }
      catch( RuntimeException ex )
      {
          // log and ignore tags
          getLogger().info( ex.getLocalizedMessage() );
      }
      return readPref;
  }