How to use

FixedRekord

in

com.noodlesandwich.rekord

@Override
public Keys<T> acceptedKeys() {
  return delegate.acceptedKeys();
}

@Override
public <V> V get(Key<T, V> key) {
  return delegate.get(key);
}

@Override
public boolean has(Key<T, ?> key) {
  return delegate.has(key);
}

public static <T> boolean equals(FixedRekord<T> a, Object bObject) {
  if (a == bObject) {
    return true;
  }
  if (!(bObject instanceof FixedRekord)) {
    return false;
  }
  @SuppressWarnings("unchecked")
  FixedRekord<T> b = (FixedRekord<T>) bObject;
  return a.name().equals(b.name()) && a.properties().equals(b.properties());
}

  @Override
  protected boolean matchesSafely(FixedRekord<T> rekord, Description mismatchDescription) {
    Keys<T> expectedKeys = rekord.acceptedKeys();
    Keys<T> actualKeys = rekord.keys();
    Set<Key<T, ?>> missingKeys = difference(expectedKeys, actualKeys);
    mismatchDescription.appendText("was missing the keys ").appendValue(missingKeys);
    return missingKeys.isEmpty();
  }
};

  @Override
  protected boolean matchesSafely(FixedRekord<T> actualRekord, Description mismatchDescription) {
    mismatchDescription.appendText("a rekord that looks like ").appendValue(actualRekord);

    if (!expectedProperties.keySet().equals(actualRekord.keys().toSet())) {
      return false;
    }

    for (Map.Entry<Key<T, ?>, Matcher<?>> property : expectedProperties.entrySet()) {
      Key<T, ?> expectedKey = property.getKey();
      Matcher<?> expectedValue = property.getValue();
      if (!expectedValue.matches(actualRekord.get(expectedKey))) {
        return false;
      }
    }
    return true;
  }
}

@Override
public Properties<T> properties() {
  return delegate.properties();
}

@Override
public String name() {
  return delegate.name();
}

@Override
public Keys<T> keys() {
  return delegate.keys();
}

  @Override
  public String toString() {
    return delegate.toString();
  }
}

@Override
public <R, E extends Exception> R serialize(Serializer<R, E> serializer) throws E {
  return delegate.serialize(serializer);
}

  public static <T> int hashCode(FixedRekord<T> rekord) {
    return Objects.hash(rekord.name(), rekord.properties());
  }
}

@Override
public Properties<T> properties() {
  return delegate.properties();
}

@Override
public String name() {
  return delegate.name();
}

@Override
public Keys<T> keys() {
  return delegate.keys();
}

  @Override
  public String toString() {
    return delegate.toString();
  }
}

@Override
public <R, E extends Exception> R serialize(Serializer<R, E> serializer) throws E {
  return delegate.serialize(serializer);
}

@Override
public ValidatingRekord<T> merge(FixedRekord<T> other) {
  ValidatingRekord<T> result = this;
  for (Property<T, ?> property : other.properties()) {
    result = result.with(property);
  }
  return result;
}

@Override
public <T> Document serialize(String name, FixedRekord<T> rekord) throws ParserConfigurationException {
  DocumentBuilder documentBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
  Document document = documentBuilder.newDocument();
  NodeCreator nodeCreator = new NodeCreator(locale, document);
  Element root = nodeCreator.elementNamed(rekord.name());
  Serialization.serialize(rekord).into(new DomXmlAccumulator(root, nodeCreator));
  document.appendChild(root);
  return document;
}

  @Override
  protected boolean matchesSafely(FixedRekord<T> rekord, Description mismatchDescription) {
    Keys<T> actualKeys = rekord.keys();
    Set<Key<T, ?>> missingKeys = difference(expectedKeys, actualKeys);
    mismatchDescription.appendText("was missing the keys ").appendValue(missingKeys);
    return missingKeys.isEmpty();
  }
};