Exemple #1
0
        // 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.VERBOSE)
            {
                NeoCounter.LogExt("TakeNextNumber", nc);
            }

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

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

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

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

            return(currentNextNumber);
        }
Exemple #2
0
        public static BigInteger TakeNextNumber(NeoVersionedAppUser vau, NeoCounters counter)
        {
            NeoCounter nc = NeoCounter.GetElement(vau, DOMAINAC, (int)counter); // Get persisted counter value

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

            if (NeoCounter.IsMissing(nc))
            {
                nc = NeoCounter.New(); // Create a new counter value
                if (NeoTrace.VERBOSE)
                {
                    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.VERBOSE)
                {
                    NeoTraceRuntime.TraceRuntime("newNumber", newNumber);
                }
                newNumber = newNumber + 1;
                if (NeoTrace.VERBOSE)
                {
                    NeoTraceRuntime.TraceRuntime("newNumber", newNumber);
                }
                NeoCounter.SetCurrentNumber(nc, newNumber);
                if (NeoTrace.VERBOSE)
                {
                    NeoCounter.LogExt("TakeNextNumber.putincr", nc);
                }
                NeoCounter.PutElement(nc, vau, DOMAINAC, (int)counter); // Persist the new counter
            }

            return(NeoCounter.GetCurrentNumber(nc));
        }
Exemple #3
0
        // 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.VERBOSE)
            {
                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.VERBOSE)
                {
                    NeoTraceRuntime.TraceRuntime("currentNumber", currentNumber);
                }
                currentNumber = currentNumber - 1;
                if (NeoTrace.VERBOSE)
                {
                    NeoTraceRuntime.TraceRuntime("currentNumber", currentNumber);
                }
                NeoCounter.SetCurrentNumber(nc, currentNumber);
                if (NeoTrace.VERBOSE)
                {
                    NeoCounter.LogExt("GiveBackLastNumber", nc);
                }
                NeoCounter.PutElement(nc, vau, domain, (int)counter); // Persist the incremented current value of the counter
                if (NeoTrace.VERBOSE)
                {
                    NeoCounter.LogExt("GiveBackLastNumber", nc);
                }
            }

            return(NeoCounter.GetCurrentNumber(nc));
        }
Exemple #4
0
        public static object Main()
        {
            object result = false;

            NeoVersionedAppUser vau = NeoVersionedAppUser.New(_AppName, _AppVersionMajor, _AppVersionMinor, _AppVersionBuild, _OwnerAccountScriptHash);

            NeoCounter counter1 = NeoCounter.New(1234);

            NeoCounter.Put(counter1, "MyCounter1");
            NeoCounter.Log("counter1", counter1);
            counter1 = NeoCounter.Get("MyCounter1");
            NeoCounter.Log("counter1", counter1);

            NeoCounter counter2 = NeoCounter.New(5678);

            NeoCounter.PutElement(counter2, vau, DOMAIN_MYCOUNTER2, 0);
            NeoCounter.Log("counter2", counter2);
            counter2 = NeoCounter.GetElement(vau, DOMAIN_MYCOUNTER2, 0);
            NeoCounter.Log("counter2", counter2);

            BigInteger nextNumber3 = NeoCounter.TakeNextNumber(vau, NeoCounter.NeoCounters.PointCounter);

            NeoTrace.Trace("nextNumber3", nextNumber3);
            nextNumber3 = NeoCounter.TakeNextNumber(vau, NeoCounter.NeoCounters.PointCounter);
            NeoTrace.Trace("nextNumber3", nextNumber3);
            nextNumber3 = NeoCounter.TakeNextNumber(vau, NeoCounter.NeoCounters.PointCounter);
            NeoTrace.Trace("nextNumber3", nextNumber3);

            BigInteger nextNumber5 = NeoCounter.TakeNextNumber(vau, DOMAIN_MYCOUNTER5, NeoCounter.NeoCounters.RequisitionCounter);

            NeoTrace.Trace("nextNumber5", nextNumber5);
            nextNumber5 = NeoCounter.TakeNextNumber(vau, DOMAIN_MYCOUNTER5, NeoCounter.NeoCounters.RequisitionCounter);
            NeoTrace.Trace("nextNumber5", nextNumber5);
            nextNumber5 = NeoCounter.TakeNextNumber(vau, DOMAIN_MYCOUNTER5, NeoCounter.NeoCounters.RequisitionCounter);
            NeoTrace.Trace("nextNumber5", nextNumber5);

            int iteration = 0;

            while (true)
            {
                if (iteration >= 10)
                {
                    break;
                }
                NeoTrace.Trace("iteration", iteration);

                BigInteger nextIndex = NeoCounter.TakeNextNumber(vau, NeoCounter.NeoCounters.UserCounter);
                NeoTrace.Trace("nextIndex", nextIndex);

                UserLedgerEntry e = UserLedgerEntry.New(_User1AccountScriptHash, _User1PassphraseScriptHash);
                UserLedgerEntry.Log("e.put1", e);
                UserLedgerEntry.SetUserScriptHash(e, _User2AccountScriptHash);
                UserLedgerEntry.Log("e.put2", e);
                UserLedgerEntry.SetPassphraseScriptHash(e, _User2PassphraseScriptHash);
                UserLedgerEntry.Log("e.put3", e);

                UserLedgerEntry.PutElement(e, vau, DOMAIN_USERLEDGER, (int)nextIndex);
                iteration++;
            }

            iteration = 0;
            BigInteger nUsers = NeoCounter.GetNextNumber(vau, NeoCounter.NeoCounters.UserCounter);

            UserLedgerEntry[] users = new UserLedgerEntry[(int)nUsers];
            while (true)
            {
                if (iteration >= nUsers)
                {
                    break;
                }
                NeoTrace.Trace("iteration", iteration);

                UserLedgerEntry e = UserLedgerEntry.GetElement(vau, DOMAIN_USERLEDGER, iteration);
                UserLedgerEntry.Log("e.get", e);
                users[iteration] = e;
                UserLedgerEntry.Log("users[iteration]", users[iteration]);
                iteration++;
            }

            result = users;
            return(result);
        }