vtkNestingExpatBase.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 *
 * $Id: vtkNestingExpatBase.h,v 1.3 2004/05/29 23:19:34 xpxqx Exp $
 *
 * Copyright (c) 2004 Sean McInerney
 * All rights reserved.
 *
 * See Copyright.txt or http://vtkextensions.sourceforge.net/Copyright.html
 * for details.
 *
 *    This software is distributed WITHOUT ANY WARRANTY; without even 
 *    the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
 *    PURPOSE.  See the above copyright notice for more information.
 *
 */
#ifndef VTK_NESTING_EXPAT_BASE_H_
#  define VTK_NESTING_EXPAT_BASE_H_
#  include "vtkExpatBase.h"

VTK_EXTENSIONS_NAMESPACE_BEGIN

class VTK_EXTENSIONS_COMMON_EXPORT vtkNestingExpatBase : public vtkExpatBase
{
public:
  vtkTypeRevisionMacro (vtkNestingExpatBase, vtkExpatBase);
  void PrintSelf (ostream&, vtkIndent);

  void                  RedirectInternalParser (vtkNestingExpatBase* aChild);

  virtual vtkNestingExpatBase*  ReturnToParent (void);

  virtual vtkNestingExpatBase*  GetChild (void) const;

public:
  static void           NestedStartElementCb (void*             aPtr,
                                              const XML_Char*   aName,
                                              const XML_Char**  aAttrs);

  static void           NestedEndElementCb (void*               aPtr,
                                            const XML_Char*     aName);
protected:
  vtkNestingExpatBase (vtkNestingExpatBase* parent = NULL);
  ~vtkNestingExpatBase();

  virtual void          SetupHandlers (void);

  virtual void          SetChild (vtkNestingExpatBase* /*const&*/ child);

  virtual void          DeleteChild (void);

  void                  GrabInternalParserFromParent (void);

  void                  SetParent (vtkNestingExpatBase* aParent);

  void                  OrphanChild (vtkNestingExpatBase* aCallingChild);

  vtkNestingExpatBase*  Parent;

  int                   Depth;  

  bool                  SelfDeleting;

  vtkNestingExpatBase*  Child;
private:
  vtkNestingExpatBase (const vtkNestingExpatBase&);
  void operator= (const vtkNestingExpatBase&);
};


// ----------------------------------------------------------------------------
inline void
vtkNestingExpatBase::GrabInternalParserFromParent (void)
{
  assert(this->Parent != NULL);

  vtkDebugMacro(<< "GrabInternalParserFromParent()");

  this->Parser = this->Parent->Parser;
  this->GrabInternalParser();

  this->Modified();
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
inline void
vtkNestingExpatBase::SetParent (vtkNestingExpatBase* aParent)
{
  vtkDebugMacro(<< "SetParent(" << aParent << ")");

  if (this->Parent != NULL)
    {
    assert(this->Parent == aParent);
    }
  else
    {  // root parser being adopted, cleanup!
    this->ReleaseParser();
    this->Parent = aParent;
    this->GrabInternalParserFromParent();
    }

  this->SelfDeleting = false;

  this->Modified();
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
inline void
vtkNestingExpatBase::RedirectInternalParser (vtkNestingExpatBase* aChild)
{
  assert(aChild != NULL);

  vtkDebugMacro(<< "RedirectInternalParser(" << aChild << ")");

  this->SetChild(aChild);
  aChild->SetParent(this);
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
inline void
vtkNestingExpatBase::OrphanChild (vtkNestingExpatBase* aCallingChild)
{
  assert(aCallingChild == this->Child);

  vtkDebugMacro(<< "OrphanChild(" << aCallingChild << ")");

  this->Child = NULL;

  this->Modified();
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
inline vtkNestingExpatBase*
vtkNestingExpatBase::ReturnToParent (void)
{
  assert(this->Parent != NULL);

  vtkNestingExpatBase* parent = this->Parent;

  vtkDebugMacro(<< "ReturnToParent() returning " << parent);

  this->Parent->GrabInternalParser();

  this->Parent = NULL;
  this->Parser = NULL;  // Prevent parser shutdown by destructor!

  if (this->SelfDeleting)
    {
    parent->OrphanChild(this);
    // MUST BE LAST THING CALLED IN NON-VIRTUAL FUNCTION, NO MEMBER ACCESS
    this->Delete();
    }

  return parent;
}

// ----------------------------------------------------------------------------
inline void
vtkNestingExpatBase::NestedStartElementCb (void*            aPtr,
                                           const XML_Char*  aName,
                                           const XML_Char** aAttrs)
{
  assert(aPtr != NULL);

  vtkNestingExpatBase* parser = reinterpret_cast<vtkNestingExpatBase*>(aPtr);

  parser->Depth++;
  parser->StartElement(aName, aAttrs); // probably user override
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
inline void
vtkNestingExpatBase::NestedEndElementCb (void*           aPtr,
                                         const XML_Char* aName)
{
  if (aPtr == NULL) { return; } // This is end tag callback of a root parser.

  vtkNestingExpatBase* parser = reinterpret_cast<vtkNestingExpatBase*>(aPtr);

  // We don't know until we hit a closing tag 'outside' us that our run is done.
  if (parser->Depth == 0)
    {
    vtkNestingExpatBase* parentParser = parser->ReturnToParent();
    // Callbacks for vtkNestingExpatBase stay registered, so safe
    // If we don't invoke their callback, they will not balance
    // their \c vtkNestingExpatBase::Depth.
    vtkNestingExpatBase::NestedEndElementCb(parentParser, aName);               
    }
  else
    {
    // end of an element this parser has started
    parser->EndElement(aName);  // probably user override
    parser->Depth--;
    }
}

VTK_EXTENSIONS_NAMESPACE_END

#endif /* VTK_NESTING_EXPAT_BASE_H_ */
/*
 * End of: $Id: vtkNestingExpatBase.h,v 1.3 2004/05/29 23:19:34 xpxqx Exp $.
 * 
 */

---