在 Go 中包装一个指针

Question

库foo 公开了一个类型A，而该库中的一个函数Fn 返回一个*A。

我为A 定义了一个名为B 的“包装器”：

type B foo.A

我可以在不取消引用 A 的情况下将 *A 转换为 *B 吗？

换句话说，如果我有

a := foo.Fn()   // a is a *A
b := B(*a)
return &b

如何在不使用*a 的情况下将*a 转换为*b？

我问的原因是，在我正在使用的库中，github.com/coreos/bbolt，*DB 函数返回的 *DB 值包含一个 sync.Mutex，所以当我尝试制作一个Mutex 的副本。

更新说明我将如何使用它

我有一个

type Datastore struct {
    *bolt.DB
}

我也有这样的功能（其中之一）：

func (ds *Datastore) ReadOne(bucket, id string, data interface{}) error {
    return ds.View(func(tx *bolt.Tx) error {
        b, err := tx.CreateBucketIfNotExists([]byte(bucket))
        if err != nil {
            return fmt.Errorf("opening bucket %s: %v", bucket, err)
        }

        bytes := b.Get([]byte(id))
        if bytes == nil {
            return fmt.Errorf("id %s not found", id)
        }

        if err := json.Unmarshal(bytes, data); err != nil {
            return fmt.Errorf("unmarshalling item: %v", err)
        }

        return nil
    })
}

我想使用哈希映射来模拟底层的 BoltDB 数据库。我遇到了一个问题，因为 View 期待一个接受 bolt.Tx 的函数。然后使用tx 在CreateBucketIfNotExists 中创建一个新存储桶。我无法用调用我的哈希映射模拟版本CreateBucketIfNotExists 的参数替换该匿名函数参数。

我想出了这个：

package boltdb

import (
    "github.com/coreos/bbolt"
)

type (
    bucket bolt.Bucket

    // Bucket is a wrapper for bolt.Bucket to facilitate mocking.
    Bucket interface {
        ForEach(fn func([]byte, []byte) error) error
        Get(key []byte) []byte
        NextSequence() (uint64, error)
        Put(key, value []byte) error
    }

    db bolt.DB

    // DB is a wrapper for bolt.DB to facilitate mocking.
    DB interface {
        Close() error
        Update(fn func(*Tx) error) error
        View(fn func(*Tx) error) error
    }

    transaction bolt.Tx

    // Tx is a wrapper for bolt.Tx to facilitate mocking.
    Tx interface {
        CreateBucketIfNotExists(name []byte) (Bucket, error)
    }
)

// ForEach executes a function for each key/value pair in a bucket.
func (b *bucket) ForEach(fn func([]byte, []byte) error) error {
    return ((*bolt.Bucket)(b)).ForEach(fn)
}

// Get retrieves the value for a key in the bucket.
func (b *bucket) Get(key []byte) []byte {
    return ((*bolt.Bucket)(b)).Get(key)
}

// NextSequence returns an autoincrementing integer for the bucket.
func (b *bucket) NextSequence() (uint64, error) {
    return ((*bolt.Bucket)(b)).NextSequence()
}

// Put sets the value for a key in the bucket.
func (b *bucket) Put(key, value []byte) error {
    return ((*bolt.Bucket)(b)).Put(key, value)
}

// Close releases all database resources.
func (db *db) Close() error {
    return ((*bolt.DB)(db)).Close()
}

// Update executes a function within the context of a read-write managed transaction.
func (db *db) Update(fn func(Tx) error) error {
    return ((*bolt.DB)(db)).Update(func(tx *bolt.Tx) error {
        t := transaction(*tx)
        return fn(&t)
    })
}

// View executes a function within the context of a managed read-only transaction.
func (db *db) View(fn func(Tx) error) error {
    return ((*bolt.DB)(db)).View(func(tx *bolt.Tx) error {
        t := transaction(*tx)
        return fn(&t)
    })
}

// CreateBucketIfNotExists creates a new bucket if it doesn't already exist.
func (tx *transaction) CreateBucketIfNotExists(name []byte) (Bucket, error) {
    b, err := ((*bolt.Tx)(tx)).CreateBucketIfNotExists(name)
    if err != nil {
        return nil, err
    }
    w := bucket(*b)
    return &w, nil
}

到目前为止，在我的代码中，我只使用了上面显示的函数。如果新代码需要，我可以添加更多。

我将在实际代码中将每个bolt.DB 替换为DB，将bolt.Tx 替换为Tx，并将bolt.Bucket 替换为Bucket。 mocker 将对使用底层哈希映射而不是存储到磁盘的所有三种类型进行替换。然后我可以测试我的所有代码，一直到数据库调用。

Answer 1

您可以简单/直接地将*A 类型的值转换为*B 类型的值，您只需将*B 括起来即可：

a := foo.Fn()   // a is a *A
b := (*B)(a)
return b

你甚至可以转换函数调用的返回值：

return (*B)(foo.Fn())

在Go Playground 上试用。

这是可能的，因为Spec: Conversions:

在以下任何一种情况下，非常量值 x 都可以转换为类型 T：

• x 是 assignable 到 T。

• ...

还有Spec: Assignability:

如果以下条件之一适用，则值 x 可分配给 T 类型的 variable（“x 可分配给 T”）：

• ...

• x 的类型V 和T 具有相同的underlying types，并且V 或T 中的至少一个不是defined 类型。

*B 和 *A 类型均未定义，*B 的底层类型与 *A 的底层类型相同（即指向任何类型的底层类型的指针） A 的类型声明）。