StructTable Class Reference

#include <StructTable.h>

Collaboration diagram for StructTable:

Public Types
typedef std::map< std::string, std::set< std::string > >	Interpretations
typedef std::map< dword, StructPath >	NodePaths

Public Member Functions
	StructTable (Brain &brain, const std::string &filename=std::string())
	~StructTable ()
void	clear ()
void	attachBrain (Brain &brain)
dataset_ptr	getDataset ()
SensorCollection *	getSensors ()
void	reattachSensors ()
void	adaptDataScale ()
bool	load (const std::string &filename)
bool	read (ParseFile &is)
void	write (std::ostream &os) const
const std::string &	getFilename () const
const std::string &	getPath () const
std::map< std::string, MStructure > &	getStructs ()
const std::map< std::string, MStructure > &	getStructs () const
bool	hasStructure (const std::string &sname) const
const MStructure &	getStructure (const std::string &sname) const
MStructure &	getNextStruct (int dir=1, bool wrap=true)
void	evalRelations ()
void	rebuildExpMaps ()
void	draw () const
void	startSearch (bool dostart=true)
int	searchDone () const
bool	stepSearch (float dt)
bool	triggerTest (int mx, int my, int what)
float	findBestConnection ()
bool	findBestConnection (StructPath &path, const Winner &winner) const
const StructPath &	getBestPath () const
const std::string &	getBestInterpretation () const
const std::map< std::string, StructPath > &	getIPaths () const
void	setShownIP (const std::string &curip) const
const std::string &	getShownIP () const
bool	showNextIP (int dir=1) const

Static Public Member Functions
static DMatrixf &	adjustByAvgDir (DMatrixf &mat)

Protected Types
enum	TimeMarks { TM_UPDEM, TM_TIMEOUT, TM_LAST }
enum	StateFlags { ST_RUN =1, ST_RESULT =2, ST_DONE =4, ST_TIMEOUT =16 }

Protected Member Functions
void	connectSubSuper ()
bool	readInterpreations (ParseFile &is)

Protected Attributes
std::map< std::string, MStructure >	m_Structs
std::string	m_FileName
std::string	m_Path
Brain *	m_Brain
std::string	m_CurStruct
StructPath	m_BestPath
float	m_Time
dword	m_State
std::vector< float >	m_TMarks
Interpretations	m_Interpretations
std::map< std::string, StructPath >	m_IPaths
std::string	m_BestIP
std::string	m_CurIP
std::map< std::string, NodePaths >	m_NodePaths

Friends
ParseFile &	operator>> (ParseFile &is, StructTable &st)
std::ostream &	operator<< (std::ostream &os, const StructTable &st)

Detailed Description

Definition at line 49 of file StructTable.h.

Member Typedef Documentation

typedef std::map<std::string, std::set<std::string> > StructTable::Interpretations

Definition at line 51 of file StructTable.h.

typedef std::map<dword, StructPath> StructTable::NodePaths

Definition at line 52 of file StructTable.h.

Member Enumeration Documentation

enum StructTable::StateFlags

protected

Enumerator
ST_RUN
ST_RESULT
ST_DONE
ST_TIMEOUT

Definition at line 106 of file StructTable.h.

{ ST_RUN=1, ST_RESULT=2, ST_DONE=4, ST_TIMEOUT=16 };

enum StructTable::TimeMarks

protected

Enumerator
TM_UPDEM
TM_TIMEOUT
TM_LAST

Definition at line 105 of file StructTable.h.

{ TM_UPDEM, TM_TIMEOUT, TM_LAST };

Constructor & Destructor Documentation

StructTable::StructTable	(	Brain &	brain,
		const std::string &	filename = std::string()
	)

Definition at line 18 of file StructTable.cpp.

{
    m_TMarks.clear();
    m_TMarks.resize(TM_LAST, 0.0f);
    attachBrain(brain);
    load(filename);
}

StructTable::~StructTable

(

)

Definition at line 26 of file StructTable.cpp.

{
    clear();
}

Member Function Documentation

void StructTable::adaptDataScale

(

)

Definition at line 60 of file StructTable.cpp.

Referenced by Brain::attachBrowseData().

{
    for(map<string,MStructure>::iterator si = m_Structs.begin();
        si != m_Structs.end(); si++)
    {
        si->second.getModel().adaptDataScale();
    }
}

DMatrixf & StructTable::adjustByAvgDir ( DMatrixf &  mat )

static

Definition at line 216 of file StructTable.cpp.

References Point2D::angle(), DMatrix< T >::getData(), mapAnglePI(), Point2D::rotate(), and DMatrix< T >::size().

Referenced by SubStructure::analyseTF().

{
    Point2D dir(0,0);
    DMatrixf::iterator el = mat.getData().begin();
    for(dword ind=0; ind<mat.size(); ind++, el++)
        dir += Point2D(1,0).rotate(*el);
    float avgdir = dir.angle();
    el = mat.getData().begin();
    for(dword ind=0; ind<mat.size(); ind++, el++)
        *el = mapAnglePI(*el, avgdir);
    return mat;
}

void StructTable::attachBrain ( Brain &  brain )

inline

Definition at line 57 of file StructTable.h.

{ m_Brain = &brain; }

void StructTable::clear

(

)

Definition at line 31 of file StructTable.cpp.

{
    m_Structs.clear();
    m_CurStruct.clear();
    m_Time = 0;
    m_State = 0;
    m_TMarks.clear();
    m_TMarks.resize(TM_LAST, 0.0f);
    m_BestPath.clear();
    m_Interpretations.clear();
}

void StructTable::connectSubSuper ( )

protected

Definition at line 206 of file StructTable.cpp.

{
    for(map<string,MStructure>::iterator si = m_Structs.begin();
        si != m_Structs.end(); si++)
        si->second.refSubSuper(true);   // just clear super-list
    for(map<string,MStructure>::iterator si = m_Structs.begin();
        si != m_Structs.end(); si++)
        si->second.refSubSuper();       // update super-list of substructs
}

void StructTable::draw

(

)

const

Definition at line 377 of file StructTable.cpp.

References Model::draw(), and Winner::m_Model.

Referenced by Brain::drawAllModels().

{
    const string& ipname = getShownIP();
    map<string,StructPath>::const_iterator spath = m_IPaths.find(ipname);
    for(map<string,MStructure>::const_iterator si = m_Structs.begin();
        si != m_Structs.end(); si++)
    {
        if((m_State & ST_RESULT) == 0) si->second.m_Searcher.draw();
        if(spath != m_IPaths.end()) {
            StructPath::const_iterator wi = spath->second.find(si->first);
            if(wi != spath->second.end()) {
                const Winner *nw = si->second.getWinner(wi->second);
                if(nw && nw->m_Model) {
                    glColor3f(1,.1,0);
                    glLineWidth(4.0f);
                    nw->m_Model->draw();
                }
            }
        }
    }
}

void StructTable::evalRelations

(

)

Definition at line 187 of file StructTable.cpp.

Referenced by Brain::triggerTest().

{
//     int ret = matlabCall(string("addpath ")+m_Path + ", antpca");
//     DUMP(ret);
    for(map<string,MStructure>::iterator si = m_Structs.begin();
        si != m_Structs.end(); si++)
    {
        si->second.buildAllStats();
    }
    //rebuildExpMaps();
}

float StructTable::findBestConnection

(

)

Definition at line 400 of file StructTable.cpp.

References StructPath::blockOtherPaths(), StructPath::getRelGoodness(), MStructure::getSearcher(), Searcher::getWinList(), and StructPath::m_Goodness.

{
    if(m_Structs.empty()) return m_BestPath.m_Goodness;
    m_BestPath.unprotectWinners(*this);
    m_BestPath.clear();
    for(map<string,MStructure>::iterator si = m_Structs.begin();
        si != m_Structs.end(); si++)
    {
        si->second.verifyWinnerRating();
    }

    m_IPaths.clear();
    for(Interpretations::const_iterator ip=m_Interpretations.begin();
        ip != m_Interpretations.end(); ip++)
    { // for each interpretation
        cout << "scanning interpretation " << ip->first << endl;
        m_NodePaths.clear();
        for(map<string,MStructure>::iterator si = m_Structs.begin();
            si != m_Structs.end(); si++)
        { // for each structure
            MStructure& st = si->second;
            StructPath bestpath;
            const map<dword,Winner>& winners = st.getSearcher().getWinList();
            for(map<dword,Winner>::const_iterator wi = winners.begin();
                wi != winners.end(); wi++)
            { // for each winner in current structure
                StructPath path;
                path.blockOtherPaths(ip->second, *this);
                findBestConnection(path, wi->second);
                if(path.m_Goodness > bestpath.m_Goodness)
                {
                    bestpath = path;
                }
            }
            if(bestpath.m_Goodness > m_IPaths[ip->first].m_Goodness)
            {
                m_IPaths[ip->first] = bestpath;
            }
            cout << "  best cost for " << si->first << ": "
                 << bestpath.m_Goodness
                 << " (" << bestpath.getRelGoodness() << ") " << endl;
            //<< " length: "<<bestpath.size()<<endl;
        }
        if(m_IPaths[ip->first].getRelGoodness() > m_BestPath.getRelGoodness())
        {
            m_BestPath = m_IPaths[ip->first];
            m_BestIP = ip->first;
        }
    }
    cout << "best interpretation is " << m_BestIP << endl;
    m_BestPath.protectWinners(*this);
    m_BestPath.print(cout, *this);
//     DUMP(m_BestPath.m_Goodness);
//     DUMP(m_BestPath.size());
//     cout << "showing path" << endl;
//     for(StructPath::const_iterator ps=m_BestPath.begin();
//         ps != m_BestPath.end(); ps++)
//     {
//         cout << ps->first << ": " << ps->second.m_BestRating << endl;
//     }
    return m_BestPath.getRelGoodness();
}

bool StructTable::findBestConnection	(	StructPath &	path,
		const Winner &	winner
	)		const

Definition at line 463 of file StructTable.cpp.

References StructPath::branch(), Model::getQualityOfFit(), MStructure::getWeight(), MStructure::getWinner(), StructPath::m_Goodness, StructPath::m_Maxness, Winner::m_Model, SubStructure::m_RateTH, SubStructure::m_RateWeight, Winner::m_Ratings, Winner::m_StructName, MStructure::m_SubStructures, Winner::m_WinnerID, StructPath::merge(), TRACE0, Winner::WID_EMPTY, and Winner::WID_FRAME.

{
    if(winner.m_WinnerID == Winner::WID_EMPTY) { TRACE0; return false; }
    const string& csname = winner.m_StructName;
    if(csname.empty()) { TRACE0; return false; }
    if(path[csname] != Winner::WID_EMPTY) {
        return false;           // termination criterion
    }
    if(winner.m_WinnerID == Winner::WID_FRAME) {
        path[csname] = winner.m_WinnerID;
        return true;     // confirm, but don't add goodness
    }
    NodePaths &np = m_NodePaths[csname];
    NodePaths::const_iterator wpath = np.find(winner.m_WinnerID);
    if(wpath != np.end()) { // we already have this path!
        path.merge(wpath->second);
        return true;
    }
    StructPath &bestpath = np[winner.m_WinnerID];
    bestpath = path.branch();

    const MStructure& cstruct = getStructure(csname);
    bestpath[csname] = winner.m_WinnerID;
    bestpath.m_Goodness += cstruct.getWeight()
        *winner.m_Model->getQualityOfFit();
    //* cstruct.m_Searcher.relativeQOF(winner.m_Model->getQualityOfFit());
    bestpath.m_Maxness  += cstruct.getWeight();

    for(Winner::Ratings::const_iterator wr = winner.m_Ratings.begin();
        wr != winner.m_Ratings.end(); wr++)
    {  // for each rating structure
        map<string,MStructure>::const_iterator sti =
            m_Structs.find(wr->first);
        if(sti != m_Structs.end()) {
            const MStructure& refstruct = sti->second;
            const SubStructure& subs =
                refstruct.m_SubStructures.find(csname)->second;
            StructPath spath = bestpath;
            for(map<dword,float>::const_iterator wi = wr->second.begin();
                wi != wr->second.end(); wi++)
            {
                const Winner* nextWinner = refstruct.getWinner(wi->first);
                StructPath cpath = spath;
                if(nextWinner && wi->second > subs.m_RateTH) {
                    if(findBestConnection(cpath, *nextWinner)) {
                        cpath.m_Goodness += subs.m_RateWeight*wi->second;
                        cpath.m_Maxness  += subs.m_RateWeight;
                    }
                }
                if(cpath.m_Goodness > bestpath.m_Goodness)
                    bestpath = cpath;
            }
        }
    }
    path.merge(bestpath);
    return true;
}

const std::string& StructTable::getBestInterpretation ( ) const

inline

Definition at line 92 of file StructTable.h.

Referenced by Brain::run().

{ return m_BestIP; }

const StructPath& StructTable::getBestPath ( ) const

inline

Definition at line 91 of file StructTable.h.

{ return m_BestPath; }

dataset_ptr StructTable::getDataset

(

)

Definition at line 43 of file StructTable.cpp.

Referenced by MStructure::addExpectation(), MStructure::MStructure(), and MStructure::rebuildExpMap().

{
    return m_Brain->getSensorData().shared_from_base<Dataset>();
}

const std::string& StructTable::getFilename ( ) const

inline

Definition at line 69 of file StructTable.h.

Referenced by MStructure::getInfoFilename(), and Brain::triggerTest().

{ return m_FileName; }

const std::map<std::string,StructPath>& StructTable::getIPaths ( ) const

inline

Definition at line 93 of file StructTable.h.

Referenced by Brain::drawAllModels(), Brain::run(), and Brain::triggerTest().

    { return m_IPaths; }

MStructure & StructTable::getNextStruct	(	int	dir = 1,
		bool	wrap = true
	)

Definition at line 156 of file StructTable.cpp.

Referenced by Brain::doCommand(), Brain::load(), Brain::run(), and Brain::triggerTest().

{
    static MStructure nostruc;
    if(m_Structs.empty()) return nostruc;
    if(m_CurStruct.empty()) {
        m_CurStruct = m_Structs.begin()->first;
        return m_Structs.begin()->second;
    }
    map<string,MStructure>::iterator st = m_Structs.find(m_CurStruct);
    if(st == m_Structs.end()) {
        m_CurStruct = m_Structs.begin()->first;
        return m_Structs.begin()->second;
    }
    if(dir > 0) {
        st++;
        if(st == m_Structs.end()) {
            if(wrap) st = m_Structs.begin();
            else { m_CurStruct.clear(); return nostruc; }
        }
        m_CurStruct = st->first;
    } else if(dir < 0) {
        if(st == m_Structs.begin()) {
            if(wrap) st = m_Structs.end();
            else { m_CurStruct.clear(); return nostruc; }
        }
        st--;
        m_CurStruct = st->first;
    }
    return st->second;
}

const std::string& StructTable::getPath ( ) const

inline

Definition at line 70 of file StructTable.h.

Referenced by MStructure::write().

{ return m_Path; }

SensorCollection * StructTable::getSensors

(

)

Definition at line 48 of file StructTable.cpp.

Referenced by MStructure::MStructure().

{ return (SensorCollection*) &m_Brain->getSensors(); }

const std::string& StructTable::getShownIP ( ) const

inline

Definition at line 97 of file StructTable.h.

Referenced by Brain::drawAllModels(), and Brain::triggerTest().

    { return m_CurIP.empty() ? m_BestIP : m_CurIP; }

std::map<std::string, MStructure>& StructTable::getStructs ( )

inline

Definition at line 71 of file StructTable.h.

Referenced by StructPath::blockOtherPaths(), MStructure::buildAllStats(), StructPath::protectWinners(), MStructure::rebuildExpMap(), MStructure::refSubSuper(), MStructure::showStats(), Brain::triggerTest(), StructPath::unprotectWinners(), and MStructure::verifyWinnerRating().

{ return m_Structs; }

const std::map<std::string, MStructure>& StructTable::getStructs ( ) const

inline

Definition at line 72 of file StructTable.h.

    { return m_Structs; }

const MStructure & StructTable::getStructure

(

const std::string &

sname

)

const

Definition at line 151 of file StructTable.cpp.

Referenced by StructPath::print().

{
    return m_Structs.find(sname)->second;
}

bool StructTable::hasStructure

(

const std::string &

sname

)

const

Definition at line 146 of file StructTable.cpp.

{
    return m_Structs.find(sname) != m_Structs.end();
}

bool StructTable::load

(

const std::string &

filename

)

Definition at line 69 of file StructTable.cpp.

Referenced by Brain::load(), and Brain::triggerTest().

{
    if(filename.empty()) return false;
    cout << "loading " << filename << endl;
    ParseFile is(filename);
    if(is) m_FileName = filename;
    return read(is);
}

bool StructTable::read

(

ParseFile &

is

)

Definition at line 78 of file StructTable.cpp.

References ParseFile::error(), ParseFile::getErrorMsg(), MStructure::getName(), ParseFile::getPath(), MStructure::read(), and ParseFile::setParseError().

{
    if(is) {
        clear();
        m_Path = is.getPath();
        MStructure cstructure("", this);
        while(is) {
            if(cstructure.read(is)) {
                if(cstructure) m_Structs[cstructure.getName()] = cstructure;
            } else if(!readInterpreations(is))
                is.setParseError(
                    string("error reading structure table. ") +
                    "(A structure has to begin with struct <name>)");
        }
        connectSubSuper();
        evalRelations();
    }
    if(is.error()) { cerr << is.getErrorMsg() << endl; return false; }
    return true;
}

bool StructTable::readInterpreations ( ParseFile &  is )

protected

Definition at line 99 of file StructTable.cpp.

References ParseFile::getKey(), ParseFile::getNextLine(), ParseFile::getValue(), ParseFile::pushLine(), and ParseFile::setParseError().

{
    m_Interpretations.clear();
    bool readon = true, allright = false;
    while(is.getNextLine() && readon) {
        if(is.getKey() == "interpretations") allright = true;
        else if(!allright) { is.pushLine(); return false; }
        else if(is.getKey() == "end") readon = false;
        else {
            set<string>& elements = m_Interpretations[is.getKey()];
            istringstream slist(is.getValue());
            slist >> ws;
            while(slist) {
                string structure; slist >> structure;
                if(structure.empty()) break;
                elements.insert(structure);
                slist >> ws;
            }
            if(elements.empty())
                is.setParseError("error reading structure interpretation");
        }
    }
    return true;
}

void StructTable::reattachSensors

(

)

Definition at line 51 of file StructTable.cpp.

{
    for(map<string,MStructure>::iterator si = m_Structs.begin();
        si != m_Structs.end(); si++)
    {
        si->second.getModel().reattachSensors();
    }
}

void StructTable::rebuildExpMaps

(

)

Definition at line 199 of file StructTable.cpp.

{
    for(map<string,MStructure>::iterator si = m_Structs.begin();
        si != m_Structs.end(); si++)
        si->second.rebuildExpMap();
}

int StructTable::searchDone ( ) const

inline

Definition at line 81 of file StructTable.h.

Referenced by Brain::run().

                           {
        if(m_State&ST_DONE) return 1;
        if(m_State&ST_TIMEOUT) return -1; else return 0;
    }

void StructTable::setShownIP ( const std::string &  curip ) const

inline

Definition at line 95 of file StructTable.h.

Referenced by Brain::triggerTest().

    { m_CurIP = curip; }

bool StructTable::showNextIP

(

int

dir = 1

)

const

Definition at line 345 of file StructTable.cpp.

Referenced by Brain::triggerTest().

{
    bool ret = true;
    Interpretations::const_iterator cip = m_Interpretations.find(m_CurIP);
    if(cip == m_Interpretations.end()) {
        if(m_Interpretations.empty()) {
            m_CurIP.clear();
            return false;
        }
        cip = m_Interpretations.begin();
    }
    if(dir == 1) {
        cip++;
        if(cip==m_Interpretations.end()) {
            cip = m_Interpretations.begin();
            ret = false;
        }
    } else if(dir > 1) {
        cip = m_Interpretations.end(); cip--;
    } else if(dir == -1) {
        if(cip==m_Interpretations.begin()) {
            cip = m_Interpretations.end();
            ret = false;
        }
        cip--;
    } else if(dir < -1) {
        cip = m_Interpretations.begin();
    }
    m_CurIP = cip->first;
    return ret;
}

void StructTable::startSearch

(

bool

dostart = true

)

Definition at line 287 of file StructTable.cpp.

Referenced by Brain::run().

{
    if(dostart) {
        m_State|=ST_RUN;
        m_State&=~(ST_DONE|ST_TIMEOUT);
        m_Time=0;
        m_TMarks[TM_UPDEM] = m_TMarks[TM_TIMEOUT] = 0;
        m_BestPath.clear();
        m_IPaths.clear();
    } else m_State &= ~ST_RUN;
    for(map<string,MStructure>::iterator si = m_Structs.begin();
        si != m_Structs.end(); si++)
    {
        if(dostart) si->second.m_Searcher.clear();
        si->second.m_Searcher.startSearch(dostart);
    }
}

bool StructTable::stepSearch

(

float

dt

)

Definition at line 305 of file StructTable.cpp.

References getSearchPara(), and SearcherParams::m_EvolveCycle.

Referenced by Brain::evolve(), and MStructure::getExpMap().

{
    bool dotimeout=false;
    bool ret=true;
    if((m_State&ST_DONE)) return true;
    if((m_State&ST_RUN) == 0) return false;
    if(m_Time == 0) {
//initialize
        for(map<string,MStructure>::iterator si = m_Structs.begin();
            si != m_Structs.end(); si++)
            si->second.buildMasterModel();
        m_TMarks[TM_TIMEOUT] = m_Time + getSearchPara().m_EvolveCycle*3000;
    }
    if(dotimeout && m_TMarks[TM_TIMEOUT] - m_Time <= 0) {
//finalize
        m_State &= ~ST_RUN;
        m_State |= ST_RESULT;
        ret = false;
    } else {
        bool doupdate = m_TMarks[TM_UPDEM] - m_Time <= 0;
        if(doupdate) {   //pre update
            rebuildExpMaps();
            m_TMarks[TM_UPDEM] = m_Time + getSearchPara().m_EvolveCycle;
        }
        for(map<string,MStructure>::iterator si = m_Structs.begin();
            si != m_Structs.end(); si++)
        {
            if(doupdate) si->second.m_Searcher.evolve();
            ret &= si->second.stepSearch(dt);
        }
        if(doupdate) findBestConnection();
    }
    m_Time += dt;
    if(ret) {
        m_State |= ST_DONE;
        cout << "search terminated after " << m_Time << " seconds." << endl;
    }
    return ret;
}

bool StructTable::triggerTest	(	int	mx,
		int	my,
		int	what
	)

Definition at line 229 of file StructTable.cpp.

Referenced by Brain::triggerTest().

{
    switch(what)
    {
    case KEY_t:
        rebuildExpMaps();
        break;
    case KEY_g:
        evalRelations();
        break;
    case KEY_n:
    {
        for(map<string,MStructure>::iterator si = m_Structs.begin();
            si != m_Structs.end(); si++)
            si->second.buildMasterModel();
    }
    break;
    case KEY_v:
    {
        findBestConnection();
//             for(map<string,MStructure>::iterator si = m_Structs.begin();
//                 si != m_Structs.end(); si++)
//                 si->second.verifyWinnerRating();
    }
    break;
    case KEY_c:
        //m_TMarks[TM_TIMEOUT] = m_Time + 10;
        m_State = m_State ^ ST_RESULT;
        break;
    case KEY_u:
        cout << "starting structure search" << endl;
        startSearch();
        break;
    case KEY_i:
        cout << "stopping structure search" << endl;
        startSearch(false);
        break;
    default:
    {
        if(what == KEY_h) {
            m_State&=~ST_RUN;
        } if(what == KEY_s) {
            m_State^=ST_RUN;
        } else if(what == KEY_r) {
            m_Time=0;
            m_TMarks[TM_UPDEM] = m_TMarks[TM_TIMEOUT] = 0;
            m_BestPath.clear();
        }
        bool ret=false;
        for(map<string,MStructure>::iterator si = m_Structs.begin();
            si != m_Structs.end(); si++)
            ret = si->second.m_Searcher.triggerTest(mx,my,what);
        return ret;
    }
    }
    return true;
}

void StructTable::write

(

std::ostream &

os

)

const

Definition at line 124 of file StructTable.cpp.

Referenced by MStructure::hasSupStruct().

{
    for(map<string,MStructure>::const_iterator si = m_Structs.begin();
        si != m_Structs.end(); si++)
    {
        si->second.write(os);
    }
    if(!m_Interpretations.empty()) {
        os << "interpretations" << endl;
        for(map<string,set<string> >::const_iterator ip =
                m_Interpretations.begin(); ip != m_Interpretations.end(); ip++)
        {
            os << "  " << ip->first;
            for(set<string>::const_iterator sp = ip->second.begin();
                sp != ip->second.end(); sp++)
                os << " " << *sp;
            os << endl;
        }
        os << "end" << endl << endl;
    }
}

Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  os, const StructTable &  st  )

friend

Definition at line 67 of file StructTable.h.

    { st.write(os); return os; }

ParseFile& operator>> ( ParseFile &  is, StructTable &  st  )

friend

Definition at line 65 of file StructTable.h.

    { st.read(is); return is; }

Member Data Documentation

std::string StructTable::m_BestIP

protected

Definition at line 118 of file StructTable.h.

StructPath StructTable::m_BestPath

protected

Definition at line 112 of file StructTable.h.

Brain* StructTable::m_Brain

protected

Definition at line 110 of file StructTable.h.

std::string StructTable::m_CurIP

mutableprotected

Definition at line 119 of file StructTable.h.

std::string StructTable::m_CurStruct

protected

Definition at line 111 of file StructTable.h.

std::string StructTable::m_FileName

protected

Definition at line 108 of file StructTable.h.

Interpretations StructTable::m_Interpretations

protected

Definition at line 116 of file StructTable.h.

std::map<std::string,StructPath> StructTable::m_IPaths

protected

Definition at line 117 of file StructTable.h.

std::map<std::string,NodePaths> StructTable::m_NodePaths

mutableprotected

Definition at line 120 of file StructTable.h.

std::string StructTable::m_Path

protected

Definition at line 109 of file StructTable.h.

dword StructTable::m_State

protected

Definition at line 114 of file StructTable.h.

std::map<std::string, MStructure> StructTable::m_Structs

protected

Definition at line 107 of file StructTable.h.

float StructTable::m_Time

protected

Definition at line 113 of file StructTable.h.

std::vector<float> StructTable::m_TMarks

protected

Definition at line 115 of file StructTable.h.

---

The documentation for this class was generated from the following files:

• src/StructTable.h
• src/StructTable.cpp