XSElementDeclaration.hpp

Go to the documentation of this file.

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
/*
 * $Id$
 */
 
#if !defined(XERCESC_INCLUDE_GUARD_XSELEMENTDECLARATION_HPP)
#define XERCESC_INCLUDE_GUARD_XSELEMENTDECLARATION_HPP
 
#include <xercesc/framework/psvi/XSObject.hpp>
#include <xercesc/framework/psvi/XSNamedMap.hpp>
 
XERCES_CPP_NAMESPACE_BEGIN
 
// forward declarations
class XSAnnotation;
class XSComplexTypeDefinition;
class XSIDCDefinition;
class XSTypeDefinition;
class SchemaElementDecl;
 
class XMLPARSER_EXPORT XSElementDeclaration : public XSObject
{
public:
 
    //  Constructors and Destructor
    // -----------------------------------------------------------------------
 
    XSElementDeclaration
    (
        SchemaElementDecl* const             schemaElementDecl
        , XSTypeDefinition* const            typeDefinition
        , XSElementDeclaration* const        substitutionGroupAffiliation
        , XSAnnotation* const                annot
        , XSNamedMap<XSIDCDefinition>* const identityConstraints
        , XSModel* const                     xsModel
        , XSConstants::SCOPE                 elemScope = XSConstants::SCOPE_ABSENT
        , XSComplexTypeDefinition* const     enclosingTypeDefinition = 0
        , MemoryManager* const               manager = XMLPlatformUtils::fgMemoryManager
    );
 
 
    ~XSElementDeclaration();
 
    //---------------------
 
    const XMLCh* getName() const;
 
    const XMLCh* getNamespace() const;
 
    XSNamespaceItem *getNamespaceItem();
 
 
    //---------------------
 
    XSTypeDefinition *getTypeDefinition() const;
 
    XSConstants::SCOPE getScope() const;
 
    XSComplexTypeDefinition *getEnclosingCTDefinition() const;
 
    XSConstants::VALUE_CONSTRAINT getConstraintType() const;
 
    const XMLCh *getConstraintValue();
 
    bool getNillable() const;
 
    XSNamedMap <XSIDCDefinition> *getIdentityConstraints();
 
    XSElementDeclaration *getSubstitutionGroupAffiliation() const;
 
    bool isSubstitutionGroupExclusion(XSConstants::DERIVATION_TYPE exclusion);
 
    short getSubstitutionGroupExclusions() const;
 
    bool isDisallowedSubstitution(XSConstants::DERIVATION_TYPE disallowed);
 
    short getDisallowedSubstitutions() const;
 
    bool getAbstract() const;
 
    XSAnnotation *getAnnotation() const;
 
 
    //----------------------------------
 
    void setTypeDefinition(XSTypeDefinition* typeDefinition);
 
private:
 
    void setEnclosingCTDefinition(XSComplexTypeDefinition* const toSet);
    friend class XSObjectFactory;
 
    // -----------------------------------------------------------------------
    //  Unimplemented constructors and operators
    // -----------------------------------------------------------------------
    XSElementDeclaration(const XSElementDeclaration&);
    XSElementDeclaration & operator=(const XSElementDeclaration &);
 
protected:
 
    // -----------------------------------------------------------------------
    //  data members
    // -----------------------------------------------------------------------
    short                         fDisallowedSubstitutions;
    short                         fSubstitutionGroupExclusions;    
    XSConstants::SCOPE            fScope;
    SchemaElementDecl*            fSchemaElementDecl;
    XSTypeDefinition*             fTypeDefinition;
    XSComplexTypeDefinition*      fEnclosingTypeDefinition;
    XSElementDeclaration*         fSubstitutionGroupAffiliation;
    XSAnnotation*                 fAnnotation;
    XSNamedMap<XSIDCDefinition>*  fIdentityConstraints;
};
 
inline XSTypeDefinition* XSElementDeclaration::getTypeDefinition() const
{
    return fTypeDefinition;
}
 
inline XSNamedMap<XSIDCDefinition>* XSElementDeclaration::getIdentityConstraints()
{
    return fIdentityConstraints;
}
 
inline XSElementDeclaration* XSElementDeclaration::getSubstitutionGroupAffiliation() const
{
    return fSubstitutionGroupAffiliation;
}
 
inline short XSElementDeclaration::getSubstitutionGroupExclusions() const
{
    return fSubstitutionGroupExclusions;
}
 
inline short XSElementDeclaration::getDisallowedSubstitutions() const
{
    return fDisallowedSubstitutions;
}
 
inline XSAnnotation *XSElementDeclaration::getAnnotation() const
{
    return fAnnotation;
}
 
inline XSConstants::SCOPE XSElementDeclaration::getScope() const
{
    return fScope;
}
 
inline XSComplexTypeDefinition *XSElementDeclaration::getEnclosingCTDefinition() const
{
    return fEnclosingTypeDefinition;
}
 
inline void XSElementDeclaration::setTypeDefinition(XSTypeDefinition* typeDefinition)
{
    fTypeDefinition = typeDefinition;
}
 
inline void XSElementDeclaration::setEnclosingCTDefinition(XSComplexTypeDefinition* const toSet)
{
    fEnclosingTypeDefinition = toSet;
}
 
XERCES_CPP_NAMESPACE_END
 
#endif