我正在尝试构建一些C代码,使得.c文件和私有.h文件定义了一个相当复杂的结构,但是面向公众的头文件只需要指向该结构类型的指针.我试过的是这个:

publicRadio.h

typedef struct _radio Radio;
void radioReceive(Radio *radio, ....);

privateRadio.h

#include <publicRadio.h>
struct _radio {
    ...
    ...
}

radio.c

#include <publicRadio.h>
#include <privateRadio.h>

void radioReceive(Radio *radio, ....)
{
    ...
}

当我尝试编译它时,我会得到类似的东西

radio.c:91:9: error: parameter 'radio' has just a forward declaration
radio.c:90:6: error: conflicting types for 'radioReceive'
publicRadio.h:29:6: note: previous declaration of 'radioReceive' was here

我试图模仿我在其他具有公共面向API的库中看到的模式,这些API通过函数公开它们的结构,但是隐藏了血腥的细节.用来实现这一目的的食谱是什么？

我想我要么 a) 对 FreeRTOS taskGetTickCount() 函数的工作方式有误解，要么 b) 我们的端口不太正确。

我进行了一些调试，其中显示了 xTaskGetCount() 的输出。每当我执行 vTaskDelayUntil() 时，它似乎都会更新并且是最新的。但如果我进行旋转等待，等待它增加，它永远不会增加。我认为中断会触发并增加该值。但我现在只运行一项任务，所以也许它足够聪明，从不检查重新安排并且tickCount永远不会更新？如果有人能够让我了解 FreeRTOS 滴答计数的工作原理，我将不胜感激。

编辑：示例片段：

void someTask(void * _)
{
    portTickType now = xTaskGetTickCount();
    for( ; xTaskGetTickCount() - now < 25; )
    {
        debug("%u", xTaskGetTickCount();
    }
} 

这将永远旋转，远远超过当刻度 = 1 毫秒时暗示的 25 毫秒。输出将不断地一遍又一遍地列出相同的值。如果我将 vTaskDelay() 添加到循环的底部，它将健康地增加，并最终退出。

我有一些字节数据想要被解析为流,因为序列中较早的字节控制下游字节的解释.所以BytesIO看起来像我想要的东西.但我也想使用struct模块提供的功能.但是struct的接口不是流式的.是否有一种聪明/惯用的方式来嫁给这两个人？

举例来说,这是一个示例数据块:

b'\n\x00\x02\x90\x10\x00\n\x00\x02`\x10\x00\n\x00\x02\x80\x10\x00'

我想将前4个字节拉为无符号大端int(例如struct.unpack(fmt='>I').因为下一个字节是0x10,我知道应该再多一个字节,结果是0x00.然后重新开始,读取下一个4(0x0A000290),清洗,冲洗,重复.紧接在每个4字节id之后的字节触发各种下游读取(一些字节,一些短路).

我可以做的事情

stream = b'\n\x00\x02\x90\x10\x00\n\x00\x02`\x10\x00\n\x00\x02\x80\x10\x00'
while stream:
    id = struct.unpack('>I', stream[:4])
    stream = stream[4:]
    ...

但这似乎不够优雅.

我正在组建一个NLP实验,其中概念是系统中的代理,旨在产生由新概念组成的Emergent属性(这里是那些不知道Emergence是什么的链接).Smalltalk(特别是Pharo方言)似乎是这种应用程序的理想选择,因为我可以轻松地创建完全封装的概念对象,这些对象彼此相关,作为独立代理,而SmallTalk允许我检查系统正在运行的状态.

我担心的是,如果存在太多对象并且所有对象都相互发送消息,系统是否会开始阻塞.从理论上讲,我的实现可以产生数百万个概念对象,如果系统无法处理那么大的东西,我不想把时间花在SmallTalk上.

1. 有关SmallTalk图像中活动对象数量的限制因素(软件因素,而不是硬件)吗？

2. 系统能否处理具有数百万个chatty对象的系统中存在的消息流量？

预先感谢您的帮助!

随后AFNetworking我遵循了创建特定于应用程序的子类的建议模式AFHTTPSessionManager.我看起来像这样:

static NSString* Username = @"";
static NSString* Password = @"";
static NSString* BaseURL = @"https://abc.xyz.com:12345/";

@implementation HttpConnection

+ (HttpConnection*) current {
    static HttpConnection* current = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        current = [[self alloc] initWithBaseURL: [NSURL URLWithString: BaseURL]];
        current.securityPolicy.allowInvalidCertificates = YES;
        current.responseSerializer = [AFJSONResponseSerializer serializer];
        current.requestSerializer = [AFJSONRequestSerializer serializer];
    });
    [current.requestSerializer setAuthorizationHeaderFieldWithUsername: Username password: Password];
    return current;
}

我很好奇我应该如何翻译这个模式Alamofire.它只是如下吗？

static let BaseURL = "https://abc.xyz.com:12345/"
static var User = ""
static var Password …

尝试使用扩展程序,但是在使用以下内容时遇到问题:

let value = -13
abs(value)

extension Int {
    var abs:Int {
        return abs(self) // -> Cannot invoke 'abs' with an argument list of type '(Int)'
    }
}

value.abs

编译错误很奇怪,因为它可以abs()用Int一个参数直接运行上面的函数.我猜我还有一些灯泡可以触发仿制药.开导我.

受此示例的启发，我CALayer为楔形和圆弧创建了一个自定义子类。请允许我绘制弧形和楔形并为它们中的变化设置动画，以便它们径向扫描。

对它们的挫败之一是，显然，当您走这种拥有子类的途径时，drawInContext()您会受到图层框架的剪辑的限制。对于库存图层，masksToBounds默认情况下具有false！但是，一旦您继承了带有绘画的子类路线，那是因为隐式且不可更改true。

因此，我想我将尝试通过子类化CAShapeLayer来尝试另一种方法。而不是添加一个自定义drawInContext()，我只需为接收器添加变量start并sweep更新path。效果很好，但不再像过去那样动画：

import UIKit

class WedgeLayer:CAShapeLayer {
    var start:Angle = 0.0.rotations { didSet { self.updatePath() }}
    var sweep:Angle = 1.0.rotations  { didSet { self.updatePath() }}
    dynamic var startRadians:CGFloat { get {return self.start.radians.raw } set {self.start = newValue.radians}}
    dynamic var sweepRadians:CGFloat { get {return self.sweep.radians.raw } set {self.sweep = newValue.radians}}

    // more dynamic unit variants omitted
    // we …

BLE的GATT架构适用于小的固定数据(每个特性最多20个字节).但在某些情况下,您最终希望"流式传输"一些任意长度的数据,即大于20个字节.例如,固件升级,即使您知道它很慢.

我很好奇其他人使用过什么方案,以便在BLE特征上"流式传输"数据(即使是小而慢).

到目前为止,我使用了两种不同的方案:

一种是使用控制特性,其中接收设备通知发送设备已经接收了多少数据,然后发送设备使用它来触发对不同特征的下一次写入(我同时执行with_response和without_response).

我最近做的另一个方案是将数据基本上分成19个字节的段,其中第一个字节表示当它达到0时要跟随的数据包的数量,这表明接收器可以将所有最近的更新连接并处理为一个包.

我正在寻找的那种答案,概述了有经验的人如何实现这样做的体面模式.并且可以证明为什么他们所做的是最好的(或至少更好的)解决方案.

有几个类似的问题（例如我之前的 iOS10 变体），但我认为应该有一个针对 iOS 11 的最新答案，使用 Swift4，不使用私有 API，也不依赖于您将图标限制为 unicode 表情符号。

随着 API 向 iOS11 的发展，我们现在可以放置图像和文本，但它们被迫进入模板模式，并使用您设置的任何背景颜色反转颜色。例如

let rename = UIContextualAction(style: .normal, title: "Rename") { (_, view, _) in
    self.renameEntry(indexPath)
}
rename.backgroundColor = UIColor.black
rename.image = UIImage(named: "pencilEdit")
let locate = UIContextualAction(style: .normal, title: "Locate") { (_, view, _) in
    self.locateEntry(indexPath)
}
locate.backgroundColor = UIColor.blue
locate.image = UIImage(named: "locatePin")
let delete = UIContextualAction(style: .destructive, title: "Forget") { (_, view, _) in
    self.deleteEntry(indexPath)
}
delete.backgroundColor = UIColor.red
delete.image = UIImage(named: "triggerDeleteSelector") …

我正在做一些串行协议的东西,并希望在python中实现一个基本的字节填充算法.我正在努力确定什么是最pythonic方式来做到这一点.

字节填充基本上只是用一个由转义字节组成的对和用可逆方式转换的原始字节(例如xor'ed)替换任何"保留"字节.

到目前为止,我已经有了5种不同的方法,每种方法都有一些我不喜欢的方法:

1通过发电机

def stuff1(bits):
    for byte in bits:
        if byte in _EscapeCodes:
            yield PacketCode.Escape
            yield byte ^ 0xFF
        else:
            yield byte

这可能是我最喜欢的,但也许只是因为我对基于产量的发电机着迷.我担心发电机会让它变慢,但它实际上是第二快的.

2简单字节()

def stuff2(bits):
    result = bytes()
    for byte in bits:
        if byte in _EscapeCodes:
            result += bytes([PacketCode.Escape, byte ^ 0xFF])
        else:
            result += bytes([byte])
    return result

不断创建单个元素数组只是为了抛出它们,因为我不知道任何"带有一个额外元素的复制"操作.它与最慢的一群联系在一起.

3使用字节数组()

def stuff3(bits):
    result = bytearray()
    for byte in bits:
        if byte in _EscapeCodes:
            result.append(PacketCode.Escape)
            result.append(byte ^ 0xFF)
        else:
            result.append(byte)
    return result

似乎比直接bytes()方法更好.实际上比yield生成器慢,并且可以一次执行一个字节(而不是需要中间1个元素集合).但它感到野蛮.这是包装性能的中间部分.

4 BytesIO()

def stuff4(bits): …