Package tigase.xml.db

Class XMLDB

  • public class XMLDB
extends Object
    XMLDB is the main database access class. It allows you to create new database in given file, open database from given file, add, delete and retrieve data and data lists. All data or data lists are stored in database nodes. There are three possible kinds of nodes for each database:
    1. root node - this is top node in each XML hierachy tree. There can be only one root node in database as there can be only one root element in XML file. The element name for root node can be defined by the user when new database is created or defualt element name 'root' is used.
    2. node1 nodes - these are the first level nodes under root node. There can be any number of nodes on this level. All data added for this database are added to first level node unless subnode path is given. User can define element name of node1 when new database is created. If not given default element name 'node' is used.
    3. subnodes - node on any deeper level under node1 level. There can be any number of subnodes on any level. Subnodes have always 'node' element name and this can't be changed.

    All node1 nodes and subnodes can contains any number of data associated with keys. With some keys there ca be more than one value assigned. Such kind of data are called data lists.
    Although element name for subnode can not be defined it is actually not important. Because user database doesn't use subnode element names. He doesn't even use neiher root node element name nor node1 element name. database user uses node name what is quite different from node element name. Let see example below:

    <node name='roster'/>

    In this example node element name is node and node name is roster.
    database users (actually developers) use only node names.
    If you want to access subnode on some level you need to give full path to this subnode. For example, let's assume we have following database:

    
 <node name='tigase'>
      <node name='server'></node>
      <node name='xmpp'></node>
 </node>

    If you need to access 'server' subnode you need to call method with '/tigase/server' as subnode path and for subnode 'xmpp' proper subnode path is of course '/tigase/xmpp'. If you skip subnode path or give null as a parameter you will be accessing data on node1 level. You can not access or save data on root node level.

    Created: Tue Oct 26 15:27:33 2004

    Author:
    Artur Hefczyc

    • Constructor Detail

      • XMLDB

        public XMLDB​(String db_file)
      throws IOException,
             XMLDBException
        Creates XMLDB object with desired filename, if file modes is enabled then appropriate saver thread is created as well. For filenames starting with "memory://" memory mode (i.e. without writing to disk) is enabled
        Parameters:
        db_file - indicates path to the file on disk to/from which write/read; if parameter starts with "memory://" then memory mode (without actual file usage) is enabled
        Throws:
        IOException - when the file doesn't exist
        XMLDBException - when there is a problem with XML DB

    • Method Detail

      • createDB

        public static XMLDB createDB​(String db_file,
                             String root_name,
                             String node1_name)
        Factory method creating and setting up XMLDB
        Parameters:
        db_file - indicates path to the file on disk to/from which write/read; if parameter starts with "memory://" then memory mode (without actual file usage) is enabled
        root_name - name of the root element
        node1_name - name of the node
        Returns:
        XMLDB object

      • getDBFileName

        public String getDBFileName()
        Retrieves filename
        Returns:
        filename

      • getAllNode1sCount

        public final long getAllNode1sCount()
        Retrieve number of nodes
        Returns:
        number of nodes

      • getAllNode1s

        public final List<String> getAllNode1s()
        Retrieve list of nodes
        Returns:
        list of nodes

      • findNode1

        public final DBElement findNode1​(String node1_id)
        Return Element corresponding to the node name
        Parameters:
        node1_id - node name
        Returns:
        Element corresponding to the node name

      • setData

        public void setData​(String node1_id,
                    String subnode,
                    String key,
                    Object value)
             throws NodeNotFoundException
        Sets data for the given node at given path
        Parameters:
        node1_id - name of the node
        subnode - path to the node
        key - under which save the data
        value - actual value to be saved
        Throws:
        NodeNotFoundException - when node doesn't exist on first level

      • setData

        public void setData​(String node1_id,
                    String key,
                    Object value)
             throws NodeNotFoundException
        Sets data for the given node at root
        Parameters:
        node1_id - name of the node
        key - under which save the data
        value - actual value to be saved
        Throws:
        NodeNotFoundException - when node doesn't exist on first level

      • getDataList

        public String[] getDataList​(String node1_id,
                            String subnode,
                            String key)
                     throws NodeNotFoundException
        Retrieve values of given node under specific path
        Parameters:
        node1_id - name of the node
        subnode - path to the node
        key - under which read the data
        Returns:
        array of Strings
        Throws:
        NodeNotFoundException - when node doesn't exist on first level

      • getDataIntList

        public int[] getDataIntList​(String node1_id,
                            String subnode,
                            String key)
                     throws NodeNotFoundException
        Retrieve values of given node under specific path
        Parameters:
        node1_id - name of the node
        subnode - path to the node
        key - under which read the data
        Returns:
        array of Integers
        Throws:
        NodeNotFoundException - when node doesn't exist on first level

      • getDataDoubleList

        public double[] getDataDoubleList​(String node1_id,
                                  String subnode,
                                  String key)
                           throws NodeNotFoundException
        Retrieve values of given node under specific path
        Parameters:
        node1_id - name of the node
        subnode - path to the node
        key - under which read the data
        Returns:
        array of Doubles
        Throws:
        NodeNotFoundException - when node doesn't exist on first level

      • getData

        public Object getData​(String node1_id,
                      String subnode,
                      String key,
                      Object def)
               throws NodeNotFoundException
        Retrieve value of given node under specific path
        Parameters:
        node1_id - name of the node
        subnode - path to the node
        key - under which read the data
        def - default value if nothing is stored
        Returns:
        Object with value
        Throws:
        NodeNotFoundException - when node doesn't exist on first level

      • getDataInt

        public int getDataInt​(String node1_id,
                      String subnode,
                      String key,
                      int def)
               throws NodeNotFoundException
        Retrieve value of given node under specific path
        Parameters:
        node1_id - name of the node
        subnode - path to the node
        key - under which read the data
        def - default value if nothing is stored
        Returns:
        Integer value
        Throws:
        NodeNotFoundException - when node doesn't exist on first level

      • getDataDouble

        public double getDataDouble​(String node1_id,
                            String subnode,
                            String key,
                            double def)
                     throws NodeNotFoundException
        Retrieve value of given node under specific path
        Parameters:
        node1_id - name of the node
        subnode - path to the node
        key - under which read the data
        def - default value if nothing is stored
        Returns:
        Double value
        Throws:
        NodeNotFoundException - when node doesn't exist on first level

      • getData

        public Object getData​(String node1_id,
                      String subnode,
                      String key)
               throws NodeNotFoundException
        Retrieve value of given node under specific path
        Parameters:
        node1_id - name of the node
        subnode - path to the node
        key - under which read the data
        Returns:
        Object value
        Throws:
        NodeNotFoundException - when node doesn't exist on first level

      • getSubnodes

        public String[] getSubnodes​(String node1_id,
                            String subnode)
                     throws NodeNotFoundException
        Retrieve list of subnodes under specific path
        Parameters:
        node1_id - name of the node
        subnode - path to the node
        Returns:
        arrays of subnodes names
        Throws:
        NodeNotFoundException - when node doesn't exist on first level

      • getSubnodes

        public String[] getSubnodes​(String node1_id)
                     throws NodeNotFoundException
        Retrieve list of subnodes under root
        Parameters:
        node1_id - name of the node
        Returns:
        arrays of subnodes names
        Throws:
        NodeNotFoundException - when node doesn't exist on first level

      • getKeys

        public String[] getKeys​(String node1_id,
                        String subnode)
                 throws NodeNotFoundException
        Retrieve list of keys under specific path
        Parameters:
        node1_id - name of the node
        subnode - path to the node
        Returns:
        arrays of keys names
        Throws:
        NodeNotFoundException - when node doesn't exist on first level

      • removeData

        public void removeData​(String node1_id,
                       String subnode,
                       String key)
                throws NodeNotFoundException
        Removes data of specific key from node of given name under given path
        Parameters:
        node1_id - name of the node
        subnode - path to the node
        key - name of the key
        Throws:
        NodeNotFoundException - when node doesn't exist on first level

      • removeData

        public void removeData​(String node1_id,
                       String key)
                throws NodeNotFoundException
        Removes data of specific key from node of given name under root element
        Parameters:
        node1_id - name of the node
        key - name of the key
        Throws:
        NodeNotFoundException - when node doesn't exist on first level

      • removeSubnode

        public void removeSubnode​(String node1_id,
                          String subnode)
                   throws NodeNotFoundException
        Removes node of given name under given path
        Parameters:
        node1_id - name of the node
        subnode - path to the node
        Throws:
        NodeNotFoundException - when node doesn't exist on first level

      • sync

        public void sync()
          throws IOException
        Performs synchronization with the file
        Throws:
        IOException - when the file doesn't exist

      • setupNewDB

        protected void setupNewDB​(String db_file,
                          String root_name,
                          String node1_name)
        Creates basic Elements of the XMLDB
        Parameters:
        db_file - indicates path to the file on disk to/from which write/read; if parameter starts with "memory://" then memory mode (without actual file usage) is enabled
        root_name - name of the root element
        node1_name - name of the node

      • saveDB

        protected void saveDB()
        Saves XML to file

      • getNode

        protected final DBElement getNode​(String node1_id,
                                  String subnode,
                                  boolean auto_create)
                           throws NodeNotFoundException
        Retrieves the node of the given name at specific path
        Parameters:
        node1_id - name of the node
        subnode - path to the node
        auto_create - whether to create path if it's missing
        Returns:
        retrieved node
        Throws:
        NodeNotFoundException - when node doesn't exist on first level