src/gen/result.h

См. документацию.

#include <xml_loader.h>
#include <xml_types.h>
#include <xml_defines.h>
#include <document.h>

namespace result{
class DocumentImpl;
class extension;
class ext;
class extension_subcl;
class location;

/* 
         This extension point allows PDE to find source archives for libraries in Eclipse plug-ins found in an Eclipse-based product. It is used to contribute locations that contain source archives. These locations are expected to contain the same layout as the 'plugins' directory. 
<p>
For each plug-in or fragment, a directory in the form {id}_{version} should exist. The content of the directory corresponds to the plug-in/fragment location. It should contain source code zip file in the form {library name}src.zip where library name is the name of the Java library that matches the source code. For JAR'd plug-ins and libraries named '.', the source zip file must be named simply <code>src.zip</code>.  
<p>
In addition, it should contain any file or directory specified in the build.properties using <code>src.includes</code> variable.
      
*/

/* 
         2.0
      
*/

/* 
         The following is an example of the <code>source</code> extension:
<pre>
 <extension point = "org.eclipse.pde.core.source">
     <location path="src"/>
  </extension>
</pre>

In the example above, the source location <code>src</code> in the contributing plug-in has been registered.
      
*/

/* 
         No Java code is requied for this extension point.
      
*/

/* 
         Eclipse SDK comes with source plug-ins that contain source information for all the plug-ins and fragments in Eclipse SDK.
      
*/

/* 
         Copyright (c) 2004 IBM Corporation and others.
<br>
All rights reserved. This program and the accompanying materials are made 
available under the terms of the Eclipse Public License v1.0 which 
accompanies this distribution, and is available at 
<a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
      
*/


}
void to_xml(const result::extension&);
void to_xml(const result::ext&);
void to_xml(const result::extension_subcl&);
void to_xml(const result::location&);

void applyXPath (result::extension * obj, XPath::iterator xp, XPath::iterator ite, XPathResult& res );
void applyXPath (result::ext * obj, XPath::iterator xp, XPath::iterator ite, XPathResult& res );
void applyXPath (result::extension_subcl * obj, XPath::iterator xp, XPath::iterator ite, XPathResult& res );
void applyXPath (result::location * obj, XPath::iterator xp, XPath::iterator ite, XPathResult& res );

namespace result{
typedef location extension_subt;

#ifndef _class_ext
#define _class_ext
class ext {
     friend void ::applyXPath(ext*, XPath::iterator, XPath::iterator, XPathResult& );
     friend class xpath_iterator<ext>;
     ATTRIBUTE(xboolean, isTrue)
     ATTRIBUTE(xENTITIES, ents)

     public: ext() {
     }
     public: ext( const char** atts) {
          for(const char** c = atts; *c != NULL; c++) {
               IGNORE_IF_NULL
               INIT_IF_MATCH(isTrue)
               INIT_IF_MATCH(ents)
          }
     }
     public: ext(const xboolean& visTrue ,const xENTITIES& vents) :_isTrue (visTrue) ,_ents (vents) {
     }
};
#endif //_class_ext


#ifndef _class_extension_subcl
#define _class_extension_subcl
class extension_subcl {
     friend void ::applyXPath(extension_subcl*, XPath::iterator, XPath::iterator, XPathResult& );
     friend class xpath_iterator<extension_subcl>;

     public: extension_subcl() {
     }
     public: extension_subcl( const char** atts) {
     }
};
#endif //_class_extension_subcl


#ifndef _class_extension
#define _class_extension
class extension {
     friend void ::applyXPath(extension*, XPath::iterator, XPath::iterator, XPathResult& );
     friend class xpath_iterator<extension>;
/* This is an extension class
*/

     public: LIST<result::location*> locations;

     public: LIST<result::extension_subt*> extension_subts;

     public: LIST<result::ext*> exts;

     extension_subcl* extension_subcls;

     ATTRIBUTE(xstring, point)
     ATTRIBUTE(xdouble, number)
     ATTRIBUTE(xstring, id)
     ATTRIBUTE(xstring, name)

     public: extension() {
          extension_subcls = NULL;
     }
     public: extension( const char** atts) {
          extension_subcls = NULL;
          for(const char** c = atts; *c != NULL; c++) {
               IGNORE_IF_NULL
               INIT_IF_MATCH(point)
               INIT_IF_MATCH(number)
               INIT_IF_MATCH(id)
               INIT_IF_MATCH(name)
          }
     }
     public: extension(const xstring& vpoint ,const xdouble& vnumber ,const xstring& vid ,const xstring& vname) :_point (vpoint) ,_number (vnumber) ,_id (vid) ,_name (vname) {
          extension_subcls = NULL;
     }
};
#endif //_class_extension

#ifndef _class_location
#define _class_location
class location {
     friend void ::applyXPath(location*, XPath::iterator, XPath::iterator, XPathResult& );
     friend class xpath_iterator<location>;
     ATTRIBUTE(xstring, path)
     ATTRIBUTE(xstring, path1)

     public: location() {
     }
     public: location( const char** atts) {
          for(const char** c = atts; *c != NULL; c++) {
               IGNORE_IF_NULL
               INIT_IF_MATCH(path)
               INIT_IF_MATCH(path1)
          }
     }
     public: location(const xstring& vpath ,const xstring& vpath1) :_path (vpath) ,_path1 (vpath1) {
     }
};
#endif //_class_location



class DocumentImpl: public Document {
     static void extension_element ( xml_loader *th, const char *name, const char **atts );
     static void ext_element ( xml_loader *th, const char *name, const char **atts );
     static void extension_subcl_element ( xml_loader *th, const char *name, const char **atts );
     static void location_element ( xml_loader *th, const char *name, const char **atts );
public:
     virtual XPathResult applyXPath(XPath);
     virtual void element ( xml_loader *th, const char *name, const char **atts );
};
}


template<>
class xpath_iterator<result::extension> : public abstract_xpath_iterator {
     result::extension* value;
public:
     xpath_iterator(abstract_xpath_iterator* par, result::extension* val): abstract_xpath_iterator(par), value(val) {
     }
     virtual void ApplyByPath(XPath::const_iterator, XPath::const_iterator, xpath_iterator_functor& f);
     virtual void getValueByPath(XPath::const_iterator xp, XPath::const_iterator xe, XPathResult& res);
     virtual bool checkPathCondition(XPath::const_iterator, XPath::const_iterator);
     void setValue(result::extension* val) {
          value = val;
     }
     virtual void to_xml(std::ostream& out = std::cout);
};

template<>
class xpath_iterator<result::ext> : public abstract_xpath_iterator {
     result::ext* value;
public:
     xpath_iterator(abstract_xpath_iterator* par, result::ext* val): abstract_xpath_iterator(par), value(val) {
     }
     virtual void ApplyByPath(XPath::const_iterator, XPath::const_iterator, xpath_iterator_functor& f);
     virtual void getValueByPath(XPath::const_iterator xp, XPath::const_iterator xe, XPathResult& res);
     virtual bool checkPathCondition(XPath::const_iterator, XPath::const_iterator);
     void setValue(result::ext* val) {
          value = val;
     }
     virtual void to_xml(std::ostream& out = std::cout);
};

template<>
class xpath_iterator<result::extension_subcl> : public abstract_xpath_iterator {
     result::extension_subcl* value;
public:
     xpath_iterator(abstract_xpath_iterator* par, result::extension_subcl* val): abstract_xpath_iterator(par), value(val) {
     }
     virtual void ApplyByPath(XPath::const_iterator, XPath::const_iterator, xpath_iterator_functor& f);
     virtual void getValueByPath(XPath::const_iterator xp, XPath::const_iterator xe, XPathResult& res);
     virtual bool checkPathCondition(XPath::const_iterator, XPath::const_iterator);
     void setValue(result::extension_subcl* val) {
          value = val;
     }
     virtual void to_xml(std::ostream& out = std::cout);
};

template<>
class xpath_iterator<result::location> : public abstract_xpath_iterator {
     result::location* value;
public:
     xpath_iterator(abstract_xpath_iterator* par, result::location* val): abstract_xpath_iterator(par), value(val) {
     }
     virtual void ApplyByPath(XPath::const_iterator, XPath::const_iterator, xpath_iterator_functor& f);
     virtual void getValueByPath(XPath::const_iterator xp, XPath::const_iterator xe, XPathResult& res);
     virtual bool checkPathCondition(XPath::const_iterator, XPath::const_iterator);
     void setValue(result::location* val) {
          value = val;
     }
     virtual void to_xml(std::ostream& out = std::cout);
};

---