var_map.hh

// -*- c-basic-offset: 4; tab-width: 8; indent-tabs-mode: t -*-
// vim:set sts=4 ts=8:

// Copyright (c) 2001-2011 XORP, Inc and Others
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License, Version 2, June
// 1991 as published by the Free Software Foundation. Redistribution
// and/or modification of this program under the terms of any other
// version of the GNU General Public License is not permitted.
// 
// 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. For more details,
// see the GNU General Public License, Version 2, a copy of which can be
// found in the XORP LICENSE.gpl file.
// 
// XORP Inc, 2953 Bunker Hill Lane, Suite 204, Santa Clara, CA 95054, USA;
// http://xorp.net

// $XORP: xorp/policy/var_map.hh,v 1.12 2008/10/02 21:58:01 bms Exp $

#ifndef __POLICY_VAR_MAP_HH__
#define __POLICY_VAR_MAP_HH__






#include "policy/common/policy_exception.hh"
#include "policy/common/varrw.hh"

#include "process_watch.hh"

class VarMap :
    public NONCOPYABLE
{
public:
    class VarMapErr : public PolicyException {
    public:
        VarMapErr(const char* file, size_t line, const string& init_why = "")   
            : PolicyException("VarMapErr", file, line, init_why) {} 
    };

    enum Access {
    READ,
    READ_WRITE,
    WRITE
    };

    struct Variable {
    Access access;
    string name;
    string type;
    VarRW::Id id;

    Variable(const string& n, const string& t, Access a,
         VarRW::Id i) :
            access(a), name(n), type(t), id(i)
    {
    }

    Variable(const Variable& v)
    {
        access = v.access;
        name = v.name;
        type = v.type;
        id = v.id;
    }

    bool writable() const 
    { 
        return access == READ_WRITE || access == WRITE; 
    }
    
    bool operator==(const Variable& other) const {
        return ((access == other.access)
            && (name == other.name)
            && (type == other.type)
            && (id == other.id));
    }
    };

    typedef map<VarRW::Id,Variable*> VariableMap;
    typedef map<string,VariableMap*> ProtoMap;

    const Variable& variable(const string& protocol, 
                 const VarRW::Id& varname) const;

    VarRW::Id var2id(const string& protocol, const string& varname) const;

    VarMap(ProcessWatchBase& pw);
    ~VarMap();

    bool protocol_known(const string& protocol);

    void add_protocol_variable(const string& protocol, Variable* var);

    
    string str(); 

private:
    void add_metavariable(Variable *var);

    void add_variable(VariableMap& vm, Variable* var);

    const VariableMap& variablemap(const string& protocol) const;

    ProtoMap _protocols;
    ProcessWatchBase& _process_watch;

    typedef VariableMap MetaVarContainer;
    MetaVarContainer _metavars;
};

#endif // __POLICY_VAR_MAP_HH__