1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *

    16 */

    17 /*

    18  * Licensed to the Apache Software Foundation (ASF) under one or more

    19  * contributor license agreements.  See the NOTICE file distributed with

    20  * this work for additional information regarding copyright ownership.

    21  * The ASF licenses this file to You under the Apache License, Version 2.0

    22  * (the "License"); you may not use this file except in compliance with

    23  * the License.  You may obtain a copy of the License at

    24  * 

    25  *      http://www.apache.org/licenses/LICENSE-2.0

    26  * 

    27  * Unless required by applicable law or agreed to in writing, software

    28  * distributed under the License is distributed on an "AS IS" BASIS,

    29  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

    30  * See the License for the specific language governing permissions and

    31  * limitations under the License.

    32  */

    33 

    34 /*

    35  * $Id: DOM_Entity.hpp 568078 2007-08-21 11:43:25Z amassari $

    36  */

    37 

    38 #ifndef DOM_Entity_HEADER_GUARD_

    39 #define DOM_Entity_HEADER_GUARD_

    40 

    41 #include <xercesc/util/XercesDefs.hpp>

    42 #include "DOM_Node.hpp"

    43 

    44 XERCES_CPP_NAMESPACE_BEGIN

    45 

    46 

    47 class EntityImpl;

    48 

    49 /**

    50  * This interface represents an entity, either parsed or unparsed, in an XML

    51  * document.

    52  *

    53  * Note that this models the entity itself not the entity

    54  * declaration. <code>Entity</code> declaration modeling has been left for a

    55  * later Level of the DOM specification.

    56  * <p>The <code>nodeName</code> attribute that is inherited from

    57  * <code>Node</code> contains the name of the entity.

    58  * <p>An XML processor may choose to completely expand entities before  the

    59  * structure model is passed to the DOM; in this case there will be no

    60  * <code>EntityReference</code> nodes in the document tree.

    61  *

    62  * <p>Note: the first release of this parser does not create entity

    63  *    nodes when reading an XML document.  Entities may be

    64  *    programatically created using DOM_Document::createEntity().

    65  */

    66 class DEPRECATED_DOM_EXPORT DOM_Entity: public DOM_Node {

    67 public:

    68     /** @name Constructors and assignment operator */

    69     //@{

    70     /**

    71       * Default constructor for DOM_Entity.

    72       *

    73       */

    74     DOM_Entity();

    75 

    76     /**

    77       * Copy constructor.

    78       *

    79       * @param other The object to be copied.

    80       */

    81     DOM_Entity(const DOM_Entity &other);

    82 

    83     /**

    84       * Assignment operator.

    85       *

    86       * @param other The object to be copied.

    87       */

    88     DOM_Entity & operator = (const DOM_Entity &other);

    89 

    90     /**

    91       * Assignment operator.  This overloaded variant is provided for

    92       *   the sole purpose of setting a DOM_Node reference variable to

    93       *   zero.  Nulling out a reference variable in this way will decrement

    94       *   the reference count on the underlying Node object that the variable

    95       *   formerly referenced.  This effect is normally obtained when reference

    96       *   variable goes out of scope, but zeroing them can be useful for

    97       *   global instances, or for local instances that will remain in scope

    98       *   for an extended time,  when the storage belonging to the underlying

    99       *   node needs to be reclaimed.

   100       *

   101       * @param val   Only a value of 0, or null, is allowed.

   102       */

   103     DOM_Entity & operator = (const DOM_NullPtr *val);

   104 

   105     //@}

   106     /** @name Destructor. */

   107     //@{

   108 	 /**

   109 	  * Destructor for DOM_Entity.

   110 	  *

   111 	  */

   112     ~DOM_Entity();

   113 

   114     //@}

   115     /** @name Get functions. */

   116     //@{

   117   /**

   118    * The public identifier associated with the entity, if specified.

   119    *

   120    * If the public identifier was not specified, this is <code>null</code>.

   121    */

   122   DOMString        getPublicId() const;

   123 

   124   /**

   125    * The system identifier associated with the entity, if specified.

   126    *

   127    * If the system identifier was not specified, this is <code>null</code>.

   128    */

   129   DOMString        getSystemId() const;

   130 

   131   /**

   132    * For unparsed entities, the name of the notation for the entity.

   133    *

   134    * For parsed entities, this is <code>null</code>.

   135    */

   136   DOMString        getNotationName() const;

   137 

   138   DOM_Node		getFirstChild() const;

   139   DOM_Node      getLastChild() const;

   140   DOM_NodeList  getChildNodes() const;

   141   bool          hasChildNodes() const;

   142   DOM_Node		getPreviousSibling() const;

   143   DOM_Node		getNextSibling() const;

   144   //@}

   145 

   146 protected:

   147     DOM_Entity(EntityImpl *impl);

   148 

   149     friend class DOM_Document;

   150 };

   151 

   152 XERCES_CPP_NAMESPACE_END

   153 

   154 #endif

   155