小编Hei*_*nzi的帖子

我是git的新手,刚刚发现了"git bisect".当您使用新编写的单元测试(事先没有)检查错误时,通常如何使用？

假设我们有一个包含单元测试的存储库,但是 - 经常 - 它们并不完整.在某些版本中,我们发现某个功能无效,但我们知道它之前的某个版本.不幸的是,单元测试未检查该功能.我现在想做的是:

1. 编写测试用例(当然首先失败)
2. 使用此测试用例,使用git bisect查找引入错误的提交
3. 更正错误并提交修复程序(和测试用例)

这个用例有一个问题.由于git bisect检出旧版本,刚插入的测试用例不会出现,所以我不能用它来检查错误.我可以尝试不提交测试,但要将其保持为本地更改.但想象测试文件在某些​​版本之间发生了变化,我可能会遇到合并冲突.

那么该怎么办？git bisect一般是如何使用的？

在我的scala代码中,我使用的是一个java库,它定义了一个名为"val"的公共属性的对象:

public class XYZ {
    public int val=...
}

有没有办法在scala中获取此属性？

我正在使用CMake进行项目,并使用googletest进行测试用例.通过浏览互联网,将googletest源复制到存储库的子文件夹并将其包含在"add_subdirectory(googletest)"中似乎是一种常见做法.我做到了

现在我正在使用CPack为我的项目生成debian包.不幸的是,CPack生成的软件包与我的项目一起安装了googletest.这当然不是我想要的.

在googletest目录中,我在那里找到了一些INSTALL cmake命令,所以很明显,为什么会这样.现在的问题是 - 我该如何避免呢？我不喜欢从googletest修改CMakeLists.txt文件,因为我必须记住在更新时重新应用我的修改.是否有另一种方法可以在CPack中禁用这些安装？

我正在为一个项目（https://www.cryfs.org）编写自制程序。由于它是一个文件系统，它依赖于 osxfuse，不幸的是它只能作为一个桶提供。也就是说，公式应该将木桶作为依赖项。

我尝试了以下

depends_on :cask => "osxfuse"

但我收到了错误信息

Unsupported special dependency :cask

将桶作为依赖项添加到公式的语法是什么？

此代码在 MSVC 上编译失败，因为static_assert失败：

template<class MyType>
struct Test {
    static_assert(MyType(5) != MyType(6), "fails");
};

请参阅： https: //godbolt.org/z/vUSMHu

任何想法 MSVC 如何在不知道 MyType 是什么的情况下评估它？

更晦涩的是：

template<class MyType>
struct Test {
    static_assert(MyType(5) == MyType(6), "succeeds");
    static_assert(!(MyType(5) == MyType(6)), "fails");
};

参见： https: //godbolt.org/z/3631tu

实例化它（即给 MyType 一个类型）也没有帮助：

template<class MyType>
struct Test {
    static_assert(MyType(5) != MyType(6), "still fails");
};
Test<int> variable;

请参阅： https: //godbolt.org/z/yxF4h0

或者更复杂一点： https: //godbolt.org/z/68g6yO

我想构建一个哈希图，其中键是引用。我希望这些引用的相等意味着引用相等，即两个引用借用同一个对象。

use std::collections::hash_map::HashMap;

struct SomeKey();
struct SomeValue();

fn main() {
    let m = HashMap::<&SomeKey, SomeValue>::new();
    
    let t = SomeKey();
    m.get(&t);
}

不幸的是，这失败了，编译器告诉我&SomeKey没有实现Hash/ Eq。

error[E0599]: the method `get` exists for struct `HashMap<&SomeKey, SomeValue>`, but its trait bounds were not satisfied
  --> src/main.rs:10:7
   |
10 |     m.get(&t);
   |       ^^^ method cannot be called on `HashMap<&SomeKey, SomeValue>` due to unsatisfied trait bounds
   |
   = note: the following trait bounds were not satisfied:
           `&SomeKey: Eq`
           `&SomeKey: Hash`

（操场）

我注意到，如果我实现 …

tldr;> 给定一个接受通用回调参数并返回关联类型的特征函数，编译器会抱怨关联类型可能从回调函数借用参数。有没有办法告诉编译器事实并非如此？

详细信息：我计划实现一个接受回调参数的特征函数，并希望强制该特征函数的实现实际调用该回调。我通过让回调返回一个只能通过调用此回调来构造的类型，并强制特征函数返回该类型来实现此目的。

/// If this type is used as a generic argument in a trait function and that trait function
/// returns `CallbackResult`, then that enforces that any implementation of that
/// trait function must call the callback.
pub trait Callback<T> {
    type CallbackResult;

    fn call(self, v: T) -> Self::CallbackResult;
}

有关如何使用它的示例：

trait MyTrait {
  fn func<C>(&self, callback: C) -> C::CallbackResult
  where
    C: Callback<i32>;
}

struct MyStruct {}
impl MyTrait for MyStruct {
  fn func<C>(&self, callback: C) -> C::CallbackResult …

对于MySQL连接我有一个连接对象,并使用一个交易机制connection.startTransaction(),connection.commitTransaction(),connection.rollbackTransaction().

对于每一个startTransaction(),必须始终有要么打电话commitTransaction()或到rollbackTransaction().错过这样的电话或同时打电话都会破坏我的交易系统.

所以我用以下方式使用它们:

boolean i_am_in_a_transaction=true;
try {
    connection.startTransaction();
    ...
    i_am_in_a_transaction=false;
    connection.commitTransaction();
} finally {
    if(i_am_in_a_transaction) {
        connection.rollbackTransaction();
    }
}

这确保了声明的调用顺序,但这是很费力的,因为我必须在我使用事务的地方写这些行.

在C++中,我将使用一个事务对象来检查它的析构函数,如果commit()函数被调用,否则调用rollback():

class Transaction {
    public:
        Transaction()
            :am_in_transaction(false) {
        }

        ~Transaction() {
            if(_am_in_transaction) {
                rollback();
            }
        }

        void startTransaction() {
            _am_in_transaction=true;
            ...start Transaction...
        }

        void commit() {
            _am_in_transaction=false;
            ...commit Transaction...
        }

        void rollback() {
            _am_in_transaction=false;
            ...rollback Transaction...
        }

    private:
        bool _am_in_transaction;
}

这样我就可以在一个地方实现逻辑,并且可以非常简单地使用它:

Transaction my_transaction; …

当我在squeryl中创建一个查询时,它返回一个Query [T]对象.查询尚未执行,并且当我遍历Query对象时(Query [T]扩展Iterable [T]).

在执行查询时,必须有一个事务{}或一个inTransaction {}块.

我只是谈论SELECT查询而不需要交易,但是squeryl框架需要它们.

我想在我的应用程序模型中创建一个查询,并将其直接传递给视图,其中模板中的视图助手迭代它并呈现数据.这只有在将事务{}块放在控制器中时才有可能(控制器包含模板的调用,因此进行迭代的模板也在内部).将事务{}块放在模型中是不可能的,因为模型并不真正执行查询.

但据我了解,交易与控制器无关.这是模型的决定,使用哪个数据库框架,如何使用它以及在何处使用事务.所以我希望transaction {}块在模型中.

我知道我可以 - 而不是返回Query [T]实例 - 在此Query [T]对象上调用Iterable [T] .toList,然后返回创建的列表.然后整个查询在模型中执行,一切都很好.但我不喜欢这种方法,因为数据库中请求的所有数据都必须缓存在此列表中.我更喜欢这种数据直接传递给视图的方式.我喜欢在结果集很大的时候流式传输结果集的MySql功能.

有可能吗？也许类似函数Query [T] .executeNow()将请求发送到数据库,能够关闭事务,但仍然使用MySQL流功能并接收剩余的(选定的,因此固定的)结果集它被访问了吗？因为结果集在查询时刻是固定的,所以关闭事务应该不是问题.

使用scala 2.10.3,我的目标是做以下工作:

object A {
  implicit class Imp(i: Int) {
    def myPrint() {
      println(i)
    }
  }
}

object B {
  implicit class Imp(i: String) {
    def myPrint() {
      println(i)
    }
  }
}

import A._
import B._

object MyApp extends App {
  3.myPrint()
}

这失败了

value myPrint is not a member of Int

如果我给A.Imp和B.Imp赋予不同的名称(例如A.Imp1和B.Imp2),它就可以了.

更深入地潜入它,隐式转换似乎存在同样的问题.

这有效:

object A {
  implicit def Imp(i: Int) = new {
    def myPrint() {
      println(i)
    }
  }

  implicit def Imp(i: String) = new {
    def myPrint() …