Esempio n. 1
0
        public static void Initialize(MixedValueWrapper *v)
        {
#if BLIT_VALUE && !GENERIC_BLIT_VALUE
#elif BLIT_VALUE && GENERIC_BLIT_VALUE
#else
            v->value = BlittableTypeWrapper.Create(default(MixedValue));
#endif
        }
Esempio n. 2
0
        public static void FreeFromContext(MixedValueWrapper *v)
        {
#if BLIT_VALUE
            MallocFixedPageSize <MixedValueWrapper> .PhysicalInstance.FreeAtEpoch((long)v);
#else
            ((BlittableTypeWrapper *)v)->Free <MixedValue>();
#endif
        }
Esempio n. 3
0
        public static void UpsertCompletionCallback(MixedKeyWrapper *key, MixedValueWrapper *value, MixedContextWrapper *ctx)
        {
            userFunctions.UpsertCompletionCallback(
                UserType.Convert(ctx));

            UserType.FreeFromContext(key);
            UserType.FreeFromContext(value);
            UserType.FreeFromContext(ctx);
        }
Esempio n. 4
0
        public static ref MixedValue Convert(MixedValueWrapper *v)
        {
#if BLIT_VALUE && !GENERIC_BLIT_VALUE
            return(ref v->value);
#elif BLIT_VALUE && GENERIC_BLIT_VALUE
            return(ref Unsafe.AsRef <MixedValue>(v));
#else
            return(ref ((BlittableTypeWrapper *)v)->GetObject <MixedValue>());
#endif
        }
Esempio n. 5
0
 public static void AcquireWriteLock(MixedValueWrapper *value)
 {
 }
Esempio n. 6
0
 public static void Copy(MixedValueWrapper *src, MixedValueWrapper *dst)
 {
     dst->value = src->value;
 }
Esempio n. 7
0
 public static int GetLength(MixedValueWrapper *input)
 {
     return(sizeof(MixedValueWrapper));
 }
Esempio n. 8
0
 public static void ConcurrentWriter(MixedKeyWrapper *key, MixedValueWrapper *src, MixedValueWrapper *dst)
 {
     MixedValueWrapper.AcquireWriteLock(dst);
     MixedValueWrapper.Copy(src, dst);
     MixedValueWrapper.ReleaseWriteLock(dst);
 }
Esempio n. 9
0
 public static void SingleWriter(MixedKeyWrapper *key, MixedValueWrapper *src, MixedValueWrapper *dst)
 {
     MixedValueWrapper.Copy(src, dst);
 }
Esempio n. 10
0
 public static void Free(MixedValueWrapper *key)
 {
     throw new InvalidOperationException();
 }
Esempio n. 11
0
        public static void CopyUpdater(MixedKeyWrapper *key, MixedInputWrapper *input, MixedValueWrapper *oldValue, MixedValueWrapper *newValue)
        {
            UserType.Initialize(newValue);

            userFunctions.CopyUpdater(
                UserType.Convert(key),
                UserType.Convert(input),
                UserType.Convert(oldValue),
                ref UserType.Convert(newValue));
        }
Esempio n. 12
0
        public static void InPlaceUpdater(MixedKeyWrapper *key, MixedInputWrapper *input, MixedValueWrapper *value)
        {
            MixedValueWrapper.AcquireWriteLock(value);

            userFunctions.InPlaceUpdater(
                UserType.Convert(key),
                UserType.Convert(input),
                ref UserType.Convert(value));

            MixedValueWrapper.ReleaseWriteLock(value);
        }
Esempio n. 13
0
        public static void InitialUpdater(MixedKeyWrapper *key, MixedInputWrapper *input, MixedValueWrapper *value)
        {
            UserType.Initialize(value);

            userFunctions.InitialUpdater(
                UserType.Convert(key),
                UserType.Convert(input),
                ref UserType.Convert(value));
        }
Esempio n. 14
0
 public static void Free(MixedValueWrapper *key)
 {
     throw new NotImplementedException();
 }
Esempio n. 15
0
 public static void Deserialize(MixedValueWrapper *key, Stream fromStream)
 {
     throw new NotImplementedException();
 }
Esempio n. 16
0
 public static void ReleaseWriteLock(MixedValueWrapper *value)
 {
 }
Esempio n. 17
0
 public static void Deserialize(MixedValueWrapper *key, Stream fromStream)
 {
     throw new InvalidOperationException();
 }
Esempio n. 18
0
 public static void SingleReader(MixedKeyWrapper *key, MixedInputWrapper *input, MixedValueWrapper *value, MixedOutputWrapper *dst)
 {
     userFunctions.Reader(
         UserType.Convert(key),
         UserType.Convert(input),
         UserType.Convert(value),
         ref UserType.Convert(dst));
 }
Esempio n. 19
0
 public static MixedValueWrapper *MoveToContext(MixedValueWrapper *value)
 {
     return(value);
 }
Esempio n. 20
0
        public static void ConcurrentReader(MixedKeyWrapper *key, MixedInputWrapper *input, MixedValueWrapper *value, MixedOutputWrapper *dst)
        {
            MixedValueWrapper.AcquireReadLock(value);

            userFunctions.Reader(
                UserType.Convert(key),
                UserType.Convert(input),
                UserType.Convert(value),
                ref UserType.Convert(dst));

            MixedValueWrapper.ReleaseReadLock(value);
        }