CWE-ou-minkata/Sources/Tools/MaxConvert/UserPropMgr.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
// UserPropMgr.cpp

#include "hsTypes.h"
#include "UserPropMgr.h"
#include "hsStringTokenizer.h"
#include "hsUtils.h"
#include "hsHashTable.h"

#define REFMSG_USERPROP  (REFMSG_USER + 1)

const UInt32 UserPropMgr::kQuickSize = 150001;//199999;

UserPropMgr gUserPropMgr(GetCOREInterface());

UserPropMgr::UserPropMgr(Interface *ip) : 
nm(0)
{
    this->ip = ip;

    fQuickTable = nil;
    fQuickNode = nil;

    vProps = false;
}

UserPropMgr::~UserPropMgr()
{
    CloseQuickTable();
}

void UserPropMgr::SetUserPropFlag(INode *node, const char *name, const BOOL setFlag, const Int32 hFlag) 
{
    if (setFlag) SetUserProp(node,name,NULL,hFlag);
    else ClearUserProp(node,name,hFlag);
}

void UserPropMgr::ClearUserPropALL(const char *name, const Int32 hFlag) 
{
    for (int i=0; i<GetSelNodeCount(); i++) 
    {
        ClearUserProp(GetSelNode(i),name,hFlag);
    }
}

void UserPropMgr::SelectUserPropFlagALL(INode *node, const char *name, const BOOL flag) {
    if (node) 
    {
        if (UserPropExists(node,name) == flag) ip->SelectNode(node,false);
    } else node = ip->GetRootNode();

    for (int i=0; i<node->NumberOfChildren(); i++) {
        SelectUserPropFlagALL(node->GetChildNode(i),name,flag);
    }
}


void UserPropMgr::DeSelectWithOut(const char *name, const char *value) {
    BOOL oldProps = vProps;
    vProps=false;
    TSTR val;
    INode *nodes[1];
    INodeTab nodeTab;
    for (int i=0; i<GetSelNodeCount(); i++) {
        if (value) {
            if (!(GetUserProp(GetSelNode(i),name,val) && !stricmp(val,value))) {
                nodes[0] = GetSelNode(i);
                nodeTab.Append(1,nodes);
            }
        } else if (!UserPropExists(GetSelNode(i),name)) {
            nodes[0] = GetSelNode(i);
            nodeTab.Append(1,nodes);
        }
    }
    vProps=oldProps;
    if (nodeTab.Count() > 0) ip->SelectNodeTab(nodeTab,false,false);
    
}

void UserPropMgr::RecursiveSelectAll(INode *node) {
    if (node) {
        if (!node->Selected()) ip->SelectNode(node,false);
    } else node = ip->GetRootNode();

    for (int i=0; i<node->NumberOfChildren(); i++) {
        RecursiveSelectAll(node->GetChildNode(i));
    }
}


void UserPropMgr::DeSelectUnAlike(INode *node) {
theHold.Begin();

ip->ThawSelection();

    RecursiveSelectAll();

    TSTR buf;
    GetUserPropBuffer(node,buf);

    hsStringTokenizer toker(buf," \r\n");
    toker.ParseQuotes(TRUE);
    char *tok;
    TSTR name;
    bool isName = true;
    while (tok=toker.next()) {
        if (isName) {
            if (*tok != '=') {
                name = tok;
                tok = toker.next();
                if (tok && *tok == '=') {
                    tok = toker.next();
                } else tok = NULL;
                DeSelectWithOut(name,tok);
            } else isName = false;
        } else {
            isName = true;
        }
    }


    TSTR undostr; undostr.printf("Select");
    theHold.Accept(undostr);

    ip->FreezeSelection();

    ip->RedrawViews(ip->GetTime());
}



int UserPropMgr::RecursiveCountAlike(INode *node, BOOL MatchAll) {
    int count=0;
    if (node) {
        if (!node->IsNodeHidden() && !node->IsFrozen() && IsAlike(node,MatchAll)) count++;
    } else node = ip->GetRootNode();

    for (int i=0; i<node->NumberOfChildren(); i++) {
        count += RecursiveCountAlike(node->GetChildNode(i),MatchAll);
    }
    return count;
}


int UserPropMgr::CountAlike(BOOL MatchAll) {
    return RecursiveCountAlike(NULL, MatchAll);
}

BOOL UserPropMgr::IsMatch(const char *val1, const char *val2) {
    if (!stricmp(val1,val2)) return true;
    hsStringTokenizer toker(val1," ,@");
    char *tok;

    while (tok=toker.next()) {
        hsStringTokenizer toker2(val2," ,@");
        BOOL found = false;
        char *tok2;
        while ((tok2=toker2.next()) && !found) {
            if (tok[0] >= '1' && tok[0] <= '0') {
                if (!stricmp(tok,tok2)) found = true;
            } else if (toker.HasMoreTokens()) {
                if (!stricmp(tok,tok2)) found = true;if (!stricmp(tok,tok2)) found = true;
            } else {
                if (!strnicmp(tok,tok2,strlen(tok))) found = true;
            }
        }
        if (!found) return false;
    }
    return true;
}


BOOL UserPropMgr::IsAlike(INode *node, BOOL MatchAll) {
    TSTR buf;
    GetUserPropBuffer(node,buf);

    BOOL oldProps = vProps;
    vProps=false;

    hsStringTokenizer toker(buf," \r\n");
    toker.ParseQuotes(TRUE);
    char *tok;
    TSTR name;
    TSTR value;
    TSTR tval;
    BOOL match = MatchAll;
    bool isName = true;
    tok = toker.next();
    while (tok && (match==MatchAll)) {
        if (isName) {
            if (*tok != '=') {
                name = tok;
                tok = toker.next();
                if (tok && *tok == '=') {
                    tok = toker.next();
                    if (tok) value = tok;
                    else value = "";
                    tok = toker.next();
                } else value = "";
                if (GetUserProp(node,name,tval)) match = IsMatch(value,tval);
                else match = false;
                continue;
            } else isName = false;
        } else {
            isName = true;
        }
        tok=toker.next();
    }

    if (match==MatchAll) {
        if (!vname.isNull()) match = IsMatch(vname,node->GetName());
    }

    vProps = oldProps;
    return match;
}

int UserPropMgr::GetUserPropCount(INode *node) {
    TSTR buf;

    GetUserPropBuffer(node,buf);

    int numProps = 0;

    hsStringTokenizer toker(buf," \r\n");
    toker.ParseQuotes(TRUE);
    char *tok;
    bool isName = true;
    while (tok=toker.next()) {
        if (isName) {
            if (*tok != '=') {
                numProps++;
            } else isName = false;
        } else {
            isName = true;
        }
    }

    return numProps;
}

void UserPropMgr::GetUserPropBuffer(INode *node, TSTR &buf) {
    if (vProps) buf = vbuf;
    else if (node) node->GetUserPropBuffer(buf);
    else buf = "";
}

void UserPropMgr::SetUserPropBuffer(INode *node, const TSTR &buf) 
{
    // QuickTable invalidate
    if (node && node == fQuickNode)
    {
        fQuickNode = nil;
    }

    if (vProps)
    {
        vbuf = buf;
    }
    else if (node)
    {
        node->SetUserPropBuffer(buf);
        node->NotifyDependents(FOREVER, PART_ALL, REFMSG_USERPROP);
    }
}

void UserPropMgr::SetUserPropFlagALL(const char *name, const BOOL setFlag, const Int32 hFlag) 
{
    for (int i=0; i<GetSelNodeCount();i++) 
    {
        SetUserPropFlag(GetSelNode(i),name,setFlag,hFlag);
    }
}
BOOL UserPropMgr::GetUserPropFlagALL(const char *name, BOOL &isSet, const Int32 hFlag)
 {
    isSet = UserPropMgr::UserPropExists(GetSelNode(0),name,hFlag);

    for (int i=0; i<GetSelNodeCount(); i++) {
        if (isSet != UserPropMgr::UserPropExists(GetSelNode(i),name,hFlag)) return FALSE;
    }
    return TRUE;
}

INode* UserPropMgr::GetAncestorIfNeeded(INode* node, const Int32 hFlag)
{
    if (hFlag == kParent)
    {
        if (!(node->IsRootNode() || node->GetParentNode()->IsRootNode()))
            node = node->GetParentNode();
    }
    else
    if (hFlag == kRoot)
    {
        while (!(node->IsRootNode() || node->GetParentNode()->IsRootNode()))
            node = node->GetParentNode();
    }
    return node;
}


void UserPropMgr::ClearUserProp(INode *node, const char *name, const Int32 hFlag) 
{
    node = GetAncestorIfNeeded(node,hFlag);

    // QuickTable invalidate
    if (node && node == fQuickNode)
    {
        fQuickNode = nil;
    }

    TSTR buf;
    GetUserPropBuffer(node,buf);

    hsStringTokenizer toker(buf," \r\n");
    toker.ParseQuotes(TRUE);
    char *tok;
    bool isName = true;
    while (tok=toker.next()) 
    {
        if (isName) 
        {
            if (*tok != '=') 
            {
                if (!stricmp(tok,name)) 
                {
                    char *tok2 = toker.next();
                    if (tok2) 
                    {
                        if (*tok2 == '=')
                        {
                            tok2 = toker.next();
                            if (tok2)
                            {
                                tok2 = toker.next();
                                if (tok2)
                                {
                                    buf.remove(tok-toker.fString,tok2-tok);
                                }
                                else
                                {
                                    buf.remove(tok-toker.fString);
                                }
                            }
                            else
                            {
                                buf.remove(tok-toker.fString);
                            }
                        }
                        else 
                        {
                            buf.remove(tok-toker.fString,tok2-tok);
                        }
                    } 
                    else
                    {
                        buf.remove(tok-toker.fString);
                    }
                    break;
                }
            } 
            else
            {
                isName = false;
            }
        }
        else
        {
            isName = true;
        }
    }
    if (vProps) 
    {
        vbuf = buf;
    }
    else 
    {
        node->SetUserPropBuffer(buf);
        node->NotifyDependents(FOREVER, PART_ALL, REFMSG_USERPROP);
    }
};

BOOL UserPropMgr::GetUserProp(INode *node, const char *name, TSTR &value, const Int32 hFlag)
{
    node = GetAncestorIfNeeded(node,hFlag);

    // QuickTable lookup
    if (node && fQuickTable)
    {
        if (node != fQuickNode)
            IBuildQuickTable(node);
        return ICheckQuickEntry(name,value);
    }

    TSTR buf;
    GetUserPropBuffer(node,buf);

    hsStringTokenizer toker(buf," \r\n");
    toker.ParseQuotes(TRUE);
    char *tok;
    bool isName = true;
    while (tok=toker.next()) 
    {
        if (isName)
        {
            if (*tok != '=')
            {
                if (!stricmp(tok,name))
                {
                    tok = toker.next();
                    if (tok && *tok == '=')
                    {
                        tok = toker.next();
                        if (tok) value = tok;
                        else value = "";
                        return true;
                    }
                    else 
                    {
                        value = "";
                        return true;
                    }
                }
            } 
            else 
                isName = false;
        } 
        else
        {
            isName = true;
        }
    }
    return false;
}

void UserPropMgr::SetUserProp(INode *node, const char *name, const char *value, const Int32 hFlag) 
{
    node = GetAncestorIfNeeded(node,hFlag);

    // QuickTable invalidate
    if (node && node == fQuickNode)
    {
        fQuickNode = nil;
    }

    TSTR buf;
    GetUserPropBuffer(node,buf);

    hsStringTokenizer toker(buf," \r\n");
    toker.ParseQuotes(TRUE);
    char *tok;
    bool isName = true;
    while (tok=toker.next())
    {
        if (isName) 
        {
            if (*tok != '=') 
            {
                if (!stricmp(tok,name)) 
                {
                    char *tok2 = toker.next();
                    if (tok2)
                    {
                        if (*tok2 == '=')
                        {
                            tok2 = toker.next();
                            if (tok2) 
                            {
                                tok2 = toker.next();
                                if (tok2)
                                {
                                    buf.remove(tok-toker.fString,tok2-tok);
                                } 
                                else
                                {
                                    buf.remove(tok-toker.fString);
                                }
                            } 
                            else
                            {
                                buf.remove(tok-toker.fString);
                            }
                        } 
                        else
                        {
                            buf.remove(tok-toker.fString,tok2-tok);
                        }
                    } 
                    else
                    {
                        buf.remove(tok-toker.fString);
                    }
                    break;
                }
            } 
            else 
            {
                isName = false;
            }
        } 
        else
        {
            isName = true;
        }
    }
    if (buf.last('\n') < buf.length()-1)
    {
        // better start with a separator
        buf += "\r\n";
    }
    buf += name;
    if (value && *value)
    {
        buf += " = ";
        if (strchr(value,' '))
        {
            buf += "\"";
            buf += value;
            buf += "\"";
        }
        else
        {
            buf += value;
        }
    }
    buf += "\r\n";
    if (vProps)
    {
        vbuf = buf;
    }
    else
    {
        node->SetUserPropBuffer(buf);
        node->NotifyDependents(FOREVER, PART_ALL, REFMSG_USERPROP);
    }
}


BOOL UserPropMgr::GetUserPropString(INode *node, const char *name, TSTR &value, const Int32 hFlag)
{
     return GetUserProp(node,name,value,hFlag);
}
void UserPropMgr::SetUserPropString(INode *node, const char *name, const char *value, const Int32 hFlag) 
{
    SetUserProp(node,name,value,hFlag);
}
BOOL UserPropMgr::GetUserPropFloat(INode *node, const char *name, float &value, const Int32 hFlag)
{
    TSTR valStr;
    if (GetUserProp(node,name,valStr,hFlag)) 
    {
        value = (float)atof(valStr);
        return TRUE;
    }
    return FALSE;
}
void UserPropMgr::SetUserPropFloat(INode *node, const char *name, const float value, const Int32 hFlag) 
{
    char valStr[50];
    if (sprintf(valStr,"%g",value)) SetUserProp(node,name,valStr,hFlag);
}
BOOL UserPropMgr::GetUserPropInt(INode *node, const char *name, int &value, const Int32 hFlag)
{
    TSTR valStr;
    if (GetUserProp(node,name,valStr,hFlag)) {
        value = atoi(valStr);
        return TRUE;
    }
    return FALSE;
}
void UserPropMgr::SetUserPropInt(INode *node, const char *name, const int value, const Int32 hFlag) 
{
    char valStr[50];
    if (sprintf(valStr,"%d",value)) SetUserProp(node,name,valStr,hFlag);
}

BOOL UserPropMgr::UserPropExists(INode *node, const char *name, const Int32 hFlag) 
{
    TSTR value;
    return GetUserProp(node,name,value,hFlag);
}

BOOL UserPropMgr::GetUserPropStringList(INode *node, const char *name, int &num, TSTR list[]) {
    TSTR sdata;
    if (UserPropMgr::GetUserPropString(node,name,sdata)) {
        num=0;
        hsStringTokenizer toker(sdata,", ");
        char *tok;
        while ( tok = toker.next() ) {
            list[num] = tok;
            num++;
        }
        return true;
    } else return false;
}

BOOL UserPropMgr::GetUserPropIntList(INode *node, const char *name, int &num, int list[]) {
    TSTR sdata;
    if (UserPropMgr::GetUserPropString(node,name,sdata)) {
        num=0;
        hsStringTokenizer toker(sdata,", ");
        char *tok;
        while ( tok = toker.next() ) {
            list[num] = atoi(tok);
            num++;
        }
        return true;
    } else return false;
}

BOOL UserPropMgr::GetUserPropFloatList(INode *node, const char *name, int &num, float list[]) {
    TSTR sdata;
    if (UserPropMgr::GetUserPropString(node,name,sdata)) {
        num=0;
        hsStringTokenizer toker(sdata,", ");
        char *tok;
        while ( tok = toker.next() ) {
            list[num] = (float)atof(tok);
            num++;
        }
        return true;
    } else return false;
}

BOOL UserPropMgr::GetUserPropStringALL(const char *name, TSTR &value, const Int32 hFlag)
{
    BOOL propSet  = UserPropMgr::GetUserPropString(GetSelNode(0),name,value,hFlag);

    TSTR tvalue;
    int i=1;
    BOOL propMixed = FALSE;
    while (i < GetSelNodeCount() && !propMixed) {
        if (propSet ^ UserPropMgr::GetUserPropString(GetSelNode(i),name,tvalue,hFlag)) propMixed = TRUE;
        propMixed = (!(value == tvalue));
        i++;
    }

    return (!propMixed);
}
void UserPropMgr::SetUserPropStringALL(const char *name, const char *value, const Int32 hFlag) 
{
    for (int i=0; i<GetSelNodeCount(); i++) {
        UserPropMgr::SetUserPropString(GetSelNode(i),name,value,hFlag);
    }
}

BOOL UserPropMgr::GetUserPropStringListALL(const char *name, int &num, TSTR list[]) {
    TSTR val;
    GetUserPropStringList(GetSelNode(0),name,num,list);
    return GetUserPropStringALL(name,val);
}

BOOL UserPropMgr::GetUserPropIntListALL(const char *name, int &num, int *list) {
    TSTR val;
    GetUserPropIntList(GetSelNode(0),name,num,list);
    return GetUserPropStringALL(name,val);
}

BOOL UserPropMgr::GetUserPropFloatListALL(const char *name, int &num, float *list) {
    TSTR val;
    GetUserPropFloatList(GetSelNode(0),name,num,list);
    return GetUserPropStringALL(name,val);
}

BOOL UserPropMgr::GetNodeNameALL(TSTR &name) {
    if (vProps) name = vname;
    else if (ip->GetSelNodeCount() == 1) name = ip->GetSelNode(0)->GetName();
    else return false;

    return true;
}

void UserPropMgr::SetNodeNameALL(const char *name) {
    if (vProps) {
        vname = name;
    } else {
        if (ip->GetSelNodeCount() > 1) {
            TSTR uName;
            for (int i=0; i<ip->GetSelNodeCount(); i++) {
                uName = name;
                ip->MakeNameUnique(uName);
                ip->GetSelNode(i)->SetName(uName);
            }
        } else ip->GetSelNode(0)->SetName((char*)name);
    }
}


void UserPropMgr::LoadVirtualProps(BOOL reset) {
    if (reset)
    {
        vbuf = "";
        vname = "";
    }
    vProps = true;
}
void UserPropMgr::DestroyVirtualProps() {
    vProps = false;
}
BOOL UserPropMgr::IsVirtual() {
    return vProps;
}

int UserPropMgr::GetSelNodeCount() {
    if (vProps) return 1;
    else return ip->GetSelNodeCount();
}
INode *UserPropMgr::GetSelNode(int i) {
    if (vProps) return NULL;
    else return ip->GetSelNode(i);
}


void UserPropMgr::OpenQuickTable()
{
        if (!fQuickTable)
        {
        fQuickTable = TRACKED_NEW hsHashTable<QuickPair>(kQuickSize);
        }
    fQuickNode = nil;
}

void UserPropMgr::CloseQuickTable()
        {
#ifdef HS_DEBUGGING
    if (fQuickNode && fQuickTable)
            {
        char str[256];
        sprintf(str,"%d Hash Collisions reported\n",fQuickTable->CollisionCount());
        hsStatusMessage(str);
            }
#endif

    delete fQuickTable;
    fQuickTable = nil;
    fQuickNode = nil;
    QuickPair::SetBuffer(nil);
        }

void UserPropMgr::IBuildQuickTable(INode* node)
{
    if (fQuickTable && fQuickNode != node)
    {
        fQuickNode = node;

        // clear old QuickTable
        fQuickTable->clear();

        // build new one
        TSTR buf;
        GetUserPropBuffer(node,buf);

        hsStringTokenizer toker(buf," \r\n");
        toker.ParseQuotes(TRUE);

        char *tok;
        bool inName = false;
        bool isName = true;
        while ( inName || (tok=toker.next()) ) 
        {
            if (isName) 
            {
                if (*tok != '=') 
                {
                    QuickPair qPair;
                    qPair.SetKey(tok);
                
                    tok = toker.next();
                    if (tok && *tok == '=') 
                    {
                        tok = toker.next();
                        qPair.SetVal(tok);

                        inName = false;
                    }
                    else 
                    {
                        qPair.SetVal(nil);
                        inName = (tok != 0);
                    }

                    fQuickTable->insert(qPair);
                } 
                else 
                {
                    isName = false;
                }
            } 
            else 
            {
                isName = true;
            }
        }

        // QuickPair owns the tok'd buffer now
        QuickPair::SetBuffer(toker.fString);
        toker.fString = nil;
    }
}

BOOL UserPropMgr::ICheckQuickEntry(const char *key, TSTR &value)
{
    QuickPair q;
    q.SetKey(key);
    hsHashTableIterator<QuickPair> it = fQuickTable->find(q);
    return it->GetVal(value);
    }


char* UserPropMgr::QuickPair::fBuffer = nil;

void UserPropMgr::QuickPair::SetBuffer(char* buf)
{
    delete [] fBuffer;
    fBuffer = buf;
    }

UInt32 UserPropMgr::QuickPair::GetHash() const
{
    const char * k = fKey;
    int len = k ? strlen(k) : 0;
    int h;
    for (h=len; len--;) 
    {
        h = ((h<<5)^(h>>27))^tolower(*k++);
    }
    return h;
}

hsBool UserPropMgr::QuickPair::GetVal(TSTR& value)
    {
    if (fKey)
        {
        value = fVal ? fVal : "";
        return true;
        }
            else
            {
        return false;
        }
    }

bool UserPropMgr::QuickPair::operator==(const QuickPair& other) const
{
    return !_stricmp(fKey,other.fKey);
}