Dart DocumentationbotAttachableObject

AttachableObject class

class AttachableObject extends DisposableImpl {
  final HashMap<Property, Object> _propertyValues =
      new HashMap<Property, Object>();

  final HashMap<Attachable, EventHandle> _eventHandlers =
      new HashMap<Attachable, EventHandle>();

  void disposeInternal(){
    super.disposeInternal();
    _eventHandlers.forEach((a, e) {
      e.dispose();
    });
    _eventHandlers.clear();
  }

  GlobalId _addHandler(Attachable property, Action1 watcher) {
    validateNotDisposed();
    var handle = _eventHandlers.putIfAbsent(property, () => new EventHandle());
    return handle.add(watcher);
  }

  bool _removeHandler(Attachable property, GlobalId handlerId){
    validateNotDisposed();
    requireArgumentNotNull(handlerId, 'handlerId');
    var handle = _eventHandlers[property];
    if(handle != null){
      return handle.remove(handlerId);
    }
    return false;
  }

  void _fireEvent(Attachable attachable, Dynamic args) {
    validateNotDisposed();
    var handle = _eventHandlers[attachable];
    if(handle != null){
      handle.fireEvent(args);
    }
  }

  void _set(Property key, Object value){
    validateNotDisposed();
    assert(!identical(value, Property.Undefined));
    _propertyValues[key] = value;
    _fireChange(key);
  }

  bool _isSet(Property key){
    validateNotDisposed();
    return _propertyValues.containsKey(key);
  }

  void _remove(Property key){
    validateNotDisposed();
    var exists = _isSet(key);
    if(exists){
      // NOTE: remove returns the removed item, which could be null. Bleh.
      // TODO: ponder null-ish value to avoid these double access scenarios? Maybe?
      _propertyValues.remove(key);
      _fireChange(key);
    }
  }

  Object _getValueOrUndefined(Property key, AttachableObject obj,
                              Func1<AttachableObject, Object> ifAbsent){
    validateNotDisposed();
    if(_isSet(key)){
      return _propertyValues[key];
    }
    else if(ifAbsent != null){
      var value = ifAbsent(obj);
      _set(key, value);
      return value;
    }
    else{
      return Property.Undefined;
    }
  }

  void _fireChange(Property key) {
    validateNotDisposed();
    var handle = _eventHandlers[key];
    if(handle != null){
      handle.fireEvent(key);
    }
  }
}

Extends

DisposableImpl > AttachableObject

Subclasses

PElement, Stage

Properties

final bool isDisposed #

inherited from DisposableImpl
bool get isDisposed => _disposed;

final Type runtimeType #

inherited from Object

A representation of the runtime type of the object.

external Type get runtimeType;

Operators

bool operator ==(other) #

inherited from Object

The equality operator.

The default behavior for all Objects is to return true if and only if this and other are the same object.

If a subclass overrides the equality operator it should override the hashCode method as well to maintain consistency.

bool operator ==(other) => identical(this, other);

Methods

void dispose() #

inherited from DisposableImpl
void dispose(){
  if (!_disposed) {
    // Set disposed_ to true first, in case during the chain of disposal this
    // gets disposed recursively.
    this._disposed = true;
    this.disposeInternal();
  }
}

void disposeInternal() #

Do not call this method directly. Call dispose instead. Subclasses should override this method to implement Disposable behavior.

docs inherited from DisposableImpl
void disposeInternal(){
  super.disposeInternal();
  _eventHandlers.forEach((a, e) {
    e.dispose();
  });
  _eventHandlers.clear();
}

int hashCode() #

inherited from Object

Get a hash code for this object.

All objects have hash codes. Hash codes are guaranteed to be the same for objects that are equal when compared using the equality operator ==. Other than that there are no guarantees about the hash codes. They will not be consistent between runs and there are no distribution guarantees.

If a subclass overrides hashCode it should override the equality operator as well to maintain consistency.

external int hashCode();

noSuchMethod(String name, List args) #

inherited from Object

noSuchMethod is invoked when users invoke a non-existant method on an object. The name of the method and the arguments of the invocation are passed to noSuchMethod. If noSuchMethod returns a value, that value becomes the result of the original invocation.

The default behavior of noSuchMethod is to throw a noSuchMethodError.

external Dynamic noSuchMethod(String name, List args);

const Object() #

inherited from Object

Creates a new Object instance.

Object instances have no meaningful state, and are only useful through their identity. An Object instance is equal to itself only.

const Object();

String toString() #

inherited from Object

Returns a string representation of this object.

external String toString();

void validateNotDisposed() #

inherited from DisposableImpl
void validateNotDisposed() {
  assert(!_disposed);
}