Xerces-C++  3.1.4
XMLValidator.hpp
Go to the documentation of this file.
1 /*
2  * Licensed to the Apache Software Foundation (ASF) under one or more
3  * contributor license agreements. See the NOTICE file distributed with
4  * this work for additional information regarding copyright ownership.
5  * The ASF licenses this file to You under the Apache License, Version 2.0
6  * (the "License"); you may not use this file except in compliance with
7  * the License. You may obtain a copy of the License at
8  *
9  * http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17 
18  /*
19  * $Id: XMLValidator.hpp 932887 2010-04-11 13:04:59Z borisk $
20  */
21 
22 #if !defined(XERCESC_INCLUDE_GUARD_XMLVALIDATOR_HPP)
23 #define XERCESC_INCLUDE_GUARD_XMLVALIDATOR_HPP
24 
27 
29 
30 class ReaderMgr;
31 class XMLBufferMgr;
32 class XMLElementDecl;
33 class XMLScanner;
34 class Grammar;
35 
36 
53 {
54 public:
55  // -----------------------------------------------------------------------
56  // Constructors are hidden, just the virtual destructor is exposed
57  // -----------------------------------------------------------------------
58 
61 
66  virtual ~XMLValidator()
67  {
68  }
70 
71 
72  // -----------------------------------------------------------------------
73  // The virtual validator interface
74  // -----------------------------------------------------------------------
75 
78 
103  virtual bool checkContent
104  (
105  XMLElementDecl* const elemDecl
106  , QName** const children
107  , XMLSize_t childCount
108  , XMLSize_t* indexFailingChild
109  ) = 0;
110 
119  virtual void faultInAttr
120  (
121  XMLAttr& toFill
122  , const XMLAttDef& attDef
123  ) const = 0;
124 
128  virtual void preContentValidation(bool reuseGrammar,
129  bool validateDefAttr = false) = 0;
130 
138  virtual void postParseValidation() = 0;
139 
145  virtual void reset() = 0;
146 
153  virtual bool requiresNamespaces() const = 0;
154 
165  virtual void validateAttrValue
166  (
167  const XMLAttDef* attDef
168  , const XMLCh* const attrValue
169  , bool preValidation = false
170  , const XMLElementDecl* elemDecl = 0
171  ) = 0;
172 
180  virtual void validateElement
181  (
182  const XMLElementDecl* elemDef
183  ) = 0;
184 
188  virtual Grammar* getGrammar() const =0;
189 
193  virtual void setGrammar(Grammar* aGrammar) =0;
194 
195 
197 
198  // -----------------------------------------------------------------------
199  // Virtual DTD handler interface.
200  // -----------------------------------------------------------------------
201 
204 
209  virtual bool handlesDTD() const = 0;
210 
211  // -----------------------------------------------------------------------
212  // Virtual Schema handler interface.
213  // -----------------------------------------------------------------------
214 
221  virtual bool handlesSchema() const = 0;
222 
224 
225  // -----------------------------------------------------------------------
226  // Setter methods
227  //
228  // setScannerInfo() is called by the scanner to tell the validator
229  // about the stuff it needs to have access to.
230  // -----------------------------------------------------------------------
231 
234 
248  void setScannerInfo
249  (
250  XMLScanner* const owningScanner
251  , ReaderMgr* const readerMgr
252  , XMLBufferMgr* const bufMgr
253  );
254 
264  void setErrorReporter
265  (
266  XMLErrorReporter* const errorReporter
267  );
268 
270 
271 
272  // -----------------------------------------------------------------------
273  // Error emitter methods
274  // -----------------------------------------------------------------------
275 
278 
297  void emitError(const XMLValid::Codes toEmit);
298  void emitError
299  (
300  const XMLValid::Codes toEmit
301  , const XMLCh* const text1
302  , const XMLCh* const text2 = 0
303  , const XMLCh* const text3 = 0
304  , const XMLCh* const text4 = 0
305  );
306  void emitError
307  (
308  const XMLValid::Codes toEmit
309  , const char* const text1
310  , const char* const text2 = 0
311  , const char* const text3 = 0
312  , const char* const text4 = 0
313  );
314  void emitError
315  (
316  const XMLValid::Codes toEmit
317  , const XMLExcepts::Codes originalErrorCode
318  , const XMLCh* const text1 = 0
319  , const XMLCh* const text2 = 0
320  , const XMLCh* const text3 = 0
321  , const XMLCh* const text4 = 0
322 
323  );
324 
326 
327 protected :
328  // -----------------------------------------------------------------------
329  // Hidden constructors
330  // -----------------------------------------------------------------------
332  (
333  XMLErrorReporter* const errReporter = 0
334  );
335 
336 
337  // -----------------------------------------------------------------------
338  // Protected getters
339  // -----------------------------------------------------------------------
340  const XMLBufferMgr* getBufMgr() const;
341  XMLBufferMgr* getBufMgr();
342  const ReaderMgr* getReaderMgr() const;
343  ReaderMgr* getReaderMgr();
344  const XMLScanner* getScanner() const;
345  XMLScanner* getScanner();
346 
347 
348 private :
349  // -----------------------------------------------------------------------
350  // Unimplemented Constructors and Operators
351  // -----------------------------------------------------------------------
352  XMLValidator(const XMLValidator&);
353  XMLValidator& operator=(const XMLValidator&);
354 
355 
356  // -----------------------------------------------------------------------
357  // Private data members
358  //
359  // fErrorReporter
360  // The error reporter we are to use, if any.
361  //
362  // -----------------------------------------------------------------------
363  XMLBufferMgr* fBufMgr;
364  XMLErrorReporter* fErrorReporter;
365  ReaderMgr* fReaderMgr;
366  XMLScanner* fScanner;
367 };
368 
369 
370 // -----------------------------------------------------------------------
371 // Setter methods
372 // -----------------------------------------------------------------------
373 inline void
374 XMLValidator::setScannerInfo(XMLScanner* const owningScanner
375  , ReaderMgr* const readerMgr
376  , XMLBufferMgr* const bufMgr)
377 {
378  // We don't own any of these, we just reference them
379  fScanner = owningScanner;
380  fReaderMgr = readerMgr;
381  fBufMgr = bufMgr;
382 }
383 
384 inline void
386 {
387  fErrorReporter = errorReporter;
388 }
389 
390 
391 // ---------------------------------------------------------------------------
392 // XMLValidator: Protected getter
393 // ---------------------------------------------------------------------------
394 inline const XMLBufferMgr* XMLValidator::getBufMgr() const
395 {
396  return fBufMgr;
397 }
398 
399 inline XMLBufferMgr* XMLValidator::getBufMgr()
400 {
401  return fBufMgr;
402 }
403 
404 inline const ReaderMgr* XMLValidator::getReaderMgr() const
405 {
406  return fReaderMgr;
407 }
408 
409 inline ReaderMgr* XMLValidator::getReaderMgr()
410 {
411  return fReaderMgr;
412 }
413 
414 inline const XMLScanner* XMLValidator::getScanner() const
415 {
416  return fScanner;
417 }
418 
419 inline XMLScanner* XMLValidator::getScanner()
420 {
421  return fScanner;
422 }
423 
425 
426 #endif
This class makes it possible to override the C++ memory management by adding new/delete operators to ...
Definition: XMemory.hpp:40
This abstract class defines a callback mechanism for the scanner.
Definition: XMLErrorReporter.hpp:42
const XMLScanner * getScanner() const
Definition: XMLValidator.hpp:414
#define XMLPARSER_EXPORT
Definition: XercesDefs.hpp:163
Codes
Definition: XMLValidityCodes.hpp:15
This class defines the information about an attribute that will come out of the scanner during parsin...
Definition: XMLAttr.hpp:53
Represents the core information of an attribute definition.
Definition: XMLAttDef.hpp:52
const ReaderMgr * getReaderMgr() const
Definition: XMLValidator.hpp:404
This class defines the core information of an element declaration.
Definition: XMLElementDecl.hpp:51
void setScannerInfo(XMLScanner *const owningScanner, ReaderMgr *const readerMgr, XMLBufferMgr *const bufMgr)
Definition: XMLValidator.hpp:374
SIZE_T XMLSize_t
Definition: Xerces_autoconf_config.borland.hpp:86
Definition: QName.hpp:34
#define XERCES_CPP_NAMESPACE_BEGIN
Definition: XercesDefs.hpp:112
wchar_t XMLCh
Definition: Xerces_autoconf_config.borland.hpp:92
This abstract class provides the interface for all validators.
Definition: XMLValidator.hpp:52
virtual ~XMLValidator()
The derived class should clean up its allocated data, then this class will do the same for data alloc...
Definition: XMLValidator.hpp:66
#define XERCES_CPP_NAMESPACE_END
Definition: XercesDefs.hpp:113
void setErrorReporter(XMLErrorReporter *const errorReporter)
This method is called to set an error reporter on the validator via which it will report any errors i...
Definition: XMLValidator.hpp:385
const XMLBufferMgr * getBufMgr() const
Definition: XMLValidator.hpp:394