CoreOSC 软件包包含通用的基础设施代码，用于您的应用程序通过 OSC 在计算机、声音合成器和其他多媒体设备之间进行通信。

CoreOSC 基于 GNU Affero 通用公共许可证第 3 版获得许可。如果您需要商业许可证用于不想触发 AGPLv3 义务的应用程序（例如，开源您的应用程序），请联系我们。

地址的语法类似于 URL，并以字符 "/" 开头，后跟从树根到方法的路径上所有容器的名称（按顺序排列），容器名称之间用正斜杠字符分隔，最后是方法的名称。CoreOSC 中找到的所有类型的地址仅包含 ASCII 字符，如 OSC 1.0 中所规定。

地址模式是“OSC 服务器”托管的一个或多个方法的潜在目标地址。可以使用许多通配符，例如“*”，以允许单个地址模式调用多个方法。

let addressPattern = try? OSCAddressPattern("/core/osc/*")

如果格式不正确或在给定的 String 中找到无效字符，OSCAddressPattern 的初始化将 throw 异常。

可以使用以下方法评估 String，以验证它是否是有效的地址模式

let valid: Bool = OSCAddressPattern.evaluate("/core/osc/*")

地址是“OSC 服务器”托管的方法的路径。不允许使用通配符，因为此地址表示 OSCMesage 的端点以及消息为调用与其关联的方法而遍历的完整路径。

let address = try? OSCAddress("/core/osc/method")

如果格式不正确或在给定的 String 中找到无效字符，OSCAddress 的初始化将 throw 异常。

let valid: Bool = OSCAddress.evaluate("/core/osc/method")

OSCMessage 是一个数据包，由 OSCAddressPattern 组成，它将数据包定向到“OSC 服务器”托管的一个或多个方法，以及在调用方法时可以使用的参数。CoreOSC 实现了 OSC 1.1 中规定的所有必需的参数类型。

let addressPattern = try! OSCAddressPattern("/core/osc/*")
let message = OSCMessage(with: addressPattern,
                         arguments: [Int32(1),
                                     Float32(3.142),
                                     "Core OSC",
                                     OSCTimeTag.immediate,
                                     true,
                                     false,
                                     Data([0x01, 0x01]),
                                     OSCArgument.nil,
                                     OSCArgument.impulse])

使用原始地址模式 `String` 初始化

let message = try? OSCMessage(with: "/core/osc/*",
                              arguments: [Int32(1),
                                          Float32(3.142),
                                          "Core OSC",
                                          OSCTimeTag.immediate,
                                          true,
                                          false,
                                          Data([0x01, 0x01]),
                                          OSCArgument.nil,
                                          OSCArgument.impulse])

如果格式不正确或在给定的 String 地址模式中找到无效字符，OSCMessage 的初始化将 throw 异常。

OSCBundle 是消息的容器，也是其他捆绑包的容器，并允许原子性地调用多个消息，以及安排它们在未来的某个时间点被调用。有关捆绑包及其关联的 OSCTimeTag 的时间语义的更多信息，请参阅 OSC 1.0。

let message1 = try! OSCMessage(with: "/core/osc/1")
let message2 = try! OSCMessage(with: "/core/osc/2")
let message3 = try! OSCMessage(with: "/core/osc/3")
    
let bundle = OSCBundle([.message(message1), .message(message2), .message(message3)], 
                       timetag: .immediate)

OSCAddressSpace 是“OSC 服务器”托管的一组方法，可以被一个或多个 OSCMessage 调用。可以将其视为代码块的容器，当收到消息时，并且地址模式与方法的 OSCAddress 匹配时，可以调度这些代码块。

OSCMethod 是一个 struct，它封装了一个闭包和调用它所需的 OSCAddress。其想法是，如果您想在应用程序中向“OSC 客户端”提供控制功能，您将首先创建 OSCMethod，将它们添加到 OSCAddressSpace，并且当收到 OSCMessage 时，它将被传递到地址空间以潜在地调用它包含的方法。

let method = OSCMethod(with try! OSCAddress("object/coords"), invokedAction { [weak self] message, _ in
    guard message.arguments.count == 2,
          let x = message.argument[0] as? Float32, 
          let y = message.argument[1] as? Float32 else { return }
    print("Received /object/coords, x: \(x), y: \(y)"
    self?.object.x = x
    self?.object.y = y
})
    
var addressSpace = OSCAddressSpace(methods: [method])
    
let message = try! OSCMessage("object/coords", arguments: [Float32(3), Float32(5)])
addressSpace.invoke(with: message)
                                                     
print(object.x) // 3
print(object.y) // 5

以下对象不是 OSC 规范的组成部分，而是在观察 OSC 在实际应用中的实现后开发的，旨在为您集成它们提供帮助和功能。

OSC 注解是一个脚本，用于以人类可读的格式编写 OSCMessage，使您的用户能够通过键入快速创建 OSCMessage，并在日志中呈现它们。CoreOSC 中有两种可用的注解样式。强烈建议使用 OSCAnnotationStyle.spaces，而不是 OSCAnnotationStyle.equalsComma，因为它允许您在 OSCAddressPattern 中使用有效的“=”字符。

let annotation = "/core/osc 1 3.142 \"A string with spaces\" aString true false nil impulse"
let valid: Bool = OSCAnnotation.evaluate(annotation, style: .spaces)

let annotation = "/core/osc 1 3.142 \"a string with spaces\" aString true"
    
let message = OSCAnnotation.message(for: annotation, style: .spaces)

print(message) // CoreOSC.OSCMessage(addressPattern: CoreOSC.OSCAddressPattern(fullPath: "/core/osc", parts: ["core", "osc"], methodName: "osc"), arguments: [1, 3.142, "a string with spaces", "aString", true])

let message = try! OSCMessage(with: "/core/osc",
                              arguments: [Int32(1),
                                          Float32(3.142),
                                          "Core OSC",
                                          true,
                                          false,
                                          OSCArgument.nil,
                                          OSCArgument.impulse])
// Without argument type tags.
let annotation1 = OSCAnnotation.annotation(for: message,
                                           style: .spaces,
                                           type: false)
                                               
print(annotation1) // "/core/osc 1 3.142 "Core OSC" true false nil impulse"
    
// With argument type tags.
let annotation2 = OSCAnnotation.annotation(for: message,
                                           style: .spaces,
                                           type: true)
                                               
print(annotation2) // "/core/osc 1(i) 3.142(f) "Core OSC"(s) true(T) false(F) nil(N) impulse(I)"

OSCAddressFilter 有点像 OSCAddressSpace 的反面。地址空间允许地址模式调用多个预定义方法。地址过滤器允许使用“#”通配符并通过省略模式匹配中的部分，使单个方法被多个松散格式的地址模式调用。可以将地址过滤器视为代码块的容器，当收到消息时，并且地址模式与过滤器方法的 OSCFilterAddress 匹配时，可以调度这些代码块。

OSCFilterMethod 是一个 struct，它封装了一个闭包和调用它所需的 OSCFilterAddress。其想法是，如果您想在应用程序中向“OSC 客户端”提供控制功能，而无需为每个控制功能建立包含 OSCAddress 和方法的地址空间的开销，您将首先创建 OSCFilterMethod，将它们添加到 OSCAddressFilter，并且当收到 OSCMessage 时，它将被传递到地址过滤器以潜在地调用它包含的方法。

let method = OSCFilterMethod(with try! OSCAddress("cue/#/fired"), invokedAction { [weak self] message, _ in
    print("Received: \(message.addressPattern.fullPath)")
    self?.logs.append("Cue \(message.addressPattern.parts[1])")
})
    
var addressFilter = OSCAddressFilter(methods: [method])
    
let message1 = try! OSCMessage(with: "cue/1/fired")
addressFilter.invoke(with: message1)
    
let message2 = try! OSCMessage(with: "cue/2/fired")
addressFilter.invoke(with: message2)
    
let message3 = try OSCMessage(with: "cue/3/fired")
addressFilter.invoke(with: message3)
    
print(logs) // ["Cue 1", "Cue 2", "Cue 3"]

⚠️- OSCFilterAddress 使用“#”字符，之所以选择它，是因为它在 OSCAddressPattern 中无效。在任何情况下，您都不应尝试使用 OSCFilterAddress 作为其地址模式来创建 OSCMessage。

OSCRefractingAddress 可用于将 OSCAddressPattern“折射”到其他内容。此对象的中心思想是允许“OSC 服务器”充当路由器，从一个应用程序接收 OSCMessage 并将其路由到另一个应用程序，并对地址模式进行修改。通过使用“#”通配符（后缀为部分索引号，非 0 索引）来实现折射。在折射地址中使用通配符的地方，该部分将被给定地址模式中的部分替换。为了成功折射，后缀索引号必须相对于给定地址模式的部分数量有效。

let refractingAddress = try? OSCRefractingAddress("/core/#2/#4")
        
let addressPattern = try? OSCAddressPattern("/core/osc/refracting/test")
        
let refractedAddress: OSCAddressPattern = try? refractingAddress.refract(address: addressPattern)
        
print(refractedAddress!.fullPath) // "/core/osc/test"

可以使用以下方法评估 String，以验证它是否是有效的折射地址

let valid: Bool = OSCRefractingAddress.evaluate("/core/#2/#4")

⚠️- OSCRefractingAddress 使用“#”字符，之所以选择它，是因为它在 OSCAddressPattern 中无效。在任何情况下，您都不应尝试使用 OSCRefractingAddress 作为其地址模式来创建 OSCMessage。

CoreOSC

许可证

架构

地址

OSC 地址模式

OSC 地址

消息

使用 `OSCAddressPattern` 初始化

使用原始地址模式 `String` 初始化

捆绑包

地址空间

方法

扩展

注解

地址过滤器

过滤器方法

折射

待办事项

作者

CoreOSC

许可证

架构

地址

OSC 地址模式

OSC 地址

消息

使用 OSCAddressPattern 初始化

使用原始地址模式 String 初始化

捆绑包

地址空间

方法

扩展

注解

地址过滤器

过滤器方法

折射

待办事项

作者

使用 `OSCAddressPattern` 初始化

使用原始地址模式 `String` 初始化