Provide a non-fatal notification, unless suppressed by the -nowarn option.
@param noteKey    The key for the localized notification message.
761844
public void note(JavaFileObject file, Note noteKey) {
        report(diags.note(getSource(file), null, noteKey));
    }
863533
def warn(self, key):
        """"""
        return (not self.quiet and not self.warn_none and
                (self.warn_all or getattr(self, "warn_%s" % key)))
1166445
public void printNotice(SourcePosition pos, String msg) {
        if (diagListener != null) {
            report(DiagnosticType.NOTE, pos, msg);
            return;
        }

        if (pos == null)
            noticeWriter.println(msg);
        else
            noticeWriter.println(pos + ": " + msg);
        noticeWriter.flush();
    }
319038
public void printVerbose(String key, Object... args) {
        PrintWriter noticeWriter = writers.get(WriterKind.NOTICE);
        printRawLines(noticeWriter, localize("verbose." + key, args));
    }
1352626
public void note(JavaFileObject file, String key, Object ... args) {
        note(file, diags.noteKey(key, args));
    }
503065
def handle_notification(self, data):
        """"""
        if data.get('method') in self._callbacks:
            self._callbacks.get(data.get('method'))(data.get('params'))
875485
public void markNotReady()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "markNotReady");

    ready = false;
    if(keyGroup != null)
      keyGroup.markNotReady();

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "markNotReady");

  }
381198
public void onShowNotification(NotificationView view, View contentView, NotificationEntry entry, int layoutId) {
        if (DBG) Log.v(TAG, "onShowNotification - " + entry.ID);

        final Drawable icon = entry.iconDrawable;
        final CharSequence title = entry.title;
        final CharSequence text = entry.text;
        final CharSequence when = entry.showWhen ? entry.whenFormatted : null;

        ChildViewManager mgr = view.getChildViewManager();

        if (layoutId == R.layout.notification_simple ||
            layoutId == R.layout.notification_large_icon ||
            layoutId == R.layout.notification_full) {

            boolean titleChanged = true;
            boolean contentChanged = view.isContentLayoutChanged();
            NotificationEntry lastEntry = view.getLastNotification();

            if (!contentChanged && title != null &&
                lastEntry != null && title.equals(lastEntry.title)) {
                titleChanged = false;
            }

            mgr.setImageDrawable(ICON, icon, titleChanged);
            mgr.setText(TITLE, title, titleChanged);
            mgr.setText(TEXT, text);
            mgr.setText(WHEN, when);

        } else if (layoutId == R.layout.notification_simple_2) {

            mgr.setImageDrawable(ICON, icon);
            mgr.setText(TITLE, title);
            mgr.setText(TEXT, text);
            mgr.setText(WHEN, when);
        }
    }
477480
public void setNote(String note) {
       try {
           staticTableHistory.updateNote(historyId, note);
           httpMessageCachedData.setNote(note != null && note.length() > 0);
           notifyEvent(HistoryReferenceEventPublisher.EVENT_NOTE_SET);
       } catch (DatabaseException e) {
           log.error(e.getMessage(), e);
       }
       
   }
274436
@Override
    public void handleNotification(Notification notification, Object handback) {
        if(notification instanceof MBeanServerNotification) {
            MBeanServerNotification mbeanNotification = (MBeanServerNotification) notification;
            if(mbeanNotification.getType().equals("JMX.mbean.registered")) {
                jmxTree = null;
               
               registerAsNotificationListener(mbeanNotification.getMBeanName());
                
            } else if(mbeanNotification.getType().equals("JMX.mbean.unregistered")) {
                jmxTree = null;
            }
        } 
        for (NotificationListener listener : listeners) {
            listener.handleNotification(notification, handback);
        }

    }
832709
public static boolean verifyNotify(Map<String, String> params, String paternerKey) {
		String sign = params.get("sign");
		String localSign = PaymentKit.createSign(params, paternerKey);
		return sign.equals(localSign);
	}
843721
public void setSSECustomerKey(SSECustomerKey sseKey) {
        if (sseKey != null && this.sseAwsKeyManagementParams != null) {
            throw new IllegalArgumentException(
                "Either SSECustomerKey or SSEAwsKeyManagementParams must not be set at the same time.");
        }
        this.sseCustomerKey = sseKey;
    }
476958
private void notifyAdditionalOnScrollListener(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {
        if (mAdditionalOnScrollListener != null) {
            mAdditionalOnScrollListener.onScroll(view, firstVisibleItem, visibleItemCount, totalItemCount);
        }
    }
152329
public static void warn(String message) {
        if (Boolean.getBoolean("visibleassertions.silence")) {
            return;
        }

        System.out.println("        " + yellow(bright(WARN_MARK + " " + message)));
    }
640006
function (successCallback, errorCallback, args) {
		winble.logger.logApiEntry("enableNotification");
		var deviceHandle = args[0] ? args[0] : "";
		var charHandle = args[1] ? args[1] : "";
		winble.deviceManager.enableCharacteristicNotification(successCallback, errorCallback, deviceHandle, charHandle);
		winble.logger.logApiExit("enableNotification");
	}
1244453
public void setTitleKey(String titleKey) {

        m_titleKey = titleKey;
        if (LOG.isDebugEnabled()) {
            LOG.debug(Messages.get().getBundle().key(Messages.LOG_SET_TITLE_KEY_1, titleKey));
        }
    }
855741
def stop_NoteContainer(self, nc, channel=1):
        """"""
        self.notify_listeners(self.MSG_PLAY_NC, {'notes': nc,
            'channel': channel})
        if nc is None:
            return True
        for note in nc:
            if not self.stop_Note(note, channel):
                return False
        return True