json_lexer.h

Go to the documentation of this file.

/*NB_REVISION*/
 
/*NB_COPYRIGHT*/
 
#ifndef _JSON_LEXER_H
#define _JSON_LEXER_H
 
#include <buffers.h>
#include <math.h>
#include <nettypes.h>
#include <webclient/web_buffers.h>
#include <nbstring.h>
 
enum json_primitive_type
{
    UNDEFINED,         
    BEGIN_ARRAY,       
    BEGIN_OBJECT,      
    END_ARRAY,         
    END_OBJECT,        
    NAME,              
    STRING,            
    VALUE_SEPERATOR,   
    NUMBER,            
    FALSE_EL,          
    TRUE_EL,           
    NULL_EL,           
    STRING_TOO_BIG,    
    STRING_CHUNK,      
    ALLOC_STRING,      
    NOTFOUND,          
    EOF_EL             
};
 
const char *GetTypeName(json_primitive_type t);
 
 
typedef json_primitive_type json_primative_type; // Added for backwards compatibility
 
typedef void(CharOutputFn)(const char *chars, int len, void *blob);
 
struct JsonAllocString
{
    JsonAllocString * pNext;     
    char data[];                 
};
 
class ParsedJsonDataSet;        // forward declaration
 
class JsonRef {
    const ParsedJsonDataSet *parser;
    PoolPtr m_pCurrent_Pool;
    int m_nCurrent_Position;
 
    JsonRef() {parser = 0; m_pCurrent_Pool = 0; m_nCurrent_Position = 0;}
    friend class ParsedJsonDataSet;
        // Used to print objects
    int printhelper(CharOutputFn *pf, void *p, bool pretty);
 
 
 
    public:
    JsonRef(const JsonRef &pos);
    json_primitive_type GetCurrent() const;
    json_primitive_type GetRawCurrent() const;          // Get current position element including non public types
    json_primitive_type GetNextName();
    json_primitive_type GetNext();
    json_primitive_type GetFirst();
    json_primitive_type GetNextNameInCurrentArray();
    json_primitive_type GetNextNameInCurrentObject();   // Retrieve only name elements inside current object
    json_primitive_type FindFullAtName(const char *name);
    json_primitive_type SkipCurrentValue();             // Skips over the current value
    json_primitive_type FindFullName(const char *name);
    json_primitive_type FindElementAfterName(const char *name);
    json_primitive_type FindElementAfterNameInCurrentObject(const char *name);
    json_primitive_type FindGlobalElementAfterName(const char *name);
    json_primitive_type GetIndexInCurrentArray(int i);
    json_primitive_type FindElementAfterNameInCurrentArray(const char *name);
 
 
    const char *CurrentName() const;
    bool CurrentNameMatches(const char *name) const;
    const char *CurrentString() const;
    int CopyCurrentString(char *buf, int buflen) const;
    int CopyCurrentString(NBString &nbs) const;
    double CurrentNumber() const;
    inline double CurrentIntNumber() const { double dv=CurrentNumber(); if(isnan(dv))return 0; return dv;};
    bool CurrentBool() const;
    bool PermissiveCurrentBool() const;
 
    JsonRef operator [](int i);
 
    JsonRef object(const char *name)
    {
        JsonRef prf = *this;
        if (prf.Valid())
        {
            if (prf.GetCurrent() == BEGIN_OBJECT)
                prf.next();
 
            while (1)
            {
                json_primitive_type t = prf.FindElementAfterNameInCurrentObject(name);
                if ((t != NOTFOUND) && (t != UNDEFINED) && (t != EOF_EL))
                    return prf;
 
                if (t == NOTFOUND)
                {
                    prf.MakeInvalid();
                    return prf;
                };
 
                if (t == BEGIN_OBJECT)
                {
                    prf.MakeInvalid();
                    return prf;
                };
            }
        }
        else
        {
            return prf;
        }
    };
 
    JsonRef GetA(const char *name,json_primitive_type pt1,json_primitive_type pt2=UNDEFINED)
    {
        JsonRef prf = *this;
        if (prf.Valid())
        {
            if (prf.GetCurrent() == BEGIN_OBJECT)
                prf.next();
 
            while (1)
            {
                json_primitive_type t = prf.FindElementAfterNameInCurrentObject(name);
                if(t==pt1) return prf;
                if((t==pt2) &&(t!=UNDEFINED)) return prf;
 
                if((t == UNDEFINED) || (t == EOF_EL)||(t == NOTFOUND))
                {
                    prf.MakeInvalid();
                    return prf;
                };
 
            }
        }
        else
        {
            return prf;
        }
    };
 
 
inline  JsonRef Number(const char * name) {return GetA(name,NUMBER); };
inline  JsonRef Bool(const char * name) {return GetA(name,FALSE_EL,TRUE_EL);};
inline  JsonRef String(const char * name) {return GetA(name,STRING,ALLOC_STRING);};
inline  JsonRef Array(const char * name) {return GetA(name,BEGIN_ARRAY);};
 
 
 
 
    JsonRef name(const char *name);
 
    JsonRef operator()(const char *namev) {return name(namev); };
    operator bool ()    const {return PermissiveCurrentBool(); };
 
    operator float ()   const {return (float)CurrentNumber(); };
 
    operator double ()  const {return CurrentNumber(); };
 
    operator uint8_t()  const {return  (uint8_t)CurrentIntNumber(); };
 
    operator int()      const {return  (int)CurrentIntNumber(); };
 
    operator uint16_t() const {return (uint16_t)CurrentIntNumber(); };
 
    operator uint32_t() const {return (uint32_t)CurrentIntNumber(); };
 
    operator int8_t()   const {return   (int8_t)CurrentIntNumber(); };
 
    operator int16_t()  const {return (int16_t)CurrentIntNumber(); };
 
    operator int32_t()  const {return (uint32_t)CurrentIntNumber(); };
 
    operator time_t()   const {return (time_t)CurrentIntNumber(); };
 
    operator const char *() const {return CurrentString(); };
 
    operator NBString() const {return (NBString)CurrentString(); };
 
    inline bool IsNumber() {return (Valid() && GetCurrent() == NUMBER); };
 
    inline bool IsObject() {return (Valid() && GetCurrent() == BEGIN_OBJECT); } ;
 
    inline bool IsString() {return (Valid() &&  ((GetCurrent() == STRING)||(GetCurrent() == ALLOC_STRING))); } ;
 
    inline bool IsBool()   {return (Valid() && ((GetCurrent() == TRUE_EL) || (GetCurrent() == FALSE_EL))); } ;
 
    inline bool IsNull()   {return (Valid() && GetCurrent() == NULL_EL); } ;
 
    inline bool IsArray()  {return (Valid() && GetCurrent() == BEGIN_ARRAY); } ;
 
    inline bool Valid()const {return ((m_pCurrent_Pool) && (parser));};
 
    inline JsonRef start()
    {
        JsonRef prf = *this;
        if (prf.Valid())
            prf.ResetPosition();
        return prf;
    };
 
    JsonRef next() const  {JsonRef prf=*this;  if(prf.Valid()) prf.IncPosition();  return prf; };
 
    bool IncPosition();
 
    bool JumpPosition(int siz);
 
    void ResetPosition();
 
    void SkipElement();
 
    void SkipArray();
 
    void SkipObject();
 
    int PrintChildren(bool pretty = false);
 
    int PrintChildrenToFd(int fd, bool pretty = false);
 
    int PrintChildrenToBuffer(char *buffer, int maxlen, bool pretty = false);
 
 
    int PrintChildrenToString(NBString & s,bool pretty = false);
 
 
    int GetChildPrintSize(bool pretty=false);
 
    void DiagDump(const char * lab);
 
 
    void MakeInvalid(){m_pCurrent_Pool=0; };
 
};
 
 
//Standalons function to check validity.
inline bool Valid(const JsonRef & ref) {return ref.Valid(); }
 
 
class ParsedJsonDataSet : public buffer_object {
    PoolPtr m_pStorage_List_Head;
    JsonRef m_ref;
    JsonAllocString * pStringList;
    int m_nMax_Position;
    int m_nPool_Count;
 
    int m_currentLine;
    int m_currentColumn;
    NBString m_stateStack;
    json_primitive_type m_LastEmit;
    json_primitive_type m_PrevLastEmit;
    NBString m_LastError;
    bool m_syntaxValid = true;
 
 
    unsigned char m_BoolFlags;
    const unsigned char fEnableLargeStrings=1;
    const unsigned char fNeedComma=2;
    const unsigned char fFirstFind=4;
    const unsigned char fNeedNameTerm=8;
 
    inline bool EnableLargeStrings() {return ((m_BoolFlags & fEnableLargeStrings)!=0);};
    inline bool NeedComma()          {return ((m_BoolFlags & fNeedComma)!=0);};
    inline bool NeedNameTerm()       {return ((m_BoolFlags & fNeedNameTerm)!=0);};
    inline void CheckLastComma() {if(m_LastEmit==VALUE_SEPERATOR){Error("Trailing comma");}};
 
    inline void pushStack(char c) {m_stateStack+=c; };
 
    inline bool popStack(char c)  
    {int len=m_stateStack.length(); 
     if((len==0) || (m_stateStack[len-1]!=c))
        return false;
     m_stateStack.shrink(1); 
     return true;
    };
 
    inline char topStack()
    {int len=m_stateStack.length(); 
     if(len==0) return 0;
     return m_stateStack[len-1];
    }
    
    inline bool OkForValue(json_primitive_type prev)
    {
 
        if(prev==BEGIN_ARRAY) return true;
        if((prev==VALUE_SEPERATOR) &&(topStack()=='['))return true;
        if(prev==NAME) return true;
        if(prev==UNDEFINED) return true;
        return false;
    }
 
    inline bool OkForName(json_primitive_type prev)
    {
        if((prev==BEGIN_OBJECT)) return true;
        if((prev==VALUE_SEPERATOR) &&(topStack()=='{'))return true;
        return false;
    }
    
 
 
    unsigned char m_sep;   // Current string separator
    unsigned short m_tv;
 
 
    // Parser state vars used when receiving text data
    int m_state;           // Parser state flag
    unsigned char *m_pPrevStringStart;
    int m_nStrLen;
 
    unsigned char *PutChar(unsigned char c);   // Used to process incoming text
    void CheckForAndFixBrokenString();
    void ProcessChar(unsigned char c);
    void ZeroNextString();
    void ZeroNextNumber(char c);
    void AddStringChar(char c);
    void AddEscapedStringChar(char c);
    void AddNumberChar(char c);
    void EmitNumberBuffer();
    bool CheckStringEmit(json_primitive_type t);
    void Emit(json_primitive_type t);
    void ChangeString(json_primitive_type t);
    inline bool IncPosition() { return m_ref.IncPosition(); };
    inline bool JumpPosition(int siz) {return m_ref.JumpPosition(siz); };
    bool Built();
 
    virtual void Error(const char *err);// Error handler
    virtual void Error(NBString & s);   // Error handler
    virtual void Warn(const char *err); // Warn handler
    virtual void Warn(NBString & s);    // Warn handler
 
 
 
   private:
    ParsedJsonDataSet *InsertName(const char *name);
    ParsedJsonDataSet *InsertString(const char *s);
    ParsedJsonDataSet *Insert(short i);
    ParsedJsonDataSet *Insert(int i);
    ParsedJsonDataSet *Insert(long i);
    ParsedJsonDataSet *Insert(unsigned short i);
    ParsedJsonDataSet *Insert(unsigned int i);
    ParsedJsonDataSet *Insert(unsigned long i);
    ParsedJsonDataSet *Insert(bool b);
    ParsedJsonDataSet *Insert(double d);
    ParsedJsonDataSet *Insert(const IPADDR &ip);
 
 
   public:
   friend class JsonRef;
 
 
   inline void DiagDump(const char * lab) {m_ref.DiagDump(lab);};
 
    inline void EnableLargeStrings(bool b)
    {
        if(b) m_BoolFlags|=fEnableLargeStrings;
              else
              m_BoolFlags&=~fEnableLargeStrings;
 
    };
 
    inline void NeedComma(bool b)
    {
        if(b) m_BoolFlags|=fNeedComma;
              else
              m_BoolFlags&=~fNeedComma;
 
    };
 
    inline bool FirstFind()      {return ((m_BoolFlags & fFirstFind)!=0);};
    inline void FirstFind(bool b)
    {
        if(b) m_BoolFlags|=fFirstFind;
              else
              m_BoolFlags&=~fFirstFind;
 
    };
 
 
 
 
 
    virtual int WriteData(const unsigned char *pCopyFrom, int numBytes);
 
    virtual int ReadFrom(int fd);
 
    bool CopyObject(ParsedJsonDataSet & src_set);
 
    void ClearObject();
    inline JsonRef operator [](int i){return m_ref[i]; };
 
    inline JsonRef operator()(const char * name){return m_ref.name(name);}
 
    inline JsonRef name(const char * name){return m_ref.name(name);}
 
    inline JsonRef object(const char * name){return m_ref.object(name);}
 
    inline JsonRef start(){return m_ref.start();};
 
    inline JsonRef next(){return m_ref.next();};
 
    inline json_primitive_type GetFirst() {return m_ref.GetFirst(); };
 
   inline json_primitive_type GetNext() {return m_ref.GetNext();};
 
    inline json_primitive_type GetCurrent() {return m_ref.GetCurrent();};
 
    // Get current position element including non public types
    inline json_primitive_type GetRawCurrent() {return m_ref.GetRawCurrent(); };
 
    // Retrieve only name elements
    // returns NOTFOUND if its not there
 
    inline json_primitive_type GetNextName() {return m_ref.GetNextName(); };
 
    json_primitive_type GetNextObject();
 
    json_primitive_type GetNextArray();
 
    inline json_primitive_type GetNextNameInCurrentObject(){return m_ref.GetNextNameInCurrentObject(); };
 
    inline json_primitive_type GetNextNameInCurrentArray() {return m_ref.GetNextNameInCurrentArray(); };
 
    json_primitive_type GetNextNumberInCurrentArray();
 
    json_primitive_type GetNextStringInCurrentArray();
 
    json_primitive_type GetNextBoolInCurrentArray();
 
    json_primitive_type GetNextObjectInCurrentArray();
    inline json_primitive_type SkipCurrentValue() {return m_ref.SkipCurrentValue(); }; // Skips over the current value
 
    // Get/Restore parser position
    inline void ResetPosition() {m_ref.ResetPosition(); };
 
    JsonRef GetParsePosition();
 
    JsonRef SetParsePosition(JsonRef pos);
 
   inline json_primitive_type FindFullName(const char *name){ return m_ref.FindFullName(name); };
 
    inline json_primitive_type FindFullAtName(const char *name) {return m_ref.FindFullAtName(name); };
   inline json_primitive_type FindElementAfterName(const char *name) {return m_ref.FindElementAfterName(name); };
 
    inline json_primitive_type FindGlobalElementAfterName(const char *name) {return m_ref.FindGlobalElementAfterName(name); };
 
    inline json_primitive_type FindElementAfterNameInCurrentObject(const char *name) {return m_ref.FindElementAfterNameInCurrentObject(name);  };
    inline json_primitive_type FindElementAfterNameInCurrentArray(const char *name)
    {return m_ref.FindElementAfterNameInCurrentArray(name);};
 
    inline bool CurrentBool() {return m_ref.CurrentBool(); };
 
    inline bool PermissiveCurrentBool() {return m_ref.PermissiveCurrentBool(); };
 
    inline double CurrentNumber() {return m_ref.CurrentNumber(); };
 
    inline const char *CurrentString() {return m_ref.CurrentString(); };
 
    inline int CopyCurrentString(char *buf, int buflen) {return m_ref.CopyCurrentString(buf, buflen); };
 
    inline int CopyCurrentString(NBString &nbs) {return m_ref.CopyCurrentString(nbs); };
 
    inline const char *CurrentName() {return m_ref.CurrentName(); };
    inline bool CurrentNameMatches(const char *name) {return m_ref.CurrentNameMatches(name); };
 
    bool FindFullNameBoolean(const char *name)
    {
        if (FindFullName(name) == TRUE_EL) return true;
        return false;
    };
 
    bool FindGlobalBoolean(const char *name)
    {
        if (FindGlobalElementAfterName(name) == TRUE_EL) return true;
        return false;
    };
 
    bool FindBoolean(const char *name)
    {
        if (FindElementAfterName(name) == TRUE_EL) return true;
        return false;
    };
 
    bool FindBooleanInCurentObject(const char *name)
    {
        if (FindElementAfterNameInCurrentObject(name) == TRUE_EL) return true;
        return false;
    };
 
    bool FindFullNamePermissiveBoolean(const char *name)
    {
        if (FindFullName(name) != NOTFOUND) return PermissiveCurrentBool();
        return false;
    };
 
    bool FindGlobalPermissiveBoolean(const char *name)
    {
        if (FindGlobalElementAfterName(name) != NOTFOUND) return PermissiveCurrentBool();
        return false;
    };
 
    bool FindPermissiveBoolean(const char *name)
    {
        if (FindElementAfterName(name) != NOTFOUND) return PermissiveCurrentBool();
        return false;
    };
 
    bool FindPermissiveBooleanInCurentObject(const char *name)
    {
        if (FindElementAfterNameInCurrentObject(name) != NOTFOUND) return PermissiveCurrentBool();
        return false;
    };
 
    // If item not found returns null
    const char *FindFullNameString(const char *name)
    {
        if (FindFullName(name) == STRING) return CurrentString();
        return 0;
    };
 
    int FindAndCopyFullNameString(const char *name, char *buf, int buflen)
    {
        json_primitive_type type = FindFullName(name);
        if (type == STRING) return CopyCurrentString(buf, buflen);
        if (type == STRING_CHUNK) return CopyCurrentString(buf, buflen);
        return 0;
    };
 
    int FindAndCopyFullNameString(const char *name, NBString &nbs)
    {
        json_primitive_type type = FindFullName(name);
        if (type == STRING) return CopyCurrentString(nbs);
        if (type == STRING_CHUNK) return CopyCurrentString(nbs);
        return 0;
    };
    const char *FindGlobalString(const char *name)
    {
        if (FindGlobalElementAfterName(name) == STRING) return CurrentString();
        return 0;
    };
 
 
    int FindAndCopyGlobalString(const char *name, char *buf, int buflen)
    {
        json_primitive_type type = FindGlobalElementAfterName(name);
        if (type == STRING) return CopyCurrentString(buf, buflen);
        if (type == STRING_CHUNK) return CopyCurrentString(buf, buflen);
        return 0;
    };
 
    int FindAndCopyGlobalString(const char *name, NBString &nbs)
    {
        json_primitive_type type = FindGlobalElementAfterName(name);
        if (type == STRING) return CopyCurrentString(nbs);
        if (type == STRING_CHUNK) return CopyCurrentString(nbs);
        return 0;
    };
 
    const char *FindString(const char *name)
    {
        if (FindElementAfterName(name) == STRING) return CurrentString();
        return 0;
    };
 
    int FindAndCopyString(const char *name, char *buf, int buflen)
    {
        json_primitive_type type = FindElementAfterName(name);
        if (type == STRING) return CopyCurrentString(buf, buflen);
        if (type == STRING_CHUNK) return CopyCurrentString(buf, buflen);
        return 0;
    };
 
    int FindAndCopyString(const char *name, NBString &nbs)
    {
        json_primitive_type type = FindElementAfterName(name);
        if (type == STRING) return CopyCurrentString(nbs);
        if (type == STRING_CHUNK) return CopyCurrentString(nbs);
        return 0;
    };
 
    const char *FindStringInCurentObject(const char *name)
    {
        if (FindElementAfterNameInCurrentObject(name) == STRING) return CurrentString();
        return 0;
    };
 
    // if item is not found returns nan
    double FindFullNameNumber(const char *name)
    {
        if (FindFullName(name) == NUMBER) return CurrentNumber();
        return nan("quiet");
    };
 
    double FindGlobalNumber(const char *name)
    {
        if (FindGlobalElementAfterName(name) == NUMBER) return CurrentNumber();
        return nan("quiet");
    };
 
    double FindNumber(const char *name)
    {
        if (FindElementAfterName(name) == NUMBER) return CurrentNumber();
        return nan("quiet");
    };
 
    double FindNumberInCurentObject(const char *name)
    {
        if (FindElementAfterNameInCurrentObject(name) == NUMBER) return CurrentNumber();
        return nan("quiet");
    };
 
    // If item is not found returns false
    bool FindGlobalObject(const char *name)
    {
        if (FindGlobalElementAfterName(name) == BEGIN_OBJECT) return true;
        return false;
    };
 
    bool FindObject(const char *name)
    {
        if (FindElementAfterName(name) == BEGIN_OBJECT) return true;
        return false;
    };
 
    bool FindObjectInCurentObject(const char *name)
    {
        if (FindElementAfterNameInCurrentObject(name) == BEGIN_OBJECT) return true;
        return false;
    };
    // Constructors
    // Build emty
    ParsedJsonDataSet();
    ParsedJsonDataSet(const char *pData, int len = 0, bool bBigStrings=false);   // 0 len mean use strlen
    // Destructor
    virtual ~ParsedJsonDataSet(); //Needs to be virtual for derived classes....
 
    void DumpState();
 
    inline int PrintObject(bool pretty = false){return m_ref.start().PrintChildren(pretty);}
 
    inline int PrintObjectToBuffer(char *buffer, int maxlen, bool pretty = false) {return m_ref.start().PrintChildrenToBuffer(buffer,maxlen,pretty);}
 
    inline int PrintObjectToFd(int fd, bool pretty = false){return m_ref.start().PrintChildrenToFd(fd,pretty);};
 
 
    inline int PrintObjectToString(NBString & s, bool pretty = false)
    {
        FDCounter fdc;
        int len=m_ref.start().PrintChildrenToFd(fdc.GetActiveFD(),pretty);
        s.clear();
        s.Reserve(len+2);
        return m_ref.start().PrintChildrenToString(s,pretty);
    }
 
 
 
    inline int PrintChildren(bool pretty = false) {return m_ref.PrintChildren(pretty); }
 
    int PrintChildrenToFd(int fd, bool pretty = false) {return m_ref.PrintChildrenToFd(fd,pretty); }
 
    int PrintChildrenToBuffer(char *buffer, int maxlen, bool pretty = false){return m_ref.PrintChildrenToBuffer(buffer,maxlen,pretty); }
 
    inline int GetPrintSize(bool pretty = false){return m_ref.start().GetChildPrintSize(pretty);};
    ParsedJsonDataSet *StartBuilding();
 
    ParsedJsonDataSet *AddObjectStart(const char *name);
 
    ParsedJsonDataSet *AddMyMac(const char *name);
 
    ParsedJsonDataSet *Add(const char *name, int i);
 
    ParsedJsonDataSet *Add(const char *name, short i);
 
    ParsedJsonDataSet *Add(const char *name, long i);
 
    ParsedJsonDataSet *Add(const char *name, unsigned int i);
 
    ParsedJsonDataSet *Add(const char *name, unsigned short i);
 
    ParsedJsonDataSet *Add(const char *name, unsigned long i);
 
    ParsedJsonDataSet *Add(const char *name, double d);
 
    ParsedJsonDataSet *Add(const char *name, const char *str);
 
    ParsedJsonDataSet *Add(const char *name, bool b);
 
    ParsedJsonDataSet *Add(const char *name, IPADDR4 i4);
 
    ParsedJsonDataSet *Add(const char *name, const IPADDR &i);
 
    ParsedJsonDataSet *Add(const char *name, const MACADR &ma);
 
    ParsedJsonDataSet *AddNull(const char *name);
 
    ParsedJsonDataSet *AddArrayStart(const char *name);
 
    ParsedJsonDataSet *EndArray();
 
    ParsedJsonDataSet *AddArrayElement(int i);
 
    ParsedJsonDataSet *AddArrayElement(short i);
 
    ParsedJsonDataSet *AddArrayElement(long i);
 
    ParsedJsonDataSet *AddArrayElement(unsigned int i);
 
    ParsedJsonDataSet *AddArrayElement(unsigned short i);
 
    ParsedJsonDataSet *AddArrayElement(unsigned long i);
 
    ParsedJsonDataSet *AddArrayElement(double d);
 
    ParsedJsonDataSet *AddArrayElement(const char *str);
 
    ParsedJsonDataSet *AddArrayElement(bool b);
 
    ParsedJsonDataSet *AddArrayElement(const IPADDR &i);
 
    ParsedJsonDataSet *AddArrayElementArray();
 
    ParsedJsonDataSet *AddArrayObjectStart();
 
    ParsedJsonDataSet *AddNullArrayElement();
 
    ParsedJsonDataSet *EndObject();
 
    ParsedJsonDataSet *DoneBuilding();
  bool CheckLint();
  NBString LastError();
};
 
#include <fd_adapter.h>
class JsonLexerFDAdapter :public ParsedJsonDataSet, public fd_adapter
{
    virtual int read(char *buf, int nbytes);
    virtual int write(const char *buf, int nbytes);
    virtual int close();
public:
    JsonLexerFDAdapter() {};
};
 
 
#endif