func (wrappedCachedObject *LeakDetectionWrapperImpl) RTransaction(callback func(object StorableObject), identifiers ...interface{}) CachedObject {
	wrappedCachedObject.CachedObjectImpl.RTransaction(callback, identifiers...)
	return wrappedCachedObject
}
RTransaction is a synchronization primitive that executes the callback together with other RTransactions but never
together with a normal Transaction.

The identifiers allow to define the scope of the RTransaction. RTransactions with different scopes can run at the
same time independently of other RTransactions and act as if they are secured by different mutexes.

It is also possible to provide multiple identifiers and the callback waits until all of them can be acquired at the
same time. In contrast to normal mutexes where acquiring multiple locks can lead to deadlocks, this method is
deadlock safe.

Note: It is the equivalent of a mutex.RLock/RUnlock.
package objectstorage
import (
	"fmt"
	"os"
	"strconv"
	"sync"
	"sync/atomic"
	"time"
	"github.com/iotaledger/hive.go/typeutils"
	"github.com/iotaledger/hive.go/platform"
	"github.com/iotaledger/hive.go/reflect"
)
type LeakDetectionWrapper interface {
	CachedObject
	Base() *CachedObjectImpl
	GetInternalId() int64
	SetRetainCallStack(callStack *reflect.CallStack)
	GetRetainCallStack() *reflect.CallStack
	GetRetainTime() time.Time
	SetReleaseCallStack(callStack *reflect.CallStack)
	GetReleaseCallStack() *reflect.CallStack
	WasReleased() bool
}
type LeakDetectionWrapperImpl struct {
	*CachedObjectImpl
	internalId       int64
	retainTime       time.Time
	released         int32
	retainCallStack  *reflect.CallStack
	releaseCallStack *reflect.CallStack
}
func (wrappedCachedObject *LeakDetectionWrapperImpl) Transaction(callback func(object StorableObject), identifiers ...interface{}) CachedObject {
	wrappedCachedObject.CachedObjectImpl.Transaction(callback, identifiers...)
	return wrappedCachedObject
}