Ejemplo n.º 1
0
        //////////////////////////////////////////////////////////////////////////////

        public int LookupAny12(int surr1, int surr2)
        {
            Prepare123();

            if (Ints123.Contains12(insertList, insertCount, surr1, surr2))
            {
                int idxFirst = Ints123.IndexFirst12(insertList, insertCount, surr1, surr2);
                return(insertList[3 * idxFirst + 2]);
            }

            int idx = Ints123.IndexFirst12(deleteList, deleteCount, surr1, surr2);

            if (idx == -1)
            {
                return(table.GetIter12(surr1, surr2).Get1());
            }

            int count = Ints123.Count12(deleteList, deleteCount, surr1, surr2, idx);

            TernaryTable.Iter12 it = table.GetIter12(surr1, surr2);
            while (!it.Done())
            {
                // Tuples in the [idx, idx+count) range are sorted in both 1/2/3
                // and 3/1/2 order, since the first two arguments are the same
                if (!Ints312.Contains3(deleteList, idx, count, it.Get1()))
                {
                    return(it.Get1());
                }
                it.Next();
            }

            throw ErrorHandler.InternalFail();
        }
Ejemplo n.º 2
0
        public void CheckKey_13()
        {
            if (insertCount != 0)
            {
                Prepare312();

                int prevArg1 = -1;
                int prevArg2 = -1;
                int prevArg3 = -1;

                for (int i = 0; i < insertCount; i++)
                {
                    int arg1 = insertList[3 * i];
                    int arg2 = insertList[3 * i + 1];
                    int arg3 = insertList[3 * i + 2];

                    if (arg1 == prevArg1 & arg3 == prevArg3 & arg2 != prevArg2)
                    {
                        throw Cols13KeyViolationException(arg1, arg2, arg3, prevArg2);
                    }

                    if (!Ints312.Contains13(deleteList, deleteCount, arg1, arg3) && table.Contains13(arg1, arg3))
                    {
                        throw Cols13KeyViolationException(arg1, arg2, arg3);
                    }

                    prevArg1 = arg1;
                    prevArg2 = arg2;
                    prevArg3 = arg3;
                }
            }
        }
Ejemplo n.º 3
0
 public void Prepare312()
 {
     if (deleteCount != 0 | insertCount != 0)
     {
         if (currOrd != Ord.ORD_312)
         {
             Ints312.Sort(deleteList, deleteCount);
             Ints312.Sort(insertList, insertCount);
             currOrd = Ord.ORD_312;
         }
     }
 }
Ejemplo n.º 4
0
        public bool Contains13(int surr1, int surr3)
        {
            Prepare312();

            if (Ints312.Contains13(insertList, insertCount, surr1, surr3))
            {
                return(true);
            }

            if (!table.Contains13(surr1, surr3))
            {
                return(false);
            }

            int idx = Ints312.IndexFirst31(deleteList, deleteCount, surr3, surr1);

            if (idx == -1)
            {
                return(true);
            }
            int count = Ints312.Count13(deleteList, deleteCount, surr1, surr3, idx);

            TernaryTable.Iter it = table.GetIter13(surr1, surr3);
            while (!it.Done())
            {
                // Tuples in the [idx, idx+count) range are sorted in both 3/1/2
                // and 2/3/1 order, since the first and last argument are the same
                if (!Ints231.Contains2(deleteList, idx, count, it.Get1()))
                {
                    return(true);
                }
                it.Next();
            }

            return(false);
        }
Ejemplo n.º 5
0
        public bool Contains12(int surr1, int surr2)
        {
            Prepare123();

            if (Ints123.Contains12(insertList, insertCount, surr1, surr2))
            {
                return(true);
            }

            if (!table.Contains12(surr1, surr2))
            {
                return(false);
            }

            int idx = Ints123.IndexFirst12(deleteList, deleteCount, surr1, surr2);

            if (idx == -1)
            {
                return(true);
            }
            int count = Ints123.Count12(deleteList, deleteCount, surr1, surr2, idx);

            TernaryTable.Iter it = table.GetIter12(surr1, surr2);
            while (!it.Done())
            {
                // Tuples in the [idx, idx+count) range are sorted in both 1/2/3
                // and 3/1/2 order, since the first two arguments are the same
                if (!Ints312.Contains3(deleteList, idx, count, it.Get1()))
                {
                    return(true);
                }
                it.Next();
            }

            return(false);
        }
Ejemplo n.º 6
0
        public bool Contains3(int surr3)
        {
            Prepare312();

            if (Ints312.Contains3(insertList, insertCount, surr3))
            {
                return(true);
            }

            if (!table.Contains3(surr3))
            {
                return(false);
            }

            int idx = Ints312.IndexFirst3(deleteList, deleteCount, surr3);

            if (idx == -1)
            {
                return(true);
            }
            int count = Ints312.Count3(deleteList, deleteCount, surr3, idx);

            TernaryTable.Iter it = table.GetIter3(surr3);
            while (!it.Done())
            {
                // Tuples in the [idx, idx+count) range are sorted in both 3/1/2
                // and 1/2/3 order, since the third argument is always the same
                if (!Ints123.Contains12(deleteList, idx, count, it.Get1(), it.Get2()))
                {
                    return(true);
                }
                it.Next();
            }

            return(false);
        }
Ejemplo n.º 7
0
        public bool Contains2(int surr2)
        {
            Prepare231();

            if (Ints231.Contains2(insertList, insertCount, surr2))
            {
                return(true);
            }

            if (!table.Contains2(surr2))
            {
                return(false);
            }

            int idx = Ints231.IndexFirst2(deleteList, deleteCount, surr2);

            if (idx == -1)
            {
                return(true);
            }
            int count = Ints231.Count2(deleteList, deleteCount, surr2, idx);

            TernaryTable.Iter it = table.GetIter2(surr2);
            while (!it.Done())
            {
                // Tuples in the [idx, idx+count) range are sorted in both 2/3/1
                // and 3/1/2 order, since the second argument is always the same
                if (!Ints312.Contains13(deleteList, idx, count, it.Get1(), it.Get2()))
                {
                    return(true);
                }
                it.Next();
            }

            return(false);
        }