import com.google.protobuf.Internal; //导入依赖的package包/类
public static <T extends Message> T unpack(AxAnyProto.AxAny any, Class<T> message) throws InvalidProtocolBufferException {
    T var1 = Internal.getDefaultInstance(message);
    if (!is(any, var1)) {
        throw new InvalidProtocolBufferException("Type of the Any message does not match the given class.");
    }
    T result = (T) var1.getParserForType()
            .parseFrom(any.getValue());
    return result;
}
 

import com.google.protobuf.Internal; //导入依赖的package包/类
ReferenceValidator(Enricher enricher,
        Class<? extends Message> eventClass,
        Class<? extends Message> enrichmentClass) {
    this.enricher = enricher;
    this.eventDescriptor = Internal.getDefaultInstance(eventClass)
                                   .getDescriptorForType();
    this.enrichmentDescriptor = Internal.getDefaultInstance(enrichmentClass)
                                        .getDescriptorForType();
}
 

import com.google.protobuf.Internal; //导入依赖的package包/类
@Override
public T apply(S eventMsg, C context) {
    checkNotNull(eventMsg);
    checkNotNull(context);
    ensureActive();
    verifyOwnState();

    final T defaultTarget = Internal.getDefaultInstance(getEnrichmentClass());
    final Message.Builder builder = defaultTarget.toBuilder();
    setFields(builder, eventMsg, context);
    @SuppressWarnings("unchecked") // types are checked during the initialization and validation
    final T result = (T) builder.build();
    return result;
}
 

import com.google.protobuf.Internal; //导入依赖的package包/类
/**
 * Calculate hash code for object.
 *
 * @param a the a
 * @return the int
 */
private static int calculateHashCodeForObject(Object a) {
    if (a instanceof byte[]) {
        return Internal.hashCode((byte[]) a);
    }
    // Enums should be stored as integers internally.
    if (a instanceof EnumLite) {
        throw new UnsupportedOperationException();
    }
    return a.hashCode();
}
 

import com.google.protobuf.Internal; //导入依赖的package包/类
/**
 * Constructs a FieldMask from the passed field numbers.
 *
 * @throws IllegalArgumentException if any of the fields are invalid for the message.
 */
public static FieldMask fromFieldNumbers(
    Class<? extends Message> type, Iterable<Integer> fieldNumbers) {
  Descriptor descriptor = Internal.getDefaultInstance(type).getDescriptorForType();

  FieldMask.Builder builder = FieldMask.newBuilder();
  for (Integer fieldNumber : fieldNumbers) {
    FieldDescriptor field = descriptor.findFieldByNumber(fieldNumber);
    checkArgument(
        field != null,
        String.format("%s is not a valid field number for %s.", fieldNumber, type));
    builder.addPaths(field.getName());
  }
  return builder.build();
}
 

import com.google.protobuf.Internal; //导入依赖的package包/类
@Override
public boolean match(Internal.EnumLite forward, Internal.EnumLite opcode) {
    return DOMAIN.MATCHING_VALUE == forward.getNumber() && REQUEST_OPCODE.JOIN_MATCH_QUENE.equals(opcode);
}
 

import com.google.protobuf.Internal; //导入依赖的package包/类
@Override
public boolean match(Internal.EnumLite forward, Internal.EnumLite opcode) {
    return forward.getNumber() == DOMAIN.MATCHING_VALUE
            && NOTIFY_OPCODE.NOTIFY_MATCH_SUCCESS.getNumber() == opcode.getNumber();
}
 

import com.google.protobuf.Internal; //导入依赖的package包/类
@Override
public boolean match(Internal.EnumLite forward, Internal.EnumLite opcode) {
    return forward.getNumber() == DOMAIN.MATCHING_VALUE && opcode.getNumber() == REQUEST_OPCODE.JOIN_MATCH_QUENE_VALUE;
}
 

import com.google.protobuf.Internal; //导入依赖的package包/类
public static ResponseBodyMessage<String> error(Internal.EnumLite code) {
    Preconditions.checkArgument(code.getNumber() > 0);
    return success(code, null);
}
 

import com.google.protobuf.Internal; //导入依赖的package包/类
public static <T extends Serializable> ResponseBodyMessage<T> success(Internal.EnumLite code, T data) {
    return new ResponseBodyMessage<>(code.getNumber(), data);
}
 

import com.google.protobuf.Internal; //导入依赖的package包/类
public static ResponseBodyEntity<String> error(Internal.EnumLite code) {
    return success(code, null);
}
 

import com.google.protobuf.Internal; //导入依赖的package包/类
public static <T> ResponseBodyEntity<T> success(Internal.EnumLite code, T data) {
    return new ResponseBodyEntity<>(code.getNumber(), data);
}
 

import com.google.protobuf.Internal; //导入依赖的package包/类
private ServiceEmptyMessage(Internal.EnumLite errorCode) {
    this.errorCode = errorCode;
}
 

import com.google.protobuf.Internal; //导入依赖的package包/类
public static ServiceEmptyMessage newMessage(Internal.EnumLite errorCode) {
    return newMessage(errorCode);
}
 

import com.google.protobuf.Internal; //导入依赖的package包/类
public Internal.EnumLite getErrorCode() {
    return errorCode;
}
 

import com.google.protobuf.Internal; //导入依赖的package包/类
private ServiceMessage(Internal.EnumLite errorCode, T data) {
    this.errorCode = errorCode;
    this.data = data;
}
 

import com.google.protobuf.Internal; //导入依赖的package包/类
public static <T> ServiceMessage<T> newMessage(Internal.EnumLite errorCode, T t) {
    return new ServiceMessage<>(errorCode, t);
}
 

import com.google.protobuf.Internal; //导入依赖的package包/类
public static <T extends Message> boolean is(AxAnyProto.AxAny any, Class<T> clazz) {
    return is(any, Internal.getDefaultInstance(clazz));
}
 

import com.google.protobuf.Internal; //导入依赖的package包/类
public static Internal.EnumLiteMap<Type> internalGetValueMap() {
	return internalValueMap;
}
 

import com.google.protobuf.Internal; //导入依赖的package包/类
/**
 * Compute the number of bytes that would be needed to encode a particular value of arbitrary type, excluding tag.
 *
 * @param type The field's type.
 * @param value Object representing the field's value. Must be of the exact type which would be returned by
 *            {@link Message#getField(Descriptors.FieldDescriptor)} for this field.
 * @return the int
 */
public static int computeElementSizeNoTag(final WireFormat.FieldType type, final Object value) {
    switch (type) {
        // Note: Minor violation of 80-char limit rule here because this would
        // actually be harder to read if we wrapped the lines.
        case DOUBLE:
            return CodedOutputStream.computeDoubleSizeNoTag((Double) value);
        case FLOAT:
            return CodedOutputStream.computeFloatSizeNoTag((Float) value);
        case INT64:
            return CodedOutputStream.computeInt64SizeNoTag((Long) value);
        case UINT64:
            return CodedOutputStream.computeUInt64SizeNoTag((Long) value);
        case INT32:
            return CodedOutputStream.computeInt32SizeNoTag((Integer) value);
        case FIXED64:
            return CodedOutputStream.computeFixed64SizeNoTag((Long) value);
        case FIXED32:
            return CodedOutputStream.computeFixed32SizeNoTag((Integer) value);
        case BOOL:
            return CodedOutputStream.computeBoolSizeNoTag((Boolean) value);
        case STRING:
            return CodedOutputStream.computeStringSizeNoTag((String) value);
        case GROUP:
            return CodedOutputStream.computeGroupSizeNoTag((MessageLite) value);
        case BYTES:
            if (value instanceof ByteString) {
                return CodedOutputStream.computeBytesSizeNoTag((ByteString) value);
            } else {
                return CodedOutputStream.computeByteArraySizeNoTag((byte[]) value);
            }
        case UINT32:
            return CodedOutputStream.computeUInt32SizeNoTag((Integer) value);
        case SFIXED32:
            return CodedOutputStream.computeSFixed32SizeNoTag((Integer) value);
        case SFIXED64:
            return CodedOutputStream.computeSFixed64SizeNoTag((Long) value);
        case SINT32:
            return CodedOutputStream.computeSInt32SizeNoTag((Integer) value);
        case SINT64:
            return CodedOutputStream.computeSInt64SizeNoTag((Long) value);

        case MESSAGE:
            if (value instanceof LazyField) {
                return CodedOutputStream.computeLazyFieldSizeNoTag((LazyField) value);
            } else {
                return computeObjectSizeNoTag(value);
            }

        case ENUM:
            if (value instanceof Internal.EnumLite) {
                return CodedOutputStream.computeEnumSizeNoTag(((Internal.EnumLite) value).getNumber());
            } else {
                if (value instanceof EnumReadable) {
                    return CodedOutputStream.computeEnumSizeNoTag(((EnumReadable) value).value());
                } else if (value instanceof Enum) {
                    return CodedOutputStream.computeEnumSizeNoTag(((Enum) value).ordinal());
                }

                return CodedOutputStream.computeEnumSizeNoTag((Integer) value);
            }
    }

    throw new RuntimeException("There is no way to get here, but the compiler thinks otherwise.");
}