小编Cou*_*per的帖子

在我的应用程序中,我想UIWindow在主UIWindow 上创建一个新的,我编写如下,但它不起作用.首先,我创建一个UIWindow作为主窗口,然后使其键和可见,然后创建一个新的UIWindow叠加,但没有任何反应.

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
    self.window = [[UIWindow alloc] initWithFrame:[[UIScreen mainScreen] bounds]];
    self.window.backgroundColor = [UIColor redColor];
    ViewController *vc = [[ViewController alloc]initWithNibName:@"ViewController" bundle:nil];
    self.window.rootViewController = vc;
    [self.window makeKeyAndVisible];
    UIWindow *window1 = [[UIWindow alloc] initWithFrame:CGRectMake(0, 0, 320, 320)];
    window1.backgroundColor = [UIColor redColor];
    window1.windowLevel = UIWindowLevelAlert;
    [window1 makeKeyAndVisible];
    return YES;
}

有人可以帮我解决这个问题：

“Tomcat 启动/停止时出现错误，返回代码：1 确保您已安装 Java JDK 或 JRE，并且所需端口可用。查看“/xampp/tomcat/logs”文件夹以获取更多信息。”

我已经安装了 Java JDK。谢谢

我想在一个Xcode项目中的两个单独的测试目标中有一个单元测试库的单个项目,该库在Mac OS X和iOS上执行单元测试.单元测试文件应共享.

这似乎是不可能的,或者不打算工作,或者以其他方式揭示一个错误:

虽然可以为每个iOS和Mac OS X运行完整的单元测试(通过命令产品 - >测试),但是通过单击装订线中的菱形来运行单独的测试方法是不可能的:

执行此操作时,Xcode会打开一个错误表,告诉:

运行目标My Mac 64位对您选择执行的测试无效.

请选择支持您要执行的测试的运行目标.

我想,问题似乎是在一个有两个目标的项目中,共享单元测试文件必须与iOS 和 Mac OS X测试目标相关联.也就是说,为iOS和MacOSX目标设置特定单元测试文件的"目标成员资格".

当将共享单元测试文件关联到一个目标时,从装订线中的菱形开始单独测试似乎只有效.

有没有人设法让这个工作？什么是替代解决方案？

我有一个有几个目标的项目.有一个与项目关联的xcconfig文件和几个与目标关联的xcconfig文件.

现在我想通过CocoaPods整合第三方库.$ pod installCocoaPods 之后搞砸了原始项目,因为它将自己的xcconfig文件Pds.xcconfig与原始项目的目标相关联.这完全忽略并覆盖与项目关联的原始xcconfig中定义的设置,并切换出与目标关联的原始xcconfig文件.因此,该项目最终搞砸了.

例如,Cocoapods在Pods.xcconfig其中定义了与每个目标相关联的以下内容:

GCC_PREPROCESSOR_DEFINITIONS = $(inherited) COCOAPODS=1

我为每个配置配置了不同的配置,例如配置文件osx.debug.xcconfig定义的Debug

GCC_PREPROCESSOR_DEFINITIONS = DEBUG=1 DEBUG_LOG=2 __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES=0

解决此类冲突的合理可行方法是什么？

编辑:

我在GitHub上搜索了CocoaPods问题列表.似乎存在大量与xcconfig文件相关的问题,其中一些问题已超过2年.他们被讨论,然后关闭,但是 - 正如我发生的那样 - 问题尚未解决.

恕我直言,这是一个基本问题和一个基本问题:有一个项目使用xcconfig文件.然后,想要通过CocoaPods包含第三方库.执行后pod install,项目搞砸了.

那么,这有什么用呢？

我正在尝试为现有的库项目创建POD规范.

在Xcode项目中,构建设置为不同的构建配置定义了不同的预处理器宏(例如:"Debug"和"Release")

例如:

对于"调试"配置:

GCC_PREPROCESSOR_DEFINITIONS = DEBUG=1 

对于"发布"配置:

GCC_PREPROCESSOR_DEFINITIONS = NDEBUG NS_BLOCK_ASSERTIONS

如何将这些设置映射到相应的POD规范？

例如:

spec.compiler_flags = '-DDEBUG=1'

和

spec.compiler_flags = '-DNDEBUG -DNS_BLOCK_ASSERTIONS'

不幸的是,官方文档通常更令人困惑和不清楚,而不是真正有用:

构建设置

构建设置

在该组中列出了与应该用于构建库的构建环境的配置相关的属性.

如果未在子规范中定义,则该组的属性将继承父级的值.

例子:

spec.compiler_flags =' - DOS_OBJECT_USE_OBJC = 0',' - Wno-format'

直观地说,我会做这样的事情:

configuration :Debug do
    spec.compiler_flags = '-DDEBUG=1'
end

configuration :Release do
    spec.compiler_flags = '-DNDEBUG -DNS_BLOCK_ASSERTIONS'
end

但是,这是在猜测.

在 Swift 中，类和结构的成员将被编译器生成的函数取消初始化（销毁）。

当不再有强引用时，对象将自动销毁。在最后一个强引用不再存在的任何线程上，该对象将在该线程上被销毁。这将销毁其所有结构成员，并可能销毁其成员对象，如果这也是最后一个强引用。

struct 类型的值将在其作用域停止退出后自动销毁。也就是说，无论发生这种情况的线程，该线程都会执行结构值的取消初始化。

我想知道这种取消初始化是否已受到保护以防止数据竞争。我的第一个猜测是，事实并非如此。但是，当它不是，怎么会一个插入时，由编译器生成这些成员变量的反初始化适当的同步原语和当有潜在的数据竞争？

我将用一个例子来说明这个问题：

public class Foo {
    private let _syncQueue = DispatchQueue(label: "sync-queue", attributes: .serial)

    private var _array: [String] = [] 

    init() {
    }

    deinit {
    }

    func add(_ s: String) {
        _syncQueue.async {
            self._array.append(s)
        }
    }

}

这只是一个类，其实例可以从任何线程使用，并且调用该add(_:)方法是线程安全的。因此，在任何情况下，类型对象的使用Foo都应该是线程安全的。是真的吗？

好吧，如果取消初始化不同步，那么它不是！

当有一个最后的强引用生活中的一个线索是不是在以前的访问已经取得了同一个线程的问题，实现其利用同步原语（例如派遣LIB）和森林论坛的主题恰好可以不通过一些与此其他线程同步其他不相关的操作。

我能够真正产生这些数据的比赛，然后在出现的deinit方法Foo。找到发生这种情况的某些使用场景实际上并不容易，更糟糕的是，它们并不总是发生在同一场景中（取决于 GCD 产生的当前线程）。但最终它发生了，在 Xcode 8 beta 中新的 Thread Sanitizer 的帮助下，我实际上检测到了这些。

但我仍然想知道，在当前的 Swift 语言中，这是否被视为“按预期运行”，或者这是否实际上是一个错误。

如果 Swift 将使用一些与任何线程同步并在值的取消初始化之前使用的全局栅栏，则情况会是后者，但对于某些错误和在某些情况下，它会意外地不被使用。

是否有"足够"可靠的方法来检测模板参数中的分配器.也就是说,我需要一些is_allocator类型特征,可用于enable_if:

假设有一个类模板future(带模板参数T):

    // Default ctor with allocator
    template <class Alloc, class... Args
        class Enable = typename std::enable_if<
            is_allocator<Alloc>::value
            and std::is_constructible<T, Args...>::value
        >::type
    >
    future(const Alloc& a, Args&&... args)
    : _shared_value(std::allocate_shared<T>(a, std::forward<T>(args...))
    {
    }



    // Default ctor (without allocator)
    template <class... Args
        class Enable = typename std::enable_if<
            std::is_constructible<T, Args...>::value
        >::type
    >
    future(Args&&... args)
    : _shared_value(std::make_shared<T>(std::forward<T>(args...))
    {
    }

在这里,_shared_value是一个std::shared_pointer<T>.

不允许使用别名模板的部分特化:

例如,尝试创造性,在clang中产生此错误:

template <typename T>
using unwrapped_future_t = T;

template <typename T>
using unwrapped_future_t<future<T>> = typename future<T>::value_type;
                        ^~~~~~~~~~~
> error: partial specialization of alias templates is not permitted

为什么不允许这样做？

假设，我们有一个 struct M：

public struct M<T> {
    let value: T
    public init(_ value: T) { self.value = value }

    public func map<U>(f: T -> U) -> M<U> { return M<U>(f(value)) }
    public func flatMap<U>(f: T -> M<U>) -> M<U> { return f(value) }
}

以及一些计算值 ( T) 并将其作为包装值返回的函数M：

func task1() -> M<Int> {
    return M(1)
}

func task2(value: Int = 2) -> M<Int> {
    return M(value)
}

func task3(value: Int = 3) -> M<Int> {
    return …

给出类中的以下代码：

cancellable = input
    .receive(on: scheduler)
    .map { ... }
    .sink(receiveValue: { value in
        self.state = value
    })

其中input是 PassthroughSubject。

现在，什么时候scheduler将从主线程调用主队列或 RunLoop.main AND 输入，是否以receive(on: scheduler)编程方式优化对主队列的显式分派？

所以，基本上是这样的：

 if Thread.isMainThread { 
    /* execute closure */
 } else { 
    /* dispatch closure async to main */
 }

的文档receive(on:)给出了一个模糊的提示，它可能会执行一些优化：

“优先使用 receive(on:options:) 而不是显式使用调度队列”

pub.sink {
    DispatchQueue.main.async {
        // Do something.
    }
}