graphhandler.cpp

AIML的实现

	{
		//Do nothing	
		logging("caught nullString on message.getChar()");
	}

	for(unsigned int i = 0; i < attributes.getLength(); i++)
	{
		try
		{
			attributeName.translate(attributes.getName(static_cast<unsigned int>(i)));
			logging("Attribute name:" + attributeName.getString()); 

			attributeValue.translate(attributes.getValue(static_cast<unsigned int>(i)));
			logging("Attribute Value:" + attributeValue.getString());
			m_currentStartElement->setAttribute(attributeName.getStringPimpl(), attributeValue.getStringPimpl());
		}
		catch(nullString &)
		{
			//Do nothing	
			logging("caught nullString on attributeValue.getChar()");
		}
	}
}

void GraphHandler::endElement(const XMLCh *const name)
{
	LOG_BOT_METHOD("void GraphHandler::endElement(const XMLCh *const name)");

	/*
	 * Important note. No error handling needs to take place and match up end tags
	 * with the begining tags.
     *
	 * The reason is that the SAX parser is going to handle all the endElement
	 * Errors.
	 */
	
	try
	{
		Transcode element(name);
		logging("</" + element.getString() + ">");
		const String messageString(element.getChar());

		if(m_tagStack.empty())
		{
			logging("Internal programmer Error the stack is empty");
			InternalProgrammerErrorExceptionImpl("[void GraphHandler::endElement(const XMLCh *const name)], Stack is empty");
		}

		shared_ptr<Tag> tag = m_tagStack.top();
		m_tagStack.pop();

		if(!m_tagStack.empty())
		{
			m_tagStack.top()->handleInnerTag(tag);
			m_currentStartElement = m_tagStack.top();
		}
		else
		{
			logging("Tag stack empty, not doing anything");
		}
	}
	catch(nullString &)
	{
		//Do nothing
		logging("caught nullString on someChars.getChar()");
	}
}

///@todo put this somewhere else or just remove this.
void GraphHandler::setAIMLVersion(const String &version)
{
	LOG_BOT_METHOD("void GraphHandler::setAIMLVersion(const String &version)");

	m_aimlVersion = version;

	if(version == "1.0")
	{
		logging("Version of AIML is 1.0");
		m_aimlVersion = "1.0";
	}
	else if(version == "1.0.1")
	{
		logging("Version of AIML is 1.0.1");
		m_aimlVersion = "1.0.1";
	}
	else
	{
		logging("Error, unsupported version of aiml");
		String msg("Unsupported version of aiml.  You are trying to use version:" + version);
		throw ExceptionImpl(msg.c_str());
	}

}

String GraphHandler::getAIMLVersion()
{
	return m_aimlVersion;
}
/* Commented out.  Not fast enough to justify use
shared_ptr<Tag> GraphHandler::createTagClassFromMap(const String &className) 
{
	typedef map<String, createTagMethod>::iterator I;
	I it = m_tagLookup.find(className);
	if(it != m_tagLookup.end())
	{
		logging("Returning the className of:" + className);
		return (*this.*(it->second))();
	}
	else 
	{
		//This tag is not implemented.  More than likely a
		//bogus tag such as HTML:(something).  Just return
		//a non implemented tag that just takes the text 
		//inbetween and returns it.  This way if you have a 
		//tag such as <html:em>some text<html:em>  the 
		//unimplemented tag will return "some text"
		logging("Unimplemeneted tag found.  Name is:" + className);
		return shared_ptr<Tag>(new PlainWord);
	}
}

void GraphHandler::init()
{
	m_tagLookup.insert(pair<String, createTagMethod>("category", &GraphHandler::createCategoryTag)); //1
	m_tagLookup.insert(pair<String, createTagMethod>("pattern", &GraphHandler::createPatternTag)); //2
	m_tagLookup.insert(pair<String, createTagMethod>("template", &GraphHandler::createTemplateTag)); //3
	m_tagLookup.insert(pair<String, createTagMethod>("topic", &GraphHandler::createTopicTag)); //4

	m_tagLookup.insert(pair<String, createTagMethod>("srai", &GraphHandler::createSraiTag)); //5
	m_tagLookup.insert(pair<String, createTagMethod>("that", &GraphHandler::createThatTag)); //6
	m_tagLookup.insert(pair<String, createTagMethod>("star", &GraphHandler::createStarTag)); //7

	m_tagLookup.insert(pair<String, createTagMethod>("set", &GraphHandler::createSetTag)); //8
	m_tagLookup.insert(pair<String, createTagMethod>("get", &GraphHandler::createGetTag)); //9
	m_tagLookup.insert(pair<String, createTagMethod>("think", &GraphHandler::createThinkTag)); //10

	m_tagLookup.insert(pair<String, createTagMethod>("person", &GraphHandler::createPersonTag)); //11
	m_tagLookup.insert(pair<String, createTagMethod>("bot", &GraphHandler::createConditionTag)); //12
	m_tagLookup.insert(pair<String, createTagMethod>("condition", &GraphHandler::createConditionTag)); //13

	m_tagLookup.insert(pair<String, createTagMethod>("li", &GraphHandler::createLiTag)); //14
	m_tagLookup.insert(pair<String, createTagMethod>("random", &GraphHandler::createRandomTag)); //15
	m_tagLookup.insert(pair<String, createTagMethod>("sr", &GraphHandler::createSrTag)); //16

	m_tagLookup.insert(pair<String, createTagMethod>("input", &GraphHandler::createInputTag)); //17
	m_tagLookup.insert(pair<String, createTagMethod>("thatstar", &GraphHandler::createThatStarTag)); //18
	m_tagLookup.insert(pair<String, createTagMethod>("topcstar", &GraphHandler::createTopicStarTag)); //19

	m_tagLookup.insert(pair<String, createTagMethod>("person2", &GraphHandler::createPerson2Tag)); //20
	m_tagLookup.insert(pair<String, createTagMethod>("gender", &GraphHandler::createGenderTag)); //21
	m_tagLookup.insert(pair<String, createTagMethod>("lowercase", &GraphHandler::createLowerCaseTag)); //22

	m_tagLookup.insert(pair<String, createTagMethod>("uppercase", &GraphHandler::createUpperCaseTag)); //23
	m_tagLookup.insert(pair<String, createTagMethod>("sentence", &GraphHandler::createSentenceTag)); //24
	m_tagLookup.insert(pair<String, createTagMethod>("formal", &GraphHandler::createFormalTag)); //25

	m_tagLookup.insert(pair<String, createTagMethod>("date", &GraphHandler::createDateTag)); //26
	m_tagLookup.insert(pair<String, createTagMethod>("id", &GraphHandler::createIdTag)); //27
	m_tagLookup.insert(pair<String, createTagMethod>("size", &GraphHandler::createSizeTag)); //28

	m_tagLookup.insert(pair<String, createTagMethod>("version", &GraphHandler::createVersionTag)); //29
	m_tagLookup.insert(pair<String, createTagMethod>("system", &GraphHandler::createSystemTag)); //30
	m_tagLookup.insert(pair<String, createTagMethod>("gossip", &GraphHandler::createGossipTag)); //31
	m_tagLookup.insert(pair<String, createTagMethod>("aiml", &GraphHandler::createAimlTag)); //32
}

shared_ptr<Tag> GraphHandler::createCategoryTag()
{
		++m_size;
		m_builder.setSize(m_size);
		m_builder.getCallBacks().categoryLoaded();
		return shared_ptr<Tag>(new Category);
}
shared_ptr<Tag> GraphHandler::createPatternTag()
{
		return shared_ptr<Tag>(new Pattern);
}
shared_ptr<Tag> GraphHandler::createTemplateTag()
{
		return shared_ptr<Tag>(new Template);
}
shared_ptr<Tag> GraphHandler::createTopicTag()
{
		return shared_ptr<Tag>(new Topic(m_rootNodeMapper));
}
shared_ptr<Tag> GraphHandler::createSraiTag()
{
		return shared_ptr<Tag>(new Srai(m_builder));
}
shared_ptr<Tag> GraphHandler::createThatTag()
{
		return shared_ptr<Tag>(new That(m_builder));
}
shared_ptr<Tag> GraphHandler::createStarTag()
{
		return shared_ptr<Tag>(new Star(m_builder));
}
shared_ptr<Tag> GraphHandler::createSetTag()
{
		return shared_ptr<Tag>(new Set(m_builder));
}
shared_ptr<Tag> GraphHandler::createGetTag()
{
		return shared_ptr<Tag>(new Get(m_builder));
}
shared_ptr<Tag> GraphHandler::createThinkTag()
{
		return shared_ptr<Tag>(new Think);
}
shared_ptr<Tag> GraphHandler::createPersonTag()
{
		return shared_ptr<Tag>(new Person(m_builder));
}

shared_ptr<Tag> GraphHandler::createBotTag()
{
		return shared_ptr<Tag>(new Bot(m_builder));
}

shared_ptr<Tag> GraphHandler::createConditionTag()
{
		return shared_ptr<Tag>(new Condition(m_builder));
}
shared_ptr<Tag> GraphHandler::createLiTag()
{
		return shared_ptr<Tag>(new Li);
}
shared_ptr<Tag> GraphHandler::createRandomTag()
{
		return shared_ptr<Tag>(new Random);
}
shared_ptr<Tag> GraphHandler::createSrTag()
{
		shared_ptr<Tag> nonImplemented(new NonImplemented);
		shared_ptr<Tag> srai(new Srai(m_builder));
		shared_ptr<Tag> star(new Star(m_builder));
		srai->handleInnerTag(star);
		nonImplemented->handleInnerTag(srai);
		return nonImplemented;
}
shared_ptr<Tag> GraphHandler::createInputTag()
{
		return shared_ptr<Input>(new Input(m_builder));
}
shared_ptr<Tag> GraphHandler::createThatStarTag()
{
		return shared_ptr<ThatStar>(new ThatStar(m_builder));
}
shared_ptr<Tag> GraphHandler::createTopicStarTag()
{
		return shared_ptr<TopicStar>(new TopicStar(m_builder));
}
shared_ptr<Tag> GraphHandler::createPerson2Tag()
{
		return shared_ptr<Tag>(new Person2(m_builder));
}

shared_ptr<Tag> GraphHandler::createGenderTag()
{
		return shared_ptr<Tag>(new Gender(m_builder));
}

shared_ptr<Tag> GraphHandler::createLowerCaseTag()
{
		return shared_ptr<Tag>(new LowerCase);
}
shared_ptr<Tag> GraphHandler::createUpperCaseTag()
{
		return shared_ptr<Tag>(new UpperCase);
}
shared_ptr<Tag> GraphHandler::createSentenceTag()
{
		return shared_ptr<Tag>(new Sentence);
}
shared_ptr<Tag> GraphHandler::createFormalTag()
{
		return shared_ptr<Tag>(new Formal);
}
shared_ptr<Tag> GraphHandler::createDateTag()
{
		return shared_ptr<Tag>(new Date);
}
shared_ptr<Tag> GraphHandler::createIdTag()
{
		return shared_ptr<Tag>(new Id(m_builder));
}
shared_ptr<Tag> GraphHandler::createSizeTag()
{
		return shared_ptr<Tag>(new Size(m_builder));
}
shared_ptr<Tag> GraphHandler::createVersionTag()
{
		return shared_ptr<Tag>(new Version(m_builder));
}
shared_ptr<Tag> GraphHandler::createSystemTag()
{
		return shared_ptr<Tag>(new System);
}
shared_ptr<Tag> GraphHandler::createGossipTag()
{
		return shared_ptr<Tag>(new Gossip(m_builder));
}
shared_ptr<Tag> GraphHandler::createAimlTag()
{
		return shared_ptr<Tag>(new AIML(*this, m_rootNodeMapper));
}

*/

} // end of namespace impl
} // end of namespace rebecca