/// <summary> /// Does a address match a address pattern /// </summary> /// <param name="addressPattern">address pattern (may include wildcards and lists)</param> /// <param name="address">literal address</param> /// <returns>true if the addess matches the pattern</returns> public static bool IsMatch(string addressPattern, string address) { if (IsValidAddressLiteral(address) == false) { return(false); } // are they both literals if (IsValidAddressLiteral(addressPattern) == true) { // preform a string match return(addressPattern.Equals(address)); } if (IsValidAddressPattern(addressPattern) == false) { return(false); } // create a new pattern for the match OscAddress pattern = new OscAddress(addressPattern); // return the result return(pattern.Match(address)); }
/// <summary> /// Detach an event listener /// </summary> /// <param name="address">the address of the container</param> /// <param name="event">the event to remove</param> public void Detach(string address, OscMessageEvent @event) { if (@event == null) { throw new ArgumentNullException("event"); } if (OscAddress.IsValidAddressLiteral(address) == true) { OscLiteralEvent container; lock (m_Lock) { if (m_LiteralAddresses.TryGetValue(address, out container) == false) { // no container was found so abort return; } } // unregiser the event container.Event -= @event; // if the container is now empty remove it from the lookup if (container.IsNull == true) { m_LiteralAddresses.Remove(container.Address); } } else if (OscAddress.IsValidAddressPattern(address) == true) { OscPatternEvent container; OscAddress oscAddress = new OscAddress(address); lock (m_Lock) { if (m_PatternAddresses.TryGetValue(oscAddress, out container) == false) { // no container was found so abort return; } } // unregiser the event container.Event -= @event; // if the container is now empty remove it from the lookup if (container.IsNull == true) { m_PatternAddresses.Remove(container.Address); } } else { throw new ArgumentException(String.Format(Strings.Container_IsValidContainerAddress, address), "address"); } }
/// <summary> /// Attach an event listener on to the given address /// </summary> /// <param name="address">the address of the contianer</param> /// <param name="event">the event to attach</param> public void Attach(string address, OscMessageEvent @event) { if (@event == null) { throw new ArgumentNullException("event"); } // if the address is a literal then add it to the literal lookup if (OscAddress.IsValidAddressLiteral(address) == true) { OscLiteralEvent container; lock (m_Lock) { if (m_LiteralAddresses.TryGetValue(address, out container) == false) { // no container was found so create one container = new OscLiteralEvent(address); // add it to the lookup m_LiteralAddresses.Add(address, container); } } // attach the event container.Event += @event; } // if the address is a pattern add it to the pattern lookup else if (OscAddress.IsValidAddressPattern(address) == true) { OscPatternEvent container; OscAddress oscAddress = new OscAddress(address); lock (m_Lock) { if (m_PatternAddresses.TryGetValue(oscAddress, out container) == false) { // no container was found so create one container = new OscPatternEvent(oscAddress); // add it to the lookup m_PatternAddresses.Add(oscAddress, container); } } // attach the event container.Event += @event; } else { throw new ArgumentException(String.Format(Strings.Container_IsValidContainerAddress, address), "address"); } }
/// <summary> /// Match this address against another /// </summary> /// <param name="address">the address to match against</param> /// <returns>true if the addresses match, otherwise false</returns> public bool Match(OscAddress address) { // if both addresses are literals then we can match on original string if (m_Type == OscAddressType.Literal && address.m_Type == OscAddressType.Literal) { return(m_OrigialString.Equals(address.m_OrigialString)); } // if this address is a literal then use the others regex else if (m_Type == OscAddressType.Literal) { return(address.m_Regex.IsMatch(m_OrigialString)); } // if the other is a literal use this ones regex else if (address.m_Type == OscAddressType.Literal) { return(m_Regex.IsMatch(address.m_OrigialString)); } // if both are patterns then we just match on pattern original strings else { return(m_OrigialString.Equals(address.m_OrigialString)); } }
/// <summary> /// Invoke any event that matches the address on the message /// </summary> /// <param name="message">the message argument</param> /// <returns>true if there was a listener to invoke otherwise false</returns> public bool Invoke(OscMessage message) { bool invoked = false; OscAddress oscAddress = null; List <OscLiteralEvent> shouldInvoke = new List <OscLiteralEvent>(); List <OscPatternEvent> shouldInvoke_Filter = new List <OscPatternEvent>(); do { lock (m_Lock) { if (OscAddress.IsValidAddressLiteral(message.Address) == true) { OscLiteralEvent container; if (m_LiteralAddresses.TryGetValue(message.Address, out container) == true) { //container.Invoke(message); shouldInvoke.Add(container); invoked = true; } } else { oscAddress = new OscAddress(message.Address); foreach (KeyValuePair <string, OscLiteralEvent> value in m_LiteralAddresses) { if (oscAddress.Match(value.Key) == true) { //value.Value.Invoke(message); shouldInvoke.Add(value.Value); invoked = true; } } } if (m_PatternAddresses.Count > 0) { if (oscAddress == null) { oscAddress = new OscAddress(message.Address); } foreach (KeyValuePair <OscAddress, OscPatternEvent> value in m_PatternAddresses) { if (oscAddress.Match(value.Key) == true) { //value.Value.Invoke(message); shouldInvoke_Filter.Add(value.Value); invoked = true; } } } } }while (invoked == false && OnUnknownAddress(message.Address) == true); foreach (OscLiteralEvent @event in shouldInvoke) { @event.Invoke(message); } foreach (OscPatternEvent @event in shouldInvoke_Filter) { @event.Invoke(message); } return(invoked); }