ViewVC Help

View File | Revision Log | Show Annotations | Download File | View Changeset | Root Listing

root/repos/SiteMapper/SiteMapper.cpp

Comparing SiteMapper/SiteMapper.cpp (file contents):
Revision 134 by Douglas Thrift, 2004-03-24T22:23:19-08:00 vs.
Revision 423 by douglas, 2005-03-09T19:23:17-08:00

#	Line 5 | Line 5
5		// $Id$
6
7		#include "SiteMapper.hpp"
8	<	#include "Matcher.hpp"
9	<	#include "Page.hpp"
8	>	#include "Matcher/Matcher.hpp"
9
10	<	#include <xalanc/Include/PlatformDefinitions.hpp>
11	<	#include <xercesc/util/PlatformUtils.hpp>
13	<	#include <xercesc/framework/LocalFileInputSource.hpp>
14	<	#include <xalanc/XPath/XObject.hpp>
15	<	#include <xalanc/XPath/XPathEvaluator.hpp>
16	<	#include <xalanc/DOMSupport/XalanDocumentPrefixResolver.hpp>
17	<	#include <xalanc/XalanSourceTree/XalanSourceTreeDOMSupport.hpp>
18	<	#include <xalanc/XalanSourceTree/XalanSourceTreeInit.hpp>
19	<	#include <xalanc/XalanSourceTree/XalanSourceTreeParserLiaison.hpp>
20	<
21	<	XALAN_USING_XERCES(XMLPlatformUtils)
22	<	XALAN_USING_XERCES(LocalFileInputSource)
23	<	XALAN_USING_XALAN(XObjectPtr)
24	<	XALAN_USING_XALAN(XPathEvaluator)
25	<	XALAN_USING_XALAN(XalanDocument)
26	<	XALAN_USING_XALAN(XalanDocumentPrefixResolver)
27	<	XALAN_USING_XALAN(XalanDOMString)
28	<	XALAN_USING_XALAN(XalanNode)
29	<	XALAN_USING_XALAN(XalanSourceTreeInit)
30	<	XALAN_USING_XALAN(XalanSourceTreeDOMSupport)
31	<	XALAN_USING_XALAN(XalanSourceTreeParserLiaison)
32	<
33	<	string program;
34	<	bool debug = false;
35	<
36	<	int main(int argc, char* argv[])
37	<	{
38	<	program = argv[0];
39	<
40	<	string siteIndex, siteMap;
10	>	#include <menes-api/exename.hpp>
11	>	#include <menes-app/application.hpp>
12
13	<	for (int index = 1; index < argc; index++)
13	>	struct SiteMapperCommand : public app::Application
14	>	{
15	>	virtual int Run(const app::ArgumentList& args)
16		{
17	<	string arg(argv[index]);
45	<	Matcher matcher;
17	>	SiteMapper::program = api::GetExecutablePath().GetName();
18
19	<	if (arg == matcher("^-index=(.*)$"))
19	>	ext::String siteIndex, siteMap;
20	>
21	>	_foreach (const app::ArgumentList, arg, args)
22		{
23	<	siteIndex = matcher[1];
23	>	Matcher matcher;
24	>
25	>	if (*arg == matcher("^-index=(.*)$"))
26	>	{
27	>	siteIndex = matcher[1];
28	>	}
29	>	else if (*arg == matcher("^-map=(.*)$"))
30	>	{
31	>	siteMap = matcher[1];
32	>	}
33	>	else if (*arg == "-D")
34	>	{
35	>	if (!SiteMapper::debug) SiteMapper::debug = true;
36	>	}
37		}
38	<	else if (arg == matcher("^-map=(.*)$"))
38	>
39	>	if (!siteIndex.IsEmpty() && !siteMap.IsEmpty())
40		{
41	<	siteMap = matcher[1];
41	>	SiteMapper mapper(siteIndex, siteMap);
42		}
43	<	else if (arg == "-D")
43	>	else
44		{
45	<	if (!debug) debug = true;
45	>	api::Cout << "Usage: " << SiteMapper::program << " -index=index -map=map [-D]\n";
46		}
47	+
48	+	return 0;
49		}
50	+	} mapper;
51
52	<	if (siteIndex != "" && siteMap != "")
53	<	{
54	<	XMLPlatformUtils::Initialize();
55	<	XPathEvaluator::initialize();
52	>	SiteMapper::SiteMapper(const ext::String& siteIndex, const ext::String& siteMap)
53	>	{
54	>	oldMap(siteMap);
55	>	newIndex(siteIndex);
56	>	newMap(siteMap);
57	>	}
58
59	<	SiteMapper mapper(siteIndex, siteMap);
59	>	ext::String SiteMapper::program;
60	>	bool SiteMapper::debug(false);
61
62	<	XPathEvaluator::terminate();
63	<	XMLPlatformUtils::Terminate();
64	<	}
65	<	else
62	>	void SiteMapper::oldMap(const ext::String& siteMap)
63	>	{
64	>	ext::Handle<xml::Document> document(xml::Parse(siteMap));
65	>	ext::Handle<xml::Node> list(*document/"page"/"section"/"list");
66	>
67	>	comment = *document/"comment()";
68	>
69	>	if (debug) api::Cerr << "comment = " << comment << ios::NewLine;
70	>
71	>	oldMap(pages, list);
72	>	}
73	>
74	>	void SiteMapper::oldMap(ext::Vector<Page>& pages, xml::Node* list)
75	>	{
76	>	xml::NodeSet nodes(*list/"item");
77	>
78	>	_foreach (xml::NodeSet, node, nodes)
79		{
80	<	cout << "Usage: " << program << " -index=index -map=map [-D]\n";
81	<	}
80	>	ext::String url(**node/"link"/"@address"), title(**node/"link");
81	>	Page page(url, title);
82	>	ext::Handle<xml::Node> list(**node/"list");
83
84	<	return 0;
84	>	if (!list.IsEmpty()) oldMap(page.getChildren(), list);
85	>
86	>	pages.InsertLast(page);
87	>	}
88		}
89
90	<	SiteMapper::SiteMapper(const string& siteIndex, const string& siteMap)
90	>	void SiteMapper::newIndex(const ext::String& siteIndex)
91		{
92	<	XalanSourceTreeInit init;
92	>	ext::Handle<xml::Document> document(xml::Parse(siteIndex));
93	>	xml::NodeSet nodes(*document/"index"/"page");
94
95	<	oldMap(siteMap);
96	<	index(siteIndex);
97	<	newMap(siteMap);
95	>	_foreach (xml::NodeSet, node, nodes)
96	>	{
97	>	ios::String address(**node/"address");
98	>	ext::String port(**node/"port");
99	>
100	>	if (!port.IsEmpty()) address << ":" << port;
101	>
102	>	ext::String path(**node/"path"), title(**node/"title");
103	>	Page page(address, path, title);
104	>	Matcher matcher;
105	>
106	>	if (page == matcher("^Douglas\\sThrift's\\sWebsite\\s\\|\\sDouglas\\sThrift's\\sBlog:\\s(.+)$"))
107	>	{
108	>	if (Matcher("^\\w+\\s\\d{4}\\sArchives$") == matcher[1])
109	>	{
110	>	page.setTitle(matcher[1]);
111	>
112	>	if (newIndex(pages, page)) continue;
113	>	}
114	>	else continue;
115	>	}
116	>	else if (page == matcher("^Douglas\\sThrift's.+Website\\s\\|\\s(.+)$"))
117	>	{
118	>	page.setTitle(matcher[1]);
119	>
120	>	if (newIndex(pages, page)) continue;
121	>	}
122	>	else continue;
123	>
124	>	std::multimap<std::string, Page> items;
125	>
126	>	newPages.insert(std::pair<std::string, std::multimap<std::string, Page> >(page.getAddress(), items)).first->second.insert(std::pair<std::string, Page>(page.getChildOf(), page));
127	>	}
128		}
129
130	<	void SiteMapper::oldMap(const string& siteMap)
130	>	bool SiteMapper::newIndex(ext::Vector<Page>& pages, Page& page)
131		{
132	<	XalanSourceTreeDOMSupport support;
133	<	XalanSourceTreeParserLiaison liaison(support);
132	>	_foreach (ext::Vector<Page>, page_, pages)
133	>	{
134	>	if (*page_ == page.getAddress())
135	>	{
136	>	Matcher matcher;
137
138	<	support.setParserLiaison(&liaison);
138	>	if (*page_ == page)
139	>	{
140	>	page.setChildren(page_->getChildren());
141
142	<	XalanDOMString file(siteMap.c_str());
96	<	LocalFileInputSource source(file.c_str());
142	>	*page_ = page;
143
144	<	XalanDocument* document = liaison.parseXMLStream(source);
144	>	api::Cout << "Updated: " << page.getUrl() << ios::NewLine;
145
146	<	if (document == 0) return;
146	>	return true;
147	>	}
148	>	else if (matcher("^" + page_->getPath()) == page)
149	>	{
150	>	page.setChildOf(matcher[0]);
151
152	<	XPathEvaluator evaluator;
153	<	XalanNode* list = evaluator.selectSingleNode(support, document,
154	<	XalanDOMString("/page/section/list").c_str());
152	>	if (matcher("^" + page_->getTitle() + "\\s\\|\\s(.+)$") == page) page.setTitle(matcher[1]);
153	>
154	>	return newIndex(page_->getChildren(), page);
155	>	}
156	>	}
157	>	}
158
159	<	if (list == 0) return;
159	>	return false;
160		}
161
162	<	void SiteMapper::index(const string& siteIndex)
162	>	void SiteMapper::newMap(const ext::String& siteMap)
163		{
164	<	//
164	>	api::FileWriter file(siteMap);
165	>	ios::FormatWriter fout(file);
166	>	xml::TextWriter xml(file);
167	>
168	>	fout << ios::NewLine << "<?xml-stylesheet type=\"text/xsl\" href=\"stylesheets/sitemap.xsl\"?>" << ios::NewLine << "<!DOCTYPE page SYSTEM \"stylesheets/page.dtd\">";
169	>
170	>	xml.OutputComment(comment);
171	>
172	>	xml::ScopeElement page(xml, "page");
173	>
174	>	xml.OpenElement("title");
175	>	xml.OutputText("Sitemap");
176	>	xml.CloseElement();
177	>
178	>	xml::ScopeElement section(xml, "section"), list(xml, "list");
179	>
180	>	_foreach (ext::Vector<Page>, page, pages)
181	>	{
182	>	if (newPages.find(page->getAddress()) != newPages.end()) newMap(page->getChildren(), page->getPath(), newPages.find(page->getAddress())->second);
183	>
184	>	xml << *page;
185	>	}
186		}
187
188	<	void SiteMapper::newMap(const string& siteMap)
188	>	void SiteMapper::newMap(ext::Vector<Page>& pages, const ext::String& childOf, std::multimap<std::string, Page>& newPages)
189		{
190	<	//
190	>	_foreach (ext::Vector<Page>, page, pages) newMap(page->getChildren(), page->getPath(), newPages);
191	>
192	>	typedef std::multimap<std::string, Page> MultiMap;
193	>
194	>	_for (MultiMap::const_iterator, itor, newPages.lower_bound(childOf), newPages.upper_bound(childOf))
195	>	{
196	>	api::Cout << "Added: " << itor->second.getUrl() << ios::NewLine;
197	>
198	>	pages.InsertLast(itor->second);
199	>	}
200	>
201	>	newPages.erase(childOf);
202		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines