bool OperCFThread::Copy(FS *srcFs, FSPath &__srcPath, FSList *list, FS *destFs, FSPath &__destPath, cstrhash<bool,unicode_t> &resList)
{
if (list->Count()<=0) return true;
FSPath srcPath = __srcPath; int srcPos = srcPath.Count();
FSPath destPath = __destPath; int destPos = destPath.Count();
FSStat st;
int ret_error;
int res = destFs->Stat(__destPath, &st, &ret_error, Info());
if (res == -2) return false;
if (res && !destFs->IsENOENT(ret_error))
{
RedMessage( _LT("Can't copy to:\n"), destFs->Uri(destPath).GetUtf8(), bOk, destFs->StrError(ret_error).GetUtf8());
return false;
}
bool exist = (res == 0);
if (list->Count()>1)
{
//если файлов >1 то копировать можно только в каталог
if (!exist) {
RedMessage( _LT("Can't copy files, destination is not found:\n"), destFs->Uri(__destPath).GetUtf8(), bOk);
return false;
}
if (!st.IsDir())
{
RedMessage( _LT("Destination is not directory:\n"), destFs->Uri(__destPath).GetUtf8(), bOk);
return false;
}
for (FSNode *node = list->First(); node; node = node->next)
{
if (Info()->Stopped()) return false;
srcPath.SetItemStr(srcPos, node->Name());
destPath.SetItemStr(destPos, node->Name());
if (!CopyNode(srcFs, srcPath, node, destFs, destPath, false)) return false;
resList[node->Name().GetUnicode()] = true;
}
} else {
// 1 element
if (exist && st.IsDir())
destPath.SetItemStr(destPos, list->First()->Name());
srcPath.SetItemStr(srcPos, list->First()->Name());
if (!CopyNode(srcFs, srcPath, list->First(), destFs, destPath, false)) return false;
resList[list->First()->Name().GetUnicode()] = true;
};
return true;
}
// only copy a complete independent tree
// when node name exists
void ComputationNetwork::CopySubTree(const ComputationNetwork& fromNet,
const std::wstring fromName, std::wstring toNamePrefix,
const CopyNodeFlags flags)
{
InvalidateCompiledNetwork();
if (!(flags & CopyNodeFlags::copyNodeValue))
LogicError("CopySubTree: you cannot copy a tree without copying the node values.");
ComputationNodeBasePtr fromRoot = fromNet.GetNodeFromName(fromName);
if (!fromNet.EvalOrderExists(fromRoot))
const_cast<ComputationNetwork&>(fromNet).FormEvalOrder(fromRoot);
for (const auto& fromNode : fromNet.GetEvalOrder(fromRoot)) // BUGBUG: This probably will fail because the precomputed eval orders are invalid at this point.
{
wstring fromNodeName = fromNode->NodeName();
wstring toNodeName = toNamePrefix + fromNodeName;
ComputationNodeBasePtr toNode = CopyNode(fromNet, fromNodeName,
toNodeName,
CopyNodeFlags::copyNodeValue);
if (flags & CopyNodeFlags::copyNodeInputLinks)
{
// copy the children structure but use the new nodes generated
for (int i = 0; i < fromNode->GetNumInputs(); i++)
toNode->SetInput(i, GetNodeFromName(toNamePrefix + fromNode->GetInputs()[i]->NodeName()));
}
}
}
// only copy a complete independent tree
// when node name exists
void ComputationNetwork::CopySubTree(const ComputationNetwork& fromNet,
const std::wstring fromName, std::wstring toNamePrefix,
const CopyNodeFlags flags)
{
InvalidateCompiledNetwork();
if (!(flags & CopyNodeFlags::copyNodeValue))
LogicError("CopySubTree: you cannot copy a tree without copying the node values.");
ComputationNodeBasePtr fromRoot = fromNet.GetNodeFromName(fromName);
for (const auto& fromNode : GetEvalOrder(fromRoot))
{
wstring fromNodeName = fromNode->NodeName();
wstring toNodeName = toNamePrefix + fromNodeName;
ComputationNodeBasePtr toNode = CopyNode(fromNet, fromNodeName,
toNodeName,
CopyNodeFlags::copyNodeValue);
if (flags & CopyNodeFlags::copyNodeChildren)
{
// copy the children structure but use the new nodes generated
for (int i = 0; i < fromNode->GetNumInputs(); i++)
toNode->SetInput(i, GetNodeFromName(toNamePrefix + fromNode->GetInputs()[i]->NodeName()));
}
}
}
void Factory::AddNode(GroupNode *pParent, SceneNode *pChild)
{
DbgEnter();
if (pParent && pChild)
{
pParent->AddNode(CopyNode(pChild));
}
}
NodeList FindNodesByName(Node *parent, char type, char *name)
{
NodeList ret = NULL;
NodeList head = NULL;
if (parent != NULL && name != NULL) {
switch (type) {
case NODE_TYPE_NODE:
case NODE_TYPE_ELEMENT:
case NODE_TYPE_ATTRIBUTE:
case NODE_TYPE_TEXT:
{
Node *cur = parent->children;
while (cur != NULL) {
if (cur->nodeType == type) {
int cmp = strcmp(cur->nodeName, name);
if (cmp == 0) {
if (ret == NULL) {
ret = CopyNode(cur);
head = ret;
}else{
Node *tmp = CopyNode(cur);
ret->nextSub = tmp;
tmp->prevSub = ret;
ret = tmp;
}
}
}
if (cur->nextSub != NULL) {
cur = cur->nextSub;
} else {
break;
}
}
}
break;
default:
break;
}
}
return head;
}
void AdjacencyList::CopyFrom(const AdjacencyList &adjacencyList) {
if (this == &adjacencyList) return;
for (Index i = 0; i < numVertices_; ++i) {
RemoveNode(list_[i]);
}
delete [] list_;
numVertices_ = adjacencyList.numVertices_;
numEdges_ = adjacencyList.numEdges_;
list_ = new ListNode * [numVertices_];
for (Index i = 0; i < numVertices_; ++i) {
list_[i] = CopyNode(list_[i], adjacencyList.list_[i]);
}
}
bool OperCFThread::CopyDir(FS *srcFs, FSPath &__srcPath, FSNode *srcNode, FS *destFs, FSPath &__destPath, bool move)
{
if (Info()->Stopped()) return false;
FSList list;
int ret_error;
while (true) {
int ret = srcFs->ReadDir(&list, __srcPath, &ret_error, Info());
if (ret == -2) return false;
if (!ret) break;
switch ( RedMessage( _LT("Can`t open directory:\n") , srcFs->Uri(__srcPath).GetUtf8(), bRetrySkipCancel, srcFs->StrError(ret_error).GetUtf8()) ) {
case CMD_SKIP: return true;
case CMD_RETRY: continue;
default: return false;
}
}
while (destFs->MkDir(__destPath, MkDirMode, &ret_error, Info()) && !destFs->IsEEXIST(ret_error)) {
switch (RedMessage( _LT("Can't create the directory:\n"), destFs->Uri(__destPath).GetUtf8(), bRetrySkipCancel, destFs->StrError(ret_error).GetUtf8())) {
case CMD_CANCEL: return false;
case CMD_SKIP: return true;
}
}
FSPath srcPath = __srcPath; int srcPos = srcPath.Count();
FSPath destPath = __destPath; int destPos = destPath.Count();
for (FSNode *node = list.First(); node; node = node->next)
{
if (Info()->Stopped()) return false;
srcPath.SetItemStr(srcPos, node->Name());
destPath.SetItemStr(destPos, node->Name());
if (!CopyNode(srcFs, srcPath, node, destFs, destPath, move)) return false;
}
destFs->SetFileTime(destPath, srcNode->st.mtime, srcNode->st.mtime, 0, Info());
return !move || RmDir(srcFs, __srcPath);
}
//========================================================
// Name : _CopyBranch
// Desc : recursive internal copy branch
// Param :
// Return :
//--------------------------------------------------------
// Coder Date Desc
// bro 2002-10-29
//========================================================
void _tagXMLNode::_CopyBranch( LPXNode node )
{
CopyNode( node );
for( unsigned int i = 0 ; i < node->childs.size(); i++)
{
LPXNode child = node->childs[i];
if( child )
{
LPXNode mychild = new XNode;
mychild->CopyNode( child );
AppendChild( mychild );
mychild->_CopyBranch( child );
}
}
}
SceneNode *Factory::CopyNode(SceneNode *pNode)
{
DbgEnter();
//check if node already belongs to some parent
if (pNode && pNode->GetCount() > 0)
{
GroupNode *pGroup = dynamic_cast<GroupNode *>(pNode);
if (pGroup)
{
//save list of child nodes
SceneNodeList &nodes = pGroup->GetNodeList();
//create new group node
pGroup = NewObject<GroupNode>();
//add copies of all child nodes to new group node
for (SceneNodeList::iterator it = nodes.begin(); it != nodes.end(); it++)
{
pGroup->AddNode(CopyNode(*it));
}
return pGroup;
}
}
//return original node
return pNode;
}
// you can only copy inputs from nodes in the same network
void ComputationNetwork::CopyInputs(const std::wstring fromName, std::wstring toName)
{
CopyNode(*this, fromName, toName, CopyNodeFlags::copyNodeChildren);
}
HRESULT CKADmerge::Merge(string sAddOnFileName, BOOL bOverwrite, string sLogFile)
{
HRESULT hRes = 0;
IXMLDOMDocument * pXMLAddOn = NULL;
if(sLogFile != "")
{
// open log file
OpenLog(sLogFile, sDescription + " " + m_sFileName + " with " + sAddOnFileName);
}
try
{
// load AddOn file
hRes = LoadXMLFile(sAddOnFileName, &pXMLAddOn);
IXMLDOMElement * pKadRoot = NULL;
hRes = GetRootElement(m_pXMLKad, &pKadRoot);
if(hRes == S_FALSE)
{
// create root element
hRes = GetRootElement(pXMLAddOn, &pKadRoot);
if(hRes == S_FALSE)
{
throw string("ERROR: could not get addon kad root element: " + sAddOnFileName);
}
_bstr_t bTagName(GetName(pKadRoot).c_str());
hRes = m_pXMLKad->createElement(bTagName, &pKadRoot);
hRes = m_pXMLKad->putref_documentElement(pKadRoot);
// log changes
Log("Create Root-Element: " + GetName(pKadRoot) );
m_bIsDirty = TRUE;
}
if(pKadRoot)
pKadRoot->Release();
IXMLDOMNode * pXMLKadNode = NULL;
IXMLDOMNode * pXMLAddOnNode = NULL;
hRes = GetRootElement(m_pXMLKad, &pXMLKadNode);
hRes = GetRootElement(pXMLAddOn, &pXMLAddOnNode);
// copy nodes
hRes = CopyNode(&pXMLKadNode, &pXMLAddOnNode, bOverwrite, "");
if(pXMLKadNode != NULL)
pXMLKadNode->Release();
if(pXMLAddOnNode != NULL)
pXMLAddOnNode->Release();
if(m_bIsDirty)
{
hRes = SaveXMLFile(m_sFileName, m_pXMLKad);
m_bIsDirty = FALSE;
}
}
catch(string str)
{
Log(str);
hRes = S_FALSE;
}
if(pXMLAddOn != NULL)
pXMLAddOn->Release();
// close log file
CloseLog();
return hRes;
}
HRESULT CKADmerge::CopyNode(IXMLDOMNode ** pXMLDest, IXMLDOMNode ** pXMLSrc, BOOL bOverwrite, string sPath)
{
HRESULT hRes = 0;
IXMLDOMNodeList * pNodeList = NULL;
if(*pXMLDest == NULL || *pXMLSrc == NULL)
{
Log("ERROR: CopyNode " + GetName(*pXMLSrc) + " to " + GetName(*pXMLDest));
hRes = S_FALSE;
return hRes;
}
hRes = (*pXMLSrc)->get_childNodes(&pNodeList);
if(SUCCEEDED(hRes))
{
LONG lListLength = 0;
hRes = pNodeList->get_length(&lListLength);
IXMLDOMNode * pCurrentNode = NULL;
hRes = pNodeList->nextNode(&pCurrentNode);
while(pCurrentNode != NULL)
{
// iterate through the xml tree
string sPatternString = GetPatternString(pCurrentNode, TRUE);
IXMLDOMNode * pDestNode = NULL;
BOOL bHasNode = HasNode(*pXMLDest, sPatternString, &pDestNode);
if(bHasNode && (!m_Overwriteable[GetName(pCurrentNode)] || !bOverwrite ))
{
// copy child elements
CopyNode(&pDestNode, &pCurrentNode, bOverwrite, sPath + "/" + sPatternString);
}
else if(bHasNode && m_Overwriteable[GetName(pCurrentNode)] && bOverwrite)
{
// compare element
sPatternString = GetPatternString(pCurrentNode, TRUE);
bHasNode = HasNode(*pXMLDest, sPatternString, &pDestNode);
if(bHasNode)
{
sPatternString = GetPatternString(pCurrentNode, FALSE);
bHasNode = HasNode(*pXMLDest, sPatternString, &pDestNode);
if(!bHasNode)
{
// replace element
IXMLDOMNode * pNewNode = NULL;
IXMLDOMNode * pXMLOldChild = NULL;
hRes = pCurrentNode->cloneNode(VARIANT_TRUE, &pNewNode);
hRes = (*pXMLDest)->replaceChild(pNewNode, // new child
pDestNode, // old child
&pXMLOldChild); // out old child
// log changes
Log("Replace Element: " + sPath + "/" + sPatternString);
if(pNewNode)
pNewNode->Release();
if(pXMLOldChild)
pXMLOldChild->Release();
m_bIsDirty = TRUE;
}
}
}
else if(!bHasNode)
{
// attach entire sub tree
IXMLDOMNode * pDestNode = NULL;
IXMLDOMNode * pXMLNewChild = NULL;
hRes = pCurrentNode->cloneNode(VARIANT_TRUE, &pDestNode);
hRes = (*pXMLDest)->appendChild(pDestNode, // new child
&pXMLNewChild); // out new child
// log changes
sPatternString = GetPatternString(pCurrentNode, FALSE);
Log("Attach Element: " + sPath + "/" + sPatternString);
if(pDestNode)
pDestNode->Release();
if(pXMLNewChild)
pXMLNewChild->Release();
m_bIsDirty = TRUE;
}
hRes = pNodeList->nextNode(&pCurrentNode);
}
}
return hRes;
}
typename AdjacencyList::ListNode * AdjacencyList::CopyNode(AdjacencyList::ListNode *dest, AdjacencyList::ListNode *src) {
if (src == NULL) return NULL;
dest = new ListNode(src->idx, src->weight);
dest->next = CopyNode(dest->next, src->next);
return dest;
}
