Logo
Distributed Genetic Programming Framework
print print

File org.sfc.xml.NamespaceManager.java

Here you can find all the information about the file org.sfc.xml.NamespaceManager.java. You may explore it here or download it onto your local disk.
/*
 * Copyright (c) 2005 Thomas Weise
 *
 * E-Mail           : tweise@gmx.de
 * Creation Date    : 2005-08-12 16:38:29
 * Original Filename: org.sfc.xml.NamespaceManager.java
 * Version          : 1.0.2
 * Last modification: 2006-03-07
 *                by: Thomas Weise
 *
 * License          : GNU LESSER GENERAL PUBLIC LICENSE
 *                    Version 2.1, February 1999
 *                    You should have received a copy of this license along
 *                    with this library; if not, write to the Free Software
 *                    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 *                    MA 02111-1307, USA or download the license under
 *                    http://www.gnu.org/copyleft/lesser.html.
 *
 * Warranty         : This software is provided "as is" without any
 *                    warranty; without even the implied warranty of
 *                    merchantability or fitness for a particular purpose.
 *                    See the Gnu Lesser General Public License for more
 *                    details.
 */


package org.sfc.xml;

import java.io.Serializable;
import java.util.Map;

import org.sfc.collections.Collections;
import org.sfc.text.Text;

/**
 * This class can be used to manage namespaces.
 *
 * @author Thomas Weise
 */

public  class NamespaceManager implements Serializable
  {
/**
 * The serial version uid.
 */

  private static final long serialVersionUID = 1;

/**
 * The hashmap with the namespaces.
 */

  private     Map<String,String>          m_namespaces      ;
/**
 * The base namespace of the document.
 */

  private     String                      m_base_namespace  ;

/**
 * Create a new namespace manager.
 */

  public  NamespaceManager  ()
    {
    super();
    this.m_namespaces = Collections.create_map(-1);
    }


/**
 * Sets the basic namespace of the document.
 *
 * @param p_base_namespace  The new base namespace of the document.
 */

  protected void  set_base_namespace  (final  String p_base_namespace)
    {
    this.m_base_namespace = p_base_namespace;
    }

/**
 * This method returns the base namespace of the document.
 * @return  The base namespace of the document.
 */

  public  final String  get_base_namespace  ()
    {
    return this.m_base_namespace;
    }


/**
 * Returns a prefix assigned to a given namespace.
 * @param p_namespace_uri   The namespace we want the prefix for.
 * @return  The prefix for the namespace p_namespace.
 */

  public  final String  get_prefix  (final  String p_namespace_uri)
    {
    return this.m_namespaces.get(p_namespace_uri);
    }

/**
 * Returns a namespace belonging to a give prefix.
 * @param p_prefix  The prefix we want to get the namespace for.
 * @return  The namespace belonging to the prefix p_prefix.
 */

  public  final String  get_namespace(final  String p_prefix)
    {
    return this.m_namespaces.get(p_prefix);
    }

/**
 * Adds a namespace. This provides two-way mapping.
 * @param   p_prefix          The prefix suggested of the namespace.
 *                            You cannot make any assumption on if it
 *                            will really be used or not. You can
 *                            only access the namespace using the
 *                            returned value.
 * @param   p_namespace_uri   The uri of the namespace.
 * @return  The prefix that is finally used for the namespace.
 */

  public  final String  add_namespace (String p_prefix,
                                       String p_namespace_uri)
    {
    int     l_i;
    String  l_s;

    if((p_namespace_uri = Text.preprocess(p_namespace_uri)) == null)
      {
      return null;
      }

    if(this.m_base_namespace == null)
      {
      set_base_namespace(p_namespace_uri);
      return null;
      }

    if(this.m_base_namespace.equals(p_namespace_uri))
      {
      return null;
      }

    if((l_s = this.m_namespaces.get(p_namespace_uri)) != null)
      {
      return l_s;
      }

    if(((p_prefix = Text.preprocess(p_prefix)) == null) ||
       (((l_s = this.m_namespaces.get(p_prefix)) != null) &&
           (!(l_s.equals(p_namespace_uri)))))
      {
      l_i = 0;
      while(this.m_namespaces.get(p_prefix = ("ns" + l_i)) != null) l_i++;
      }

    this.m_namespaces.put(p_namespace_uri, p_prefix);
    this.m_namespaces.put(p_prefix, p_namespace_uri);

    this.on_new_prefix(p_prefix, p_namespace_uri);

    return p_prefix;
    }

/**
 * This method is called whenever a new namespace has been introducted to
 * the namespace manager.
 * @param p_prefix        The prefix assigned to the new namespace.
 * @param p_namespace_uri The new namespace uri.
 */

  protected void  on_new_prefix (final  String  p_prefix,
                                 final  String  p_namespace_uri)
    {
    //
    }

/**
 * Creates qualifies a plain name associated with a namespace.
 * Creates a namespace prefix if needed.
 * @param   p_namespace_uri   The namespace's uri to use.
 * @param   p_plain_name      The un-qualified name.
 * @return                    The qualified name with prefix and shit.
 */

  public  final String  qualify   (final  String   p_namespace_uri,
                                   final  String   p_plain_name)
    {
    String  l_s;

    if((l_s = add_namespace(null, p_namespace_uri)) == null)
      {
      return p_plain_name;
      }

    return l_s + XML.NAMESPACE_SEPARATOR + p_plain_name;
    }

/**
 * Copy this namespace manager.
 * @return  A perfect copy of this namespace manager.
 */

  @Override
  public Object  clone()
    {
    NamespaceManager  l_nm;

    l_nm = this.shallow_clone();
    l_nm.m_namespaces.putAll(this.m_namespaces);

    return l_nm;
    }

/**
 * Copy this namespace manager but not containing any mapped namespaces.
 * @return  A perfect copy of this namespace manager but not containing any
 *          mapped namespaces.
 */

  protected final NamespaceManager shallow_clone()
    {
    NamespaceManager  l_nm;

    try
      {
      l_nm = ((NamespaceManager)(super.clone()));
      }
    catch(CloneNotSupportedException l_cnse)
      {
      throw new RuntimeException(l_cnse);
      }
    l_nm.m_namespaces = Collections.create_map(-1);

    return l_nm;
    }

/**
 * Delete all stored namespaces.
 */

  protected final void  clear_namespaces  ()
    {
    this.m_namespaces.clear();
    }

///**
// * Finds a suitable qualified name for an element where some information is
// * known.
// * @param p_uri         The namespace-uri, or <code>null</code> if not
// *                      known.
// * @param p_local_name  The local name, or <code>null</code> if not
// *                      known.
// * @param p_q_name      The qualified name, or <code>null</code> if not
// *                      known.
// * @return The really usable, qualified name.
// */

//  public  final String  check_qualify(String      p_uri,
//                                      String      p_local_name,
//                                      String      p_q_name)
//    {
//    int     l_i;
//    String  l_pfx;
//
//    if(  (p_q_name != null) &&
//        ((p_q_name = p_q_name.trim()).length() > 0) )
//      {
//      if( (l_i = p_q_name.indexOf(NAMESPACE_SEPARATOR)) > 0)
//        {
//        l_pfx = this.add_namespace(p_q_name.substring(0, l_i), p_uri);
//        p_q_name = p_q_name.substring(l_i+1).trim();
//        if(p_q_name.length() > 0)
//          {
//          return l_pfx + NAMESPACE_SEPARATOR + p_q_name;
//          }
//        return l_pfx + NAMESPACE_SEPARATOR + p_local_name;
//        }
//      }
//
//    if( (p_local_name == null) ||
//       ((p_local_name = p_local_name.trim()).length() <= 0))
//      {
//      p_local_name = p_q_name;
//      }
//
//    if((p_uri != null) && ((p_uri = p_uri.trim()).length() > 0))
//      {
//      if((l_pfx = this.add_namespace(null, p_uri)) != null)
//        {
//        return l_pfx + NAMESPACE_SEPARATOR + p_local_name;
//        }
//      }
//
//    return p_local_name;
//    }
  }

File Information:

file name:NamespaceManager.java
package:org.sfc.xml
qualified name:org.sfc.xml.NamespaceManager.java
file type:Java Source File
download location:download http://dgpf.sourceforge.net/source/org/sfc/xml/NamespaceManager.java
size:8.064 KB (8258 B)
uploaded: 2018-01-07 12:03:36 GMT+0000
last update: 2006-03-07 04:20:28 GMT+0000
last access: 2018-04-26 00:44:59 GMT+0000

statistics online since 2006-01-02.   RSS Feed
Contact us by sending an email to tweise@gmx.de to receive further information, to report errors, or to join our project.
All content on this site (http://dgpf.sourceforge.net/) is LGPL-licensed.
http://dgpf.sourceforge.net/scripts/source/source.php last modified at 2018-01-07 12:03:34 GMT+0000 served at 2018-04-26 00:44:59 GMT+0000.
Valid CSS Valid XHTML 1.1
Valid RSS SourceForge.net Logo