atm_mib.cpp

JdonFramework need above jdk 1.4.0This version has passed under Tomcat 4.x/5.x JBoss 3.x/JBoss 4.0.0

/*_############################################################################
  _## 
  _##  atm_mib.cpp  
  _## 
  _##
  _##  AgentX++ v1.4.15
  _##  ---------------------------------------------------------
  _##  Copyright (C) 2000-2006, Frank Fock, All rights reserved.
  _##  
  _##  Use of this software is subject to the license agreement you received
  _##  with this software and which can be downloaded from 
  _##  http://www.agentpp.com
  _##
  _##  This is licensed software and may not be used in a commercial
  _##  environment, except for evaluation purposes, unless a valid
  _##  license has been purchased.
  _##
  _##  Last updated: Fri Jun 16 20:00:36 CEST 2006 
  _##  
  _##########################################################################*/


#include <atm_mib.h>



/**
 *  generated by AgentGen 1.2.2 for AGENT++v3.3 with simulation extensions 
 * Fri Dec 03 16:14:40 GMT+03:30 1999.
 */

#ifdef AGENTPP_NAMESPACE
namespace Agentpp {
#endif


/**
 *  atmInterfaceMaxVpcs
 *
 */

atmInterfaceMaxVpcs::atmInterfaceMaxVpcs(const Oidx& id):
   SimMibLeaf(id, READWRITE, new SnmpInt32())
{

}

atmInterfaceMaxVpcs::~atmInterfaceMaxVpcs()
{
}

MibEntryPtr atmInterfaceMaxVpcs::clone()
{
	MibEntryPtr other = new atmInterfaceMaxVpcs(oid);
	((atmInterfaceMaxVpcs*)other)->replace_value(value->clone());
	((atmInterfaceMaxVpcs*)other)->set_reference_to_table(my_table);
	return other;
}

boolean atmInterfaceMaxVpcs::value_ok(const Vbx& vb)
{
	long v;
	vb.get_value(v);
	if (!(((v >= 0) && (v <= 4096))))
		 return FALSE;
	// place additional code to check validity of new values here
	return TRUE;
}

int atmInterfaceMaxVpcs::prepare_set_request(Request* req, int& ind)
{
	int status;
	if ((status = SimMibLeaf::prepare_set_request(req, ind)) !=
	    SNMP_ERROR_SUCCESS) return status;
	// place additional code to check validity of new values here
	return SNMP_ERROR_SUCCESS;
}



/**
 *  atmInterfaceMaxVccs
 *
 */

atmInterfaceMaxVccs::atmInterfaceMaxVccs(const Oidx& id):
   SimMibLeaf(id, READWRITE, new SnmpInt32())
{

}

atmInterfaceMaxVccs::~atmInterfaceMaxVccs()
{
}

MibEntryPtr atmInterfaceMaxVccs::clone()
{
	MibEntryPtr other = new atmInterfaceMaxVccs(oid);
	((atmInterfaceMaxVccs*)other)->replace_value(value->clone());
	((atmInterfaceMaxVccs*)other)->set_reference_to_table(my_table);
	return other;
}

boolean atmInterfaceMaxVccs::value_ok(const Vbx& vb)
{
	long v;
	vb.get_value(v);
	if (!(((v >= 0) && (v <= 65536))))
		 return FALSE;
	// place additional code to check validity of new values here
	return TRUE;
}

int atmInterfaceMaxVccs::prepare_set_request(Request* req, int& ind)
{
	int status;
	if ((status = SimMibLeaf::prepare_set_request(req, ind)) !=
	    SNMP_ERROR_SUCCESS) return status;
	// place additional code to check validity of new values here
	return SNMP_ERROR_SUCCESS;
}



/**
 *  atmInterfaceConfVpcs
 *
 */

atmInterfaceConfVpcs::atmInterfaceConfVpcs(const Oidx& id):
   SimMibLeaf(id, READONLY, new SnmpInt32())
{

}

atmInterfaceConfVpcs::~atmInterfaceConfVpcs()
{
}

MibEntryPtr atmInterfaceConfVpcs::clone()
{
	MibEntryPtr other = new atmInterfaceConfVpcs(oid);
	((atmInterfaceConfVpcs*)other)->replace_value(value->clone());
	((atmInterfaceConfVpcs*)other)->set_reference_to_table(my_table);
	return other;
}



/**
 *  atmInterfaceConfVccs
 *
 */

atmInterfaceConfVccs::atmInterfaceConfVccs(const Oidx& id):
   SimMibLeaf(id, READONLY, new SnmpInt32())
{

}

atmInterfaceConfVccs::~atmInterfaceConfVccs()
{
}

MibEntryPtr atmInterfaceConfVccs::clone()
{
	MibEntryPtr other = new atmInterfaceConfVccs(oid);
	((atmInterfaceConfVccs*)other)->replace_value(value->clone());
	((atmInterfaceConfVccs*)other)->set_reference_to_table(my_table);
	return other;
}



/**
 *  atmInterfaceMaxActiveVpiBits
 *
 */

atmInterfaceMaxActiveVpiBits::atmInterfaceMaxActiveVpiBits(const Oidx& id):
   SimMibLeaf(id, READWRITE, new SnmpInt32())
{

}

atmInterfaceMaxActiveVpiBits::~atmInterfaceMaxActiveVpiBits()
{
}

MibEntryPtr atmInterfaceMaxActiveVpiBits::clone()
{
	MibEntryPtr other = new atmInterfaceMaxActiveVpiBits(oid);
	((atmInterfaceMaxActiveVpiBits*)other)->replace_value(value->clone());
	((atmInterfaceMaxActiveVpiBits*)other)->set_reference_to_table(my_table);
	return other;
}

boolean atmInterfaceMaxActiveVpiBits::value_ok(const Vbx& vb)
{
	long v;
	vb.get_value(v);
	if (!(((v >= 0) && (v <= 12))))
		 return FALSE;
	// place additional code to check validity of new values here
	return TRUE;
}

int atmInterfaceMaxActiveVpiBits::prepare_set_request(Request* req, int& ind)
{
	int status;
	if ((status = SimMibLeaf::prepare_set_request(req, ind)) !=
	    SNMP_ERROR_SUCCESS) return status;
	// place additional code to check validity of new values here
	return SNMP_ERROR_SUCCESS;
}



/**
 *  atmInterfaceMaxActiveVciBits
 *
 */

atmInterfaceMaxActiveVciBits::atmInterfaceMaxActiveVciBits(const Oidx& id):
   SimMibLeaf(id, READWRITE, new SnmpInt32())
{

}

atmInterfaceMaxActiveVciBits::~atmInterfaceMaxActiveVciBits()
{
}

MibEntryPtr atmInterfaceMaxActiveVciBits::clone()
{
	MibEntryPtr other = new atmInterfaceMaxActiveVciBits(oid);
	((atmInterfaceMaxActiveVciBits*)other)->replace_value(value->clone());
	((atmInterfaceMaxActiveVciBits*)other)->set_reference_to_table(my_table);
	return other;
}

boolean atmInterfaceMaxActiveVciBits::value_ok(const Vbx& vb)
{
	long v;
	vb.get_value(v);
	if (!(((v >= 0) && (v <= 16))))
		 return FALSE;
	// place additional code to check validity of new values here
	return TRUE;
}

int atmInterfaceMaxActiveVciBits::prepare_set_request(Request* req, int& ind)
{
	int status;
	if ((status = SimMibLeaf::prepare_set_request(req, ind)) !=
	    SNMP_ERROR_SUCCESS) return status;
	// place additional code to check validity of new values here
	return SNMP_ERROR_SUCCESS;
}



/**
 *  atmInterfaceIlmiVpi
 *
 */

atmInterfaceIlmiVpi::atmInterfaceIlmiVpi(const Oidx& id):
   SimMibLeaf(id, READWRITE, new SnmpInt32(0), VMODE_DEFAULT)
{

}

atmInterfaceIlmiVpi::~atmInterfaceIlmiVpi()
{
}

MibEntryPtr atmInterfaceIlmiVpi::clone()
{
	MibEntryPtr other = new atmInterfaceIlmiVpi(oid);
	((atmInterfaceIlmiVpi*)other)->replace_value(value->clone());
	((atmInterfaceIlmiVpi*)other)->set_reference_to_table(my_table);
	return other;
}

boolean atmInterfaceIlmiVpi::value_ok(const Vbx& vb)
{
	long v;
	vb.get_value(v);
	if (!(((v >= 0) && (v <= 4095))))
		 return FALSE;
	// place additional code to check validity of new values here
	return TRUE;
}

int atmInterfaceIlmiVpi::prepare_set_request(Request* req, int& ind)
{
	int status;
	if ((status = SimMibLeaf::prepare_set_request(req, ind)) !=
	    SNMP_ERROR_SUCCESS) return status;
	// place additional code to check validity of new values here
	return SNMP_ERROR_SUCCESS;
}



/**
 *  atmInterfaceIlmiVci
 *
 */

atmInterfaceIlmiVci::atmInterfaceIlmiVci(const Oidx& id):
   SimMibLeaf(id, READWRITE, new SnmpInt32(16), VMODE_DEFAULT)
{

}

atmInterfaceIlmiVci::~atmInterfaceIlmiVci()
{
}

MibEntryPtr atmInterfaceIlmiVci::clone()
{
	MibEntryPtr other = new atmInterfaceIlmiVci(oid);
	((atmInterfaceIlmiVci*)other)->replace_value(value->clone());
	((atmInterfaceIlmiVci*)other)->set_reference_to_table(my_table);
	return other;
}

boolean atmInterfaceIlmiVci::value_ok(const Vbx& vb)
{
	long v;
	vb.get_value(v);
	if (!(((v >= 0) && (v <= 65535))))
		 return FALSE;
	// place additional code to check validity of new values here
	return TRUE;
}

int atmInterfaceIlmiVci::prepare_set_request(Request* req, int& ind)
{
	int status;
	if ((status = SimMibLeaf::prepare_set_request(req, ind)) !=
	    SNMP_ERROR_SUCCESS) return status;
	// place additional code to check validity of new values here
	return SNMP_ERROR_SUCCESS;
}



/**
 *  atmInterfaceAddressType
 *
 */

atmInterfaceAddressType::atmInterfaceAddressType(const Oidx& id):
   SimMibLeaf(id, READONLY, new SnmpInt32())
{

}

atmInterfaceAddressType::~atmInterfaceAddressType()
{
}

MibEntryPtr atmInterfaceAddressType::clone()
{
	MibEntryPtr other = new atmInterfaceAddressType(oid);
	((atmInterfaceAddressType*)other)->replace_value(value->clone());
	((atmInterfaceAddressType*)other)->set_reference_to_table(my_table);
	return other;
}



/**
 *  atmInterfaceAdminAddress
 *
 */

atmInterfaceAdminAddress::atmInterfaceAdminAddress(const Oidx& id):
   SimMibLeaf(id, READONLY, new OctetStr())
{

}

atmInterfaceAdminAddress::~atmInterfaceAdminAddress()
{
}

MibEntryPtr atmInterfaceAdminAddress::clone()
{
	MibEntryPtr other = new atmInterfaceAdminAddress(oid);
	((atmInterfaceAdminAddress*)other)->replace_value(value->clone());
	((atmInterfaceAdminAddress*)other)->set_reference_to_table(my_table);
	return other;
}



/**
 *  atmInterfaceMyNeighborIpAddress
 *
 */

atmInterfaceMyNeighborIpAddress::atmInterfaceMyNeighborIpAddress(const Oidx& id):
   SimMibLeaf(id, READWRITE, new IpAddress("0.0.0.0"))
{

}

atmInterfaceMyNeighborIpAddress::~atmInterfaceMyNeighborIpAddress()
{
}

MibEntryPtr atmInterfaceMyNeighborIpAddress::clone()
{
	MibEntryPtr other = new atmInterfaceMyNeighborIpAddress(oid);
	((atmInterfaceMyNeighborIpAddress*)other)->replace_value(value->clone());
	((atmInterfaceMyNeighborIpAddress*)other)->set_reference_to_table(my_table);
	return other;
}

boolean atmInterfaceMyNeighborIpAddress::value_ok(const Vbx& vb)
{
	// place code to check validity of new values here
	return TRUE;
}

int atmInterfaceMyNeighborIpAddress::prepare_set_request(Request* req, int& ind)
{
	int status;
	if ((status = SimMibLeaf::prepare_set_request(req, ind)) !=
	    SNMP_ERROR_SUCCESS) return status;
	// place additional code to check validity of new values here
	return SNMP_ERROR_SUCCESS;
}



/**
 *  atmInterfaceMyNeighborIfName
 *
 */

atmInterfaceMyNeighborIfName::atmInterfaceMyNeighborIfName(const Oidx& id):
   SnmpDisplayString(id, READWRITE, new OctetStr())
{

}

atmInterfaceMyNeighborIfName::~atmInterfaceMyNeighborIfName()
{
}

MibEntryPtr atmInterfaceMyNeighborIfName::clone()
{
	MibEntryPtr other = new atmInterfaceMyNeighborIfName(oid);
	((atmInterfaceMyNeighborIfName*)other)->replace_value(value->clone());
	((atmInterfaceMyNeighborIfName*)other)->set_reference_to_table(my_table);
	return other;
}

boolean atmInterfaceMyNeighborIfName::value_ok(const Vbx& vb)
{
	// place code to check validity of new values here
	return TRUE;
}

int atmInterfaceMyNeighborIfName::prepare_set_request(Request* req, int& ind)
{
	int status;
	if ((status = SnmpDisplayString::prepare_set_request(req, ind)) !=
	    SNMP_ERROR_SUCCESS) return status;
	Vb vb(req->get_value(ind));
	OctetStr v;
	vb.get_value(v);
	if (!(((v.len() >= 0) && (v.len() <= 255))))
		 return SNMP_ERROR_WRONG_LENGTH;
	return SNMP_ERROR_SUCCESS;
}



/**
 *  atmInterfaceCurrentMaxVpiBits
 *
 */

atmInterfaceCurrentMaxVpiBits::atmInterfaceCurrentMaxVpiBits(const Oidx& id):
   SimMibLeaf(id, READONLY, new SnmpInt32())
{

}

atmInterfaceCurrentMaxVpiBits::~atmInterfaceCurrentMaxVpiBits()
{
}

MibEntryPtr atmInterfaceCurrentMaxVpiBits::clone()
{
	MibEntryPtr other = new atmInterfaceCurrentMaxVpiBits(oid);
	((atmInterfaceCurrentMaxVpiBits*)other)->replace_value(value->clone());
	((atmInterfaceCurrentMaxVpiBits*)other)->set_reference_to_table(my_table);
	return other;
}



/**
 *  atmInterfaceCurrentMaxVciBits
 *
 */

atmInterfaceCurrentMaxVciBits::atmInterfaceCurrentMaxVciBits(const Oidx& id):
   SimMibLeaf(id, READONLY, new SnmpInt32())
{

}

atmInterfaceCurrentMaxVciBits::~atmInterfaceCurrentMaxVciBits()
{
}

MibEntryPtr atmInterfaceCurrentMaxVciBits::clone()
{
	MibEntryPtr other = new atmInterfaceCurrentMaxVciBits(oid);
	((atmInterfaceCurrentMaxVciBits*)other)->replace_value(value->clone());
	((atmInterfaceCurrentMaxVciBits*)other)->set_reference_to_table(my_table);
	return other;
}



/**
 *  atmInterfaceSubscrAddress
 *
 */

atmInterfaceSubscrAddress::atmInterfaceSubscrAddress(const Oidx& id):
   SimMibLeaf(id, READWRITE, new OctetStr())
{

}

atmInterfaceSubscrAddress::~atmInterfaceSubscrAddress()
{
}

MibEntryPtr atmInterfaceSubscrAddress::clone()
{
	MibEntryPtr other = new atmInterfaceSubscrAddress(oid);
	((atmInterfaceSubscrAddress*)other)->replace_value(value->clone());
	((atmInterfaceSubscrAddress*)other)->set_reference_to_table(my_table);
	return other;
}

boolean atmInterfaceSubscrAddress::value_ok(const Vbx& vb)
{
	// place code to check validity of new values here
	return TRUE;
}

int atmInterfaceSubscrAddress::prepare_set_request(Request* req, int& ind)
{
	int status;
	if ((status = SimMibLeaf::prepare_set_request(req, ind)) !=
	    SNMP_ERROR_SUCCESS) return status;
	Vb vb(req->get_value(ind));
	OctetStr v;
	vb.get_value(v);
	if (!(((v.len() >= 0) && (v.len() <= 40))))