// New a node and put it in the m_lpList
EColumn* EColumn::create(string projection, string column)
{
	Log::writeToLog("EColumn", 0, "Create: string projection, string column");
		
	EColumn* lpPObject = new EColumn(projection, column);
	pushBack(lpPObject);
	return lpPObject;
}

// New a node and put it in the m_lpList
EPlus* EPlus::create()
{
	Log::writeToLog("EPlus", 0, "Create");
		
	EPlus* lpPObject = new EPlus();
	pushBack(lpPObject);
	return lpPObject;
}

// New a node and put it in the m_lpList
JoinOutputs* JoinOutputs::create()
{
	Log::writeToLog("JoinOutputs", 10, "Create without arguments");
		
	JoinOutputs* lpNode = new JoinOutputs();
	pushBack(lpNode);
	return lpNode;
}

UAggCountNode* UAggCountNode::create(Node* lpAggCol, int iAggColIndex)
{
	Log::writeToLog("UAggCountNode", 10, "Create with arguments: Node* lpAggCol, int iAggColIndex");
		
	UAggCountNode* lpNode = new UAggCountNode(lpAggCol, iAggColIndex);
	pushBack(lpNode);
	return lpNode;
}

// New a node and put it in the m_lpList
DeleteProjectionNode* DeleteProjectionNode::create()
{
	Log::writeToLog("DeleteProjectionNode", 10, "Create without arguments");
		
	DeleteProjectionNode* lpNode = new DeleteProjectionNode();
	pushBack(lpNode);
	return lpNode;
}

//==============================================================================
void Population::pushBack(const Eigen::VectorXd& x)
{
  if (!isValidX(*mProblem, x))
    return;

  const Eigen::VectorXd f = mProblem->evaluateFitness(x);
  pushBack(x, f);
}

// New a node and put it in the m_lpList
EAgg* EAgg::create(EColumn* lpRight, string op)
{
	Log::writeToLog("EAgg", 0, "Create with argeuments: EColumn* lpRight, string op");
		
	EAgg* lpPObject = new EAgg(lpRight, op);
	pushBack(lpPObject);
	return lpPObject;
}

// New a node and put it in the m_lpList
BEq* BEq::create()
{
	Log::writeToLog("BEq", 0, "Create");
		
	BEq* lpPObject = new BEq();
	pushBack(lpPObject);
	return lpPObject;
}

// New a node and put it in the m_lpList
BJoinNode* BJoinNode::create(EColumn* lpLeft, EColumn* lpRight, int iComparisonType)
{
	Log::writeToLog("BJoinNode", 10, "Create with 2 arguments: left node and right node");
		
	BJoinNode* lpNode = new BJoinNode(lpLeft, lpRight, iComparisonType);
	pushBack(lpNode);
	return lpNode;
}

UDeleteProjectionNode* UDeleteProjectionNode::create(Node* lpChild, string sProjection, bool bIsSinglePredicate)
{
	Log::writeToLog("UDeleteProjectionNode", 10, "Create with arguments: string sProjection, bool bIsSinglePredicate");
		
	UDeleteProjectionNode* lpNode = new UDeleteProjectionNode(lpChild, sProjection, bIsSinglePredicate);
	pushBack(lpNode);
	return lpNode;
}

// New a node and put it in the m_lpList
BAggCountNode* BAggCountNode::create(Node* lpAggCol, int iAggColIndex, Node* lpAggGroup, int iGroupColIndex)
{
	Log::writeToLog("BAggCountNode", 10, "Create with arguments: Node* lpAggCol, int iAggColIndex, Node* lpAggGroup, int iGroupColIndex");
		
	BAggCountNode* lpNode = new BAggCountNode(lpAggCol, iAggColIndex, lpAggGroup, iGroupColIndex);
	pushBack(lpNode);
	return lpNode;
}

// New a node and put it in the m_lpList
BGt* BGt::create()
{
	Log::writeToLog("BGt", 0, "Create");
		
	BGt* lpPObject = new BGt();
	pushBack(lpPObject);
	return lpPObject;
}

// 前序遍历非递归二
void PreOrderNorOP(pBTNode pRoot)
{
	Stack s;
	init(&s);
	pushBack(&s, pRoot);
	while (!isEmpty(&s)) {
		pBTNode pCur = top(&s);
		pop(&s);
		while (pCur) {
			printf("%c ", pCur->_data);
			if (pCur->_pRight) {
				pushBack(&s, pCur->_pRight);
			}
			pCur = pCur->_pLeft;
		}
	}
}

// New a node and put it in the m_lpList
DeletePlan* DeletePlan::create()
{
	Log::writeToLog("DeletePlan", 10, "Create without arguments");
		
	DeletePlan* lpNode = new DeletePlan();
	pushBack(lpNode);
	return lpNode;
}

UNode* UNode::create(Node* lpChild)
{
	Log::writeToLog("UNode", 10, "Create with 1 argument: child node");
		
	UNode* lpNode = new UNode(lpChild);
	pushBack(lpNode);
	return lpNode;
}

// New a node and put it in the m_lpList
BBinaryLogic* BBinaryLogic::create(BExpression* lpLeft, BExpression* lpRight, string op)
{
	Log::writeToLog("BBinaryLogic", 0, "Create with argeuments: BExpression* lpLeft, BExpression* lpRight, string op");
		
	BBinaryLogic* lpPObject = new BBinaryLogic(lpLeft, lpRight, op);
	pushBack(lpPObject);
	return lpPObject;
}

// New a node and put it in the m_lpList
BaseNode* BaseNode::create()
{
	Log::writeToLog("BaseNode", 0, "Create");
		
	BaseNode* lpBaseNode = new BaseNode();
	pushBack(lpBaseNode);
	return lpBaseNode;
}

// New a node and put it in the m_lpList
ListCols* ListCols::create()
{
	Log::writeToLog("ListCols", 0, "Create");
		
	ListCols* lpPObject = new ListCols();
	pushBack(lpPObject);
	return lpPObject;
}

void CharLine::setAtPosition(const char symbol, const int index)
{
    if (index >= size)
        pushBack(symbol);
    else
        string[index] = symbol;

}

// New a node and put it in the m_lpList
EFloat* EFloat::create()
{
	Log::writeToLog("EFloat", 0, "Create");
		
	EFloat* lpPObject = new EFloat();
	pushBack(lpPObject);
	return lpPObject;
}