---

skTreeNode.h

/*
  Copyright 1996-2003
  Simon Whiteside

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

    This library 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
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 * $Id: skTreeNode_8h-source.html,v 1.17 2004/12/17 21:31:14 sdw Exp $
*/


#ifndef TREENODE_H
#define TREENODE_H

#include "skString.h"
#include "skException.h"
#include "skConstants.h"

class  CLASSEXPORT skTreeNode;
class  CLASSEXPORT skTreeNodeList;
class  CLASSEXPORT skExecutableContext;
class  CLASSEXPORT skInputSource;
class  CLASSEXPORT skOutputDestination;


class  CLASSEXPORT skTreeNode 
#ifdef __SYMBIAN32__
: public CBase
#endif
{
 public:
  inline skTreeNode();
#ifndef __SYMBIAN32__

  skTreeNode(const skTreeNode& );
#endif

  inline skTreeNode(const skString& label); 
  inline skTreeNode(const skString& label,const skString& data);
  IMPORT_C skTreeNode(const skString& label,bool data);
  IMPORT_C skTreeNode(const skString& label,int  data);
#ifdef USE_FLOATING_POINT

  IMPORT_C skTreeNode(const skString& label,float data);
#endif

  virtual ~skTreeNode();
  IMPORT_C skTreeNode& operator=(const skTreeNode& );
  IMPORT_C bool operator==(const skTreeNode& other) const;
  IMPORT_C bool deepCompare(const skTreeNode& other,bool check_tagname) const;
  inline skString label() const;
  inline void  label(const skString& s);
  inline void  label(const Char * s);
  inline skString data() const;
  inline void  data(const skString& s);
  inline void  data(const Char * s);
  IMPORT_C bool boolData() const;
  IMPORT_C void boolData(bool);
  IMPORT_C int  intData() const;
  IMPORT_C void intData(int);
#ifdef USE_FLOATING_POINT

  IMPORT_C float floatData() const;
  IMPORT_C void floatData(float);
#endif

  IMPORT_C void  prependChild(skTreeNode*);
  IMPORT_C void  addChild(skTreeNode*);
  IMPORT_C void  setChild(skTreeNode*); 
  IMPORT_C void  removeChild(skTreeNode*);
  IMPORT_C void  deleteChild(skTreeNode*);
  IMPORT_C bool containsChild(skTreeNode*);
  IMPORT_C skTreeNode* findChild(const skString& label) const;
#ifdef __SYMBIAN32__

  IMPORT_C skTreeNode* findChild(const TDesC& label) const;
#endif

  IMPORT_C skTreeNode* findChild(const skString& label,const skString& data) const;
  IMPORT_C skString findChildData(const skString& label) const;
  IMPORT_C skString findChildData(const skString& label,const skString& defaultVal) const;
#ifdef __SYMBIAN32__

  IMPORT_C skString findChildData(const TDesC& label) const;
#endif

  IMPORT_C bool findChildboolData(const skString& label, bool defaultVal=false) const;
  IMPORT_C int  findChildIntData(const skString& label, int defaultVal=0) const;
#ifdef __SYMBIAN32__

  IMPORT_C int  findChildIntData(const TDesC& label, int defaultVal=0) const;
#endif
#ifdef USE_FLOATING_POINT

  IMPORT_C float findChildFloatData(const skString& label, float defaultVal=0.0f) const;
#endif

  IMPORT_C skString nthChildData(USize index) const;
  IMPORT_C int  nthChildIntData(USize index) const;
  IMPORT_C void  write(skOutputDestination& out,USize tabstops,bool include_tabs=true) const;
  IMPORT_C bool write(const skString& file) const;
  IMPORT_C skTreeNode *  nthChild(USize  i) const;
  IMPORT_C USize numChildren() const;
  IMPORT_C void copyItems(skTreeNode& node);
  IMPORT_C void moveItemsFrom(skTreeNode& node);
  IMPORT_C void clear();
  static IMPORT_C skTreeNode * read(const skString& file,skExecutableContext& ctxt);
  
 private:
  static void writeTabs(skOutputDestination& out,int tabstops);
#ifdef __SYMBIAN32__

  skTreeNode(const skTreeNode& );
#endif

  skString m_Label;
  skString m_Data;
  skTreeNodeList * m_Items;
};
class  CLASSEXPORT skTreeNodeListIterator 
#ifdef __SYMBIAN32__
: public CBase
#endif
{
 public:
  IMPORT_C skTreeNodeListIterator(const skTreeNode&);
  IMPORT_C virtual ~skTreeNodeListIterator();
  IMPORT_C skTreeNode * operator ()();
  IMPORT_C void reset();
 private:
  const skTreeNode& m_Node;
  USize m_Index;
};
// switches on the optimization where a shared class buffer is used
#ifndef __SYMBIAN32__
#define USECLASSBUFFER
#endif
const int MAXBUFFER=20000;
class  CLASSEXPORT skTreeNodeReader 
#ifdef __SYMBIAN32__
: public CBase
#endif
{
 public:
   IMPORT_C skTreeNodeReader();
   IMPORT_C skTreeNodeReader(skInputSource& in, const skString& source_name);
  IMPORT_C virtual ~skTreeNodeReader();
  IMPORT_C skTreeNode* read(skExecutableContext& ctxt);
#ifdef __SYMBIAN32__

  IMPORT_C skTreeNode* read(skInputSource * in, const TDesC& source_name,skExecutableContext& ctxt);
#endif
#ifdef __SYMBIAN32__

  inline operator TCleanupItem();
  inline static void Cleanup(TAny * s);
#endif

  IMPORT_C void clear();
 private:
  enum Lexeme           { L_IDENT, L_TEXT, L_LBRACE, L_RBRACE, L_EOF, L_ERROR };
  void grabBuffer();
  void error(const skString& msg);
  void error(const Char * msg);
  Lexeme lex();
  void  unLex();
  skTreeNode *  parseTreeNode(skTreeNode * pparent);
  void parseTreeNodeList(skTreeNode * list);
  void addToLexText(Char c);
  skString m_FileName;
  bool m_UnLex;
  Lexeme m_LastLexeme;
  Char  * m_LexText;
  unsigned short m_LineNum;
  unsigned short m_Pos;
  skInputSource * m_In;
  bool  m_Error;
#ifdef USECLASSBUFFER

  bool  m_UsingClassLexText;
  static Char g_ClassLexText[MAXBUFFER];
  static bool g_LexTextUsed;
#endif
};

class CLASSEXPORT  skTreeNodeReaderException : public skException
{
 public:
  skTreeNodeReaderException(const skString& fileName,const skString& msg)
    : m_FileName(fileName),m_Msg(msg){
  }
  skString getMessage() const{
    return toString();
  }
  skString toString() const{
    return skString::addStrings(m_FileName.ptr(),s_colon,m_Msg.ptr());
  }
 private:
  skString m_FileName;
  skString m_Msg;
};
#include "skAlist.h"
#ifdef INSTANTIATE_TEMPLATES
EXTERN_TEMPLATE template class CLASSEXPORT skTAList<skTreeNode>;
#endif

class  CLASSEXPORT skTreeNodeList :  public skTAList<skTreeNode>
{           
 public:
  IMPORT_C skTreeNodeList();
#ifndef __SYMBIAN32__

  skTreeNodeList(const skTreeNodeList& list);
#endif

  IMPORT_C virtual ~skTreeNodeList();
  IMPORT_C skTreeNode * findItem(const skString& label) const;
  IMPORT_C skTreeNode * findItem(const skString& label,const skString& data) const;
  IMPORT_C skTreeNode * nthElt(USize  i) const;
  IMPORT_C skTreeNodeList&   operator=(const skTreeNodeList& list);
};

//-----------------------------------------------------------------
inline skTreeNode::skTreeNode()
//-----------------------------------------------------------------
  : m_Items(0)
{
}
//-----------------------------------------------------------------
inline skTreeNode::skTreeNode(const skString& label)
  //-----------------------------------------------------------------
  : m_Label(label),m_Items(0)
{
}
//-----------------------------------------------------------------
inline skTreeNode::skTreeNode(const skString& label,const skString&  data)
  //-----------------------------------------------------------------
  : m_Label(label),m_Data(data),m_Items(0)
{
}
//-----------------------------------------------------------------
inline skString skTreeNode::label() const
  //-----------------------------------------------------------------
{
  return m_Label;
}
//-----------------------------------------------------------------
inline void skTreeNode::label(const skString& s) 
  //-----------------------------------------------------------------
{
  m_Label=s;
}
//-----------------------------------------------------------------
inline void skTreeNode::label(const Char * s) 
  //-----------------------------------------------------------------
{
  m_Label=s;
}
//-----------------------------------------------------------------
inline skString skTreeNode::data() const
//-----------------------------------------------------------------
{
  return m_Data;
}
//-----------------------------------------------------------------
inline void skTreeNode::data(const skString& t) 
//-----------------------------------------------------------------
{
  m_Data=t;
}
//-----------------------------------------------------------------
inline void skTreeNode::data(const Char * t) 
//-----------------------------------------------------------------
{
  m_Data=t;
}
#ifdef __SYMBIAN32__
//-------------------------------------------------------------------------
inline skTreeNodeReader::operator TCleanupItem()
  //-------------------------------------------------------------------------
  // used for leave support of local variable lists
{
  return TCleanupItem(Cleanup,this);
}
//-------------------------------------------------------------------------
inline void skTreeNodeReader::Cleanup(TAny * s)
  //-------------------------------------------------------------------------
  // called in case there is a leave
{
  ((skTreeNodeReader *)s)->clear();
}
#endif
//-----------------------------------------------------------------
inline skTreeNodeList::skTreeNodeList()
//-----------------------------------------------------------------
{
}

#endif
                        

---