source: icXML/icXML-devel/src/icxercesc/validators/schema/identity/IdentityConstraintHandler.cpp @ 3153

Last change on this file since 3153 was 3153, checked in by cameron, 6 years ago

Updates for build

File size: 5.9 KB
Line 
1/*
2 * Unless required by applicable law or agreed to in writing, software
3 * distributed under the License is distributed on an "AS IS" BASIS,
4 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
5 * See the License for the specific language governing permissions and
6 * limitations under the License.
7 */
8
9/*
10 * $Id: IdentityConstraintHandler.cpp 803869 2009-08-13 12:56:21Z amassari $
11 */
12
13// ---------------------------------------------------------------------------
14//  Includes
15// ---------------------------------------------------------------------------
16#include <icxercesc/validators/schema/identity/IdentityConstraintHandler.hpp>
17
18#include <icxercesc/validators/schema/SchemaElementDecl.hpp>
19
20#include <xercesc/validators/schema/identity/FieldActivator.hpp>
21#include <xercesc/validators/schema/identity/ValueStore.hpp>
22#include <xercesc/validators/schema/identity/IC_Selector.hpp>
23
24#include <xercesc/util/OutOfMemoryException.hpp>
25
26XERCES_CPP_NAMESPACE_BEGIN
27
28typedef JanitorMemFunCall<IdentityConstraintHandler>    CleanupType;
29
30// ---------------------------------------------------------------------------
31//  IdentityConstraintHandler: Constructors and Destructor
32// ---------------------------------------------------------------------------
33IdentityConstraintHandler::IdentityConstraintHandler(XMLScanner*    const scanner
34                                         , MemoryManager* const manager)
35: fScanner(scanner)
36, fMemoryManager(manager)
37, fMatcherStack(0)
38, fValueStoreCache(0)
39, fFieldActivator(0)
40{
41        CleanupType cleanup(this, &IdentityConstraintHandler::cleanUp);
42
43        try {
44
45                fMatcherStack    = new (fMemoryManager) XPathMatcherStack(fMemoryManager);
46                fValueStoreCache = new (fMemoryManager) ValueStoreCache(fMemoryManager);
47                fFieldActivator  = new (fMemoryManager) FieldActivator(fValueStoreCache, fMatcherStack, fMemoryManager);
48
49                fValueStoreCache->setScanner(scanner);
50        }
51        catch(const OutOfMemoryException&)
52        {
53                cleanup.release();
54
55                throw;
56        }
57
58        cleanup.release();
59}
60
61IdentityConstraintHandler::~IdentityConstraintHandler()
62{
63        cleanUp();
64}
65
66// ---------------------------------------------------------------------------
67//  IdentityConstraintHandler:  methods
68// ---------------------------------------------------------------------------
69void IdentityConstraintHandler::deactivateContext(      SchemaElementDecl* const elem
70                                                                                                , const XMLCh*             const content
71                                                                                                , ValidationContext*       validationContext /*=0*/
72                                                                                                , DatatypeValidator*       actualValidator /*=0*/)
73{
74
75        XMLSize_t oldCount = fMatcherStack->getMatcherCount();
76
77        if (oldCount || elem->getIdentityConstraintCount())
78        {
79
80                for (XMLSize_t i = oldCount; i > 0; i--)
81                {
82                        XPathMatcher* matcher = fMatcherStack->getMatcherAt(i-1);
83                        matcher->endElement(*(elem), content, validationContext, actualValidator);
84                }
85
86                if (fMatcherStack->size() > 0)
87                {
88                        fMatcherStack->popContext();
89                }
90
91                // handle everything *but* keyref's.
92                XMLSize_t newCount = fMatcherStack->getMatcherCount();
93
94                for (XMLSize_t j = oldCount; j > newCount; j--)
95                {
96                        XPathMatcher* matcher = fMatcherStack->getMatcherAt(j-1);
97                        IdentityConstraint* ic = matcher->getIdentityConstraint();
98
99                        if (ic  && (ic->getType() != IdentityConstraint::ICType_KEYREF))
100                                fValueStoreCache->transplant(ic, matcher->getInitialDepth());
101                }
102
103                // now handle keyref's...
104                for (XMLSize_t k = oldCount; k > newCount; k--)
105                {
106                        XPathMatcher* matcher = fMatcherStack->getMatcherAt(k-1);
107                        IdentityConstraint* ic = matcher->getIdentityConstraint();
108
109                        if (ic && (ic->getType() == IdentityConstraint::ICType_KEYREF))
110                        {
111                                ValueStore* values = fValueStoreCache->getValueStoreFor(ic, matcher->getInitialDepth());
112
113                                if (values) { // nothing to do if nothing matched!
114                                        values->endDocumentFragment(fValueStoreCache);
115                                }
116                        }
117                }
118
119                fValueStoreCache->endElement();
120
121        }
122}
123
124void IdentityConstraintHandler::activateIdentityConstraint
125(
126        SchemaElementDecl* const                                elem
127        ,       int                                                             elemDepth
128        , const unsigned int                                    uriId
129        , const XMLCh*                 const    elemPrefix
130        , const RefVectorOf<XMLAttr>&                   attrList
131        , const XMLSize_t                                               attrCount
132        , ValidationContext*                                    validationContext
133)
134{
135        DEBUG_MESSAGE("IdentityConstraintHandler::activateIdentityConstraint");
136
137        XMLSize_t count = elem->getIdentityConstraintCount();
138
139        if (count || fMatcherStack->getMatcherCount())
140        {
141
142                fValueStoreCache->startElement();
143                fMatcherStack->pushContext();
144                fValueStoreCache->initValueStoresFor( elem, elemDepth);
145
146                for (XMLSize_t i = 0; i < count; i++)
147                {
148                        activateSelectorFor(elem->getIdentityConstraintAt(i), elemDepth);
149                }
150
151                // call all active identity constraints
152                count = fMatcherStack->getMatcherCount();
153
154                for (XMLSize_t j = 0; j < count; j++)
155                {
156                        XPathMatcher* matcher = fMatcherStack->getMatcherAt(j);
157                        matcher->startElement(*elem, uriId, elemPrefix, attrList, attrCount, validationContext);
158                }
159        }
160}
161
162void IdentityConstraintHandler::activateSelectorFor
163(
164        IdentityConstraint* const               ic
165        , const int                     initialDepth
166)
167{
168
169        IC_Selector* selector = ic->getSelector();
170
171        if (!selector)
172                return;
173
174        XPathMatcher* matcher = selector->createMatcher(fFieldActivator, initialDepth, fMemoryManager);
175
176        fMatcherStack->addMatcher(matcher);
177        matcher->startDocumentFragment();
178}
179
180// ---------------------------------------------------------------------------
181//  IdentityConstraintHandler:  Getter methods
182// ---------------------------------------------------------------------------
183
184// ---------------------------------------------------------------------------
185//  IdentityConstraintHandler: cleanUp methods
186// ---------------------------------------------------------------------------
187void IdentityConstraintHandler::cleanUp()
188{
189        if (fMatcherStack)
190                delete fMatcherStack;
191
192        if (fValueStoreCache)
193                delete fValueStoreCache;
194
195        if (fFieldActivator)
196                delete fFieldActivator;
197
198}
199
200void IdentityConstraintHandler::reset()
201{
202        fValueStoreCache->startDocument();
203        fMatcherStack->clear();
204}
205
206XERCES_CPP_NAMESPACE_END
207
208/**
209  * End of file IdentityConstraintHandler.cpp
210  */
211
Note: See TracBrowser for help on using the repository browser.