Notify all listeners that a property has been reset.

@param property
the property whose value has changed
974223
private void firePropertyReset(T property)
    {
        PropertyEvent<T> event = null;

        for (PropertyListener<T> l : listeners)
        {
            if (event == null)
            {
                event = new PropertyEvent<T>(this, property);
            }

            l.reset(event);
        }
    }
667710
public static void fireSREChanged(PropertyChangeEvent event) {
		for (final Object listener : SRE_LISTENERS.getListeners()) {
			((ISREInstallChangedListener) listener).sreChanged(event);
		}
	}
728878
@Override
    public void removeProperty(Property property) {
        properties.remove(property);
        property.removePropertyChangeListener(this);
        buildModel();
    }
1258837
public void firePropertyChange(PropertyChangeEvent evt) {
		Object oldValue = evt.getOldValue();
		Object newValue = evt.getNewValue();
		if (ObjectUtils.nullSafeEquals(oldValue, newValue)) {
			return;
		}

		String propertyName = evt.getPropertyName();
		PropertyChangeSupport child = null;
		if (children != null) {
			if (children != null && propertyName != null) {
				child = (PropertyChangeSupport) children.get(propertyName);
			}
		}

		if (listeners != null) {
			Object[] listenerList = listeners.getListenerList();
			for (int i = 0; i <= listenerList.length - 2; i += 2) {
				if (listenerList[i] == PropertyChangeListener.class) {
					((PropertyChangeListener) listenerList[i + 1]).propertyChange(evt);
				}
			}
		}

		if (child != null) {
			child.firePropertyChange(evt);
		}
	}
1231559
public void propertyChange(PropertyChangeEvent evt)
    {
        if (MenuConstants.DATE.equalsIgnoreCase(evt.getPropertyName()))
            if (evt.getNewValue() instanceof java.util.Date)
                this.setDateTime((java.util.Date)evt.getNewValue(), true, DBConstants.SCREEN_MOVE);
    }
742256
public void resetProperty(T property)
    {
        String propertyName = getTranslator().getPropertyName(property);

        if (properties.resetToDefault(propertyName))
        {
            firePropertyReset(property);
        }
    }
378962
public void notifyPropertyResolved(Object base, Object property) {
        for (EvaluationListener listener : listeners) {
            try {
                listener.propertyResolved(this, base, property);
            } catch (Throwable t) {
                Util.handleThrowable(t);
                // Ignore - no option to log
            }
        }
    }
906437
function () {
		var properties = this.properties;
		_.forEach(properties, function (prop, name) {
			prop = this.getProperty(name);
			this.stopListening(prop, EVENT_CHANGE);
		}, this);
	}
452364
protected void setProperties(Properties properties) {
        Properties oldProperties = internalProperties;
        synchronized(this) {
            internalProperties = properties;
        }
        notifyPropertiesChanged(oldProperties);
    }
32794
@Override
	public synchronized void refresh() {
	
		IntervalProperty[] properties = getProperties();
		
		for(IntervalProperty p : properties ) {
			
			p.refresh();
		}
		
	}
319388
public void remove(String property) {
		uninstallListener(property);
		Object oldValue = get(property);
		properties.remove(property);
		firePropertyChange(property, oldValue, null);
	}
173675
void reset(long time,
             long latest,
             AlarmListener listener,
             Object context,
             long index)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(
        tc,
        "reset",
        new Object[] { new Long(time), new Long(latest), listener, context, new Long(index) });
    
    data = listener;
    this.time = time;
    this.latest = latest;
    this.context = context;
    this.index = index;
    //check if this alarm has a group listener
    groupListener = (listener instanceof GroupAlarmListener);
    //flag as not canceled 
    active = true;
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "reset");
  }
743537
@Override
    public void addProperty(Property property) {
        properties.add(property);
        property.addPropertyChangeListener(this);
        buildModel();
    }
323796
@Override
	public synchronized void setProperties(Map<Object, Object> properties)
	{
		if(this.properties == null)
			this.properties = new Properties();
		
		
		this.properties.putAll(properties);
	}
1348940
private void notifyListenersIfUninhibited(R oldValue, R newValue) {
        if (inhibited) {
            inhibitCount++;
            lastInhibitedValue = newValue;
        } else {
            lastInhibitedValue = newValue; // Just in case, even though not really necessary
            lastNonInhibitedValue = newValue;
            doNotifyListeners(oldValue, newValue);
        }
    }
441986
public void notifyResetFlowProperties() 
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "notifyResetFlowProperties");
 
    pendingFlowReset = true;
  
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "notifyResetFlowProperties"); 
  }
1026105
function(value) {

		var property_container = this._value_container.getValue();

		if (property_container) {

			if (this._property_changed_listener) {

				Lava.suspendListener(this._property_changed_listener);
				property_container.set(this._property_name, value);
				Lava.resumeListener(this._property_changed_listener);

			} else if (this._enumerable_changed_listener) {

				Lava.suspendListener(this._enumerable_changed_listener);
				property_container.replaceAt(+this._property_name, value);
				Lava.resumeListener(this._enumerable_changed_listener);

			} else if (property_container.isProperties) {

				property_container.set(this._property_name, value);

			} else {

				property_container[this._property_name] = value;

			}

			this._queueForRefresh();

		}

	}