json Parser::FormatPlayers(const std::vector<Player*>& players) const
{
json data;
for(auto p : players)
{
json player;
player["name"] = p->GetName();
player["greater_Dalmuti"] = std::count(p->roles.begin(), p->roles.end(), ROLES::GREATER_DALMUTI);
player["lesser_Dalmuti"] = std::count(p->roles.begin(), p->roles.end(), ROLES::LESSER_DALMUTI);
player["merchant"] = std::count(p->roles.begin(), p->roles.end(), ROLES::MERCHANT);
player["lesser_Peon"] = std::count(p->roles.begin(), p->roles.end(), ROLES::LESSER_PEON);
player["greater_Peon"] = std::count(p->roles.begin(), p->roles.end(), ROLES::GREATER_PEON);
player["average_Turntime"] = ConvertDouble(AverageTurnTime(p->turnTimes));
player["illegal_Moves"] = p->illegalMoves;
data.push_back(player);
}
return data;
}
bool Expression::Compute(mycomplex& com)
{
if(CheckParenthesis(m_strExp) == false)
{
m_strError = "括号不匹配";
return false;
}
if(CheckOperatorPos(m_strExp) == false)
{
m_strError = "操作符不对应";
return false;
}
if(CheckDotPos(m_strExp) == false)
{
m_strError = "小数点没有填写对";
return false;
}
m_strScanDouble = ConvertDouble(m_strExp);
if(m_strScanDouble == "error")
{
m_strError = "数字输入错误";
return false;
}
m_strScanComplex = ConvertComplex(m_strScanDouble);
if(CheckImageFlag(m_strScanComplex) == false)
{
m_strError = "输入复数格式错误";
return false;
}
m_strInfix = ConvertDoubleToComplex(m_strScanComplex);
m_vecInfix = ConvertStringToInfix(m_strInfix);
m_vecPostfix = ConvertInfixToPostfix(m_vecInfix);
string str("");
com = Compute2(m_vecPostfix, str);
if(str == "error")
{
m_strError = "输入表达式错误";
return false;
}
return true;
}
//--
bool DataProperty::Satisfy(OpenBabel::OBBond* pBond,
const std::string& refTo,
std::vector<Class*>& vecSatisfiedClasses,
std::string& refValue)
{
//bool bSatisfied = false;
int iPosition = -1;
// [rad] if we are default, we automatically satisfy
if(!IsDefault())
{
if(!SatisfyCommon(vecSatisfiedClasses, iPosition))
{
// [rad] this property does not apply
refValue = "";
return(false);
}
}
// [rad] go through possible data types..
if(!refTo.compare("BOND_ORDER"))
{
ConvertInt(pBond->GetBondOrder(), refValue);
}
else if(!refTo.compare("BOND_EQUILIBRIUM_LENGTH"))
{
ConvertDouble(pBond->GetEquibLength(), refValue);
}
else if(!refTo.compare("BOND_LENGTH"))
{
ConvertDouble(pBond->GetLength(), refValue);
}
else if(!refTo.compare("BOND_IS_AROMATIC"))
{
ConvertBool(pBond->IsAromatic(), refValue);
}
else if(!refTo.compare("BOND_IS_IN_RING"))
{
ConvertBool(pBond->IsInRing(), refValue);
}
else if(!refTo.compare("BOND_IS_ROTOR"))
{
ConvertBool(pBond->IsRotor(), refValue);
}
else if(!refTo.compare("BOND_IS_AMIDE"))
{
ConvertBool(pBond->IsAmide(), refValue);
}
else if(!refTo.compare("BOND_IS_PRIMARY_AMIDE"))
{
ConvertBool(pBond->IsPrimaryAmide(), refValue);
}
else if(!refTo.compare("BOND_IS_SECONDARY_AMIDE"))
{
ConvertBool(pBond->IsSecondaryAmide(), refValue);
}
else if(!refTo.compare("BOND_IS_ESTER"))
{
ConvertBool(pBond->IsEster(), refValue);
}
else if(!refTo.compare("BOND_IS_CARBONYL"))
{
ConvertBool(pBond->IsCarbonyl(), refValue);
}
else if(!refTo.compare("BOND_IS_SINGLE_BOND"))
{
ConvertBool(pBond->IsSingle(), refValue);
}
else if(!refTo.compare("BOND_IS_DOUBLE_BOND"))
{
ConvertBool(pBond->IsDouble(), refValue);
}
else if(!refTo.compare("BOND_IS_TRIPLE_BOND"))
{
ConvertBool(pBond->IsTriple(), refValue);
}
else if(!refTo.compare("BOND_IS_CLOSURE_BOND"))
{
ConvertBool(pBond->IsClosure(), refValue);
}
else if(!refTo.compare("BOND_IS_UP"))
{
ConvertBool(pBond->IsUp(), refValue);
}
else if(!refTo.compare("BOND_IS_DOWN"))
{
ConvertBool(pBond->IsDown(), refValue);
}
else if(!refTo.compare("BOND_IS_HASH"))
{
ConvertBool(pBond->IsHash(), refValue);
}
else if(!refTo.compare("BOND_IS_WEDGE"))
{
ConvertBool(pBond->IsWedge(), refValue);
}
else
{
// [rad] unknown datatype?
refValue = "";
return(false);
}
return(true);
}
//--
bool DataProperty::Satisfy(OpenBabel::OBAtom* pAtom,
const std::string& refTo,
std::vector<Class*>& vecSatisfiedClasses,
std::string& refValue)
{
//bool bSatisfied = false;
int iPosition = -1;
// [rad] if we are default, we automatically satisfy
if(!IsDefault())
{
if(!SatisfyCommon(vecSatisfiedClasses, iPosition))
{
// [rad] this property does not apply
refValue = "";
return(false);
}
}
// [rad] go through possible data types..
if(!refTo.compare("ATOM_ATOMIC_NUMBER"))
{
ConvertInt(pAtom->GetAtomicNum(), refValue);
}
else if(!refTo.compare("ATOM_FORMAL_CHARGE"))
{
ConvertInt(pAtom->GetFormalCharge(), refValue);
}
else if(!refTo.compare("ATOM_ISOTOPE"))
{
ConvertInt(pAtom->GetIsotope(), refValue);
}
else if(!refTo.compare("ATOM_SPIN_MULTIPLICITY"))
{
ConvertInt(pAtom->GetSpinMultiplicity(), refValue);
}
else if(!refTo.compare("ATOM_ATOMIC_MASS"))
{
ConvertDouble(pAtom->GetAtomicMass(), refValue);
}
else if(!refTo.compare("ATOM_EXACT_MASS"))
{
ConvertDouble(pAtom->GetExactMass(), refValue);
}
else if(!refTo.compare("ATOM_INTERNAL_INDEX"))
{
ConvertInt(pAtom->GetIdx(), refValue);
}
else if(!refTo.compare("ATOM_VALENCE"))
{
ConvertInt(pAtom->GetValence(), refValue);
}
else if(!refTo.compare("ATOM_HYBRIDIZATION"))
{
ConvertInt(pAtom->GetHyb(), refValue);
}
else if(!refTo.compare("ATOM_IMPLICIT_VALENCE"))
{
ConvertInt(pAtom->GetImplicitValence(), refValue);
}
else if(!refTo.compare("ATOM_HEAVY_VALENCE"))
{
ConvertInt(pAtom->GetHvyValence(), refValue);
}
else if(!refTo.compare("ATOM_HETERO_VALENCE"))
{
ConvertInt(pAtom->GetHeteroValence(), refValue);
}
else if(!refTo.compare("ATOM_COORDINATE_X"))
{
ConvertDouble(pAtom->GetX(), refValue);
}
else if(!refTo.compare("ATOM_COORDINATE_Y"))
{
ConvertDouble(pAtom->GetY(), refValue);
}
else if(!refTo.compare("ATOM_COORDINATE_Z"))
{
ConvertDouble(pAtom->GetZ(), refValue);
}
else if(!refTo.compare("ATOM_PARTIAL_CHARGE"))
{
ConvertDouble(pAtom->GetPartialCharge(), refValue);
}
else if(!refTo.compare("ATOM_FREE_OXYGEN_COUNT"))
{
ConvertInt(pAtom->CountFreeOxygens(), refValue);
}
else if(!refTo.compare("ATOM_IMPLICIT_HYDROGEN_COUNT"))
{
ConvertInt(pAtom->ImplicitHydrogenCount(), refValue);
}
else if(!refTo.compare("ATOM_PARTICIPANT_RING_COUNT"))
{
ConvertInt(pAtom->MemberOfRingCount(), refValue);
}
else if(!refTo.compare("ATOM_AVERAGE_BOND_ANGLE"))
{
ConvertDouble(pAtom->AverageBondAngle(), refValue);
}
else if(!refTo.compare("ATOM_SMALLEST_BOND_ANGLE"))
{
ConvertDouble(pAtom->SmallestBondAngle(), refValue);
}
else if(!refTo.compare("ATOM_IS_IN_RING"))
{
ConvertBool(pAtom->IsInRing(), refValue);
}
else if(!refTo.compare("ATOM_IS_HETERO_ATOM"))
{
ConvertBool(pAtom->IsHeteroatom(), refValue);
}
else if(!refTo.compare("ATOM_IS_AROMATIC"))
{
ConvertBool(pAtom->IsAromatic(), refValue);
}
else if(!refTo.compare("ATOM_IS_CHIRAL"))
{
ConvertBool(pAtom->IsChiral(), refValue);
}
else if(!refTo.compare("ATOM_HAS_SINGLE_BOND"))
{
ConvertBool(pAtom->HasSingleBond(), refValue);
}
else if(!refTo.compare("ATOM_HAS_DOUBLE_BOND"))
{
ConvertBool(pAtom->HasDoubleBond(), refValue);
}
else if(!refTo.compare("ATOM_HAS_TRIPLE_BOND"))
{
ConvertBool(pAtom->HasBondOfOrder(3), refValue);
}
else if(!refTo.compare("ATOM_HAS_AROMATIC_BOND"))
{
ConvertBool(pAtom->HasAromaticBond(), refValue);
}
else if(!refTo.compare("ATOM_SINGLE_BOND_COUNT"))
{
ConvertInt(pAtom->CountBondsOfOrder(1), refValue);
}
else if(!refTo.compare("ATOM_DOUBLE_BOND_COUNT"))
{
ConvertInt(pAtom->CountBondsOfOrder(2), refValue);
}
else if(!refTo.compare("ATOM_TRIPLE_BOND_COUNT"))
{
ConvertInt(pAtom->CountBondsOfOrder(3), refValue);
}
else if(!refTo.compare("ATOM_AROMATIC_BOND_COUNT"))
{
ConvertInt(pAtom->CountBondsOfOrder(5), refValue);
}
else if(!refTo.compare("ATOM_BOND_COUNT"))
{
//return(ConvertInt(pAtom->CountBondsOfOrder(5)));
OpenBabel::OBBond* pBond;
std::vector<OpenBabel::OBEdgeBase*>::iterator iter_bond;
int iCount = 0;
for(pBond = pAtom->BeginBond(iter_bond); pBond; pBond = pAtom->NextBond(iter_bond))
{
iCount++;
}
ConvertInt(iCount, refValue);
}
else
{
// [rad] unknown datatype?
refValue = "";
return(false);
}
return(true);
}
//--
bool DataProperty::Satisfy(OpenBabel::OBMol* pMolecule,
const std::string& refTo,
std::vector<Class*>& vecSatisfiedClasses,
std::string& refValue)
{
//bool bSatisfied = false;
int iPosition = -1;
// [rad] if we are default, we automatically satisfy
if(!IsDefault())
{
if(!SatisfyCommon(vecSatisfiedClasses, iPosition))
{
// [rad] this property does not apply
refValue = "";
return(false);
}
}
// [rad] go through possible data types..
if(!refTo.compare("MOLECULE_ATOM_COUNT"))
{
ConvertInt(pMolecule->NumAtoms(), refValue);
}
else if(!refTo.compare("MOLECULE_BOND_COUNT"))
{
ConvertInt(pMolecule->NumBonds(), refValue);
}
else if(!refTo.compare("MOLECULE_RING_COUNT"))
{
std::vector<OpenBabel::OBRing*>& refSSSR = pMolecule->GetSSSR();
ConvertInt(refSSSR.size(), refValue);
}
else if(!refTo.compare("MOLECULE_HEAVY_HYDROGEN_COUNT"))
{
ConvertInt(pMolecule->NumHvyAtoms(), refValue);
}
else if(!refTo.compare("MOLECULE_RESIDUE_COUNT"))
{
ConvertInt(pMolecule->NumResidues(), refValue);
}
else if(!refTo.compare("MOLECULE_ROTOR_COUNT"))
{
ConvertInt(pMolecule->NumRotors(), refValue);
}
else if(!refTo.compare("MOLECULE_FORMULA"))
{
refValue = pMolecule->GetFormula();
}
else if(!refTo.compare("MOLECULE_FORMATION_HEAT"))
{
ConvertDouble(pMolecule->GetEnergy(), refValue);
}
else if(!refTo.compare("MOLECULE_STANDARD_MOLAR_MASS"))
{
ConvertDouble(pMolecule->GetMolWt(), refValue);
}
else if(!refTo.compare("MOLECULE_EXACT_MASS"))
{
ConvertDouble(pMolecule->GetExactMass(), refValue);
}
else if(!refTo.compare("MOLECULE_TOTAL_CHARGE"))
{
ConvertInt(pMolecule->GetTotalCharge(), refValue);
}
else if(!refTo.compare("MOLECULE_SPIN_MULTIPLICITY"))
{
ConvertInt(pMolecule->GetTotalSpinMultiplicity(), refValue);
}
else if(!refTo.compare("MOLECULE_IS_CHIRAL"))
{
ConvertBool(pMolecule->IsChiral(), refValue);
}
else if(!refTo.compare("MOLECULE_HAS_AROMATIC_RING"))
{
std::vector<OpenBabel::OBRing*>& refSSSR = pMolecule->GetSSSR();
bool bAromatic = false;
std::vector<OpenBabel::OBRing*>::iterator iter_rings = refSSSR.begin();
while(iter_rings != refSSSR.end())
{
if((*iter_rings)->IsAromatic())
{
bAromatic = true;
break;
}
iter_rings++;
}
ConvertBool(bAromatic, refValue);
}
else if(!refTo.compare("MOLECULE_HAS_HOMOCYCLIC_RING"))
{
std::vector<OpenBabel::OBRing*>& refSSSR = pMolecule->GetSSSR();
std::vector<OpenBabel::OBRing*>::iterator iter_rings = refSSSR.begin();
OpenBabel::OBAtom* pAtom;
bool bHomoCyclic = true;
while(iter_rings != refSSSR.end())
{
std::vector<int>::iterator iter_path = (*iter_rings)->_path.begin();
while(iter_path != (*iter_rings)->_path.end())
{
pAtom = pMolecule->GetAtom((*iter_path));
if(pAtom)
{
if(6 != pAtom->GetAtomicNum())
{
bHomoCyclic = false;
break;
}
}
iter_path++;
}
if(!bHomoCyclic) break;
iter_rings++;
}
ConvertBool(bHomoCyclic, refValue);
}
else if(!refTo.compare("MOLECULE_HAS_HETEROCYCLIC_RING"))
{
std::vector<OpenBabel::OBRing*>& refSSSR = pMolecule->GetSSSR();
std::vector<OpenBabel::OBRing*>::iterator iter_rings = refSSSR.begin();
OpenBabel::OBAtom* pAtom;
bool bHeteroCyclic = false;
while(iter_rings != refSSSR.end())
{
std::vector<int>::iterator iter_path = (*iter_rings)->_path.begin();
while(iter_path != (*iter_rings)->_path.end())
{
pAtom = pMolecule->GetAtom((*iter_path));
if(pAtom)
{
if(6 != pAtom->GetAtomicNum())
{
bHeteroCyclic = true;
break;
}
}
iter_path++;
}
if(bHeteroCyclic) break;
iter_rings++;
}
ConvertBool(bHeteroCyclic, refValue);
}
else
{
// [rad] maybe it's a descriptor?
if(SatisfyDescriptor(pMolecule, refTo, refValue))
{
return(true);
}
// [rad] unknown datatype?
refValue = "";
return(false);
}
return(true);
}
