Java PGNotification.getParameter方法代码示例

import org.postgresql.PGNotification; //导入方法依赖的package包/类
/**
 * Parses base type {@link PGNotification notifications} for synchronizing the state of
 * {@link BaseType base types} between multiple instances of BinNavi.
 * 
 * @param notification THe {@link PGNotification} from the database.
 * @return A {@link TypesNotificationContainer container} with the parsed information.
 */
private TypesNotificationContainer parseBaseTypesNotification(final PGNotification notification) {

  final Matcher matcher = BASE_TYPES_NOTIFICATION_PATTERN.matcher(notification.getParameter());

  if (!matcher.find()) {
    throw new IllegalStateException("Error: compiled pattern: " + BASE_TYPE_NOTIFICATION_REGEX
        + " did not match notification: " + notification.getParameter());
  }

  final String databaseOperation = matcher.group(2);
  final Integer moduleId = Integer.parseInt(matcher.group(3));
  final Integer baseTypeId = Integer.parseInt(matcher.group(4));

  return new TypesNotificationContainer(databaseOperation, moduleId, Optional.of(baseTypeId),
      Optional.<Integer>absent(), Optional.<BigInteger>absent(), Optional.<Integer>absent(),
      Optional.<Integer>absent());
}
 

import org.postgresql.PGNotification; //导入方法依赖的package包/类
/**
 * Parses expression type aka type substitution {@link PGNotification notifications} for
 * synchronizing the state of {@link TypeSubstitution type substitutions} between multiple
 * instances of BinNavi.
 * 
 * @param notification The {@link PGNotification} from the database.
 * @return A {@link TypesNotificationContainer container} with the parsed information.
 */
private TypesNotificationContainer parseExpressionTypesNotification(
    final PGNotification notification) {

  final Matcher matcher =
      EXPRESSION_TYPES_NOTIFICATION_PATTERN.matcher(notification.getParameter());

  if (!matcher.find()) {
    throw new IllegalStateException("Error: compliled pattern "
        + EXPRESSION_TYPES_NOTIFICATION_PATTERN.toString() + " did not match notification: "
        + notification.getParameter());
  }

  final String databaseOperation = matcher.group(2);
  final Integer moduleId = Integer.parseInt(matcher.group(3));
  final BigInteger address = new BigInteger(matcher.group(4));
  final Integer position = Integer.parseInt(matcher.group(5));
  final Integer expressionId = Integer.parseInt(matcher.group(6));

  return new TypesNotificationContainer(databaseOperation, moduleId, Optional.<Integer>absent(),
      Optional.<Integer>absent(), Optional.of(address), Optional.of(position),
      Optional.of(expressionId));
}
 

import org.postgresql.PGNotification; //导入方法依赖的package包/类
/**
 * Parses type {@link PGNotification notifications} for synchronizing the state of
 * {@link TypeMember type members} between multiple instances of BinNavi.
 * 
 * @param notification The {@link PGNotification} from the database.
 * @return A {@link TypesNotificationContainer container} with the parsed information.
 */
private TypesNotificationContainer parseTypesNotification(final PGNotification notification) {

  final Matcher matcher = TYPES_NOTIFICATION_PATTERN.matcher(notification.getParameter());

  if (!matcher.find()) {
    throw new IllegalStateException("Error: compiled pattern: " + TYPES_NOTIFICATION_REGEX
        + " did not match notification: " + notification.getParameter());
  }

  final String databaseOperation = matcher.group(2);
  final Integer moduleId = Integer.parseInt(matcher.group(3));
  final Integer typeMemberId = Integer.parseInt(matcher.group(4));

  return new TypesNotificationContainer(databaseOperation, moduleId, Optional.<Integer>absent(),
      Optional.of(typeMemberId), Optional.<BigInteger>absent(), Optional.<Integer>absent(),
      Optional.<Integer>absent());

}
 

import org.postgresql.PGNotification; //导入方法依赖的package包/类
@Override
public Collection<TypesNotificationContainer> parse(
    final Collection<PGNotification> notifications, final SQLProvider provider) {

  Preconditions.checkNotNull(notifications, "Error: notifications argument can not be null");
  Preconditions.checkNotNull(provider, "Error: provider argument can not be null");

  final Collection<TypesNotificationContainer> containers = Lists.newArrayList();

  for (final PGNotification notification : notifications) {
    if (notification.getParameter().startsWith(CTableNames.EXPRESSION_TYPES_TABLE)) {
      containers.add(parseExpressionTypesNotification(notification));
    } else if (notification.getParameter().startsWith(CTableNames.TYPE_MEMBERS_TABLE)) {
      containers.add(parseTypesNotification(notification));
    } else if (notification.getParameter().startsWith(CTableNames.BASE_TYPES_TABLE)) {
      containers.add(parseBaseTypesNotification(notification));
    } else {
      throw new IllegalStateException("Error: Table name supplied in notification "
          + notification.getParameter()
          + " does not match tables where type notifications are expected on.");
    }
  }
  return containers;
}
 

import org.postgresql.PGNotification; //导入方法依赖的package包/类
/**
 * Parses type instance notifications. This function parses messages for synchronization of
 * changes in the {@link CTableNames bn_type_instances} table.
 * 
 * @param notification The {@link PGNotification} which carries the information to be parsed.
 * @return A {@link TypeInstancesNotificationContainer} with the parsed information.
 */
private TypeInstancesNotificationContainer parseTypeInstanceNotification(
    final PGNotification notification) {

  final Matcher matcher = typeInstanceNotificationPattern.matcher(notification.getParameter());
  if (!matcher.find()) {
    throw new IllegalStateException("Error: compiled pattern: "
        + typeInstanceNotificationPattern.toString() + " did not match notification: "
        + notification.getParameter());
  }

  final String databaseOperation = matcher.group(2);
  final Integer moduleId = Integer.parseInt(matcher.group(3));
  final Integer typeInstanceId = Integer.parseInt(matcher.group(4));

  return new TypeInstancesNotificationContainer(databaseOperation, moduleId, typeInstanceId,
      Optional.<BigInteger>absent(), Optional.<Integer>absent(), Optional.<Integer>absent());
}
 

import org.postgresql.PGNotification; //导入方法依赖的package包/类
/**
 * Parses expression type instances or simpler type substitutions on operands. This function
 * parses messages for synchronization of changes in the {@link CTableNames
 * bn_expression_type_instances} table.
 * 
 * @param notification The {@link PGNotification} which carries the information to be parsed.
 * @return A {@link TypeInstancesNotificationContainer} with the parsed information.
 */
private TypeInstancesNotificationContainer parseExpressionTypeInstanceNotification(
    final PGNotification notification) {

  final Matcher matcher =
      expressionTypeInstanceNotificationPattern.matcher(notification.getParameter());
  if (!matcher.find()) {
    throw new IllegalStateException("Error: compiled pattern: "
        + expressionTypeInstanceNotificationPattern.toString() + " did not match notification: "
        + notification.getParameter());
  }

  final String databaseOperation = matcher.group(2);
  final Integer moduleId = Integer.parseInt(matcher.group(3));
  final BigInteger address = new BigInteger(matcher.group(4));
  final Integer position = Integer.parseInt(matcher.group(5));
  final Integer expressionId = Integer.parseInt(matcher.group(6));
  final Integer typeInstanceId = Integer.parseInt(matcher.group(7));

  return new TypeInstancesNotificationContainer(databaseOperation, moduleId, typeInstanceId,
      Optional.of(address), Optional.of(position), Optional.of(expressionId));
}
 

import org.postgresql.PGNotification; //导入方法依赖的package包/类
@Override
public Collection<TypeInstancesNotificationContainer> parse(
    final Collection<PGNotification> notifications, final SQLProvider provider) {

  Preconditions.checkNotNull(notifications, "Error: notifications argument can not be null");
  Preconditions.checkNotNull(provider, "Error: provider argument can not be null");

  final Collection<TypeInstancesNotificationContainer> containers = Lists.newArrayList();

  for (final PGNotification notification : notifications) {
    if (notification.getParameter().startsWith(CTableNames.TYPE_INSTANCE_TABLE)) {
      containers.add(parseTypeInstanceNotification(notification));
    } else if (notification.getParameter()
        .startsWith(CTableNames.EXPRESSION_TYPE_INSTANCES_TABLE)) {
      containers.add(parseExpressionTypeInstanceNotification(notification));
    } else {
      throw new IllegalStateException("Error: Table name supplied in notification "
          + notification.getParameter()
          + " does not match tables where type instance notifications are accepted on.");
    }
  }
  return containers;
}
 

import org.postgresql.PGNotification; //导入方法依赖的package包/类
private FunctionNotificationContainer parseFunctionNotification(final PGNotification notification,
    final SQLProvider provider) {

  final Pattern pattern = Pattern.compile(functionNotificationPattern);
  final Matcher matcher = pattern.matcher(notification.getParameter());
  if (!matcher.find()) {
    throw new IllegalStateException("IE02739: compiled pattern: " + pattern.toString()
        + " did not match notification: " + notification.getParameter());
  }

  final String databaseOperation = matcher.group(2);
  final Integer moduleId = Integer.parseInt(matcher.group(3));
  final IAddress functionAddress = new CAddress(new BigInteger(matcher.group(4)));
  final INaviModule module = provider.findModule(moduleId);
  return new FunctionNotificationContainer(moduleId, module, functionAddress, databaseOperation);
}
 

import org.postgresql.PGNotification; //导入方法依赖的package包/类
@Override
public Collection<FunctionNotificationContainer> parse(
    final Collection<PGNotification> notifications, final SQLProvider provider) {

  Preconditions.checkNotNull(notifications, "IE02629: notifications argument can not be null");
  Preconditions.checkNotNull(provider, "IE02630: provider argument can not be null");

  final Collection<FunctionNotificationContainer> containers =
      new ArrayList<FunctionNotificationContainer>();

  for (final PGNotification notification : notifications) {
    if (notification.getParameter().startsWith(CTableNames.FUNCTIONS_TABLE)) {
      containers.add(parseFunctionNotification(notification, provider));
    } else {
      throw new IllegalStateException("IE02738: Table name supplied in notification: "
          + notification.getParameter()
          + " does not match tables where function notifications are accepted on.");
    }
  }
  return containers;
}
 

import org.postgresql.PGNotification; //导入方法依赖的package包/类
/**
 * Parser for a bn_views notification. The function uses the viewNotificationPattern to parse the
 * incoming {@link PGNotification} into a {@link ViewNotificationContainer}.
 *
 * @param notification The {@link PGNotification} to parse.
 * @param provider The {@link SQLProvider} to access the database.
 *
 * @return A {@link ViewNotificationContainer} with the parsed information.
 */
private ViewNotificationContainer parseViewNotification(
    final PGNotification notification, final SQLProvider provider) {

  final Matcher matcher = viewNotificationPattern.matcher(notification.getParameter());
  if (!matcher.find()) {
    throw new IllegalStateException("IE02742: compiled pattern: "
        + viewNotificationPattern.toString() + " did not match notification: "
        + notification.getParameter());
  }

  final Integer viewId = Integer.parseInt(matcher.group(3));
  final Optional<INaviView> view =
      Optional.fromNullable(ViewManager.get(provider).getView(viewId));
  final String databaseOperation = matcher.group(2);

  return new ViewNotificationContainer(viewId,
      view,
      Optional.<Integer>absent(),
      Optional.<INaviModule>absent(),
      Optional.<INaviProject>absent(),
      databaseOperation);
}
 

import org.postgresql.PGNotification; //导入方法依赖的package包/类
/**
 * Parser for a bn_module_views notification. The function uses the moduleViewNotificationPattern
 * to parse the incoming {@link PGNotification} into a {@link ViewNotificationContainer}.
 *
 * @param notification The {@link PGNotification} to parse.
 * @param provider The {@link SQLProvider} to access the database.
 *
 * @return A {@link ViewNotificationContainer} with the parsed information.
 */
private ViewNotificationContainer parseModuleViewNotification(
    final PGNotification notification, final SQLProvider provider) {

  final Matcher matcher = moduleViewNotificationPattern.matcher(notification.getParameter());
  if (!matcher.find()) {
    throw new IllegalStateException("IE02743: compiled pattern: "
        + moduleViewNotificationPattern.toString() + " did not match notification: "
        + notification.getParameter());
  }

  final Integer viewId = Integer.parseInt(matcher.group(3));
  final Optional<INaviView> view =
      Optional.fromNullable(ViewManager.get(provider).getView(viewId));
  final Optional<Integer> moduleId = Optional.fromNullable(Integer.parseInt(matcher.group(4)));
  final Optional<INaviModule> module = Optional.fromNullable(provider.findModule(moduleId.get()));
  final String databaseOperation = matcher.group(2);

  return new ViewNotificationContainer(viewId,
      view,
      moduleId,
      module,
      Optional.<INaviProject>absent(),
      databaseOperation);
}
 

import org.postgresql.PGNotification; //导入方法依赖的package包/类
/**
 * Parser for the bn_project_views notification. The function uses the
 * projectViewNotificationPattern to parse the incoming {@link PGNotification} into a
 * {@link ViewNotificationContainer}
 *
 * @param notification The {@link PGNotification} to parse.
 * @param provider The {@link SQLProvider} to access the database.
 */
private ViewNotificationContainer parseProjectViewNotification(
    final PGNotification notification, final SQLProvider provider) {

  final Matcher matcher = projectViewNotificationPattern.matcher(notification.getParameter());
  if (!matcher.find()) {
    throw new IllegalStateException("IE02744: compiled pattern: "
        + projectViewNotificationPattern.toString() + " did not match notification: "
        + notification.getParameter());
  }

  final Integer viewId = Integer.parseInt(matcher.group(3));
  final Optional<INaviView> view =
      Optional.fromNullable(ViewManager.get(provider).getView(viewId));
  final Optional<Integer> projectId = Optional.fromNullable(Integer.parseInt(matcher.group(4)));
  final Optional<INaviProject> project =
      Optional.fromNullable(provider.findProject(projectId.get()));
  final String databaseOperation = matcher.group(2);

  return new ViewNotificationContainer(viewId,
      view,
      projectId,
      Optional.<INaviModule>absent(),
      project,
      databaseOperation);
}
 

import org.postgresql.PGNotification; //导入方法依赖的package包/类
/**
 * The parser function for view notifications. The function checks for the database table the
 * notification originated from and dispatches the parsing appropriately to the right function.
 *
 * @param notifications The {@link Collection} of {@link PGNotification} to parse.
 * @param provider The {@link SQLProvider} to access the database with.
 * @return A {@link Collection} of {@link ViewNotificationContainer}.
 */
@Override
public Collection<ViewNotificationContainer> parse(
    final Collection<PGNotification> notifications, final SQLProvider provider) {
  Preconditions.checkNotNull(notifications, "IE02745: notifications argument can not be null");
  Preconditions.checkNotNull(provider, "IE02746: provider argument can not be null");

  final Collection<ViewNotificationContainer> containers = Lists.newArrayList();

  for (final PGNotification notification : notifications) {
    if (notification.getParameter().startsWith(CTableNames.VIEWS_TABLE)) {
      containers.add(parseViewNotification(notification, provider));
    } else if (notification.getParameter().startsWith(CTableNames.MODULE_VIEWS_TABLE)) {
      containers.add(parseModuleViewNotification(notification, provider));
    } else if (notification.getParameter().startsWith(CTableNames.PROJECT_VIEWS_TABLE)) {
      containers.add(parseProjectViewNotification(notification, provider));
    } else {
      throw new IllegalStateException("IE02747: Table name supplied in notification: "
          + notification.getParameter()
          + " does not match tables where view notifications are accepted on.");
    }
  }
  return containers;
}
 

import org.postgresql.PGNotification; //导入方法依赖的package包/类
@Override
public void parseNotifications(final List<PGNotification> notifications) {
    for (final PGNotification notification : notifications) {
        final String parameter = notification.getParameter();
        if (parameter != null && !parameter.isEmpty() && parameter.contains("|")) {
            final String[] split = parameter.split("\\|");
            final String user = split[1];
            final String questionId = split[0];
            final NotificationView notificationView = new NotificationView();
            notificationView.setQuestionId(Integer.valueOf(questionId));
            simpMessagingTemplate.convertAndSendToUser(user, "/topic/notifications", notificationView);
        }
    }
}
 

import org.postgresql.PGNotification; //导入方法依赖的package包/类
@SuppressWarnings("MethodCanBeVariableArityMethod")
private void processNotifications(@Nullable final PGNotification[] notifications)
{
	if (notifications == null)
	{
		return;
	}
	for (final PGNotification notification : notifications)
	{
		final String notificationName = notification.getName(); // same as channel parameter
		final String notificationParameter = notification.getParameter();
		processNotificationUser.processNotification(notificationName, notificationParameter);
	}
}