Show Node.cpp syntax highlighted
/*
* Copyright (C) 2003-2006 Gabest
* http://www.gabest.org
*
* 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 2, 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 GNU Make; see the file COPYING. If not, write to
* the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
* http://www.gnu.org/copyleft/gpl.html
*
*/
#include "stdafx.h"
#include "Node.h"
#include "NodeFactory.h"
#include "Exception.h"
#include "Split.h"
#include <math.h>
namespace ssf
{
Node::Node(NodeFactory* pnf, CStringW name)
: m_pnf(pnf)
, m_type('?')
, m_name(name)
, m_priority(PNormal)
, m_predefined(false)
, m_parent(NULL)
{
ASSERT(m_pnf);
}
void Node::AddTail(Node* pNode)
{
if(POSITION pos = m_nodes.Find(pNode)) // TODO: slow
{
m_nodes.MoveToTail(pos);
return;
}
m_nodes.AddTail(pNode);
m_name2node[pNode->m_name] = pNode;
}
bool Node::IsNameUnknown()
{
return m_name.IsEmpty() || !!iswdigit(m_name[0]);
}
bool Node::IsTypeUnknown()
{
return m_type.IsEmpty() || m_type == '?';
}
bool Node::IsType(CStringW type)
{
return m_type == type;
}
void Node::GetChildDefs(CAtlList<Definition*>& l, LPCWSTR type, bool fFirst)
{
CAtlList<Definition*> rdl[3];
if(fFirst)
{
if(Definition* pDef = m_pnf->GetDefByName(m_type))
{
pDef->GetChildDefs(rdl[pDef->m_priority], type, false);
}
}
POSITION pos = m_nodes.GetHeadPosition();
while(pos)
{
if(Node* pNode = m_nodes.GetNext(pos))
{
pNode->GetChildDefs(rdl[pNode->m_priority], type, false);
}
}
for(int i = 0; i < sizeof(rdl)/sizeof(rdl[0]); i++)
{
l.AddTailList(&rdl[i]);
}
}
// Reference
Reference::Reference(NodeFactory* pnf, CStringW name)
: Node(pnf, name)
{
}
Reference::~Reference()
{
}
void Reference::GetChildDefs(CAtlList<Definition*>& l, LPCWSTR type, bool fFirst)
{
CAtlList<Definition*> rdl[3];
POSITION pos = m_nodes.GetHeadPosition();
while(pos)
{
if(Definition* pDef = dynamic_cast<Definition*>(m_nodes.GetNext(pos)))
{
if(!type || pDef->m_type == type) // TODO: faster lookup
{
rdl[pDef->m_priority].AddTail(pDef);
}
}
}
for(int i = 0; i < sizeof(rdl)/sizeof(rdl[0]); i++)
{
l.AddTailList(&rdl[i]);
}
}
void Reference::Dump(OutputStream& s, int level, bool fLast)
{
if(m_predefined) return;
CStringW tabs(' ', level*4);
// s.PutString(tabs + '\n' + tabs + L" {\n");
s.PutString(L" {\n");
POSITION pos = m_nodes.GetHeadPosition();
while(pos)
{
Node* pNode = m_nodes.GetNext(pos);
if(Definition* pDef = dynamic_cast<Definition*>(pNode))
{
pDef->Dump(s, level + 1, pos == NULL);
}
}
s.PutString(tabs + '}');
}
// Definition
Definition::Definition(NodeFactory* pnf, CStringW name)
: Node(pnf, name)
, m_status(node)
, m_autotype(false)
{
}
Definition::~Definition()
{
RemoveFromCache();
}
bool Definition::IsVisible(Definition* pDef)
{
Node* pNode = m_parent;
while(pNode)
{
if(pNode->m_name2node.Lookup(pDef->m_name))
{
return true;
}
pNode = pNode->m_parent;
}
return false;
}
void Definition::AddTail(Node* pNode)
{
// if(Reference* pRef = dynamic_cast<Reference*>(pNode))
{
ASSERT(m_status == node);
m_status = node;
if(IsTypeUnknown() && !pNode->IsTypeUnknown())
{
m_type = pNode->m_type;
m_autotype = true;
}
RemoveFromCache(pNode->m_type);
}
__super::AddTail(pNode);
}
Definition& Definition::operator[] (LPCWSTR type)
{
Definition* pRetDef = NULL;
if(m_type2def.Lookup(type, pRetDef))
return *pRetDef;
pRetDef = new Definition(m_pnf, L"");
pRetDef->m_priority = PLow;
pRetDef->m_type = type;
m_type2def[type] = pRetDef;
CAtlList<Definition*> l;
GetChildDefs(l, type);
while(!l.IsEmpty())
{
Definition* pDef = l.RemoveHead();
pRetDef->m_priority = pDef->m_priority;
pRetDef->m_parent = pDef->m_parent;
if(pDef->IsValue())
{
pRetDef->SetAsValue(pDef->m_status, pDef->m_value, pDef->m_unit);
}
else
{
pRetDef->m_status = node;
pRetDef->m_nodes.AddTailList(&pDef->m_nodes);
}
}
return *pRetDef;
}
void Definition::RemoveFromCache(LPCWSTR type)
{
if(!type)
{
POSITION pos = m_type2def.GetStartPosition();
while(pos) delete m_type2def.GetNextValue(pos);
}
else if(StringMapW<Definition*>::CPair* p = m_type2def.Lookup(type))
{
delete p->m_value;
m_type2def.RemoveKey(type);
}
}
bool Definition::IsValue(status_t s)
{
return s ? m_status == s : m_status != node;
}
void Definition::SetAsValue(status_t s, CStringW v, CStringW u)
{
ASSERT(s != node);
m_nodes.RemoveAll();
m_name2node.RemoveAll();
m_status = s;
m_value = v;
m_unit = u;
}
void Definition::SetAsNumber(CStringW v, CStringW u)
{
SetAsValue(number, v, u);
Number<float> n;
GetAsNumber(n); // will throw an exception if not a number
}
template<class T>
void Definition::GetAsNumber(Number<T>& n, StringMapW<T>* n2n)
{
CStringW str = m_value;
str.Replace(L" ", L"");
n.value = 0;
n.unit = m_unit;
n.sign = 0;
if(n2n)
{
if(m_status == node) throw Exception(_T("expected value type"));
if(StringMapW<T>::CPair* p = n2n->Lookup(str))
{
n.value = p->m_value;
return;
}
}
if(m_status != number) throw Exception(_T("expected number"));
n.sign = str.Find('+') == 0 ? 1 : str.Find('-') == 0 ? -1 : 0;
str.TrimLeft(L"+-");
if(str.Find(L"0x") == 0)
{
if(n.sign) throw Exception(_T("hex values must be unsigned"));
n.value = (T)wcstoul(str.Mid(2), NULL, 16);
}
else
{
CStringW num_string = m_value + m_unit;
if(m_num_string != num_string)
{
Split sa(':', str);
Split sa2('.', sa ? sa[sa-1] : L"");
if(sa == 0 || sa2 == 0 || sa2 > 2) throw Exception(_T("invalid number"));
float f = 0;
for(size_t i = 0; i < sa; i++) {f *= 60; f += wcstoul(sa[i], NULL, 10);}
if(sa2 > 1) f += (float)wcstoul(sa2[1], NULL, 10) / pow((float)10, sa2[1].GetLength());
if(n.unit == L"ms") {f /= 1000; n.unit = L"s";}
else if(n.unit == L"m") {f *= 60; n.unit = L"s";}
else if(n.unit == L"h") {f *= 3600; n.unit = L"s";}
m_num.value = f;
m_num.unit = n.unit;
m_num_string = num_string;
n.value = (T)f;
}
else
{
n.value = (T)m_num.value;
n.unit = m_num.unit;
}
if(n.sign) n.value *= n.sign;
}
}
void Definition::GetAsString(CStringW& str)
{
if(m_status == node) throw Exception(_T("expected value type"));
str = m_value;
}
void Definition::GetAsNumber(Number<int>& n, StringMapW<int>* n2n) {return GetAsNumber<int>(n, n2n);}
void Definition::GetAsNumber(Number<DWORD>& n, StringMapW<DWORD>* n2n) {return GetAsNumber<DWORD>(n, n2n);}
void Definition::GetAsNumber(Number<float>& n, StringMapW<float>* n2n) {return GetAsNumber<float>(n, n2n);}
void Definition::GetAsBoolean(bool& b)
{
static StringMapW<bool> s2b;
if(s2b.IsEmpty())
{
s2b[L"true"] = true;
s2b[L"on"] = true;
s2b[L"yes"] = true;
s2b[L"1"] = true;
s2b[L"false"] = false;
s2b[L"off"] = false;
s2b[L"no"] = false;
s2b[L"0"] = false;
}
if(!s2b.Lookup(m_value, b)) // m_status != boolean && m_status != number ||
{
throw Exception(_T("expected boolean"));
}
}
bool Definition::GetAsTime(Time& t, StringMapW<float>& offset, StringMapW<float>* n2n, int default_id)
{
Definition& time = (*this)[L"time"];
CStringW id;
if(time[L"id"].IsValue()) id = time[L"id"];
else id.Format(L"%d", default_id);
float scale = time[L"scale"].IsValue() ? time[L"scale"] : 1.0f;
if(time[L"start"].IsValue() && time[L"stop"].IsValue())
{
time[L"start"].GetAsNumber(t.start, n2n);
time[L"stop"].GetAsNumber(t.stop, n2n);
if(t.start.unit.IsEmpty()) t.start.value *= scale;
if(t.stop.unit.IsEmpty()) t.stop.value *= scale;
float o = 0;
offset.Lookup(id, o);
if(t.start.sign != 0) t.start.value = o + t.start.value;
if(t.stop.sign != 0) t.stop.value = t.start.value + t.stop.value;
offset[id] = t.stop.value;
return true;
}
return false;
}
Definition::operator LPCWSTR()
{
CStringW str;
GetAsString(str);
return str;
}
Definition::operator float()
{
float d;
GetAsNumber(d);
return d;
}
Definition::operator bool()
{
bool b;
GetAsBoolean(b);
return b;
}
Definition* Definition::SetChildAsValue(CStringW path, status_t s, CStringW v, CStringW u)
{
Definition* pDef = this;
Split split('.', path);
for(size_t i = 0, j = split-1; i <= j; i++)
{
CStringW type = split[i];
if(pDef->m_nodes.IsEmpty() || !dynamic_cast<Reference*>(pDef->m_nodes.GetTail()))
{
EXECUTE_ASSERT(m_pnf->CreateRef(pDef) != NULL);
}
if(Reference* pRef = dynamic_cast<Reference*>(pDef->m_nodes.GetTail()))
{
pDef = NULL;
POSITION pos = pRef->m_nodes.GetTailPosition();
while(pos)
{
Definition* pChildDef = dynamic_cast<Definition*>(pRef->m_nodes.GetPrev(pos));
if(pChildDef->IsType(type))
{
if(pChildDef->IsNameUnknown()) pDef = pChildDef;
break;
}
}
if(!pDef)
{
pDef = m_pnf->CreateDef(pRef, type);
}
if(i == j)
{
pDef->SetAsValue(s, v, u);
return pDef;
}
}
}
return NULL;
}
Definition* Definition::SetChildAsNumber(CStringW path, CStringW v, CStringW u)
{
Definition* pDef = SetChildAsValue(path, number, v, u);
Number<float> n;
pDef->GetAsNumber(n); // will throw an exception if not a number
return pDef;
}
void Definition::Dump(OutputStream& s, int level, bool fLast)
{
if(m_predefined) return;
CStringW tabs(' ', level*4);
CStringW str = tabs;
if(m_predefined) str += '?';
if(m_priority == PLow) str += '*';
else if(m_priority == PHigh) str += '!';
if(!IsTypeUnknown() && !m_autotype) str += m_type;
if(!IsNameUnknown()) str += '#' + m_name;
str += ':';
s.PutString(L"%s", str);
if(!m_nodes.IsEmpty())
{
POSITION pos = m_nodes.GetHeadPosition();
while(pos)
{
Node* pNode = m_nodes.GetNext(pos);
if(Reference* pRef = dynamic_cast<Reference*>(pNode))
{
pRef->Dump(s, level, fLast);
}
else
{
ASSERT(!pNode->IsNameUnknown());
s.PutString(L" %s", pNode->m_name);
}
}
s.PutString(L";\n");
if(!fLast && (!m_nodes.IsEmpty() || level == 0)) s.PutString(L"\n");
}
else if(m_status == string)
{
CStringW str = m_value;
str.Replace(L"\"", L"\\\"");
s.PutString(L" \"%s\";\n", str);
}
else if(m_status == number)
{
CStringW str = m_value;
if(!m_unit.IsEmpty()) str += m_unit;
s.PutString(L" %s;\n", str);
}
else if(m_status == boolean)
{
s.PutString(L" %s;\n", m_value);
}
else if(m_status == block)
{
s.PutString(L" {%s};\n", m_value);
}
else
{
s.PutString(L" null;\n");
}
}
}
See more files for this project here