Ejemplo n.º 1
0
/*!
 *  \brief Read a Factory, obtain selection of default types for the different families.
 *  \param inIter Iterator to the XML node to read the Factory from.
 *  \param ioSystem System to use to read the type selector.
 *  \throw Beagle::IOException If the format is invalid.
 */
void Factory::readWithSystem(PACC::XML::ConstIterator inIter, System& ioSystem)
{
	Beagle_StackTraceBeginM();
	if((inIter->getType()!=PACC::XML::eData) || (inIter->getValue()!="Factory")) {
		throw Beagle_IOExceptionNodeM(*inIter, "tag <Factory> expected!");
	}
	for(PACC::XML::ConstIterator lChild=inIter->getFirstChild(); lChild; ++lChild) {
		if((lChild->getType()==PACC::XML::eData) && (lChild->getValue()=="Concept")) {
			std::string lConceptName = lChild->getAttribute("name");
			if(lConceptName.empty()) {
				throw Beagle_IOExceptionNodeM(*lChild, "no name attribute given for current Concept tag!");
			}
			std::string lTypeName = lChild->getAttribute("type");
			if(lTypeName.empty()) {
				throw Beagle_IOExceptionNodeM(*lChild, "no type attribute given for current Concept tag!");
			}
			Factory::AllocatorMap::const_iterator lIterAllocMap = mAllocatorMap.find(lTypeName);
			if(lIterAllocMap == mAllocatorMap.end()) {
				std::ostringstream lOSS;
				lOSS << "Type named '" << lTypeName;
				lOSS << "' does not exists in the internal allocator map of the Factory; ";
				lOSS << "could not associated to concept '" << lConceptName << "'.";
				throw Beagle_IOExceptionNodeM(*lChild, lOSS.str());
			}
			setConcept(lConceptName, lTypeName);
			Beagle_LogTraceM(
			    ioSystem.getLogger(),
			    std::string("Type associated to concept '")+lConceptName+
			    std::string("' is now '")+lTypeName+std::string("'")
			);
		}
	}
	Beagle_StackTraceEndM();
}
Ejemplo n.º 2
0
/*!
 * \brief Read object from XML using system.
 * \param inIter XML iterator of input document.
 * \param ioSystem A reference to the system.
 * \throw SCHNAPS::Core::IOException if a wrong tag is encountered.
 * \throw SCHNAPS::Core::IOException if inProbabilities attribute is missing.
 * \throw SCHNAPS::Core::RunTimeException if the primitive is undefined for the specific probabilities source.
 */
void BranchMulti::readWithSystem(PACC::XML::ConstIterator inIter, Core::System& ioSystem) {
	schnaps_StackTraceBeginM();
	if (inIter->getType() != PACC::XML::eData) {
		throw schnaps_IOExceptionNodeM(*inIter, "tag expected!");
	}
	if (inIter->getValue() != getName()) {
		std::ostringstream lOSS;
		lOSS << "tag <" << getName() << "> expected, but ";
		lOSS << "got tag <" << inIter->getValue() << "> instead!";
		throw schnaps_IOExceptionNodeM(*inIter, lOSS.str());
	}

	// retrieve probabilities of executing each branch
	if (inIter->getAttribute("inProbabilities").empty()) {
		throw schnaps_IOExceptionNodeM(*inIter, "probabilities of executing each branch expected!");
	}
	mProbabilities_Ref.assign(inIter->getAttribute("inProbabilities"));
	
	switch (mProbabilities_Ref[0]) {
		case '@':
			// individual variable value
		case '#':
			// environment variable value
		case '%':
			// local variable value
			throw schnaps_RunTimeExceptionM("The primitive is undefined for the specific probabilities source!");
			break;
		case '$':
			// parameter value
			mProbabilities = Core::castHandleT<Core::Vector>(ioSystem.getParameters().getParameterHandle(mProbabilities_Ref.substr(1)));
			break;
		default: {
			// direct value
			std::stringstream lISS(mProbabilities_Ref);
			PACC::Tokenizer lTokenizer(lISS);
			lTokenizer.setDelimiters("|", "");
			
			std::string lProbability;
			double lSum = 0;

			mProbabilities = new Core::Vector();
			while (lTokenizer.getNextToken(lProbability)) {
				mProbabilities->push_back(new Core::Double(SCHNAPS::str2dbl(lProbability)));
				lSum += SCHNAPS::str2dbl(lProbability);
			}
			
#ifndef SCHNAPS_NDEBUG
			if (lSum != 1) {
				std::cout << "Warning: multi branches probabilities must sum to 1 (current sum: " <<  lSum << "!";
				std::cout << "\tIn: void SCHNAPS::Plugins::Control::BranchMulti::readWithSystem(PACC::XML::ConstIterator, SCHNAPS::Core::System&)\n";
			}
#endif
			break; }
	}
	setNumberArguments(mProbabilities->size());
	schnaps_StackTraceEndM("void SCHNAPS::Plugins::Control::BranchMulti::readWithSystem(PACC::XML::ConstIterator, SCHNAPS::Core::System&)");
}
Ejemplo n.º 3
0
/*!
 *  \brief Read an instruction super set from a Beagle XML stream.
 *  \param inIter XML node used to read the super set from.
 *  \throw Beagle::IOException If size atribute not present.
 */
void LinGP::InstructionSuperSet::read(PACC::XML::ConstIterator inIter)
{
	if((inIter->getType() != PACC::XML::eData) || (inIter->getValue() != "InstructionSuperSet"))
		throw Beagle_IOExceptionNodeM((*inIter), "tag <InstructionSuperSet> expected!");
	unsigned int lPSIndex = 0;
	for(PACC::XML::ConstIterator lChild=inIter->getFirstChild(); lChild; ++lChild) {
		if((lChild->getType()==PACC::XML::eData) && (lChild->getValue()=="InstructionSet")) {
			mInstructionSets[lPSIndex++]->read(lChild);
		}
	}
}
Ejemplo n.º 4
0
/*!
 *  \brief Read a sigma adaptation operator from a XML subtree.
 *  \param inIter XML iterator to use to read adaptation operator.
 *  \param ioSystem Evolutionary system.
 */
void ES::AdaptOneFifthRuleOp::readWithSystem(PACC::XML::ConstIterator inIter, System& ioSystem)
{
	Beagle_StackTraceBeginM();
	if((inIter->getType()!=PACC::XML::eData) || (inIter->getValue()!=getName())) {
		std::ostringstream lOSS;
		lOSS << "tag <" << getName() << "> expected!" << std::flush;
		throw Beagle_IOExceptionNodeM(*inIter, lOSS.str());
	}
	string lMutateGaussSigmaReadName = inIter->getAttribute("mutgausssigma");
	if(lMutateGaussSigmaReadName.empty() == false) mMutateGaussSigmaName = lMutateGaussSigmaReadName;
	Beagle_StackTraceEndM();
}
Ejemplo n.º 5
0
/*!
 *  \brief Read a initialization operator from a XML subtree.
 *  \param inIter XML iterator to use to read initialization operator.
 *  \param ioSystem Evolutionary system.
 */
void InitializationOp::readWithSystem(PACC::XML::ConstIterator inIter, System& ioSystem)
{
	Beagle_StackTraceBeginM();
	if((inIter->getType()!=PACC::XML::eData) || (inIter->getValue()!=getName())) {
		std::ostringstream lOSS;
		lOSS << "tag <" << getName() << "> expected!" << std::flush;
		throw Beagle_IOExceptionNodeM(*inIter, lOSS.str());
	}
	std::string mReproProbaReadName = inIter->getAttribute("repropb");
	if(mReproProbaReadName.empty() == false) mReproProbaName = mReproProbaReadName;
	Beagle_StackTraceEndM();
}
Ejemplo n.º 6
0
/*!
 *  \brief Read a linear GP mutation operator from XML tree.
 *  \param inNode XML node to use to read mutation operator.
 *  \param ioSystem Evolutionary system.
 */
void LinGP::MutationOp::readWithSystem(PACC::XML::ConstIterator inIter, System& ioSystem)
{
	if((inIter->getType() != PACC::XML::eData) || (inIter->getValue() != getName())) {
		std::ostringstream lOSS;
		lOSS << "tag <" << getName() << "> expected!" << std::flush;
		throw Beagle_IOExceptionNodeM(*inIter, lOSS.str());
	}
	std::string lMutationPbReadName = inIter->getAttribute("mutationpb");
	if(lMutationPbReadName.empty() == false) mMutationPbName = lMutationPbReadName;
	std::string lInstructMutatePbReadName = inIter->getAttribute("mutinstructpb");
	if(lInstructMutatePbReadName.empty() == false) mInstructMutatePbName = lInstructMutatePbReadName;
}
Ejemplo n.º 7
0
/*!
 *  \brief Read an individual bag with a context.
 *  \param inIter XML iterator to read the bag from.
 *  \param ioContext Evolutionary context.
 */
void IndividualBag::readWithContext(PACC::XML::ConstIterator inIter, Context& ioContext)
{
	Beagle_StackTraceBeginM();
	if((inIter->getType()!=PACC::XML::eData) || (inIter->getValue()!="IndividualBag"))
		throw Beagle_IOExceptionNodeM(*inIter, "tag <IndividualBag> expected!");
	for(PACC::XML::ConstIterator lChild=inIter->getFirstChild(); lChild; ++lChild) {
		if(lChild->getType() == PACC::XML::eData) {
			readIndividuals(lChild, ioContext);
			break;
		}
	}
	Beagle_StackTraceEndM();
}
Ejemplo n.º 8
0
/*!
 *  \brief Read invoker primitive from XML subtree.
 *  \param inIter XML iterator to read the primitive from.
 *  \param ioContext Evolutionary context.
 */
void GP::Invoker::readWithContext(PACC::XML::ConstIterator inIter, GP::Context& ioContext)
{
	Beagle_StackTraceBeginM();
	GP::Primitive::readWithContext(inIter, ioContext);
	std::string lIndexValue = inIter->getAttribute("id");
	if(lIndexValue.empty()==false) mIndex = str2uint(lIndexValue);
	unsigned int lArgsCount = 0;
	for(PACC::XML::ConstIterator lChild=inIter->getFirstChild(); lChild; ++lChild) {
		if(lChild->getType()==PACC::XML::eData) ++lArgsCount;
	}
	setNumberArguments(lArgsCount);
	Beagle_StackTraceEndM("void GP::Invoker::readWithContext(PACC::XML::ConstIterator inIter, GP::Context& ioContext)");
}
Ejemplo n.º 9
0
/*!
 * \brief Read object from XML using system.
 * \param inIter XML iterator of input document.
 * \param ioSystem A reference to the system.
 * \throw SCHNAPS::Core::IOException if a wrong tag is encountered.
 */
void Primitive::readWithSystem(PACC::XML::ConstIterator inIter, System& ioSystem) {
	schnaps_StackTraceBeginM();
	if (inIter->getType() != PACC::XML::eData) {
		throw schnaps_IOExceptionNodeM(*inIter, "tag expected!");
	}
	if (inIter->getValue() != getName()) {
		std::ostringstream lOSS;
		lOSS << "tag <" << getName() << "> expected, but ";
		lOSS << "got tag <" << inIter->getValue() << "> instead!";
		throw schnaps_IOExceptionNodeM(*inIter, lOSS.str());
	}
	schnaps_StackTraceEndM("void SCHNAPS::Core::Primitive::readWithSystem(PACC::XML::ConstIterator, SCHNAPS::Core::System&)");
}
Ejemplo n.º 10
0
/*!
 *  \brief Read a recombination operator from XML tree.
 *  \param inIter XML iterator to use to read recombination operator.
 *  \param ioSystem Evolutionary system.
 */
void RecombinationOp::readWithSystem(PACC::XML::ConstIterator inIter, System& ioSystem)
{
	Beagle_StackTraceBeginM();
	if((inIter->getType()!=PACC::XML::eData) || (inIter->getValue()!=getName())) {
		std::ostringstream lOSS;
		lOSS << "tag <" << getName() << "> expected!" << std::flush;
		throw Beagle_IOExceptionNodeM(*inIter, lOSS.str());
	}
	std::string lRecombProbaReadName = inIter->getAttribute("recombpb");
	if(lRecombProbaReadName.empty()==false) mRecombProbaName = lRecombProbaReadName;
	std::string lNumberRecombReadName = inIter->getAttribute("nbrindrecomb");
	if(lNumberRecombReadName.empty()==false) mNumberRecombName = lNumberRecombReadName;
	Beagle_StackTraceEndM();
}
Ejemplo n.º 11
0
/*!
 *  \brief Read a bit flip mutation operator from XML subtree.
 *  \param inIter XML iterator to use to read mutation operator.
 *  \param ioSystem Evolutionary system.
 */
void BitStr::MutationFlipBitOp::readWithSystem(PACC::XML::ConstIterator inIter, System& ioSystem)
{
	Beagle_StackTraceBeginM();
	if((inIter->getType()!=PACC::XML::eData) || (inIter->getValue()!=getName())) {
		std::ostringstream lOSS;
		lOSS << "tag <" << getName() << "> expected!" << std::flush;
		throw Beagle_IOExceptionNodeM(*inIter, lOSS.str());
	}
	std::string lMutationPbReadName = inIter->getAttribute("mutationpb");
	if(lMutationPbReadName.empty() == false) mMutationPbName = lMutationPbReadName;
	std::string lBitMutatePbReadName = inIter->getAttribute("mutbitpb");
	if(lBitMutatePbReadName.empty() == false) mBitMutatePbName = lBitMutatePbReadName;
	Beagle_StackTraceEndM();
}
Ejemplo n.º 12
0
/*!
 *  \brief Read a OversizeOp operator for XML tree.
 *  \param inIter XML iterator to use to read OversizeOp operator.
 *  \param ioSystem Evolutionary system.
 */
void OversizeOp::readWithSystem(PACC::XML::ConstIterator inIter, System& ioSystem)
{
	Beagle_StackTraceBeginM();
	if((inIter->getType()!=PACC::XML::eData) || (inIter->getValue()!=getName())) {
		std::ostringstream lOSS;
		lOSS << "tag <" << getName() << "> expected!" << std::flush;
		throw Beagle_IOExceptionNodeM(*inIter, lOSS.str());
	}
	string lOversizeRatioReadName = inIter->getAttribute("ratio_name");
	if(lOversizeRatioReadName.empty() == false) mOversizeRatioName = lOversizeRatioReadName;
	
	ReplacementStrategyOp::readWithSystem(inIter, ioSystem);
	Beagle_StackTraceEndM("void OversizeOp::readWithSystem(PACC::XML::ConstIterator, System&)");
}
Ejemplo n.º 13
0
/*!
 *  \brief Read a mutation operator from XML subtree.
 *  \param inIter XML iterator to use to read crossover operator.
 *  \param ioSystem Evolutionary system.
 */
void GP::MutationSwapSubtreeOp::readWithSystem(PACC::XML::ConstIterator inIter, System& ioSystem)
{
	Beagle_StackTraceBeginM();
	if((inIter->getType()!=PACC::XML::eData) || (inIter->getValue()!=getName())) {
		std::ostringstream lOSS;
		lOSS << "tag <" << getName() << "> expected!" << std::flush;
		throw Beagle_IOExceptionNodeM(*inIter, lOSS.str());
	}
	std::string mMutationPbReadName = inIter->getAttribute("mutationpb");
	if(mMutationPbReadName.empty() == false) mMutationPbName = mMutationPbReadName;
	std::string mDistribPbReadName = inIter->getAttribute("distrpb");
	if(mDistribPbReadName.empty() == false) mDistribPbName = mDistribPbReadName;
	Beagle_StackTraceEndM();
}
Ejemplo n.º 14
0
/*!
 *  \brief Read genotype from a Beagle XML node.
 *  \param inIter XML iterator to read the genotype from.
 *  \param ioContext Evolutionary context.
 */
void Genotype::readWithContext(PACC::XML::ConstIterator inIter, Context& ioContext)
{
	Beagle_StackTraceBeginM();
	if((inIter->getType() != PACC::XML::eData) || (inIter->getValue() != "Genotype")) {
		throw Beagle_IOExceptionNodeM(*inIter, "tag <Genotype> expected!");
	}
	std::string lGenotypeType = inIter->getAttribute("type");
	if((lGenotypeType.empty() == false) && (lGenotypeType != getType())) {
		std::ostringstream lOSS;
		lOSS << "type given '" << lGenotypeType << "' mismatch type of the genotype '";
		lOSS << getType() << "'!";
		throw Beagle_IOExceptionNodeM(*inIter, lOSS.str());
	}
	Beagle_StackTraceEndM("void Genotype::readWithContext(PACC::XML::ConstIterator,Context&)");
}
Ejemplo n.º 15
0
/*!
 *  \brief Read a max fitness termination operator from a XML subtree.
 *  \param inIter XML iterator from which the operator is read.
 *  \param ioSystem Evolutionary system.
 *  \throw IOException If a reading error occurs.
 */
void TermMaxFitnessOp::readWithSystem(PACC::XML::ConstIterator inIter, System& ioSystem)
{
	Beagle_StackTraceBeginM();
	if((inIter->getType()!=PACC::XML::eData) || (inIter->getValue()!=getName())) {
		std::ostringstream lOSS;
		lOSS << "tag <" << getName() << "> expected!" << std::flush;
		throw Beagle_IOExceptionNodeM(*inIter, lOSS.str());
	}
	std::string lFitnessStr = inIter->getAttribute("fitness");
	if(lFitnessStr.empty() == false) {
		mMaxFitnessDefault = str2dbl(lFitnessStr);
		if(mMaxFitness != NULL) mMaxFitness->getWrappedValue() = mMaxFitnessDefault;
	}
	Beagle_StackTraceEndM();
}
Ejemplo n.º 16
0
void Beagle::WrapperT<T>::read(PACC::XML::ConstIterator inIter)
{
	Beagle_StackTraceBeginM();
	if(!inIter) mWrappedValue = T();
	else {
		if(inIter->getType() != PACC::XML::eString)
			throw Beagle_IOExceptionNodeM(*inIter, "value of wrapper not found");
		if(inIter->getValue().empty()) mWrappedValue = T();
		else {
			std::istringstream lISS(inIter->getValue());
			lISS >> mWrappedValue;
		}
	}
	Beagle_StackTraceEndM();
}
void Beagle::GP::MutationEphemeralOpT<T>::readWithSystem(PACC::XML::ConstIterator inIter,
        Beagle::System& ioSystem)
{
	Beagle_StackTraceBeginM();
	if((inIter->getType()!=PACC::XML::eData) || (inIter->getValue()!=getName())) {
		std::ostringstream lOSS;
		lOSS << "tag <" << getName() << "> expected!" << std::flush;
		throw Beagle_IOExceptionNodeM(*inIter, lOSS.str());
	}
	std::string lMutationPbReadName = inIter->getAttribute("mutationpb");
	if(lMutationPbReadName.empty() == false) mMutationPbName = lMutationPbReadName;
	std::string lEphemeralNameParamName = inIter->getAttribute("primitname");
	if(lEphemeralNameParamName.empty() == false) mEphemeralNameParamName = lEphemeralNameParamName;
	Beagle_StackTraceEndM("void GP::MutationEphemeralOpT<T>::readWithSystem(PACC::XML::ConstIterator, System&)");
}
Ejemplo n.º 18
0
/*!
 *  \brief Read an instruction set from a XML node.
 *  \param inIter XML node to read the instruction set from.
 *  \throw IOException If size atribute not present or if the size mismatch.
 */
void LinGP::InstructionSet::read(PACC::XML::ConstIterator inIter)
{
	if((inIter->getType() != PACC::XML::eData) || (inIter->getValue() != "InstructionSet"))
		throw Beagle_IOExceptionNodeM(*inIter, "tag <InstructionSet> expected!");
	for(PACC::XML::ConstIterator lChild=inIter->getFirstChild(); lChild; ++lChild) {
		if(lChild->getType() == PACC::XML::eData) {
			Instruction::Handle lInstruction = getInstructionByName(lChild->getValue());
			if(lInstruction == NULL) {
				std::ostringstream lOSS;
				lOSS << "Instruction '" << lChild->getValue();
				lOSS << "' is not in the instruction set!";
				throw Beagle_IOExceptionNodeM(*lChild, lOSS.str());
			}
			lInstruction->read(lChild);
		}
	}
}
Ejemplo n.º 19
0
/*!
 *  \brief Read an ES vector from a XML subtree.
 *  \param inIter XML iterator from which the ES vector is read.
 *  \param ioContext Evolutionary context.
 *  \throw IOException If a reading error occured (generally bad file format)!
 */
void GA::ESVector::readWithContext(PACC::XML::ConstIterator inIter, Context& ioContext)
{
	Beagle_StackTraceBeginM();
	if((inIter->getType() != PACC::XML::eData) || (inIter->getValue() != "Genotype")) {
		throw Beagle_IOExceptionNodeM(*inIter, "tag <Genotype> expected!");
	}
	std::string lGenotypeType = inIter->getAttribute("type");
	if((lGenotypeType.empty() == false) && (lGenotypeType != getType())) {
		std::ostringstream lOSS;
		lOSS << "type given '" << lGenotypeType << "' mismatch type of the genotype '";
		lOSS << getType() << "'!";
		throw Beagle_IOExceptionNodeM(*inIter, lOSS.str());
	}

	PACC::XML::ConstIterator lChild = inIter->getFirstChild();
	if((!lChild) || (lChild->getType()!=PACC::XML::eString)) {
		throw Beagle_IOExceptionNodeM(*lChild, "expected content for the ES vector!");
	}

	clear();
	std::istringstream lISS(lChild->getValue());
	do {
		char lC1='\0', lC2='\0', lC3='\0';
		double lValue=DBL_MAX, lStrategy=DBL_MAX;
		lISS >> lC1 >> lValue >> lC2 >> lStrategy >> lC3;
		if((lC1!='(') || (lC2!=',') || (lC3!=')'))
			throw Beagle_IOExceptionNodeM(*lChild, "bad format of ES vector!");
		if((lValue==DBL_MAX) || (lStrategy==DBL_MAX))
			throw Beagle_IOExceptionNodeM(*lChild, "bad format of ES vector!");
		push_back(ESPair(lValue, lStrategy));
	} while(lISS.get()==int('/'));
	Beagle_StackTraceEndM("void GA::ESVector::readWithContext(PACC::XML::ConstIterator,Context&)");
}
/*!
 *  \brief Read a float vector from a XML subtree.
 *  \param inIter XML iterator from which the float vector is read.
 *  \param ioContext Evolutionary context.
 *  \throw Beagle::IOException If a reading error occured (generally bad file format)!
 */
void GA::IntegerVector::readWithContext(PACC::XML::ConstIterator inIter, Context& ioContext)
{
	Beagle_StackTraceBeginM();
	if((inIter->getType() != PACC::XML::eData) || (inIter->getValue() != "Genotype")) {
		throw Beagle_IOExceptionNodeM(*inIter, "tag <Genotype> expected!");
	}
	std::string lGenotypeType = inIter->getAttribute("type");
	if((lGenotypeType.empty() == false) && (lGenotypeType != getType())) {
		std::ostringstream lOSS;
		lOSS << "type given '" << lGenotypeType << "' mismatch type of the genotype '";
		lOSS << getType() << "'!";
		throw Beagle_IOExceptionNodeM(*inIter, lOSS.str());
	}

	PACC::XML::ConstIterator lChild = inIter->getFirstChild();
	if((!lChild) || (lChild->getType()!=PACC::XML::eString))
		throw Beagle_IOExceptionNodeM(*lChild, "expected content for the float vector!");

	clear();
	std::istringstream lISS(lChild->getValue());
	while(lISS.good()) {
		int lValue=INT_MAX;
		lISS >> lValue;
		push_back(lValue);
		if(lISS.good()==false) break;
		int lDelim=lISS.get();
		if((lISS.good()==false) || (lDelim==-1)) break;
	}
	Beagle_StackTraceEndM("void GA::IntegerVector::readWithContext(PACC::XML::ConstIterator,Context&)");
}
Ejemplo n.º 21
0
/*!
 * \brief Read object from XML using system.
 * \param inIter XML iterator of input document.
 * \param ioSystem A reference to the system.
 * \throw SCHNAPS::Core::IOException if a wrong tag is encountered.
 */
void PrimitiveTree::readWithSystem(PACC::XML::ConstIterator inIter, System& ioSystem) {
	schnaps_StackTraceBeginM();
	if (inIter) {
		if (inIter->getType() != PACC::XML::eData) {
			throw schnaps_IOExceptionNodeM(*inIter, "tag expected!");
		}
		if (inIter->getValue() != getName()) {
			std::ostringstream lOSS;
			lOSS << "tag <" << getName() << "> expected, but ";
			lOSS << "got tag <" << inIter->getValue() << "> instead!";
			throw schnaps_IOExceptionNodeM(*inIter, lOSS.str());
		}

		// Get size attribute and reserve size accordingly
		std::string lSizeText = inIter->getAttribute("size");
		if (lSizeText.empty() == false) {
			reserve(str2uint(lSizeText));
		}

		PACC::XML::ConstIterator lChild = inIter->getFirstChild();
		if ((!lChild) || (lChild->getType() != PACC::XML::eData)) {
			throw schnaps_IOExceptionNodeM(*lChild, "expected a XML tag for the primitive tree!");
		}
		clear();
		readSubTree(lChild, ioSystem);
	}
	schnaps_StackTraceEndM("void SCHNAPS::Core::PrimitiveTree::readWithSystem(PACC::XML::ConstIterator, SCHNAPS::Core::System&)");
}
Ejemplo n.º 22
0
/*!
 *  \brief Read the member instance.
 *  \param inIter Iterator to XML node to read component from.
 *  \param ioContext Evolutionary context.
 */
void Member::readWithContext(PACC::XML::ConstIterator inIter, Context& ioContext)
{
	Beagle_StackTraceBeginM();
	if((inIter->getType() != PACC::XML::eData) || (inIter->getValue() != getName())) {
		std::ostringstream lOSS;
		lOSS << "expected to get tag '" << getName() << "' instead of tag '";
		lOSS << inIter->getValue() << "'!";
		throw Beagle_IOExceptionNodeM(*inIter, lOSS.str());
	}
	std::string lType = inIter->getAttribute("type");
	if((lType.empty() == false) && (lType != getType())) {
		std::ostringstream lOSS;
		lOSS << "type given '" << lType << "' mismatch type of the member '";
		lOSS << getType() << "'!";
		throw Beagle_IOExceptionNodeM(*inIter, lOSS.str());
	}
	Beagle_StackTraceEndM("void Member::readWithContext(PACC::XML::ConstIterator,Context&)");
}
Ejemplo n.º 23
0
/*!
 *  \brief Read vector from a XML subtree.
 *  \param inIter XML iterator to read the vector from.
 */
void Vector::read(PACC::XML::ConstIterator inIter)
{
	Beagle_StackTraceBeginM();
	if(inIter->getType()!=PACC::XML::eString)
		throw Beagle_IOExceptionNodeM(*inIter,"expected string to read vector!");
	clear();
	std::istringstream lISS(inIter->getValue());
	while(lISS.good()) {
		double lValue;
		lISS >> lValue;
		resize(size()+1);
		(*this)[size()-1] = lValue;
		if(lISS.good()==false) break;
		int lDelim=lISS.get();
		if((lISS.good()==false) || (lDelim==-1)) break;
	}
	Beagle_StackTraceEndM("void Vector::read(PACC::XML::ConstIterator inIter)");
}
Ejemplo n.º 24
0
/*!
 *  \brief  Read a primitive subtree from a XML subtree.
 *  \param  inIter XML iterator to read primitive tree from.
 *  \param  ioSystem A reference to the system.
 *  \return The size of the subtree read.
 *  \throw  SCHNAPS::Core::IOException if a wrong tag is encountered.
 */
unsigned int PrimitiveTree::readSubTree(PACC::XML::ConstIterator inIter, System& ioSystem) {
	schnaps_StackTraceBeginM();
	if (inIter->getType() != PACC::XML::eData) {
		throw schnaps_IOExceptionNodeM(*inIter, "tag expected!");
	}

	Primitive::Alloc::Handle lPrimitiveAlloc =  castHandleT<Primitive::Alloc>(ioSystem.getFactory().getAllocator(inIter->getValue()));
	if(lPrimitiveAlloc == NULL) {
		std::ostringstream lOSS;
		lOSS << "no primitive named '" <<  inIter->getValue();
		lOSS << "' found in the factory";
		throw schnaps_IOExceptionNodeM(*inIter, lOSS.str());
	}

	Primitive::Handle lPrimitive =  castHandleT<Primitive>(lPrimitiveAlloc->allocate());
	unsigned int lNodeIdx = size();
	push_back(Node(lPrimitive, 0));
	(*this)[lNodeIdx].mPrimitive->readWithSystem(inIter, ioSystem);

	unsigned int lSubTreeSize = 1;
	unsigned int lNbChild = 0;

	for (PACC::XML::ConstIterator lChild = inIter->getFirstChild(); lChild; lChild++) {
		if (lChild->getType() == PACC::XML::eData) {
			lSubTreeSize += readSubTree(lChild, ioSystem);
			lNbChild++;
		}
	}
	if ((*this)[lNodeIdx].mPrimitive->getNumberArguments() == Primitive::eAny) {
		(*this)[lNodeIdx].mPrimitive->setNumberArguments(lNbChild);
	} else {
		if (lNbChild != (*this)[lNodeIdx].mPrimitive->getNumberArguments()) {
			std::ostringstream lOSS;
			lOSS << "number of arguments stated by the primitives (";
			lOSS << (*this)[lNodeIdx].mPrimitive->getNumberArguments();
			lOSS << ") mismatch the number of arguments read for the tree node (";
			lOSS << lNbChild << ")!";
			throw schnaps_IOExceptionNodeM(*inIter, lOSS.str());
		}
	}
	(*this)[lNodeIdx].mSubTreeSize = lSubTreeSize;
	return lSubTreeSize;
	schnaps_StackTraceEndM("void SCHNAPS::Core::PrimitiveTree::readSubTree(PACC::XML::ConstIterator, SCHNAPS::Core::System&)");
}
Ejemplo n.º 25
0
/*!
 *  \brief Read a vivarium population from an XML iterator.
 *  \param inIter XML iterator to read the vivarium population from.
 *  \param ioContext Evolutionary context.
 *  \throw Beagle::IOException If the format is not respected.
 */
void Vivarium::readPopulation(PACC::XML::ConstIterator inIter, Context& ioContext)
{
	Beagle_StackTraceBeginM();
	if((inIter->getType()!=PACC::XML::eData) || (inIter->getValue()!="Population")) {
		throw Beagle_IOExceptionNodeM(*inIter, "tag <Population> expected!");
	}
	const Factory& lFactory = ioContext.getSystem().getFactory();
	unsigned int lPrevDemeIndex = ioContext.getDemeIndex();
	Deme::Handle lPrevDemeHandle = ioContext.getDemeHandle();
	clear();
	for(PACC::XML::ConstIterator lIter=inIter->getFirstChild(); lIter; ++lIter) {
		if((lIter->getType()!=PACC::XML::eData) || (lIter->getValue()!="Deme")) continue;
		const std::string& lDemeType = lIter->getAttribute("type");
		Deme::Alloc::Handle lDemeAlloc = NULL;
		if(lDemeType.empty()) {
			Deme::Alloc::Handle lDemeAlloc =
			    castHandleT<Deme::Alloc>(lFactory.getConceptAllocator("Deme"));
			if(lDemeAlloc == NULL) {
				std::ostringstream lOSS;
				lOSS << "Deme object can't be read, ";
				lOSS << "it appears that its type is not given and that there is not ";
				lOSS << "valid concept allocator associated to it!";
				throw Beagle_IOExceptionNodeM(*lIter, lOSS.str());
			}
		} else {
			lDemeAlloc = castHandleT<Deme::Alloc>(lFactory.getAllocator(lDemeType));
			if(lDemeAlloc == NULL) {
				std::ostringstream lOSS;
				lOSS << "Type '" << lDemeType << "' associated to deme object ";
				lOSS << "is not valid!";
				throw Beagle_IOExceptionNodeM(*lIter, lOSS.str());
			}
		}
		Deme::Handle lDeme = castHandleT<Deme>(lDemeAlloc->allocate());
		ioContext.setDemeHandle(lDeme);
		ioContext.setDemeIndex(size());
		push_back(lDeme);
		lDeme->readWithContext(lIter, ioContext);
	}
	ioContext.setDemeHandle(lPrevDemeHandle);
	ioContext.setDemeIndex(lPrevDemeIndex);
	Beagle_StackTraceEndM();
}
Ejemplo n.º 26
0
/*!
 *  \brief Read an argument primitive from XML subtree.
 *  \param inIter XML iterator to read primitive from.
 *  \param ioContext Evolutionary context.
 */
void GP::Argument::readWithContext(PACC::XML::ConstIterator inIter, GP::Context& ioContext)
{
	Beagle_StackTraceBeginM();
	GP::Primitive::readWithContext(inIter, ioContext);
	std::string lIndexValue = inIter->getAttribute("id");
	if(lIndexValue.empty()==false) {
		mIndex = str2uint(lIndexValue);
		Beagle_AssertM(mIndex < ioContext.getGenotype().getNumberArguments());
	}
	Beagle_StackTraceEndM();
}
Ejemplo n.º 27
0
void SCHNAPS::Core::ArrayT<T>::read(PACC::XML::ConstIterator inIter) {
	schnaps_StackTraceBeginM();
	if (inIter->getType() != PACC::XML::eString) {
		throw schnaps_IOExceptionNodeM(*inIter,"expected string to read array!");
	}
	std::vector<T>::clear();
	std::istringstream lISS(inIter->getValue());
	while (lISS.good()) {
		T lValue;
		lISS >> lValue;
		std::vector<T>::push_back(lValue);
		if (lISS.good() == false) {
			break;
		}
		int lDelim = lISS.get();
		if ((lISS.good() == false) || (lDelim == -1)) {
			break;
		}
	}
	schnaps_StackTraceEndM("void SCHNAPS::Core::ArrayT<T>::read(PACC::XML::ConstIterator)");
}
Ejemplo n.º 28
0
/*!
 * \brief Read object from XML using system.
 * \param inIter XML iterator of input document.
 * \param ioSystem A reference to the system.
 * \throw SCHNAPS::Core::IOException if a wrong tag is encountered.
 * \throw SCHNAPS::Core::IOException if inProbability attribute is missing.
 */
void Branch::readWithSystem(PACC::XML::ConstIterator inIter, Core::System& ioSystem) {
	schnaps_StackTraceBeginM();
	if (inIter->getType() != PACC::XML::eData) {
		throw schnaps_IOExceptionNodeM(*inIter, "tag expected!");
	}
	if (inIter->getValue() != getName()) {
		std::ostringstream lOSS;
		lOSS << "tag <" << getName() << "> expected, but ";
		lOSS << "got tag <" << inIter->getValue() << "> instead!";
		throw schnaps_IOExceptionNodeM(*inIter, lOSS.str());
	}

	// retrieve probability of executing the first branch
	if (inIter->getAttribute("inProbability").empty()) {
		throw schnaps_IOExceptionNodeM(*inIter, "probability of executing first branch expected!");
	}
	mProbability_Ref = inIter->getAttribute("inProbability");
	
	switch (mProbability_Ref[0]) {
		case '@':
			// individual variable value
		case '#':
			// environment variable value
		case '%':
			// local variable value
			mProbability = NULL;
			break;
		case '$':
			// parameter value
			mProbability = Core::castHandleT<Core::Double>(ioSystem.getParameters().getParameterHandle(mProbability_Ref.substr(1)));
			break;
		default:
			// direct value
			mProbability = new Core::Double();
			mProbability->readStr(mProbability_Ref);
			break;
	}
	schnaps_StackTraceEndM("void SCHNAPS::Plugins::Control::Branch::readWithSystem(PACC::XML::ConstIterator, SCHNAPS::Core::System&)");
}
Ejemplo n.º 29
0
/*!
 *  \brief Read a multiobjective fitness from a XML subtree.
 *  \param inIter XML iterator to use to read the fitness value.
 */
void FitnessMultiObj::read(PACC::XML::ConstIterator inIter)
{
	Beagle_StackTraceBeginM();
	if((inIter->getType()!=PACC::XML::eData) || (inIter->getValue()!="Fitness"))
		throw Beagle_IOExceptionNodeM(*inIter, "tag <Fitness> expected!");

	const std::string& lValid = inIter->getAttribute("valid");
	if(lValid.empty() || (lValid == "yes")) {
	
		// Check type of fitness read
		const std::string& lType = inIter->getAttribute("type");
		if((lType.empty() == false) && (lType != getType())) {
			std::ostringstream lOSS;
			lOSS << "type given '" << lType << "' mismatch type of the fitness '";
			lOSS << getType() << "'!";
			throw Beagle_IOExceptionNodeM(*inIter, lOSS.str());
		}

		// Read objective values
		clear();
		for(PACC::XML::ConstIterator lChild=inIter->getFirstChild(); lChild; ++lChild) {
			if((lChild->getType() != PACC::XML::eData) || (lChild->getValue() != "Obj")) continue;
			PACC::XML::ConstIterator lChild2 = lChild->getFirstChild();
			if(!lChild2) throw Beagle_IOExceptionNodeM(*lChild, "needed a double value in the <Obj> tag!");
			if(lChild2->getType() != PACC::XML::eString)
				throw Beagle_IOExceptionNodeM(*lChild2, "needed a double value in the <Obj> tag!");
			push_back(str2dbl(lChild2->getValue()));
		}
		setValid();
		
	} else if(lValid == "no") {
		clear();
		setInvalid();
	}
	else {
		throw Beagle_IOExceptionNodeM(*inIter, "bad fitness validity value!");
	}
	Beagle_StackTraceEndM();
}
Ejemplo n.º 30
0
/*!
 *  \brief Reading a history entry.
 */
void HistoryEntry::read(PACC::XML::ConstIterator inIter)
{
	Beagle_StackTraceBeginM();

	if((inIter->getType()!=PACC::XML::eData) || (inIter->getValue()!="Entry"))
		throw Beagle_IOExceptionNodeM(*inIter, "tag <Entry> expected!");

	std::string lIndividualVarText = inIter->getAttribute("var");
	if(lIndividualVarText.empty())
		throw Beagle_IOExceptionNodeM(*inIter, "attribute 'var' of the tag <Entry> expected!");
	else
		mIndividualVar = str2uint(lIndividualVarText);

	std::string lGenerationText = inIter->getAttribute("generation");
	if (lGenerationText.empty())
		throw Beagle_IOExceptionNodeM(*inIter, "attribute 'generation' of the tag <Entry> expected!");
	else
		mGeneration = str2uint(lGenerationText);

	mParents.clear();
	mActions.clear();
	mOpNames.clear();

	for(PACC::XML::ConstIterator lChild(inIter->getFirstChild()); lChild; ++lChild) {
		if(lChild->getType()==PACC::XML::eData) {
			if(lChild->getValue()=="Parent") {
				unsigned int lHistoryId = str2uint(lChild->getAttribute("id"));
				unsigned int lHistoryVar = str2uint(lChild->getAttribute("var"));
				mParents.push_back(HistoryID(lHistoryId, lHistoryVar));
			} else if(lChild->getValue()=="Operations") {
				mActions.push_back(lChild->getAttribute("action"));
				mOpNames.push_back(lChild->getAttribute("opname"));
			}
		}
	}

	Beagle_StackTraceEndM();
}