Ejemplo n.º 1
0
        /// <summary>
        /// Set multiple string values
        /// </summary>
        /// <param name="fields">
        /// Array of fieldsin format: {name}={value}
        /// </param>
        /// <returns></returns>
        public void Set(string[] fields)
        {
            bool upd = false;

            if (fields != null)
            {
                if (fields.Length > 0)
                {
                    for (int i = 0; i < fields.Length; i++)
                    {
                        int j = fields[i].IndexOf("=");
                        if (j >= 0)
                        {
                            string name  = fields[i].Substring(0, j);
                            string value = "";
                            if (j < (fields[i].Length - 1))
                            {
                                value = fields[i].Substring(j + 1, fields[i].Length - j - 1);
                            }
                            set_field(name, FIELD_TYPE_STRING, VSLib.ConvertStringToByte(value), false);
                            upd = true;
                        }
                    }
                }
            }
            if (upd)
            {
                serialize();
            }
        }
Ejemplo n.º 2
0
        // Reader/Writer with encryption

        /// <summary>
        /// File Stream
        /// </summary>
        /// <param name="filename">File name for Read/Write</param>
        /// <param name="mode">'c' - create; 'o' - open, 'a' - append</param>
        /// <param name="key">key for encrypt/decrypt ("" - no encryption)</param>
        public VSIO(string filename, string mode, string key)
        {
            string md = mode.Trim().ToLower();

            //fs = stream;
            xkey_b   = VSLib.ConvertStringToByte(key);
            _encrypt = (key != "");
            IMO      = false;

            if (md == FILE_MODE_CREATE)
            {
                fs = new FileStream(filename, FileMode.Create);
            }
            else if (md == FILE_MODE_APPEND)
            {
                fs = new FileStream(filename, FileMode.Append);
            }
            else if (md == FILE_MODE_OPEN)
            {
                fs = new FileStream(filename, FileMode.OpenOrCreate);
            }
            else
            {
                throw new VSException(DEFS.E0034_IO_ERROR_CODE, "Invalid open mode = '" + md + "'");
            }
        }
Ejemplo n.º 3
0
        /// <summary>
        /// Save catalog content
        /// </summary>
        public void Save()
        {
            string ost = sg_ok + DEFS.VSTORAGE_VERSION + "$" + ste + "$" + DEFS.DELIM_NEWLINE;

            for (int i = 0; i < dl.Count; i++)
            {
                ost += "[" + dl[i].Name + "]" + DEFS.DELIM_NEWLINE;

                ost += DEF_ID + "=" + dl[i].Id.ToString() + DEFS.DELIM_NEWLINE;
                ost += DEF_PAGESIZE + "=" + dl[i].page_size_kb.ToString() + "Kb" + DEFS.DELIM_NEWLINE;
                ost += DEF_SIZE + "=" + dl[i].space_size_pg.ToString() + "Pages" + DEFS.DELIM_NEWLINE;
                ost += DEF_EXTENSION + "=" + dl[i].extension_pg.ToString() + "Pages" + DEFS.DELIM_NEWLINE;
                ost += DEF_PARTITIONS + "=" + dl[i].partitions.ToString() + DEFS.DELIM_NEWLINE;

                ost += DEF_TIMESTAMP + "=" + dl[i].creation_timestamp + DEFS.DELIM_NEWLINE;
                ost += DEF_PATH + "=" + dl[i].path + DEFS.DELIM_NEWLINE;
                ost += DEF_INDEXSPACE + "=" + dl[i].indexspace + DEFS.DELIM_NEWLINE;

                // Create signature
                ost += DEF_SIGNATURE + "=" + dl[i].CalculateSignature() + DEFS.DELIM_NEWLINE;
            }

            if (File.Exists(catalog_file_name))
            {
                if (File.Exists(backup_file_name))
                {
                    File.Delete(backup_file_name);
                }
                File.Move(catalog_file_name, backup_file_name);
            }
            File.WriteAllBytes(catalog_file_name, VSLib.ConvertStringToByte(ost));
        }
Ejemplo n.º 4
0
        /// <summary>
        ///  Find key (string)
        /// </summary>
        /// <param name="key"></param>
        /// <param name="op">0 - equal; -1 - nearest left (less than); 1 - nearest right (more than) </param>
        /// <returns>Value</returns>
        public BTResult Find(string key, int op)
        {
            int      i   = find(VSLib.ConvertStringToByte(key), op);
            BTResult ret = new BTResult();

            ret.KeyString = (i < 0) ? "" : VSLib.ConvertByteToString(BTree[i].Key);
            ret.Value     = (i < 0) ? -1 : BTree[i].Value[0];

            return(ret);
        }
Ejemplo n.º 5
0
        /// <summary>
        /// Write FBQE
        /// </summary>
        /// <param name="f"></param>
        private void SerializeFBQE(FBQE f)
        {
            VSLib.CopyBytes(buffer, VSLib.ConvertStringToByte(DEFS.FBQE_SIGNATURE), f.address + SG_POS, SG_LEN);
            VSLib.CopyBytes(buffer, VSLib.ConvertLongToByte(f.ADDRESS_START), f.address + ADDRESS_START_POS, ADDRESS_START_LEN);
            VSLib.CopyBytes(buffer, VSLib.ConvertLongToByte(f.ADDRESS_END), f.address + ADDRESS_END_POS, ADDRESS_END_LEN);
            VSLib.CopyBytes(buffer, VSLib.ConvertLongToByte(f.LENGTH), f.address + LENGTH_POS, LENGTH_LEN);
            VSLib.CopyBytes(buffer, VSLib.ConvertIntToByte(f.PREV), f.address + PREV_POS, PREV_LEN);
            VSLib.CopyBytes(buffer, VSLib.ConvertIntToByte(f.NEXT), f.address + NEXT_POS, NEXT_LEN);

            F_Object.Write(f.address, VSLib.GetByteArray(buffer, f.address, FBQE_LENGTH), FBQE_LENGTH);
        }
Ejemplo n.º 6
0
        /// <summary>
        ///  Find all keys (non-unique), string
        /// </summary>
        /// <param name="key"></param>
        /// <param name="op">0 - equal; -1 - nearest left (less than); 1 - nearest right (more than) </param>
        /// <returns></returns>
        public BTResultList FindAll(string key, int op)
        {
            int i = find(VSLib.ConvertStringToByte(key), op);

            BTResultList ret = new BTResultList();

            ret.KeyString = (i < 0) ? "" : VSLib.ConvertByteToString(BTree[i].Key);
            ret.Value     = (i < 0) ? new long[0] : BTree[i].Value.ToArray();

            return(ret);
        }
Ejemplo n.º 7
0
 /// <summary>
 /// Memory Stream
 /// </summary>
 /// <param name="data">byte array - existing stream (read-only); null or empty - new stream</param>
 /// <param name="key">key for encrypt/decrypt ("" - no encryption)</param>
 public VSIO(byte[] data, string key)
 {
     //fs = stream;
     xkey_b   = VSLib.ConvertStringToByte(key);
     _encrypt = (key != "");
     IMO      = true;
     if (data == null)
     {
         fs = new MemoryStream();
     }
     else
     {
         fs = new MemoryStream(data);
     }
 }
Ejemplo n.º 8
0
        /// <summary>
        /// Calculate new signature
        /// </summary>
        /// <returns></returns>
        public string CalculateSignature()
        {
            ulong chs = (ulong)((Id * 123456789) - space_size_pg * 3 + extension_pg * 5 - page_size_kb * 7 + partitions * 9 - VSLib.ConvertStringToByte(CONFIG.ste)[0]);

            byte[] x = VSLib.ConvertStringToByte(indexspace.Trim().ToLower());
            for (int i = 0; i < x.Length; i++)
            {
                chs += (ulong)(x[i] * 3);
            }

            x = VSLib.ConvertStringToByte(name.Trim().ToLower());
            for (int i = 0; i < x.Length; i++)
            {
                chs += (ulong)(x[i] * 5);
            }

            signature = VSLib.ConvertULongToHexString(chs);
            return(signature);
        }
Ejemplo n.º 9
0
        /// <summary>
        /// Open new address space: _path - root folder path; _cat_file - catalog file name; idx - index in the catalog. Return: space id or -1(if error)
        /// </summary>
        /// <param name="_path"></param>
        /// <param name="_cat_file"></param>
        /// <param name="idx"></param>
        /// <returns></returns>
        public string Open(VSCatalogDescriptor desc, VSTransaction ta)
        {
            this.DESCRIPTOR = desc;
            this.page_size  = DESCRIPTOR.PageSize;
            this.imo        = DESCRIPTOR.IMO;

            e_key = VSLib.ConvertStringToByte(DEFS.ENCRYPT_SPACE);

            e_buf = new byte[page_size];

            _ta = ta;

            //////////////////////////////////////////////
            ///////////// Initiate partitions ////////////
            //////////////////////////////////////////////
            this.pd = new partition_descriptor[DESCRIPTOR.Partitions];


            //Check if all partitions exists
            if (imo)
            {
                pd[0].start_page = 0;                                           //Start Page
                pd[0].end_page   = DESCRIPTOR.space_size_pg - 1;                //End Page
            }
            else
            {
                for (int i = 0; i < DESCRIPTOR.Partitions; i++)
                {
                    short j = (short)(i + 1);
                    pd[i].file_name = DESCRIPTOR.Path + "\\" + DEFS.SPACE_FILE_NAME(DESCRIPTOR.Name, i);

                    if (!System.IO.File.Exists(pd[i].file_name))
                    {
                        return("Error: space file is not found - " + pd[i].file_name);
                    }

                    //FileStream f = null;

                    //f = File.Open(pd[i].file_name, FileMode.Open, FileAccess.ReadWrite, FileShare.None);


                    pd[i].fs = new VSIO(pd[i].file_name, VSIO.FILE_MODE_OPEN, DEFS.ENCRYPT_SPACE);
                    pd[i].fs.SetEncryption(false);

                    pd[i].start_page = (i == 0) ? 0 : pd[i - 1].end_page + 1;                         //Start Page
                    pd[i].end_page   = pd[i].start_page + ((pd[i].fs.GetLength()) / page_size) - 1;   //End Page
                }
            }

            //////////////////////////////////////////////
            ///////////// Initiate cache /////////////////
            //////////////////////////////////////////////

            // Create segment table
            segment_table = new page_segment_descriptor[DEFS.PAGE_SEGMENTS_NUMBER];

            // Create page table for 1st segment
            segment_table[0]            = new page_segment_descriptor();
            segment_table[0].start_page = 0;
            segment_table[0].end_page   = DESCRIPTOR.space_size_pg - 1;

            // Set initial number of segments used
            segments_used = 1;

            // Calculate cache size in pages
            if (imo)
            {
                cache_size_pages = DESCRIPTOR.space_size_pg;
                cache_size_bytes = DESCRIPTOR.SpaceSize;
            }
            else
            {
                string confs = VSLib.VSGetKey(DEFS.VM_CACHE_SIZE_KEY);
                if (confs == "")
                {
                    confs = DEFS.VM_CACHE_SIZE_DEFAULT;
                    VSLib.VSSetKey(DEFS.VM_CACHE_SIZE_KEY, confs);
                }
                int csize = VSLib.ConvertStringToInt(confs);

                cache_size_bytes = ((csize < 2) ? 2 : csize) * 1048576;

                if (cache_size_bytes < (page_size * 10))
                {
                    cache_size_bytes = page_size * 10;
                }

                cache_size_pages = (cache_size_bytes / page_size) + 1;
            }

            // Initialize cache
            segment_table[0].cache = new page_buffer[cache_size_pages];
            for (int i = 0; i < cache_size_pages; i++)
            {
                segment_table[0].cache[i].buf          = new byte[page_size];
                segment_table[0].cache[i].tbuf         = null;
                segment_table[0].cache[i].last_access  = 0;
                segment_table[0].cache[i].access_count = 0;
                if (imo)
                {
                    segment_table[0].cache[i].page_no = i;                  // Page no = Buf no
                    segment_table[0].cache[i].prev    = -1;
                    segment_table[0].cache[i].next    = -1;
                }
                else
                {
                    segment_table[0].cache[i].page_no = -1;
                    segment_table[0].cache[i].prev    = i - 1;
                    segment_table[0].cache[i].next    = ((i + 1) == cache_size_pages) ? -1 : i + 1;
                }
            }

            // Initialize queues (not IMO)
            if (!imo)
            {
                q_read         = new int[3];
                q_read[number] = 0;
                q_read[first]  = -1;
                q_read[last]   = -1;

                q_write         = new int[3];
                q_write[number] = 0;
                q_write[first]  = -1;
                q_write[last]   = -1;

                q_free         = new int[3];
                q_free[number] = (int)cache_size_pages;
                q_free[first]  = 0;
                q_free[last]   = (int)cache_size_pages - 1;
            }

            //////////////////////////////////////////////
            ///////////// Initiate page table ////////////
            //////////////////////////////////////////////
            segment_table[0].page_table = new page_descriptor[DESCRIPTOR.space_size_pg];
            for (int i = 0; i < segment_table[0].page_table.Length; i++)
            {
                if (imo)
                {
                    segment_table[0].page_table[i].page_state = DEFS.PAGE_READ;
                    segment_table[0].page_table[i].page_lock  = DEFS.PAGE_LOCKED;
                    segment_table[0].page_table[i].bufno      = i;                  // For IMO bufno = page table element
                }
                else
                {
                    segment_table[0].page_table[i].page_state = DEFS.PAGE_FREE;
                    segment_table[0].page_table[i].page_lock  = DEFS.PAGE_UNLOCKED;
                    segment_table[0].page_table[i].bufno      = -1;
                }
            }

            // Set state 'Opened'
            this.state = DEFS.SPACE_OPENED;

            // For IMO: write owner 'undefined'; otherwise: load and lock page 0.
            if (imo)
            {
                this.Write(DEFS.SYSTEM_OWNER_ADDRESS, DEFS.SYSTEM_OWNER_UNDEFINED.PadRight((int)DEFS.SYSTEM_OWNER_LENGTH));
            }
            else
            {
                fetch(0, 0, 0, DEFS.PAGE_READ);
                this.lock_page(0);                                                            // lock 1st page
            }

            return("");
        }
Ejemplo n.º 10
0
 /// <summary>
 /// Get ID by full or partial string key (first if if non-unique index)
 /// </summary>
 /// <param name="k"></param>
 /// <returns></returns>
 public long Find(string key, bool partial = false)
 {
     byte[] k = VSLib.ConvertStringToByte(key);
     return(Find(k, partial));
 }
Ejemplo n.º 11
0
 /// <summary>
 /// Add key (string)
 /// </summary>
 /// <param name="Value"></param>
 /// <returns></returns>
 public bool Insert(string key, long value)
 {
     return(this.insert(VSLib.ConvertStringToByte(key), value));
 }
Ejemplo n.º 12
0
 /// <summary>
 /// Write data (string)
 /// </summary>
 /// <param name="address"></param>
 /// <param name="data"></param>
 /// <returns></returns>
 public void Write(long address, string data)
 {
     Write(address, VSLib.ConvertStringToByte(data), data.Length);
 }
Ejemplo n.º 13
0
        /// <summary>
        /// Serialize all fields to object fields space
        /// Free excessive chunks if needed
        /// </summary>
        private void serialize()
        {
            // If no fields
            if (FCache.Count == 0)
            {
                set_alloc(ALLOC_RESET);
                FIELDS_SIZE = 0;
                FreeSpace   = -1;
                FCache      = null;
                return;
            }

            byte[] b        = null;
            int    old_size = (int)(FIELDS_SIZE);                  // Current used size (number of fields + all fields size)

            // 1. Calculate new size
            int new_size = FIRST_FIELD_OFFSET_REL;

            for (int i = 0; i < FCache.Count; i++)
            {
                new_size += FCache[i].FULL_LENGTH;
            }

            // 2. Check if space is availabe, extend if required
            if (new_size > (old_size + FreeSpace))
            {
                sp.Extend(this, (new_size - old_size));
            }

            // 3. Check if only value update is required

            List <FieldCache> afc = FCache;

            FCache = new List <FieldCache>(32);

            int array_size = (new_size > old_size) ? new_size : old_size;

            byte[] data = new byte[array_size];


            int data_pos = FIRST_FIELD_OFFSET_REL;

            VSLib.CopyBytes(data, VSLib.ConvertIntToByte(new_size), FIELDS_SIZE_POS, FIELDS_SIZE_LEN);                          // Size
            VSLib.CopyBytes(data, VSLib.ConvertShortToByte((short)afc.Count), FIELDS_NUMBER_POS, FIELDS_NUMBER_LEN);            // Fields number

            FCache.Clear();
            for (int i = 0; i < afc.Count; i++)
            {
                FieldCache fc_element = afc[i];
                if (!fc_element.DELETED)
                {
                    fc_element.OFFSET = data_pos;

                    // Type
                    data[data_pos] = fc_element.TYPE;
                    data_pos++;

                    // Name length
                    data[data_pos] = (byte)(fc_element.NAME.Length);
                    data_pos++;

                    // Name
                    b = VSLib.ConvertStringToByte(fc_element.NAME);
                    VSLib.CopyBytes(data, b, data_pos, b.Length);
                    data_pos += b.Length;

                    // Value
                    if (FIELD_COMPRESS[fc_element.TYPE])                                                              // int/long/decimal
                    {
                        data[data_pos] = (byte)(fc_element.LENGTH);
                        data_pos++;
                    }
                    else if ((fc_element.TYPE == FIELD_TYPE_BYTES) | (fc_element.TYPE == FIELD_TYPE_STRING))
                    {
                        b = compress(VSLib.ConvertLongToByte(fc_element.LENGTH), FIELD_TYPE_LONG);
                        data[data_pos] = (byte)b.Length;
                        data_pos++;

                        if (b.Length > 0)
                        {
                            VSLib.CopyBytes(data, b, data_pos, b.Length);
                            data_pos += b.Length;
                        }
                    }

                    // Write value
                    if (fc_element.VALUE.Length > 0)
                    {
                        VSLib.CopyBytes(data, fc_element.VALUE, data_pos, fc_element.VALUE.Length);
                        data_pos += afc[i].LENGTH;
                    }

                    // Shift offset and add to cache
                    fc_element.OLDLENGTH = afc[i].LENGTH;
                    fc_element.STATE     = STATE_LOADED;

                    FCacheTree.Insert(fc_element.NAME, FCache.Count);
                    FCache.Add(fc_element);
                }
            }

            base.Write(base.FIXED, data, data.Length);

            set_alloc(ALLOC_RENEW);

            // Fill the rest by zeros if le length < old length
            if (new_size < old_size)
            {
                long full_used_size = base.FIXED + new_size;
                b = new byte[old_size - new_size];
                base.Write(full_used_size, b, b.Length);                              // Fill be zeros unused space

                // Multiple chunks, chech if there are exessive
                if (base.Chunk > 0)
                {
                    sp.ShrinkObject(this, full_used_size);
                }
            }

            FreeSpace = (int)(this.Size - base.FIXED - new_size);
        }
Ejemplo n.º 14
0
 /// <summary>
 /// Set string value
 /// </summary>
 /// <param name="name"></param>
 /// <returns></returns>
 public void Set(string name, string value)
 {
     set_field(name, FIELD_TYPE_STRING, VSLib.ConvertStringToByte(value));
 }
Ejemplo n.º 15
0
        /// <summary>
        /// Load catalog content
        /// </summary>
        public void Load()
        {
            int    pos = 0;
            string s   = "";


            err_line = -1;

            if (!File.Exists(catalog_file_name))
            {
                File.WriteAllBytes(catalog_file_name, VSLib.ConvertStringToByte(sg_ok + DEFS.VSTORAGE_VERSION + "$" + "U" + "$" + DEFS.DELIM_NEWLINE));         // 'U'  dont encrypt (+19)
            }
            s = VSLib.ConvertByteToString(File.ReadAllBytes(catalog_file_name));
            // Parse file
            pos = s.IndexOf(DEFS.DELIM_NEWLINE);
            if (pos < 0)
            {
                return;
            }
            // Get encryption status
            string sth = s.Substring(0, pos);

            if (sth.Length < 21)
            {
                err_line = 1;
            }
            else
            {
                // Encryption
                ste     = sth.Substring(19, 1).ToUpper();
                ENCRYPT = (sth.Substring(19, 1) == "E");

                pos += DEFS.DELIM_NEWLINE.Length;
                line = 1;
                VSCatalogDescriptor desc = null;

                while ((pos < s.Length) & (err_line < 0))
                {
                    string par     = "";
                    int    ln      = 0;
                    int    new_pos = s.IndexOf(DEFS.DELIM_NEWLINE, pos);
                    if (new_pos < 0)
                    {
                        ln = s.Length - pos;
                    }
                    else
                    {
                        ln = new_pos - pos;
                    }

                    if (ln > 0)
                    {
                        par = s.Substring(pos, ln).Trim();
                    }
                    line++;
                    pos += (ln + DEFS.DELIM_NEWLINE.Length);

                    if (par != "")
                    {
                        if (par.Substring(0, 1) == "[")
                        { // Parse new descriptor
                            desc = null;
                            string sname = "";
                            int    eb    = par.IndexOf("]", 1);
                            if (eb < 0)
                            {
                                err_line = line;
                            }
                            else
                            {
                                if (eb > 1)
                                {
                                    sname = par.Substring(1, eb - 1);
                                }
                                if (sname != "")
                                {
                                    sname = sname.Trim().ToLower();
                                    for (int i = 0; i < dl.Count; i++)
                                    {
                                        if (dl[i].Name == sname)
                                        {
                                            desc = dl[i];
                                            break;
                                        }
                                    }
                                    if (desc == null)
                                    {
                                        desc      = new VSCatalogDescriptor(this);
                                        desc.name = sname;
                                        dl.Add(desc);
                                    }
                                }
                                else
                                {
                                    err_line = line;
                                }
                            }
                        }
                        else
                        { // Parse parameters
                            string s_val = "";
                            long   n_val = 0;
                            if (desc == null)
                            {
                                err_line = line;
                            }
                            else
                            {
                                par += "                            ";

                                if (parse_long(ref par, DEF_ID, out n_val))
                                {
                                    if (n_val >= 0)
                                    {
                                        desc.id = (short)n_val;
                                    }
                                }
                                else if (parse_long(ref par, DEF_SIZE, out n_val))
                                {
                                    if (n_val >= 0)
                                    {
                                        desc.space_size_pg = n_val;
                                    }
                                }
                                else if (parse_long(ref par, DEF_EXTENSION, out n_val))
                                {
                                    if (n_val >= 0)
                                    {
                                        desc.extension_pg = n_val;
                                    }
                                }
                                else if (parse_long(ref par, DEF_PAGESIZE, out n_val))
                                {
                                    if (n_val >= 0)
                                    {
                                        desc.page_size_kb = n_val;
                                    }
                                }
                                else if (parse_long(ref par, DEF_PARTITIONS, out n_val))
                                {
                                    if (n_val >= 0)
                                    {
                                        desc.partitions = n_val;
                                    }
                                }
                                else if (parse_string(ref par, DEF_PATH, out s_val))
                                {
                                    if (s_val != DEF_ERROR)
                                    {
                                        desc.path = s_val;
                                    }
                                }
                                else if (parse_string(ref par, DEF_INDEXSPACE, out s_val))
                                {
                                    if (s_val != DEF_ERROR)
                                    {
                                        desc.indexspace = s_val;
                                    }
                                }
                                else if (parse_string(ref par, DEF_TIMESTAMP, out s_val))
                                {
                                    if (s_val != DEF_ERROR)
                                    {
                                        desc.creation_timestamp = s_val;
                                    }
                                }
                                else if (parse_string(ref par, DEF_SIGNATURE, out s_val))
                                {
                                    if (s_val != DEF_ERROR)
                                    {
                                        desc.signature = s_val;
                                    }
                                }
                                else
                                {
                                    err_line = line;
                                }
                            }
                        }
                    }
                }
            }
            if (err_line >= 0)
            {
                throw new VSException(DEFS.E0016_OPEN_STORAGE_ERROR_CODE, "- invalid catalog entry at line " + err_line.ToString());
            }

            for (int i = 0; i < dl.Count; i++)
            {
                string sg = dl[i].Signature;
                dl[i].CalculateSignature();
                if (dl[i].Signature != sg)
                {
                    throw new VSException(DEFS.E0016_OPEN_STORAGE_ERROR_CODE, "- missing or invalid space signature for '" + dl[i].Name);
                }
            }
        }
Ejemplo n.º 16
0
 /// <summary>
 /// Write string
 /// </summary>
 /// <param name="offset"></param>
 /// <param name="data"></param>
 public void Write(long offset, string data)
 {
     byte[] b = VSLib.ConvertStringToByte(data);
     this.Write(offset, ref b);
 }
Ejemplo n.º 17
0
 /// <summary>
 /// Check if node exists (string key)
 /// </summary>
 /// <param name="key"></param>
 /// <param name="partial"></param>
 /// <returns>true/false</returns>
 public bool Exists(string key, bool partial = false)
 {
     return(Exists(VSLib.ConvertStringToByte(key), partial));
 }
Ejemplo n.º 18
0
 /// <summary>
 /// Delete index (string key)
 /// </summary>
 /// <param name="key"></param>
 /// <param name="id">For non-unique index. 0 - delete a </param>
 /// <returns></returns>
 public bool Delete(string key, long id)
 {
     byte[] k = VSLib.ConvertStringToByte(key);
     return(this.Delete(k, id));
 }
Ejemplo n.º 19
0
 /// <summary>
 /// Delete key (string)
 /// </summary>
 /// <param name="key"></param>
 /// <returns></returns>
 public bool Delete(string key, long value = -1)
 {
     return(this.delete(VSLib.ConvertStringToByte(key), value));
 }