/// <summary>
        /// Bury an element of an array of entities in Storage based on a NeoStorageKey (NPC Level 4)
        /// </summary>
        /// <param name="vau">vau</param>
        /// <param name="index">index</param>
        /// <returns>NeoCounter</returns>
        public static NeoCounter BuryElement(NeoVersionedAppUser vau, byte[] domain, byte[] bindex)
        {
            if (NeoVersionedAppUser.IsNull(vau)) // TODO - create NeoEntityModel.EntityState.BADKEY?
            {
                return(NeoCounter.Null());
            }

            Neo.SmartContract.Framework.Services.Neo.StorageContext ctx = Neo.SmartContract.Framework.Services.Neo.Storage.CurrentContext;
            NeoStorageKey nsk = NeoStorageKey.New(vau, domain, _bClassName);

            //byte[] bkey;
            NeoCounter e;

            byte[] bsta = Neo.SmartContract.Framework.Services.Neo.Storage.Get(ctx, NeoStorageKey.StorageKey(nsk, bindex, _bSTA));
            if (NeoTrace.RUNTIME)
            {
                TraceRuntime("Bury(vau,index).NeoCounter.bsta", bsta.Length, bsta);
            }
            if (bsta.Length == 0)
            {
                e = NeoCounter.Missing();
            }
            else // not MISSING - bury it
            {
                e = NeoCounter.Tombstone(); // TODO - should Bury() preserve the exist field values or re-initialize them? Preserve is cheaper but not as private
                Neo.SmartContract.Framework.Services.Neo.Storage.Put(ctx, NeoStorageKey.StorageKey(nsk, bindex, _bSTA), e._state.AsBigInteger());

                Neo.SmartContract.Framework.Services.Neo.Storage.Put(ctx, NeoStorageKey.StorageKey(nsk, bindex, _bCurrentNumber), e._currentNumber); // NPCLevel4EBuryElement_cs.txt
            } // Template: NPCLevel4Part2_cs.txt
            if (NeoTrace.RUNTIME)
            {
                LogExt("Bury(vau,i).NeoCounter", e);
            }
            return(e);
        }
        public static bool Put(NeoCounter e, string key)
        {
            if (key.Length == 0)
            {
                return(false);
            }
            if (NeoTrace.RUNTIME)
            {
                LogExt("Put(skey).NeoCounter", e);
            }

            Neo.SmartContract.Framework.Services.Neo.StorageContext ctx = Neo.SmartContract.Framework.Services.Neo.Storage.CurrentContext;
            string _skeyTag = key + _classKeyTag;

            if (NeoTrace.RUNTIME)
            {
                TraceRuntime("Put(skey)._skeyTag", _skeyTag);
            }

            e._state = NeoEntityModel.EntityState.PUTTED;
            BigInteger bis = e._state.AsBigInteger();

            if (NeoTrace.RUNTIME)
            {
                TraceRuntime("Put(skey).bis", bis);
            }
            Neo.SmartContract.Framework.Services.Neo.Storage.Put(ctx, _skeyTag + _sSTA, bis);
            Neo.SmartContract.Framework.Services.Neo.Storage.Put(ctx, _skeyTag + _sCurrentNumber, e._currentNumber); // Template: NPCLevel2EPut_cs.txt
            if (NeoTrace.RUNTIME)
            {
                LogExt("Put(skey).NeoCounter", e);                   // Template: NPCLevel2FGet_cs.txt
            }
            return(true);
        }
        public static NeoCounter Bury(string key)
        {
            if (key.Length == 0)
            {
                return(Null());
            }

            Neo.SmartContract.Framework.Services.Neo.StorageContext ctx = Neo.SmartContract.Framework.Services.Neo.Storage.CurrentContext;
            string _skeyTag = key + _classKeyTag;

            NeoCounter e;

            byte[] bsta = Neo.SmartContract.Framework.Services.Neo.Storage.Get(ctx, _skeyTag + _sSTA);
            if (NeoTrace.RUNTIME)
            {
                TraceRuntime("Bury(skey).NeoCounter.bsta", bsta.Length, bsta);
            }
            if (bsta.Length == 0)
            {
                e = NeoCounter.Missing();
            }
            else // not MISSING - bury it
            {
                e = NeoCounter.Tombstone(); // but don't overwrite existing field values - just tombstone it
                Neo.SmartContract.Framework.Services.Neo.Storage.Put(ctx, _skeyTag + _sSTA, e._state.AsBigInteger());

                //Neo.SmartContract.Framework.Services.Neo.Storage.Put(ctx, _skeyTag + _sCurrentNumber, e._currentNumber); // Template: NPCLevel3CBury_cs.txt
            } // Template: NPCLevel3Part2_cs.txt
            if (NeoTrace.RUNTIME)
            {
                LogExt("Bury(skey).NeoCounter", e);
            }
            return(e); // return Entity e to signal if key is Missing or bad key
        }
 // Factory methods // Template: NPCLevel1Part2_cs.txt
 private static NeoCounter _Initialize(NeoCounter e)
 {
     e._currentNumber = 0;
     e._state         = NeoEntityModel.EntityState.NULL;
     if (NeoTrace.RUNTIME)
     {
         LogExt("_Initialize(e).NeoCounter", e);
     }
     return(e);
 }
Esempio n. 5
0
        private static object[] PointGetAll(NeoVersionedAppUser AppVAU, object[] args)
        {
            object[] results = { -1 };

            byte[] encodedUsername = (byte[])args[0];
            if (NeoTrace.ARGSRESULTS)
            {
                NeoTrace.Trace("PointGetAll.encodedUsername", encodedUsername);
            }

            UserCredentials uc = FindUser(AppVAU, encodedUsername);

            if (UserCredentials.IsMissing(uc))
            {
                if (NeoTrace.INFO)
                {
                    UserCredentials.LogExt("PointGetAll.user missing", uc);
                }
            }
            else
            {
                if (NeoTrace.INFO)
                {
                    UserCredentials.LogExt("PointGetAll.user exists", uc);
                }
                BigInteger nPoints = NeoCounter.GetCurrentNextNumber(AppVAU, encodedUsername, NeoCounters.UserPointsCounter);
                if (NeoTrace.INFO)
                {
                    NeoTrace.Trace("PointGetAll.nPoints", nPoints);
                }

                UserPoint[] points = new UserPoint[(int)nPoints];
                for (int index = 0; index < nPoints; index++)
                {
                    if (NeoTrace.INFO)
                    {
                        NeoTrace.Trace("PointGetAll.index", index);
                    }
                    UserPoint up = UserPoint.GetElement(AppVAU, encodedUsername, (int)index);
                    if (NeoTrace.INFO)
                    {
                        UserPoint.LogExt("PointGetAll.up", up);
                    }
                    points[index] = up;
                }
                results = points;
            }

            if (NeoTrace.ARGSRESULTS)
            {
                NeoTrace.Trace("PointGetAll.results", results);
            }

            return(results);
        }
        public static NeoCounter Null()
        {
            NeoCounter e = new NeoCounter();

            _Initialize(e);
            if (NeoTrace.RUNTIME)
            {
                LogExt("Null().NeoCounter", e);
            }
            return(e);
        }
        public static NeoCounter New(BigInteger CurrentNumber)
        {
            NeoCounter e = new NeoCounter();

            e._currentNumber = CurrentNumber;
            e._state         = NeoEntityModel.EntityState.INIT;
            if (NeoTrace.RUNTIME)
            {
                LogExt("New(.,.).NeoCounter", e);
            }
            return(e);
        }
        public static NeoCounter Tombstone()
        {
            NeoCounter e = new NeoCounter();

            e._currentNumber = 0;
            e._state         = NeoEntityModel.EntityState.TOMBSTONED;
            if (NeoTrace.RUNTIME)
            {
                LogExt("Tombstone().NeoCounter", e);
            }
            return(e);
        }
        public static NeoCounter Missing()
        {
            NeoCounter e = new NeoCounter();

            e._currentNumber = 0;
            e._state         = NeoEntityModel.EntityState.MISSING;
            if (NeoTrace.RUNTIME)
            {
                LogExt("Missing().NeoCounter", e);
            }
            return(e);
        }
        public static BigInteger GetNextNumber(NeoVersionedAppUser vau, NeoCounters counter)
        {
            BigInteger result = -1;

            NeoCounter nc = NeoCounter.GetElement(vau, DOMAINAC, (int)counter); // Get persisted counter value

            if (!NeoCounter.IsMissing(nc))
            {
                result = NeoCounter.GetCurrentNumber(nc);
            }

            return(result); // Return the current value for this counter
        }
        // Use case example: domain = user script hash, counter = NeoCounters.UserPointsCounter
        // TakeNextNumber semantics: return the current number and then advance the counter ...like at the grocery store
        public static BigInteger TakeNextNumber(NeoVersionedAppUser vau, byte[] domain, NeoCounters counter)
        {
            NeoCounter nc = NeoCounter.GetElement(vau, domain, (int)counter); // Get persisted counter value

            if (NeoTrace.INFO)
            {
                NeoCounter.LogExt("TakeNextNumber", nc);
            }

            if (NeoCounter.IsMissing(nc)) // Create persist the new counter entity
            {
                if (NeoTrace.INFO)
                {
                    NeoCounter.LogExt("TakeNextNumber.domain and counter is missing", nc);
                }
                nc = NeoCounter.New(); // Create a new counter entity
                if (NeoTrace.INFO)
                {
                    NeoCounter.LogExt("TakeNextNumber.putnew", nc);
                }
                NeoCounter.PutElement(nc, vau, domain, (int)counter); // Persist the new counter entity with a value of zero
            }

            if (NeoTrace.INFO)
            {
                NeoCounter.LogExt("TakeNextNumber.exists", nc);
            }
            BigInteger currentNextNumber = NeoCounter.GetCurrentNumber(nc);

            if (NeoTrace.INFO)
            {
                NeoTraceRuntime.TraceRuntime("currentNextNumber", currentNextNumber);
            }
            BigInteger newNextNumber = currentNextNumber + 1;

            if (NeoTrace.INFO)
            {
                NeoTraceRuntime.TraceRuntime("nextNumber", newNextNumber);
            }
            NeoCounter.SetCurrentNumber(nc, newNextNumber);
            if (NeoTrace.INFO)
            {
                NeoCounter.LogExt("TakeNextNumber.putincr", nc);
            }
            NeoCounter.PutElement(nc, vau, domain, (int)counter); // Persist the new counter

            return(currentNextNumber);
        }
Esempio n. 12
0
        private static object[] PointDeleteLast(NeoVersionedAppUser AppVAU, object[] args)
        {
            object[] results = { -1 };

            if (NeoTrace.INFO)
            {
                NeoVersionedAppUser.LogExt("PointDeleteLast.AppVAU", AppVAU);
            }

            byte[] encodedUsername = (byte[])args[0];
            if (NeoTrace.ARGSRESULTS)
            {
                NeoTrace.Trace("PointDeleteLast.encodedUsername", encodedUsername);
            }

            UserCredentials uc = FindUser(AppVAU, encodedUsername);

            if (UserCredentials.IsMissing(uc))
            {
                if (NeoTrace.INFO)
                {
                    UserCredentials.LogExt("PointDeleteLast.user missing", uc);
                }
            }
            else
            {
                if (NeoTrace.INFO)
                {
                    UserCredentials.LogExt("PointDeleteLast.user exists", uc);
                }
                BigInteger nPoints = NeoCounter.GiveBackLastNumber(AppVAU, encodedUsername, NeoCounters.UserPointsCounter);
                if (NeoTrace.INFO)
                {
                    NeoTrace.Trace("PointDeleteLast.nPoints", nPoints);
                }

                results = new object[] { nPoints };
            }

            if (NeoTrace.ARGSRESULTS)
            {
                NeoTrace.Trace("PointDeleteLast.results", results);
            }

            return(results);
        }
        /// <summary>
        /// Get an element of an array of entities from Storage based on a NeoStorageKey (NPC Level 4)
        /// </summary>
        /// <param name="vau">vau</param>
        /// <param name="index">index</param>
        /// <returns>NeoCounter</returns>
        public static NeoCounter GetElement(NeoVersionedAppUser vau, byte[] domain, byte[] bindex)
        {
            if (NeoVersionedAppUser.IsNull(vau))
            {
                return(Null());
            }

            Neo.SmartContract.Framework.Services.Neo.StorageContext ctx = Neo.SmartContract.Framework.Services.Neo.Storage.CurrentContext;
            NeoStorageKey nsk = NeoStorageKey.New(vau, domain, _bClassName);

            NeoCounter e;

            //byte[] bkey;
            byte[] bsta = Neo.SmartContract.Framework.Services.Neo.Storage.Get(ctx, NeoStorageKey.StorageKey(nsk, bindex, _bSTA));
            if (NeoTrace.RUNTIME)
            {
                TraceRuntime("Get(bkey).NeoCounter.bsta", bsta.Length, bsta);
            }
            if (bsta.Length == 0)
            {
                e = NeoCounter.Missing();
            }
            else // not MISSING
            {
                int ista = (int)bsta.AsBigInteger();
                NeoEntityModel.EntityState sta = (NeoEntityModel.EntityState)ista;
                if (sta == NeoEntityModel.EntityState.TOMBSTONED)
                {
                    e = NeoCounter.Tombstone();
                }
                else // not MISSING && not TOMBSTONED
                {
                    e = new NeoCounter();
                    BigInteger CurrentNumber = Neo.SmartContract.Framework.Services.Neo.Storage.Get(ctx, NeoStorageKey.StorageKey(nsk, bindex, _bCurrentNumber)).AsBigInteger(); // Template: NPCLevel4CGetElement_cs.txt

                    e._currentNumber = CurrentNumber;                                                                                                                            // NPCLevel4DBuryElement_cs.txt
                    e._state         = sta;
                    e._state         = NeoEntityModel.EntityState.GETTED;                                                                                                        /* OVERRIDE */
                }
            }
            if (NeoTrace.RUNTIME)
            {
                LogExt("Get(bkey).NeoCounter.e", e);
            }
            return(e);
        }
        public static NeoCounter Get(string key)
        {
            if (key.Length == 0)
            {
                return(Null());
            }

            Neo.SmartContract.Framework.Services.Neo.StorageContext ctx = Neo.SmartContract.Framework.Services.Neo.Storage.CurrentContext;
            string _skeyTag = key + _classKeyTag;

            NeoCounter e;

            byte[] bsta = Neo.SmartContract.Framework.Services.Neo.Storage.Get(ctx, _skeyTag + _sSTA);
            if (NeoTrace.RUNTIME)
            {
                TraceRuntime("Get(skey).NeoCounter.bsta", bsta.Length, bsta);
            }
            if (bsta.Length == 0)
            {
                e = NeoCounter.Missing();
            }
            else // not MISSING
            {
                int ista = (int)bsta.AsBigInteger();
                NeoEntityModel.EntityState sta = (NeoEntityModel.EntityState)ista;
                e = new NeoCounter();

                BigInteger CurrentNumber = Neo.SmartContract.Framework.Services.Neo.Storage.Get(ctx, _skeyTag + _sCurrentNumber).AsBigInteger(); //NPCLevel2IGet_cs.txt
                if (NeoTrace.RUNTIME)
                {
                    TraceRuntime("Get(skey).e._currentNumber", e._currentNumber);                   // Template: NPCLevel2Part2_cs.txt
                }
                e._currentNumber = CurrentNumber;
                e._state         = sta;
                e._state         = NeoEntityModel.EntityState.GETTED; /* OVERRIDE */
            }
            if (NeoTrace.RUNTIME)
            {
                LogExt("Get(skey).NeoCounter", e);
            }
            return(e);
        }
        public static bool Put(NeoCounter e, byte[] key)
        {
            if (key.Length == 0)
            {
                return(false);
            }

            Neo.SmartContract.Framework.Services.Neo.StorageContext ctx = Neo.SmartContract.Framework.Services.Neo.Storage.CurrentContext;
            byte[] _bkeyTag = Helper.Concat(key, _bclassKeyTag);

            e._state = NeoEntityModel.EntityState.PUTTED;
            Neo.SmartContract.Framework.Services.Neo.Storage.Put(ctx, Helper.Concat(_bkeyTag, _bSTA), e._state.AsBigInteger());

            Neo.SmartContract.Framework.Services.Neo.Storage.Put(ctx, Helper.Concat(_bkeyTag, _bCurrentNumber), e._currentNumber); // Template: NPCLevel2CPut_cs.txt
            if (NeoTrace.RUNTIME)
            {
                LogExt("Put(bkey).NeoCounter", e);                   // Template: NPCLevel2DPut_cs.txt
            }
            return(true);
        }
        public static BigInteger TakeNextNumber(NeoVersionedAppUser vau, NeoCounters counter)
        {
            NeoCounter nc = NeoCounter.GetElement(vau, DOMAINAC, (int)counter); // Get persisted counter value

            if (NeoTrace.INFO)
            {
                NeoCounter.LogExt("TakeNextNumber", nc);
            }

            if (NeoCounter.IsMissing(nc))
            {
                nc = NeoCounter.New(); // Create a new counter value
                if (NeoTrace.INFO)
                {
                    NeoCounter.LogExt("TakeNextNumber.putnew", nc);
                }
                NeoCounter.PutElement(nc, vau, DOMAINAC, (int)counter); // Persist the new counter
            }
            else // Get and increment counter value by 1
            {
                BigInteger newNumber = NeoCounter.GetCurrentNumber(nc);
                if (NeoTrace.INFO)
                {
                    NeoTraceRuntime.TraceRuntime("newNumber", newNumber);
                }
                newNumber = newNumber + 1;
                if (NeoTrace.INFO)
                {
                    NeoTraceRuntime.TraceRuntime("newNumber", newNumber);
                }
                NeoCounter.SetCurrentNumber(nc, newNumber);
                if (NeoTrace.INFO)
                {
                    NeoCounter.LogExt("TakeNextNumber.putincr", nc);
                }
                NeoCounter.PutElement(nc, vau, DOMAINAC, (int)counter); // Persist the new counter
            }

            return(NeoCounter.GetCurrentNumber(nc));
        }
        /// <summary>
        /// Collectible methods (NPC Level 4)
        /// </summary>
        /// <param name="e">e</param>
        /// <param name="vau">vau</param>
        /// <param name="index">index</param>
        /// <returns>bool</returns>
        public static bool PutElement(NeoCounter e, NeoVersionedAppUser vau, byte[] domain, byte[] bindex)
        {
            if (NeoVersionedAppUser.IsNull(vau))
            {
                return(false);
            }

            Neo.SmartContract.Framework.Services.Neo.StorageContext ctx = Neo.SmartContract.Framework.Services.Neo.Storage.CurrentContext;
            NeoStorageKey nsk = NeoStorageKey.New(vau, domain, _bClassName);

            //byte[] bkey;
            e._state = NeoEntityModel.EntityState.PUTTED;
            Neo.SmartContract.Framework.Services.Neo.Storage.Put(ctx, NeoStorageKey.StorageKey(nsk, bindex, _bSTA), e._state.AsBigInteger());

            Neo.SmartContract.Framework.Services.Neo.Storage.Put(ctx, NeoStorageKey.StorageKey(nsk, bindex, _bCurrentNumber), e._currentNumber); // Template: NPCLevel4APutElement_cs.txt

            if (NeoTrace.RUNTIME)
            {
                LogExt("PutElement(vau,i).NeoCounter", e);                   // Template: NPCLevel4BGetElement_cs.txt
            }
            return(true);
        }
        // Use case example: domain = user script hash, counter = NeoCounters.UserPointsCounter
        public static BigInteger GiveBackLastNumber(NeoVersionedAppUser vau, byte[] domain, NeoCounters counter)
        {
            NeoCounter nc = NeoCounter.GetElement(vau, domain, (int)counter); // Get persisted counter value

            if (NeoTrace.INFO)
            {
                NeoCounter.LogExt("GiveBackLastNumber", nc);
            }

            if (NeoCounter.IsMissing(nc))
            {
                nc = NeoCounter.New(); // Create a new counter value
            }
            else // Get and decrement counter value by 1
            {
                BigInteger currentNumber = NeoCounter.GetCurrentNumber(nc);
                if (NeoTrace.INFO)
                {
                    NeoTraceRuntime.TraceRuntime("currentNumber", currentNumber);
                }
                currentNumber = currentNumber - 1;
                if (NeoTrace.INFO)
                {
                    NeoTraceRuntime.TraceRuntime("currentNumber", currentNumber);
                }
                NeoCounter.SetCurrentNumber(nc, currentNumber);
                if (NeoTrace.INFO)
                {
                    NeoCounter.LogExt("GiveBackLastNumber", nc);
                }
                NeoCounter.PutElement(nc, vau, domain, (int)counter); // Persist the incremented current value of the counter
                if (NeoTrace.INFO)
                {
                    NeoCounter.LogExt("GiveBackLastNumber", nc);
                }
            }

            return(NeoCounter.GetCurrentNumber(nc));
        }
        public static NeoCounter Get(byte[] key)
        {
            if (key.Length == 0)
            {
                return(Null());
            }

            Neo.SmartContract.Framework.Services.Neo.StorageContext ctx = Neo.SmartContract.Framework.Services.Neo.Storage.CurrentContext;
            byte[] _bkeyTag = Helper.Concat(key, _bclassKeyTag);

            NeoCounter e;

            byte[] bsta = Neo.SmartContract.Framework.Services.Neo.Storage.Get(ctx, Helper.Concat(_bkeyTag, _bSTA));
            if (NeoTrace.RUNTIME)
            {
                TraceRuntime("Get(bkey).bsta", bsta.Length, bsta);
            }
            if (bsta.Length == 0)
            {
                e = NeoCounter.Missing();
            }
            else // not MISSING
            {
                int ista = (int)bsta.AsBigInteger();
                NeoEntityModel.EntityState sta = (NeoEntityModel.EntityState)ista;
                e = new NeoCounter();

                BigInteger CurrentNumber = Neo.SmartContract.Framework.Services.Neo.Storage.Get(ctx, Helper.Concat(_bkeyTag, _bCurrentNumber)).AsBigInteger(); //NPCLevel2GGet_cs.txt
                e._currentNumber = CurrentNumber;                                                                                                              // Template: NPCLevel2HGet_cs.txt
                e._state         = sta;
                e._state         = NeoEntityModel.EntityState.GETTED;                                                                                          /* OVERRIDE */
            }
            if (NeoTrace.RUNTIME)
            {
                LogExt("Get(bkey).NeoCounter", e);
            }
            return(e);
        }
 public static void LogExt(string label, NeoCounter e)
 {
     TraceRuntime(label, e._currentNumber, e._state);
 }
 // Persistable methods
 public static bool IsMissing(NeoCounter e)
 {
     return(e._state == NeoEntityModel.EntityState.MISSING);
 }
 public static BigInteger GetCurrentNumber(NeoCounter e)
 {
     return(e._currentNumber);
 }
 // Deletable methods
 public static bool IsBuried(NeoCounter e)
 {
     return(e._state == NeoEntityModel.EntityState.TOMBSTONED);
 }
 public static void Set(NeoCounter e, BigInteger CurrentNumber) // Template: NPCLevel1Set_cs.txt
 {
     e._currentNumber = CurrentNumber;  e._state = NeoEntityModel.EntityState.SET;
 }
        // Accessors

        public static void SetCurrentNumber(NeoCounter e, BigInteger value) // Template: NPCLevel1SetXGetX_cs.txt
        {
            e._currentNumber = value; e._state = NeoEntityModel.EntityState.SET;
        }
Esempio n. 26
0
        private static object[] PointAdd(NeoVersionedAppUser AppVAU, object[] args)
        {
            object[] results = { -1 };

            if (NeoTrace.ARGSRESULTS)
            {
                NeoVersionedAppUser.LogExt("PointAdd.AppVAU", AppVAU);
            }

            byte[] encodedUsername = (byte[])args[0];
            if (NeoTrace.ARGSRESULTS)
            {
                NeoTrace.Trace("PointAdd.encodedUsername", encodedUsername);
            }
            BigInteger x = (BigInteger)(args[1]);

            if (NeoTrace.ARGSRESULTS)
            {
                NeoTrace.Trace("PointAdd.x", x);
            }
            BigInteger y = (BigInteger)(args[2]);

            if (NeoTrace.ARGSRESULTS)
            {
                NeoTrace.Trace("PointAdd.y", y);
            }

            UserCredentials uc = FindUser(AppVAU, encodedUsername);

            if (UserCredentials.IsMissing(uc))
            {
                if (NeoTrace.INFO)
                {
                    UserCredentials.LogExt("PointAdd.user missing", uc);
                }
            }
            else
            {
                if (NeoTrace.INFO)
                {
                    UserCredentials.LogExt("PointAdd.user exists", uc);
                }

                UserPoint  up    = UserPoint.New(x, y);
                BigInteger index = NeoCounter.TakeNextNumber(AppVAU, encodedUsername, NeoCounters.UserPointsCounter);
                if (NeoTrace.INFO)
                {
                    NeoTrace.Trace("PointAdd.index", index);
                }
                UserPoint.PutElement(up, AppVAU, encodedUsername, (int)index);

                results = new object[] { index };
            }

            if (NeoTrace.ARGSRESULTS)
            {
                NeoTrace.Trace("PointAdd.results", results);
            }

            return(results);
        }
 // EntityState wrapper methods
 public static bool IsNull(NeoCounter e)
 {
     return(e._state == NeoEntityModel.EntityState.NULL);
 }