Back to index...

	/*
	* Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code 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 General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package com.sun.jmx.snmp.agent;

	import java.io.Serializable;
	import java.util.Date;
	import java.util.Enumeration;
	import java.util.Hashtable;
	import java.util.Vector;
	import java.util.logging.Level;

	import javax.management.ListenerNotFoundException;
	import javax.management.MBeanNotificationInfo;
	import javax.management.Notification;
	import javax.management.NotificationBroadcaster;
	import javax.management.NotificationFilter;
	import javax.management.NotificationListener;
	import javax.management.ObjectName;

	import static com.sun.jmx.defaults.JmxProperties.SNMP_ADAPTOR_LOGGER;
	import com.sun.jmx.snmp.EnumRowStatus;
	import com.sun.jmx.snmp.SnmpInt;
	import com.sun.jmx.snmp.SnmpOid;
	import com.sun.jmx.snmp.SnmpStatusException;
	import com.sun.jmx.snmp.SnmpValue;
	import com.sun.jmx.snmp.SnmpVarBind;

	/**
	* This class is the base class for SNMP table metadata.
	* <p>
	* Its responsibility is to manage a sorted array of OID indexes
	* according to the SNMP indexing scheme over the "real" table.
	* Each object of this class can be bound to an
	* {@link com.sun.jmx.snmp.agent.SnmpTableEntryFactory} to which it will
	* forward remote entry creation requests, and invoke callbacks
	* when an entry has been successfully added to / removed from
	* the OID index array.
	* </p>
	*
	* <p>
	* For each table defined in the MIB, mibgen will generate a specific
	* class called Table<i>TableName</i> that will implement the
	* SnmpTableEntryFactory interface, and a corresponding
	* <i>TableName</i>Meta class that will extend this class. <br>
	* The Table<i>TableName</i> class corresponds to the MBean view of the
	* table while the <i>TableName</i>Meta class corresponds to the
	* MIB metadata view of the same table.
	* </p>
	*
	* <p>
	* Objects of this class are instantiated by the generated
	* whole MIB class extending {@link com.sun.jmx.snmp.agent.SnmpMib}
	* You should never need to instantiate this class directly.
	* </p>
	*
	* <p><b>This API is a Sun Microsystems internal API and is subject
	* to change without notice.</b></p>
	* @see com.sun.jmx.snmp.agent.SnmpMib
	* @see com.sun.jmx.snmp.agent.SnmpMibEntry
	* @see com.sun.jmx.snmp.agent.SnmpTableEntryFactory
	* @see com.sun.jmx.snmp.agent.SnmpTableSupport
	*
	*/

	public abstract class SnmpMibTable extends SnmpMibNode
	implements NotificationBroadcaster, Serializable {

	/**
	* Create a new <CODE>SnmpMibTable</CODE> metadata node.
	*
	* <p>
	* @param mib The SNMP MIB to which the metadata will be linked.
	*/
	public SnmpMibTable(SnmpMib mib) {
	this.theMib= mib;
	setCreationEnabled(false);
	}

	// -------------------------------------------------------------------
	// PUBLIC METHODS
	// -------------------------------------------------------------------

	/**
	* This method is invoked when the creation of a new entry is requested
	* by a remote SNMP manager.
	* <br>By default, remote entry creation is disabled - and this method
	* will not be called. You can dynamically switch the entry creation
	* policy by calling <code>setCreationEnabled(true)</code> and <code>
	* setCreationEnabled(false)</code> on this object.
	* <p><b><i>
	* This method is called internally by the SNMP runtime and you
	* should never need to call it directly. </b></i>However you might want
	* to extend it in order to implement your own specific application
	* behaviour, should the default behaviour not be at your convenience.
	* </p>
	* <p>
	* @param req The SNMP subrequest requesting this creation
	* @param rowOid The OID indexing the conceptual row (entry) for which
	* the creation was requested.
	* @param depth The position of the columnar object arc in the OIDs
	* from the varbind list.
	*
	* @exception SnmpStatusException if the entry cannot be created.
	*/
	public abstract void createNewEntry(SnmpMibSubRequest req, SnmpOid rowOid,
	int depth)
	throws SnmpStatusException;

	/**
	* Tell whether the specific version of this metadata generated
	* by <code>mibgen</code> requires entries to be registered with
	* the MBeanServer. In this case an ObjectName will have to be
	* passed to addEntry() in order for the table to behave correctly
	* (case of the generic metadata).
	* <p>
	* If that version of the metadata does not require entry to be
	* registered, then passing an ObjectName becomes optional (null
	* can be passed instead).
	*
	* @return <code>true</code> if registration is required by this
	* version of the metadata.
	*/
	public abstract boolean isRegistrationRequired();

	/**
	* Tell whether a new entry should be created when a SET operation
	* is received for an entry that does not exist yet.
	*
	* @return true if a new entry must be created, false otherwise.<br>
	* [default: returns <CODE>false</CODE>]
	**/
	public boolean isCreationEnabled() {
	return creationEnabled;
	}

	/**
	* This method lets you dynamically switch the creation policy.
	*
	* <p>
	* @param remoteCreationFlag Tells whether remote entry creation must
	* be enabled or disabled.
	* <ul><li>
	* <CODE>setCreationEnabled(true)</CODE> will enable remote entry
	* creation via SET operations.</li>
	* <li>
	* <CODE>setCreationEnabled(false)</CODE> will disable remote entry
	* creation via SET operations.</li>
	* <p> By default remote entry creation via SET operation is disabled.
	* </p>
	* </ul>
	**/
	public void setCreationEnabled(boolean remoteCreationFlag) {
	creationEnabled = remoteCreationFlag;
	}

	/**
	* Return <code>true</code> if the conceptual row contains a columnar
	* object used to control creation/deletion of rows in this table.
	* <p>
	* This columnar object can be either a variable with RowStatus
	* syntax as defined by RFC 2579, or a plain variable whose
	* semantics is table specific.
	* <p>
	* By default, this function returns <code>false</code>, and it is
	* assumed that the table has no such control variable.<br>
	* When <code>mibgen</code> is used over SMIv2 MIBs, it will generate
	* an <code>hasRowStatus()</code> method returning <code>true</code>
	* for each table containing an object with RowStatus syntax.
	* <p>
	* When this method returns <code>false</code> the default mechanism
	* for remote entry creation is used.
	* Otherwise, creation/deletion is performed as specified
	* by the control variable (see getRowAction() for more details).
	* <p>
	* This method is called internally when a SET request involving
	* this table is processed.
	* <p>
	* If you need to implement a control variable which do not use
	* the RowStatus convention as defined by RFC 2579, you should
	* subclass the generated table metadata class in order to redefine
	* this method and make it returns <code>true</code>.<br>
	* You will then have to redefine the isRowStatus(), mapRowStatus(),
	* isRowReady(), and setRowStatus() methods to suit your specific
	* implementation.
	* <p>
	* @return <li><code>true</code> if this table contains a control
	* variable (eg: a variable with RFC 2579 RowStatus syntax),
	* </li>
	* <li><code>false</code> if this table does not contain
	* any control variable.</li>
	*
	**/
	public boolean hasRowStatus() {
	return false;
	}

	// ---------------------------------------------------------------------
	//
	// Implements the method defined in SnmpMibNode.
	//
	// ---------------------------------------------------------------------
	/**
	* Generic handling of the <CODE>get</CODE> operation.
	* <p> The default implementation of this method is to
	* <ul>
	* <li> check whether the entry exists, and if not register an
	* exception for each varbind in the list.
	* <li> call the generated
	* <CODE>get(req,oid,depth+1)</CODE> method. </li>
	* </ul>
	* <p>
	* <pre>
	* public void get(SnmpMibSubRequest req, int depth)
	* throws SnmpStatusException {
	* boolean isnew = req.isNewEntry();
	*
	* // if the entry does not exists, then registers an error for
	* // each varbind involved (nb: this should not happen, since
	* // the error should already have been detected earlier)
	* //
	* if (isnew) {
	* SnmpVarBind var = null;
	* for (Enumeration e= req.getElements(); e.hasMoreElements();) {
	* var = (SnmpVarBind) e.nextElement();
	* req.registerGetException(var,noSuchNameException);
	* }
	* }
	*
	* final SnmpOid oid = req.getEntryOid();
	* get(req,oid,depth+1);
	* }
	* </pre>
	* <p> You should not need to override this method in any cases, because
	* it will eventually call
	* <CODE>get(SnmpMibSubRequest req, int depth)</CODE> on the generated
	* derivative of <CODE>SnmpMibEntry</CODE>. If you need to implement
	* specific policies for minimizing the accesses made to some remote
	* underlying resources, or if you need to implement some consistency
	* checks between the different values provided in the varbind list,
	* you should then rather override
	* <CODE>get(SnmpMibSubRequest req, int depth)</CODE> on the generated
	* derivative of <CODE>SnmpMibEntry</CODE>.
	* <p>
	*
	*/
	@Override
	public void get(SnmpMibSubRequest req, int depth)
	throws SnmpStatusException {

	final boolean isnew = req.isNewEntry();
	final SnmpMibSubRequest r = req;

	// if the entry does not exists, then registers an error for
	// each varbind involved (nb: should not happen, the error
	// should have been registered earlier)
	if (isnew) {
	SnmpVarBind var;
	for (Enumeration<SnmpVarBind> e= r.getElements(); e.hasMoreElements();) {
	var = e.nextElement();
	r.registerGetException(var,new SnmpStatusException(SnmpStatusException.noSuchInstance));
	}
	}

	final SnmpOid oid = r.getEntryOid();

	// SnmpIndex index = buildSnmpIndex(oid.longValue(false), 0);
	// get(req,index,depth+1);
	//
	get(req,oid,depth+1);
	}

	// ---------------------------------------------------------------------
	//
	// Implements the method defined in SnmpMibNode.
	//
	// ---------------------------------------------------------------------
	/**
	* Generic handling of the <CODE>check</CODE> operation.
	* <p> The default implementation of this method is to
	* <ul>
	* <li> check whether a new entry must be created, and if remote
	* creation of entries is enabled, create it. </li>
	* <li> call the generated
	* <CODE>check(req,oid,depth+1)</CODE> method. </li>
	* </ul>
	* <p>
	* <pre>
	* public void check(SnmpMibSubRequest req, int depth)
	* throws SnmpStatusException {
	* final SnmpOid oid = req.getEntryOid();
	* final int action = getRowAction(req,oid,depth+1);
	*
	* beginRowAction(req,oid,depth+1,action);
	* check(req,oid,depth+1);
	* }
	* </pre>
	* <p> You should not need to override this method in any cases, because
	* it will eventually call
	* <CODE>check(SnmpMibSubRequest req, int depth)</CODE> on the generated
	* derivative of <CODE>SnmpMibEntry</CODE>. If you need to implement
	* specific policies for minimizing the accesses made to some remote
	* underlying resources, or if you need to implement some consistency
	* checks between the different values provided in the varbind list,
	* you should then rather override
	* <CODE>check(SnmpMibSubRequest req, int depth)</CODE> on the generated
	* derivative of <CODE>SnmpMibEntry</CODE>.
	* <p>
	*
	*/
	@Override
	public void check(SnmpMibSubRequest req, int depth)
	throws SnmpStatusException {
	final SnmpOid oid = req.getEntryOid();
	final int action = getRowAction(req,oid,depth+1);

	if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
	SNMP_ADAPTOR_LOGGER.logp(Level.FINEST, SnmpMibTable.class.getName(),
	"check", "Calling beginRowAction");
	}

	beginRowAction(req,oid,depth+1,action);

	if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
	SNMP_ADAPTOR_LOGGER.logp(Level.FINEST, SnmpMibTable.class.getName(),
	"check",
	"Calling check for " + req.getSize() + " varbinds");
	}

	check(req,oid,depth+1);

	if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
	SNMP_ADAPTOR_LOGGER.logp(Level.FINEST, SnmpMibTable.class.getName(),
	"check", "check finished");
	}
	}

	// ---------------------------------------------------------------------
	//
	// Implements the method defined in SnmpMibNode.
	//
	// ---------------------------------------------------------------------
	/**
	* Generic handling of the <CODE>set</CODE> operation.
	* <p> The default implementation of this method is to
	* call the generated
	* <CODE>set(req,oid,depth+1)</CODE> method.
	* <p>
	* <pre>
	* public void set(SnmpMibSubRequest req, int depth)
	* throws SnmpStatusException {
	* final SnmpOid oid = req.getEntryOid();
	* final int action = getRowAction(req,oid,depth+1);
	*
	* set(req,oid,depth+1);
	* endRowAction(req,oid,depth+1,action);
	* }
	* </pre>
	* <p> You should not need to override this method in any cases, because
	* it will eventually call
	* <CODE>set(SnmpMibSubRequest req, int depth)</CODE> on the generated
	* derivative of <CODE>SnmpMibEntry</CODE>. If you need to implement
	* specific policies for minimizing the accesses made to some remote
	* underlying resources, or if you need to implement some consistency
	* checks between the different values provided in the varbind list,
	* you should then rather override
	* <CODE>set(SnmpMibSubRequest req, int depth)</CODE> on the generated
	* derivative of <CODE>SnmpMibEntry</CODE>.
	* <p>
	*
	*/
	@Override
	public void set(SnmpMibSubRequest req, int depth)
	throws SnmpStatusException {


	if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
	SNMP_ADAPTOR_LOGGER.logp(Level.FINEST, SnmpMibTable.class.getName(),
	"set", "Entering set");
	}

	final SnmpOid oid = req.getEntryOid();
	final int action = getRowAction(req,oid,depth+1);

	if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
	SNMP_ADAPTOR_LOGGER.logp(Level.FINEST, SnmpMibTable.class.getName(),
	"set", "Calling set for " + req.getSize() + " varbinds");
	}

	set(req,oid,depth+1);

	if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
	SNMP_ADAPTOR_LOGGER.logp(Level.FINEST, SnmpMibTable.class.getName(),
	"set", "Calling endRowAction");
	}

	endRowAction(req,oid,depth+1,action);

	if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
	SNMP_ADAPTOR_LOGGER.logp(Level.FINEST, SnmpMibTable.class.getName(),
	"set", "RowAction finished");
	}

	}

	/**
	* Add a new entry in this <CODE>SnmpMibTable</CODE>.
	* Also triggers the addEntryCB() callback of the
	* {@link com.sun.jmx.snmp.agent.SnmpTableEntryFactory} interface
	* if this node is bound to a factory.
	*
	* This method assumes that the given entry will not be registered.
	* If the entry is going to be registered, or if ObjectName's are
	* required, then
	* {@link com.sun.jmx.snmp.agent.SnmpMibTable#addEntry(SnmpOid,
	* ObjectName, Object)} should be preferred.
	* <br> This function is mainly provided for backward compatibility.
	*
	* <p>
	* @param rowOid The <CODE>SnmpOid</CODE> identifying the table
	* row to be added.
	* @param entry The entry to add.
	*
	* @exception SnmpStatusException The entry couldn't be added
	* at the position identified by the given
	* <code>rowOid</code>, or this version of the metadata
	* requires ObjectName's.
	*/
	// public void addEntry(SnmpIndex index, Object entry)
	public void addEntry(SnmpOid rowOid, Object entry)
	throws SnmpStatusException {

	addEntry(rowOid, null, entry);
	}

	/**
	* Add a new entry in this <CODE>SnmpMibTable</CODE>.
	* Also triggers the addEntryCB() callback of the
	* {@link com.sun.jmx.snmp.agent.SnmpTableEntryFactory} interface
	* if this node is bound to a factory.
	*
	* <p>
	* @param oid The <CODE>SnmpOid</CODE> identifying the table
	* row to be added.
	*
	* @param name The ObjectName with which this entry is registered.
	* This parameter can be omitted if isRegistrationRequired()
	* return false.
	*
	* @param entry The entry to add.
	*
	* @exception SnmpStatusException The entry couldn't be added
	* at the position identified by the given
	* <code>rowOid</code>, or if this version of the metadata
	* requires ObjectName's, and the given name is null.
	*/
	// protected synchronized void addEntry(SnmpIndex index, ObjectName name,
	// Object entry)
	public synchronized void addEntry(SnmpOid oid, ObjectName name,
	Object entry)
	throws SnmpStatusException {

	if (isRegistrationRequired() == true && name == null)
	throw new SnmpStatusException(SnmpStatusException.badValue);

	if (size == 0) {
	// indexes.addElement(index);
	// XX oids.addElement(oid);
	insertOid(0,oid);
	if (entries != null)
	entries.addElement(entry);
	if (entrynames != null)
	entrynames.addElement(name);
	size++;

	// triggers callbacks on the entry factory
	//
	if (factory != null) {
	try {
	factory.addEntryCb(0,oid,name,entry,this);
	} catch (SnmpStatusException x) {
	removeOid(0);
	if (entries != null)
	entries.removeElementAt(0);
	if (entrynames != null)
	entrynames.removeElementAt(0);
	throw x;
	}
	}

	// sends the notifications
	//
	sendNotification(SnmpTableEntryNotification.SNMP_ENTRY_ADDED,
	(new Date()).getTime(), entry, name);
	return;
	}

	// Get the insertion position ...
	//
	int pos= 0;
	// bug jaw.00356.B : use oid rather than index to get the
	// insertion point.
	//
	pos= getInsertionPoint(oid,true);
	if (pos == size) {
	// Add a new element in the vectors ...
	//
	// indexes.addElement(index);
	// XX oids.addElement(oid);
	insertOid(tablecount,oid);
	if (entries != null)
	entries.addElement(entry);
	if (entrynames != null)
	entrynames.addElement(name);
	size++;
	} else {
	// Insert new element ...
	//
	try {
	// indexes.insertElementAt(index, pos);
	// XX oids.insertElementAt(oid, pos);
	insertOid(pos,oid);
	if (entries != null)
	entries.insertElementAt(entry, pos);
	if (entrynames != null)
	entrynames.insertElementAt(name,pos);
	size++;
	} catch(ArrayIndexOutOfBoundsException e) {
	}
	}

	// triggers callbacks on the entry factory
	//
	if (factory != null) {
	try {
	factory.addEntryCb(pos,oid,name,entry,this);
	} catch (SnmpStatusException x) {
	removeOid(pos);
	if (entries != null)
	entries.removeElementAt(pos);
	if (entrynames != null)
	entrynames.removeElementAt(pos);
	throw x;
	}
	}

	// sends the notifications
	//
	sendNotification(SnmpTableEntryNotification.SNMP_ENTRY_ADDED,
	(new Date()).getTime(), entry, name);
	}

	/**
	* Remove the specified entry from the table.
	* Also triggers the removeEntryCB() callback of the
	* {@link com.sun.jmx.snmp.agent.SnmpTableEntryFactory} interface
	* if this node is bound to a factory.
	*
	* <p>
	* @param rowOid The <CODE>SnmpOid</CODE> identifying the table
	* row to remove.
	*
	* @param entry The entry to be removed. This parameter is not used
	* internally, it is simply passed along to the
	* removeEntryCB() callback.
	*
	* @exception SnmpStatusException if the specified entry couldn't
	* be removed (if the given <code>rowOid</code> is not
	* valid for instance).
	*/
	public synchronized void removeEntry(SnmpOid rowOid, Object entry)
	throws SnmpStatusException {
	int pos = findObject(rowOid);
	if (pos == -1)
	return;
	removeEntry(pos,entry);
	}

	/**
	* Remove the specified entry from the table.
	* Also triggers the removeEntryCB() callback of the
	* {@link com.sun.jmx.snmp.agent.SnmpTableEntryFactory} interface
	* if this node is bound to a factory.
	*
	* <p>
	* @param rowOid The <CODE>SnmpOid</CODE> identifying the table
	* row to remove.
	*
	* @exception SnmpStatusException if the specified entry couldn't
	* be removed (if the given <code>rowOid</code> is not
	* valid for instance).
	*/
	public void removeEntry(SnmpOid rowOid)
	throws SnmpStatusException {
	int pos = findObject(rowOid);
	if (pos == -1)
	return;
	removeEntry(pos,null);
	}

	/**
	* Remove the specified entry from the table.
	* Also triggers the removeEntryCB() callback of the
	* {@link com.sun.jmx.snmp.agent.SnmpTableEntryFactory} interface
	* if this node is bound to a factory.
	*
	* <p>
	* @param pos The position of the entry in the table.
	*
	* @param entry The entry to be removed. This parameter is not used
	* internally, it is simply passed along to the
	* removeEntryCB() callback.
	*
	* @exception SnmpStatusException if the specified entry couldn't
	* be removed.
	*/
	public synchronized void removeEntry(int pos, Object entry)
	throws SnmpStatusException {
	if (pos == -1)
	return;
	if (pos >= size) return;

	Object obj = entry;
	if (entries != null && entries.size() > pos) {
	obj = entries.elementAt(pos);
	entries.removeElementAt(pos);
	}

	ObjectName name = null;
	if (entrynames != null && entrynames.size() > pos) {
	name = entrynames.elementAt(pos);
	entrynames.removeElementAt(pos);
	}

	final SnmpOid rowOid = tableoids[pos];
	removeOid(pos);
	size --;

	if (obj == null) obj = entry;

	if (factory != null)
	factory.removeEntryCb(pos,rowOid,name,obj,this);

	sendNotification(SnmpTableEntryNotification.SNMP_ENTRY_REMOVED,
	(new Date()).getTime(), obj, name);
	}

	/**
	* Get the entry corresponding to the specified rowOid.
	*
	* <p>
	* @param rowOid The <CODE>SnmpOid</CODE> identifying the
	* row to be retrieved.
	*
	* @return The entry.
	*
	* @exception SnmpStatusException There is no entry with the specified
	* <code>rowOid</code> in the table.
	*/
	public synchronized Object getEntry(SnmpOid rowOid)
	throws SnmpStatusException {
	int pos= findObject(rowOid);
	if (pos == -1)
	throw new SnmpStatusException(SnmpStatusException.noSuchInstance);
	return entries.elementAt(pos);
	}

	/**
	* Get the ObjectName of the entry corresponding to the
	* specified rowOid.
	* The result of this method is only meaningful if
	* isRegistrationRequired() yields true.
	*
	* <p>
	* @param rowOid The <CODE>SnmpOid</CODE> identifying the table
	* row whose ObjectName we want to retrieve.
	*
	* @return The object name of the entry.
	*
	* @exception SnmpStatusException There is no entry with the specified
	* <code>rowOid</code> in the table.
	*/
	public synchronized ObjectName getEntryName(SnmpOid rowOid)
	throws SnmpStatusException {
	int pos = findObject(rowOid);
	if (entrynames == null) return null;
	if (pos == -1 \|\| pos >= entrynames.size())
	throw new SnmpStatusException(SnmpStatusException.noSuchInstance);
	return entrynames.elementAt(pos);
	}

	/**
	* Return the entries stored in this table <CODE>SnmpMibTable</CODE>.
	* <p>
	* If the subclass generated by mibgen uses the generic way to access
	* the entries (i.e. if it goes through the MBeanServer) then some of
	* the entries may be <code>null</code>. It all depends whether a non
	* <code>null</code> entry was passed to addEntry().<br>
	* Otherwise, if it uses the standard way (access the entry directly
	* through their standard MBean interface) this array will contain all
	* the entries.
	* <p>
	* @return The entries array.
	*/
	public Object[] getBasicEntries() {
	Object[] array= new Object[size];
	entries.copyInto(array);
	return array;
	}

	/**
	* Get the size of the table.
	*
	* @return The number of entries currently registered in this table.
	*/
	public int getSize() {
	return size;
	}

	// EVENT STUFF
	//------------

	/**
	* Enable to add an SNMP entry listener to this
	* <CODE>SnmpMibTable</CODE>.
	*
	* <p>
	* @param listener The listener object which will handle the
	* notifications emitted by the registered MBean.
	*
	* @param filter The filter object. If filter is null, no filtering
	* will be performed before handling notifications.
	*
	* @param handback The context to be sent to the listener when a
	* notification is emitted.
	*
	* @exception IllegalArgumentException Listener parameter is null.
	*/
	@Override
	public synchronized void
	addNotificationListener(NotificationListener listener,
	NotificationFilter filter, Object handback) {

	// Check listener
	//
	if (listener == null) {
	throw new java.lang.IllegalArgumentException
	("Listener can't be null") ;
	}

	// looking for listener in handbackTable
	//
	Vector<Object> handbackList = handbackTable.get(listener) ;
	Vector<NotificationFilter> filterList = filterTable.get(listener) ;
	if ( handbackList == null ) {
	handbackList = new Vector<>() ;
	filterList = new Vector<>() ;
	handbackTable.put(listener, handbackList) ;
	filterTable.put(listener, filterList) ;
	}

	// Add the handback and the filter
	//
	handbackList.addElement(handback) ;
	filterList.addElement(filter) ;
	}

	/**
	* Enable to remove an SNMP entry listener from this
	* <CODE>SnmpMibTable</CODE>.
	*
	* @param listener The listener object which will handle the
	* notifications emitted by the registered MBean.
	* This method will remove all the information related to this
	* listener.
	*
	* @exception ListenerNotFoundException The listener is not registered
	* in the MBean.
	*/
	@Override
	public synchronized void
	removeNotificationListener(NotificationListener listener)
	throws ListenerNotFoundException {

	// looking for listener in handbackTable
	//
	java.util.Vector<?> handbackList = handbackTable.get(listener) ;
	if ( handbackList == null ) {
	throw new ListenerNotFoundException("listener");
	}

	// If handback is null, remove the listener entry
	//
	handbackTable.remove(listener) ;
	filterTable.remove(listener) ;
	}

	/**
	* Return a <CODE>NotificationInfo</CODE> object containing the
	* notification class and the notification type sent by the
	* <CODE>SnmpMibTable</CODE>.
	*/
	@Override
	public MBeanNotificationInfo[] getNotificationInfo() {

	String[] types = {SnmpTableEntryNotification.SNMP_ENTRY_ADDED,
	SnmpTableEntryNotification.SNMP_ENTRY_REMOVED};

	MBeanNotificationInfo[] notifsInfo = {
	new MBeanNotificationInfo
	(types, "com.sun.jmx.snmp.agent.SnmpTableEntryNotification",
	"Notifications sent by the SnmpMibTable")
	};

	return notifsInfo;
	}


	/**
	* Register the factory through which table entries should
	* be created when remote entry creation is enabled.
	*
	* <p>
	* @param factory The
	* {@link com.sun.jmx.snmp.agent.SnmpTableEntryFactory} through
	* which entries will be created when a remote SNMP manager
	* request the creation of a new entry via an SNMP SET request.
	*/
	public void registerEntryFactory(SnmpTableEntryFactory factory) {
	this.factory = factory;
	}

	// ----------------------------------------------------------------------
	// PROTECTED METHODS - RowStatus
	// ----------------------------------------------------------------------

	/**
	* Return true if the columnar object identified by <code>var</code>
	* is used to control the addition/deletion of rows in this table.
	*
	* <p>
	* By default, this method assumes that there is no control variable
	* and always return <code>false</code>
	* <p>
	* If this table was defined using SMIv2, and if it contains a
	* control variable with RowStatus syntax, <code>mibgen</code>
	* will generate a non default implementation for this method
	* that will identify the RowStatus control variable.
	* <p>
	* You will have to redefine this method if you need to implement
	* control variables that do not conform to RFC 2579 RowStatus
	* TEXTUAL-CONVENTION.
	* <p>
	* @param rowOid The <CODE>SnmpOid</CODE> identifying the table
	* row involved in the operation.
	*
	* @param var The OID arc identifying the involved columnar object.
	*
	* @param userData A contextual object containing user-data.
	* This object is allocated through the <code>
	* {@link com.sun.jmx.snmp.agent.SnmpUserDataFactory}</code>
	* for each incoming SNMP request.
	*
	**/
	protected boolean isRowStatus(SnmpOid rowOid, long var,
	Object userData) {
	return false;
	}


	/**
	* Return the RowStatus code value specified in this request.
	* <p>
	* The RowStatus code value should be one of the values defined
	* by {@link com.sun.jmx.snmp.EnumRowStatus}. These codes correspond
	* to RowStatus codes as defined in RFC 2579, plus the <i>unspecified</i>
	* value which is SNMP Runtime specific.
	* <p>
	*
	* @param req The sub-request that must be handled by this node.
	*
	* @param rowOid The <CODE>SnmpOid</CODE> identifying the table
	* row involved in the operation.
	*
	* @param depth The depth reached in the OID tree.
	*
	* @return The RowStatus code specified in this request, if any:
	* <ul>
	* <li>If the specified row does not exist and this table do
	* not use any variable to control creation/deletion of
	* rows, then default creation mechanism is assumed and
	* <i>createAndGo</i> is returned</li>
	* <li>Otherwise, if the row exists and this table do not use any
	* variable to control creation/deletion of rows,
	* <i>unspecified</i> is returned.</li>
	* <li>Otherwise, if the request does not contain the control variable,
	* <i>unspecified</i> is returned.</li>
	* <li>Otherwise, mapRowStatus() is called to extract the RowStatus
	* code from the SnmpVarBind that contains the control variable.</li>
	* </ul>
	*
	* @exception SnmpStatusException if the value of the control variable
	* could not be mapped to a RowStatus code.
	*
	* @see com.sun.jmx.snmp.EnumRowStatus
	**/
	protected int getRowAction(SnmpMibSubRequest req, SnmpOid rowOid,
	int depth)
	throws SnmpStatusException {
	final boolean isnew = req.isNewEntry();
	final SnmpVarBind vb = req.getRowStatusVarBind();
	if (vb == null) {
	if (isnew && ! hasRowStatus())
	return EnumRowStatus.createAndGo;
	else return EnumRowStatus.unspecified;
	}

	try {
	return mapRowStatus(rowOid, vb, req.getUserData());
	} catch( SnmpStatusException x) {
	checkRowStatusFail(req, x.getStatus());
	}
	return EnumRowStatus.unspecified;
	}

	/**
	* Map the value of the <code>vbstatus</code> varbind to the
	* corresponding RowStatus code defined in
	* {@link com.sun.jmx.snmp.EnumRowStatus}.
	* These codes correspond to RowStatus codes as defined in RFC 2579,
	* plus the <i>unspecified</i> value which is SNMP Runtime specific.
	* <p>
	* By default, this method assumes that the control variable is
	* an Integer, and it simply returns its value without further
	* analysis.
	* <p>
	* If this table was defined using SMIv2, and if it contains a
	* control variable with RowStatus syntax, <code>mibgen</code>
	* will generate a non default implementation for this method.
	* <p>
	* You will have to redefine this method if you need to implement
	* control variables that do not conform to RFC 2579 RowStatus
	* TEXTUAL-CONVENTION.
	*
	* <p>
	* @param rowOid The <CODE>SnmpOid</CODE> identifying the table
	* row involved in the operation.
	*
	* @param vbstatus The SnmpVarBind containing the value of the control
	* variable, as identified by the isRowStatus() method.
	*
	* @param userData A contextual object containing user-data.
	* This object is allocated through the <code>
	* {@link com.sun.jmx.snmp.agent.SnmpUserDataFactory}</code>
	* for each incoming SNMP request.
	*
	* @return The RowStatus code mapped from the value contained
	* in <code>vbstatus</code>.
	*
	* @exception SnmpStatusException if the value of the control variable
	* could not be mapped to a RowStatus code.
	*
	* @see com.sun.jmx.snmp.EnumRowStatus
	**/
	protected int mapRowStatus(SnmpOid rowOid, SnmpVarBind vbstatus,
	Object userData)
	throws SnmpStatusException {
	final SnmpValue rsvalue = vbstatus.value;

	if (rsvalue instanceof SnmpInt)
	return ((SnmpInt)rsvalue).intValue();
	else
	throw new SnmpStatusException(
	SnmpStatusException.snmpRspInconsistentValue);
	}

	/**
	* Set the control variable to the specified <code>newStatus</code>
	* value.
	*
	* <p>
	* This method maps the given <code>newStatus</code> to the appropriate
	* value for the control variable, then sets the control variable in
	* the entry identified by <code>rowOid</code>. It returns the new
	* value of the control variable.
	* <p>
	* By default, it is assumed that there is no control variable so this
	* method does nothing and simply returns <code>null</code>.
	* <p>
	* If this table was defined using SMIv2, and if it contains a
	* control variable with RowStatus syntax, <code>mibgen</code>
	* will generate a non default implementation for this method.
	* <p>
	* You will have to redefine this method if you need to implement
	* control variables that do not conform to RFC 2579 RowStatus
	* TEXTUAL-CONVENTION.
	*
	* <p>
	* @param rowOid The <CODE>SnmpOid</CODE> identifying the table
	* row involved in the operation.
	*
	* @param newStatus The new status for the row: one of the
	* RowStatus code defined in
	* {@link com.sun.jmx.snmp.EnumRowStatus}. These codes
	* correspond to RowStatus codes as defined in RFC 2579,
	* plus the <i>unspecified</i> value which is SNMP Runtime specific.
	*
	* @param userData A contextual object containing user-data.
	* This object is allocated through the <code>
	* {@link com.sun.jmx.snmp.agent.SnmpUserDataFactory}</code>
	* for each incoming SNMP request.
	*
	* @return The new value of the control variable (usually
	* <code>new SnmpInt(newStatus)</code>) or <code>null</code>
	* if the table do not have any control variable.
	*
	* @exception SnmpStatusException If the given <code>newStatus</code>
	* could not be set on the specified entry, or if the
	* given <code>newStatus</code> is not valid.
	*
	* @see com.sun.jmx.snmp.EnumRowStatus
	**/
	protected SnmpValue setRowStatus(SnmpOid rowOid, int newStatus,
	Object userData)
	throws SnmpStatusException {
	return null;
	}

	/**
	* Tell whether the specified row is ready and can be put in the
	* <i>notInService</i> state.
	* <p>
	* This method is called only once, after all the varbind have been
	* set on a new entry for which <i>createAndWait</i> was specified.
	* <p>
	* If the entry is not yet ready, this method should return false.
	* It will then be the responsibility of the entry to switch its
	* own state to <i>notInService</i> when it becomes ready.
	* No further call to <code>isRowReady()</code> will be made.
	* <p>
	* By default, this method always return true. <br>
	* <code>mibgen</code> will not generate any specific implementation
	* for this method - meaning that by default, a row created using
	* <i>createAndWait</i> will always be placed in <i>notInService</i>
	* state at the end of the request.
	* <p>
	* If this table was defined using SMIv2, and if it contains a
	* control variable with RowStatus syntax, <code>mibgen</code>
	* will generate an implementation for this method that will
	* delegate the work to the metadata class modelling the conceptual
	* row, so that you can override the default behaviour by subclassing
	* that metadata class.
	* <p>
	* You will have to redefine this method if this default mechanism
	* does not suit your needs.
	*
	* <p>
	* @param rowOid The <CODE>SnmpOid</CODE> identifying the table
	* row involved in the operation.
	*
	* @param userData A contextual object containing user-data.
	* This object is allocated through the <code>
	* {@link com.sun.jmx.snmp.agent.SnmpUserDataFactory}</code>
	* for each incoming SNMP request.
	*
	* @return <code>true</code> if the row can be placed in
	* <i>notInService</i> state.
	*
	* @exception SnmpStatusException An error occurred while trying
	* to retrieve the row status, and the operation should
	* be aborted.
	*
	* @see com.sun.jmx.snmp.EnumRowStatus
	**/
	protected boolean isRowReady(SnmpOid rowOid, Object userData)
	throws SnmpStatusException {
	return true;
	}

	/**
	* Check whether the control variable of the given row can be
	* switched to the new specified <code>newStatus</code>.
	* <p>
	* This method is called during the <i>check</i> phase of a SET
	* request when the control variable specifies <i>active</i> or
	* <i>notInService</i>.
	* <p>
	* By default it is assumed that nothing prevents putting the
	* row in the requested state, and this method does nothing.
	* It is simply provided as a hook so that specific checks can
	* be implemented.
	* <p>
	* Note that if the actual row deletion fails afterward, the
	* atomicity of the request is no longer guaranteed.
	*
	* <p>
	* @param req The sub-request that must be handled by this node.
	*
	* @param rowOid The <CODE>SnmpOid</CODE> identifying the table
	* row involved in the operation.
	*
	* @param depth The depth reached in the OID tree.
	*
	* @param newStatus The new status for the row: one of the
	* RowStatus code defined in
	* {@link com.sun.jmx.snmp.EnumRowStatus}. These codes
	* correspond to RowStatus codes as defined in RFC 2579,
	* plus the <i>unspecified</i> value which is SNMP Runtime specific.
	*
	* @exception SnmpStatusException if switching to this new state
	* would fail.
	*
	**/
	protected void checkRowStatusChange(SnmpMibSubRequest req,
	SnmpOid rowOid, int depth,
	int newStatus)
	throws SnmpStatusException {

	}

	/**
	* Check whether the specified row can be removed from the table.
	* <p>
	* This method is called during the <i>check</i> phase of a SET
	* request when the control variable specifies <i>destroy</i>
	* <p>
	* By default it is assumed that nothing prevents row deletion
	* and this method does nothing. It is simply provided as a hook
	* so that specific checks can be implemented.
	* <p>
	* Note that if the actual row deletion fails afterward, the
	* atomicity of the request is no longer guaranteed.
	*
	* <p>
	* @param req The sub-request that must be handled by this node.
	*
	* @param rowOid The <CODE>SnmpOid</CODE> identifying the table
	* row involved in the operation.
	*
	* @param depth The depth reached in the OID tree.
	*
	* @exception SnmpStatusException if the row deletion must be
	* rejected.
	**/
	protected void checkRemoveTableRow(SnmpMibSubRequest req, SnmpOid rowOid,
	int depth)
	throws SnmpStatusException {

	}

	/**
	* Remove a table row upon a remote manager request.
	*
	* This method is called internally when <code>getRowAction()</code>
	* yields <i>destroy</i> - i.e.: it is only called when a remote
	* manager requests the removal of a table row.<br>
	* You should never need to call this function directly.
	* <p>
	* By default, this method simply calls <code>removeEntry(rowOid)
	* </code>.
	* <p>
	* You can redefine this method if you need to implement some
	* specific behaviour when a remote row deletion is invoked.
	* <p>
	* Note that specific checks should not be implemented in this
	* method, but rather in <code>checkRemoveTableRow()</code>.
	* If <code>checkRemoveTableRow()</code> succeeds and this method
	* fails afterward, the atomicity of the original SET request can no
	* longer be guaranteed.
	* <p>
	*
	* @param req The sub-request that must be handled by this node.
	*
	* @param rowOid The <CODE>SnmpOid</CODE> identifying the table
	* row involved in the operation.
	*
	* @param depth The depth reached in the OID tree.
	*
	* @exception SnmpStatusException if the actual row deletion fails.
	* This should not happen since it would break the
	* atomicity of the SET request. Specific checks should
	* be implemented in <code>checkRemoveTableRow()</code>
	* if needed. If the entry does not exists, no exception
	* is generated and the method simply returns.
	*
	**/
	protected void removeTableRow(SnmpMibSubRequest req, SnmpOid rowOid,
	int depth)
	throws SnmpStatusException {

	removeEntry(rowOid);
	}

	/**
	* This method takes care of initial RowStatus handling during the
	* check() phase of a SET request.
	*
	* In particular it will:
	* <ul><li>check that the given <code>rowAction</code> returned by
	* <code>getRowAction()</code> is valid.</li>
	* <li>Then depending on the <code>rowAction</code> specified it will:
	* <ul><li>either call <code>createNewEntry()</code> (<code>
	* rowAction = <i>createAndGo</i> or <i>createAndWait</i>
	* </code>),</li>
	* <li>or call <code>checkRemoveTableRow()</code> (<code>
	* rowAction = <i>destroy</i></code>),</li>
	* <li>or call <code>checkRowStatusChange()</code> (<code>
	* rowAction = <i>active</i> or <i>notInService</i></code>),</li>
	* <li>or generate a SnmpStatusException if the passed <code>
	* rowAction</code> is not correct.</li>
	* </ul></li></ul>
	* <p>
	* In principle, you should not need to redefine this method.
	* <p>
	* <code>beginRowAction()</code> is called during the check phase
	* of a SET request, before actual checking on the varbind list
	* is performed.
	*
	* <p>
	* @param req The sub-request that must be handled by this node.
	*
	* @param rowOid The <CODE>SnmpOid</CODE> identifying the table
	* row involved in the operation.
	*
	* @param depth The depth reached in the OID tree.
	*
	* @param rowAction The requested action as returned by <code>
	* getRowAction()</code>: one of the RowStatus codes defined in
	* {@link com.sun.jmx.snmp.EnumRowStatus}. These codes
	* correspond to RowStatus codes as defined in RFC 2579,
	* plus the <i>unspecified</i> value which is SNMP Runtime specific.
	*
	* @exception SnmpStatusException if the specified <code>rowAction</code>
	* is not valid or cannot be executed.
	* This should not happen since it would break the
	* atomicity of the SET request. Specific checks should
	* be implemented in <code>beginRowAction()</code> if needed.
	*
	* @see com.sun.jmx.snmp.EnumRowStatus
	**/
	protected synchronized void beginRowAction(SnmpMibSubRequest req,
	SnmpOid rowOid, int depth, int rowAction)
	throws SnmpStatusException {
	final boolean isnew = req.isNewEntry();
	final SnmpOid oid = rowOid;
	final int action = rowAction;

	switch (action) {
	case EnumRowStatus.unspecified:
	if (isnew) {
	if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
	SNMP_ADAPTOR_LOGGER.logp(Level.FINEST,
	SnmpMibTable.class.getName(),
	"beginRowAction", "Failed to create row[" +
	rowOid + "] : RowStatus = unspecified");
	}
	checkRowStatusFail(req,SnmpStatusException.snmpRspNoAccess);
	}
	break;
	case EnumRowStatus.createAndGo:
	case EnumRowStatus.createAndWait:
	if (isnew) {
	if (isCreationEnabled()) {
	if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
	SNMP_ADAPTOR_LOGGER.logp(Level.FINEST,
	SnmpMibTable.class.getName(),
	"beginRowAction", "Creating row[" + rowOid +
	"] : RowStatus = createAndGo \| createAndWait");
	}
	createNewEntry(req,oid,depth);
	} else {
	if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
	SNMP_ADAPTOR_LOGGER.logp(Level.FINEST,
	SnmpMibTable.class.getName(),
	"beginRowAction", "Can't create row[" + rowOid +
	"] : RowStatus = createAndGo \| createAndWait " +
	"but creation is disabled");
	}
	checkRowStatusFail(req,
	SnmpStatusException.snmpRspNoAccess);
	}
	} else {
	if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
	SNMP_ADAPTOR_LOGGER.logp(Level.FINEST,
	SnmpMibTable.class.getName(),
	"beginRowAction", "Can't create row[" + rowOid +
	"] : RowStatus = createAndGo \| createAndWait " +
	"but row already exists");
	}
	checkRowStatusFail(req,
	SnmpStatusException.snmpRspInconsistentValue);
	}
	break;
	case EnumRowStatus.destroy:
	if (isnew) {
	if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
	SNMP_ADAPTOR_LOGGER.logp(Level.FINEST,
	SnmpMibTable.class.getName(),
	"beginRowAction",
	"Warning: can't destroy row[" + rowOid +
	"] : RowStatus = destroy but row does not exist");
	}
	} else if (!isCreationEnabled()) {
	if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
	SNMP_ADAPTOR_LOGGER.logp(Level.FINEST,
	SnmpMibTable.class.getName(),
	"beginRowAction",
	"Can't destroy row[" + rowOid + "] : " +
	"RowStatus = destroy but creation is disabled");
	}
	checkRowStatusFail(req,SnmpStatusException.snmpRspNoAccess);
	}
	checkRemoveTableRow(req,rowOid,depth);
	break;
	case EnumRowStatus.active:
	case EnumRowStatus.notInService:
	if (isnew) {
	if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
	SNMP_ADAPTOR_LOGGER.logp(Level.FINEST,
	SnmpMibTable.class.getName(),
	"beginRowAction", "Can't switch state of row[" +
	rowOid + "] : specified RowStatus = active \| " +
	"notInService but row does not exist");
	}
	checkRowStatusFail(req,
	SnmpStatusException.snmpRspInconsistentValue);
	}
	checkRowStatusChange(req,rowOid,depth,action);
	break;
	case EnumRowStatus.notReady:
	default:
	if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
	SNMP_ADAPTOR_LOGGER.logp(Level.FINEST,
	SnmpMibTable.class.getName(),
	"beginRowAction", "Invalid RowStatus value for row[" +
	rowOid + "] : specified RowStatus = " + action);
	}
	checkRowStatusFail(req,
	SnmpStatusException.snmpRspInconsistentValue);
	}
	}

	/**
	* This method takes care of final RowStatus handling during the
	* set() phase of a SET request.
	*
	* In particular it will:
	* <ul><li>either call <code>setRowStatus(<i>active</i>)</code>
	* (<code> rowAction = <i>createAndGo</i> or <i>active</i>
	* </code>),</li>
	* <li>or call <code>setRowStatus(<i>notInService</i> or <i>
	* notReady</i>)</code> depending on the result of <code>
	* isRowReady()</code> (<code>rowAction = <i>createAndWait</i>
	* </code>),</li>
	* <li>or call <code>setRowStatus(<i>notInService</i>)</code>
	* (<code> rowAction = <i>notInService</i></code>),
	* <li>or call <code>removeTableRow()</code> (<code>
	* rowAction = <i>destroy</i></code>),</li>
	* <li>or generate a SnmpStatusException if the passed <code>
	* rowAction</code> is not correct. This should be avoided
	* since it would break SET request atomicity</li>
	* </ul>
	* <p>
	* In principle, you should not need to redefine this method.
	* <p>
	* <code>endRowAction()</code> is called during the set() phase
	* of a SET request, after the actual set() on the varbind list
	* has been performed. The varbind containing the control variable
	* is updated with the value returned by setRowStatus() (if it is
	* not <code>null</code>).
	*
	* <p>
	* @param req The sub-request that must be handled by this node.
	*
	* @param rowOid The <CODE>SnmpOid</CODE> identifying the table
	* row involved in the operation.
	*
	* @param depth The depth reached in the OID tree.
	*
	* @param rowAction The requested action as returned by <code>
	* getRowAction()</code>: one of the RowStatus codes defined in
	* {@link com.sun.jmx.snmp.EnumRowStatus}. These codes
	* correspond to RowStatus codes as defined in RFC 2579,
	* plus the <i>unspecified</i> value which is SNMP Runtime specific.
	*
	* @exception SnmpStatusException if the specified <code>rowAction</code>
	* is not valid.
	*
	* @see com.sun.jmx.snmp.EnumRowStatus
	**/
	protected void endRowAction(SnmpMibSubRequest req, SnmpOid rowOid,
	int depth, int rowAction)
	throws SnmpStatusException {
	final boolean isnew = req.isNewEntry();
	final SnmpOid oid = rowOid;
	final int action = rowAction;
	final Object data = req.getUserData();
	SnmpValue value = null;

	switch (action) {
	case EnumRowStatus.unspecified:
	break;
	case EnumRowStatus.createAndGo:
	if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
	SNMP_ADAPTOR_LOGGER.logp(Level.FINEST,
	SnmpMibTable.class.getName(),
	"endRowAction", "Setting RowStatus to 'active' " +
	"for row[" + rowOid + "] : requested RowStatus = " +
	"createAndGo");
	}
	value = setRowStatus(oid,EnumRowStatus.active,data);
	break;
	case EnumRowStatus.createAndWait:
	if (isRowReady(oid,data)) {
	if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
	SNMP_ADAPTOR_LOGGER.logp(Level.FINEST,
	SnmpMibTable.class.getName(),
	"endRowAction",
	"Setting RowStatus to 'notInService' for row[" +
	rowOid + "] : requested RowStatus = createAndWait");
	}
	value = setRowStatus(oid,EnumRowStatus.notInService,data);
	} else {
	if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
	SNMP_ADAPTOR_LOGGER.logp(Level.FINEST,
	SnmpMibTable.class.getName(),
	"endRowAction", "Setting RowStatus to 'notReady' " +
	"for row[" + rowOid + "] : requested RowStatus = " +
	"createAndWait");
	}
	value = setRowStatus(oid,EnumRowStatus.notReady,data);
	}
	break;
	case EnumRowStatus.destroy:
	if (isnew) {
	if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
	SNMP_ADAPTOR_LOGGER.logp(Level.FINEST,
	SnmpMibTable.class.getName(),
	"endRowAction",
	"Warning: requested RowStatus = destroy, " +
	"but row[" + rowOid + "] does not exist");
	}
	} else {
	if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
	SNMP_ADAPTOR_LOGGER.logp(Level.FINEST,
	SnmpMibTable.class.getName(),
	"endRowAction", "Destroying row[" + rowOid +
	"] : requested RowStatus = destroy");
	}
	}
	removeTableRow(req,oid,depth);
	break;
	case EnumRowStatus.active:
	if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
	SNMP_ADAPTOR_LOGGER.logp(Level.FINEST,
	SnmpMibTable.class.getName(),
	"endRowAction",
	"Setting RowStatus to 'active' for row[" +
	rowOid + "] : requested RowStatus = active");
	}
	value = setRowStatus(oid,EnumRowStatus.active,data);
	break;
	case EnumRowStatus.notInService:
	if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
	SNMP_ADAPTOR_LOGGER.logp(Level.FINEST,
	SnmpMibTable.class.getName(),
	"endRowAction",
	"Setting RowStatus to 'notInService' for row[" +
	rowOid + "] : requested RowStatus = notInService");
	}
	value = setRowStatus(oid,EnumRowStatus.notInService,data);
	break;
	case EnumRowStatus.notReady:
	default:
	if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
	SNMP_ADAPTOR_LOGGER.logp(Level.FINEST,
	SnmpMibTable.class.getName(),
	"endRowAction", "Invalid RowStatus value for row[" +
	rowOid + "] : specified RowStatus = " + action);
	}
	setRowStatusFail(req,
	SnmpStatusException.snmpRspInconsistentValue);
	}
	if (value != null) {
	final SnmpVarBind vb = req.getRowStatusVarBind();
	if (vb != null) vb.value = value;
	}
	}

	// -------------------------------------------------------------------
	// PROTECTED METHODS - get next
	// -------------------------------------------------------------------

	/**
	* Return the next OID arc corresponding to a readable columnar
	* object in the underlying entry OBJECT-TYPE, possibly skipping over
	* those objects that must not or cannot be returned.
	* Calls {@link
	* #getNextVarEntryId(com.sun.jmx.snmp.SnmpOid,long,java.lang.Object)},
	* until
	* {@link #skipEntryVariable(com.sun.jmx.snmp.SnmpOid,long,
	* java.lang.Object,int)} returns false.
	*
	*
	* @param rowOid The OID index of the row involved in the operation.
	*
	* @param var Id of the variable we start from, looking for the next.
	*
	* @param userData A contextual object containing user-data.
	* This object is allocated through the <code>
	* {@link com.sun.jmx.snmp.agent.SnmpUserDataFactory}</code>
	* for each incoming SNMP request.
	*
	* @param pduVersion Protocol version of the original request PDU.
	*
	* @return The next columnar object id which can be returned using
	* the given PDU's protocol version.
	*
	* @exception SnmpStatusException If no id is found after the given id.
	*
	**/
	protected long getNextVarEntryId(SnmpOid rowOid,
	long var,
	Object userData,
	int pduVersion)
	throws SnmpStatusException {

	long varid=var;
	do {
	varid = getNextVarEntryId(rowOid,varid,userData);
	} while (skipEntryVariable(rowOid,varid,userData,pduVersion));

	return varid;
	}

	/**
	* Hook for subclasses.
	* The default implementation of this method is to always return
	* false. Subclasses should redefine this method so that it returns
	* true when:
	* <ul><li>the variable is a leaf that is not instantiated,</li>
	* <li>or the variable is a leaf whose type cannot be returned by that
	* version of the protocol (e.g. an Counter64 with SNMPv1).</li>
	* </ul>
	*
	* @param rowOid The OID index of the row involved in the operation.
	*
	* @param var Id of the variable we start from, looking for the next.
	*
	* @param userData A contextual object containing user-data.
	* This object is allocated through the <code>
	* {@link com.sun.jmx.snmp.agent.SnmpUserDataFactory}</code>
	* for each incoming SNMP request.
	*
	* @param pduVersion Protocol version of the original request PDU.
	*
	* @return true if the variable must be skipped by the get-next
	* algorithm.
	*/
	protected boolean skipEntryVariable(SnmpOid rowOid,
	long var,
	Object userData,
	int pduVersion) {
	return false;
	}

	/**
	* Get the <CODE>SnmpOid</CODE> index of the row that follows
	* the given <CODE>oid</CODE> in the table. The given <CODE>
	* oid</CODE> does not need to be a valid row OID index.
	*
	* <p>
	* @param oid The OID from which the search will begin.
	*
	* @param userData A contextual object containing user-data.
	* This object is allocated through the <code>
	* {@link com.sun.jmx.snmp.agent.SnmpUserDataFactory}</code>
	* for each incoming SNMP request.
	*
	* @return The next <CODE>SnmpOid</CODE> index.
	*
	* @exception SnmpStatusException There is no index following the
	* specified <CODE>oid</CODE> in the table.
	*/
	protected SnmpOid getNextOid(SnmpOid oid, Object userData)
	throws SnmpStatusException {

	if (size == 0) {
	throw new SnmpStatusException(SnmpStatusException.noSuchInstance);
	}

	final SnmpOid resOid = oid;

	// Just a simple check to speed up retrieval of last element ...
	//
	// XX SnmpOid last= (SnmpOid) oids.lastElement();
	SnmpOid last= tableoids[tablecount-1];
	if (last.equals(resOid)) {
	// Last element of the table ...
	//
	throw new SnmpStatusException(SnmpStatusException.noSuchInstance);
	}

	// First find the oid. This will allow to speed up retrieval process
	// during smart discovery of table (using the getNext) as the
	// management station will use the valid index returned during a
	// previous getNext ...
	//

	// Returns the position following the position at which resOid
	// is found, or the position at which resOid should be inserted.
	//
	final int newPos = getInsertionPoint(resOid,false);

	// If the position returned is not out of bound, we will find
	// the next element in the array.
	//
	if (newPos > -1 && newPos < size) {
	try {
	// XX last = (SnmpOid) oids.elementAt(newPos);
	last = tableoids[newPos];
	} catch(ArrayIndexOutOfBoundsException e) {
	throw new SnmpStatusException(SnmpStatusException.noSuchInstance);
	}
	} else {
	// We are dealing with the last element of the table ..
	//
	throw new SnmpStatusException(SnmpStatusException.noSuchInstance);
	}


	return last;
	}

	/**
	* Return the first entry OID registered in the table.
	*
	* <p>
	* @param userData A contextual object containing user-data.
	* This object is allocated through the <code>
	* {@link com.sun.jmx.snmp.agent.SnmpUserDataFactory}</code>
	* for each incoming SNMP request.
	*
	* @return The <CODE>SnmpOid</CODE> of the first entry in the table.
	*
	* @exception SnmpStatusException If the table is empty.
	*/
	protected SnmpOid getNextOid(Object userData)
	throws SnmpStatusException {
	if (size == 0) {
	throw new SnmpStatusException(SnmpStatusException.noSuchInstance);
	}
	// XX return (SnmpOid) oids.firstElement();
	return tableoids[0];
	}

	// -------------------------------------------------------------------
	// Abstract Protected Methods
	// -------------------------------------------------------------------

	/**
	* This method is used internally and is implemented by the
	* <CODE>SnmpMibTable</CODE> subclasses generated by <CODE>mibgen</CODE>.
	*
	* <p> Return the next OID arc corresponding to a readable columnar
	* object in the underlying entry OBJECT-TYPE.</p>
	*
	* <p>
	* @param rowOid The OID index of the row involved in the operation.
	*
	* @param var Id of the variable we start from, looking for the next.
	*
	* @param userData A contextual object containing user-data.
	* This object is allocated through the <code>
	* {@link com.sun.jmx.snmp.agent.SnmpUserDataFactory}</code>
	* for each incoming SNMP request.
	*
	* @return The next columnar object id.
	*
	* @exception SnmpStatusException If no id is found after the given id.
	*
	**/
	abstract protected long getNextVarEntryId(SnmpOid rowOid, long var,
	Object userData)
	throws SnmpStatusException;

	/**
	* This method is used internally and is implemented by the
	* <CODE>SnmpMibTable</CODE> subclasses generated by <CODE>mibgen</CODE>.
	*
	* <p>
	* @param rowOid The OID index of the row involved in the operation.
	*
	* @param var The var we want to validate.
	*
	* @param userData A contextual object containing user-data.
	* This object is allocated through the <code>
	* {@link com.sun.jmx.snmp.agent.SnmpUserDataFactory}</code>
	* for each incoming SNMP request.
	*
	* @exception SnmpStatusException If this id is not valid.
	*
	*/
	abstract protected void validateVarEntryId(SnmpOid rowOid, long var,
	Object userData)
	throws SnmpStatusException;

	/**
	*
	* This method is used internally and is implemented by the
	* <CODE>SnmpMibTable</CODE> subclasses generated by <CODE>mibgen</CODE>.
	*
	* <p>
	* @param rowOid The OID index of the row involved in the operation.
	*
	* @param var The OID arc.
	*
	* @param userData A contextual object containing user-data.
	* This object is allocated through the <code>
	* {@link com.sun.jmx.snmp.agent.SnmpUserDataFactory}</code>
	* for each incoming SNMP request.
	*
	* @exception SnmpStatusException If this id is not valid.
	*
	*/
	abstract protected boolean isReadableEntryId(SnmpOid rowOid, long var,
	Object userData)
	throws SnmpStatusException;

	/**
	* This method is used internally and is implemented by the
	* <CODE>SnmpMibTable</CODE> subclasses generated by <CODE>mibgen</CODE>.
	*/
	abstract protected void get(SnmpMibSubRequest req,
	SnmpOid rowOid, int depth)
	throws SnmpStatusException;

	/**
	* This method is used internally and is implemented by the
	* <CODE>SnmpMibTable</CODE> subclasses generated by <CODE>mibgen</CODE>.
	*/
	abstract protected void check(SnmpMibSubRequest req,
	SnmpOid rowOid, int depth)
	throws SnmpStatusException;

	/**
	* This method is used internally and is implemented by the
	* <CODE>SnmpMibTable</CODE> subclasses generated by <CODE>mibgen</CODE>.
	*/
	abstract protected void set(SnmpMibSubRequest req,
	SnmpOid rowOid, int depth)
	throws SnmpStatusException;

	// ----------------------------------------------------------------------
	// PACKAGE METHODS
	// ----------------------------------------------------------------------

	/**
	* Get the <CODE>SnmpOid</CODE> index of the row that follows the
	* index extracted from the specified OID array.
	* Builds the SnmpOid corresponding to the row OID and calls
	* <code>getNextOid(oid,userData)</code>;
	*
	* <p>
	* @param oid The OID array.
	*
	* @param pos The position in the OID array at which the index starts.
	*
	* @param userData A contextual object containing user-data.
	* This object is allocated through the <code>
	* {@link com.sun.jmx.snmp.agent.SnmpUserDataFactory}</code>
	* for each incoming SNMP request.
	*
	* @return The next <CODE>SnmpOid</CODE>.
	*
	* @exception SnmpStatusException There is no index following the
	* specified one in the table.
	*/
	SnmpOid getNextOid(long[] oid, int pos, Object userData)
	throws SnmpStatusException {

	// Construct the sub-oid starting at pos.
	// This sub-oid correspond to the oid part just after the entry
	// variable oid.
	//
	final SnmpOid resOid = new SnmpEntryOid(oid,pos);

	return getNextOid(resOid,userData);
	}

	// ---------------------------------------------------------------------
	//
	// Register an exception when checking the RowStatus variable
	//
	// ---------------------------------------------------------------------

	static void checkRowStatusFail(SnmpMibSubRequest req, int errorStatus)
	throws SnmpStatusException {

	final SnmpVarBind statusvb = req.getRowStatusVarBind();
	final SnmpStatusException x = new SnmpStatusException(errorStatus);
	req.registerCheckException(statusvb,x);
	}

	// ---------------------------------------------------------------------
	//
	// Register an exception when checking the RowStatus variable
	//
	// ---------------------------------------------------------------------

	static void setRowStatusFail(SnmpMibSubRequest req, int errorStatus)
	throws SnmpStatusException {

	final SnmpVarBind statusvb = req.getRowStatusVarBind();
	final SnmpStatusException x = new SnmpStatusException(errorStatus);
	req.registerSetException(statusvb,x);
	}

	// ---------------------------------------------------------------------
	//
	// Implements the method defined in SnmpMibNode.
	//
	// ---------------------------------------------------------------------
	@Override
	final synchronized void findHandlingNode(SnmpVarBind varbind,
	long[] oid, int depth,
	SnmpRequestTree handlers)
	throws SnmpStatusException {

	final int length = oid.length;

	if (handlers == null)
	throw new SnmpStatusException(SnmpStatusException.snmpRspGenErr);

	if (depth >= length)
	throw new SnmpStatusException(SnmpStatusException.noAccess);

	if (oid[depth] != nodeId)
	throw new SnmpStatusException(SnmpStatusException.noAccess);

	if (depth+2 >= length)
	throw new SnmpStatusException(SnmpStatusException.noAccess);

	// Checks that the oid is valid
	// validateOid(oid,depth);

	// Gets the part of the OID that identifies the entry
	final SnmpOid entryoid = new SnmpEntryOid(oid, depth+2);

	// Finds the entry: false means that the entry does not exists
	final Object data = handlers.getUserData();
	final boolean hasEntry = contains(entryoid, data);

	// Fails if the entry is not found and the table does not
	// not support creation.
	// We know that the entry does not exists if (isentry == false).
	if (!hasEntry) {
	if (!handlers.isCreationAllowed()) {
	// we're not doing a set
	throw new SnmpStatusException(SnmpStatusException.noSuchInstance);
	} else if (!isCreationEnabled())
	// we're doing a set but creation is disabled.
	throw new
	SnmpStatusException(SnmpStatusException.snmpRspNoAccess);
	}

	final long var = oid[depth+1];

	// Validate the entry id
	if (hasEntry) {
	// The entry already exists - validate the id
	validateVarEntryId(entryoid,var,data);
	}

	// Registers this node for the identified entry.
	//
	if (handlers.isSetRequest() && isRowStatus(entryoid,var,data))

	// We only try to identify the RowStatus for SET operations
	//
	handlers.add(this,depth,entryoid,varbind,(!hasEntry),varbind);

	else
	handlers.add(this,depth,entryoid,varbind,(!hasEntry));
	}


	// ---------------------------------------------------------------------
	//
	// Implements the method defined in SnmpMibNode. The algorithm is very
	// largely inspired from the original getNext() method.
	//
	// ---------------------------------------------------------------------
	@Override
	final synchronized long[] findNextHandlingNode(SnmpVarBind varbind,
	long[] oid,
	int pos,
	int depth,
	SnmpRequestTree handlers,
	AcmChecker checker)
	throws SnmpStatusException {

	int length = oid.length;

	if (handlers == null) {
	// This should be considered as a genErr, but we do not want to
	// abort the whole request, so we're going to throw
	// a noSuchObject...
	//
	throw new SnmpStatusException(SnmpStatusException.noSuchObject);
	}

	final Object data = handlers.getUserData();
	final int pduVersion = handlers.getRequestPduVersion();

	long var= -1;

	// If the querried oid contains less arcs than the OID of the
	// xxxEntry object, we must return the first leaf under the
	// first columnar object: the best way to do that is to reset
	// the queried oid:
	// oid[0] = nodeId (arc of the xxxEntry object)
	// pos = 0 (points to the arc of the xxxEntry object)
	// then we just have to proceed...
	//
	if (pos >= length) {
	// this will have the side effect to set
	// oid[pos] = nodeId
	// and
	// (pos+1) = length
	// so we won't fall into the "else if" cases below -
	// so using "else if" rather than "if ..." is guaranteed
	// to be safe.
	//
	oid = new long[1];
	oid[0] = nodeId;
	pos = 0;
	length = 1;
	} else if (oid[pos] > nodeId) {
	// oid[pos] is expected to be the id of the xxxEntry ...
	// The id requested is greater than the id of the xxxEntry,
	// so we won't find the next element in this table... (any
	// element in this table will have a smaller OID)
	//
	throw new SnmpStatusException(SnmpStatusException.noSuchObject);
	} else if (oid[pos] < nodeId) {
	// we must return the first leaf under the first columnar
	// object, so we are back to our first case where pos was
	// out of bounds... => reset the oid to contain only the
	// arc of the xxxEntry object.
	//
	oid = new long[1];
	oid[0] = nodeId;
	pos = 0;
	length = 0;
	} else if ((pos + 1) < length) {
	// The arc at the position "pos+1" is the id of the columnar
	// object (ie: the id of the variable in the table entry)
	//
	var = oid[pos+1];
	}

	// Now that we've got everything right we can begin.
	SnmpOid entryoid;

	if (pos == (length - 1)) {
	// pos points to the last arc in the oid, and this arc is
	// guaranteed to be the xxxEntry id (we have handled all
	// the other possibilities before)
	//
	// We must therefore return the first leaf below the first
	// columnar object in the table.
	//
	// Get the first index. If an exception is raised,
	// then it means that the table is empty. We thus do not
	// have to catch the exception - we let it propagate to
	// the caller.
	//
	entryoid = getNextOid(data);
	var = getNextVarEntryId(entryoid,var,data,pduVersion);
	} else if ( pos == (length-2)) {
	// In that case we have (pos+1) = (length-1), so pos
	// points to the arc of the querried variable (columnar object).
	// Since the requested oid stops there, it means we have
	// to return the first leaf under this columnar object.
	//
	// So we first get the first index:
	// Note: if this raises an exception, this means that the table
	// is empty, so we can let the exception propagate to the caller.
	//
	entryoid = getNextOid(data);

	// XXX revisit: not exactly perfect:
	// a specific row could be empty.. But we don't know
	// how to make the difference! => tradeoff holes
	// in tables can't be properly supported (all rows
	// must have the same holes)
	//
	if (skipEntryVariable(entryoid,var,data,pduVersion)) {
	var = getNextVarEntryId(entryoid,var,data,pduVersion);
	}
	} else {

	// So now there remain one last case, namely: some part of the
	// index is provided by the oid...
	// We build a possibly incomplete and invalid index from
	// the OID.
	// The piece of index provided should begin at pos+2
	// oid[pos] = id of the xxxEntry object,
	// oid[pos+1] = id of the columnar object,
	// oid[pos+2] ... oid[length-1] = piece of index.
	//

	// We get the next index following the provided index.
	// If this raises an exception, then it means that we have
	// reached the last index in the table, and we must then
	// try with the next columnar object.
	//
	// Bug fix 4269251
	// The SnmpIndex is defined to contain a valid oid:
	// this is not an SNMP requirement for the getNext request.
	// So we no more use the SnmpIndex but directly the SnmpOid.
	//
	try {
	entryoid = getNextOid(oid, pos + 2, data);

	// If the variable must ne skipped, fall through...
	//
	// XXX revisit: not exactly perfect:
	// a specific row could be empty.. But we don't know
	// how to make the difference! => tradeoff holes
	// in tables can't be properly supported (all rows
	// must have the same holes)
	//
	if (skipEntryVariable(entryoid,var,data,pduVersion)) {
	throw new SnmpStatusException(SnmpStatusException.noSuchObject);
	}
	} catch(SnmpStatusException se) {
	entryoid = getNextOid(data);
	var = getNextVarEntryId(entryoid,var,data,pduVersion);
	}
	}

	return findNextAccessibleOid(entryoid,
	varbind,
	oid,
	depth,
	handlers,
	checker,
	data,
	var);
	}

	private long[] findNextAccessibleOid(SnmpOid entryoid,
	SnmpVarBind varbind,long[] oid,
	int depth, SnmpRequestTree handlers,
	AcmChecker checker, Object data,
	long var)
	throws SnmpStatusException {
	final int pduVersion = handlers.getRequestPduVersion();

	// Loop on each var (column)
	while(true) {
	// This should not happen. If it happens, (bug, or customized
	// methods returning garbage instead of raising an exception),
	// it probably means that there is nothing to return anyway.
	// So we throw the exception.
	// => will skip to next node in the MIB tree.
	//
	if (entryoid == null \|\| var == -1 ) {
	throw new SnmpStatusException(SnmpStatusException.noSuchObject);
	}

	// So here we know both the row (entryoid) and the column (var)
	//

	try {
	// Raising an exception here will make the catch() clause
	// switch to the next variable. If `var' is not readable
	// for this specific entry, it is not readable for any
	// other entry => skip to next column.
	//
	if (!isReadableEntryId(entryoid,var,data)) {
	throw new SnmpStatusException(SnmpStatusException.noSuchObject);
	}

	// Prepare the result and the ACM checker.
	//
	final long[] etable = entryoid.longValue(false);
	final int elength = etable.length;
	final long[] result = new long[depth + 2 + elength];
	result[0] = -1 ; // Bug detector!

	// Copy the entryOid at the end of `result'
	//
	java.lang.System.arraycopy(etable, 0, result,
	depth+2, elength);

	// Set the node Id and var Id in result.
	//
	result[depth] = nodeId;
	result[depth+1] = var;

	// Append nodeId.varId.<rowOid> to ACM checker.
	//
	checker.add(depth,result,depth,elength+2);

	// No we're going to ACM check our OID.
	try {
	checker.checkCurrentOid();

	// No exception thrown by checker => this is all OK!
	// we have it: register the handler and return the
	// result.
	//
	handlers.add(this,depth,entryoid,varbind,false);
	return result;
	} catch(SnmpStatusException e) {
	// Skip to the next entry. If an exception is
	// thrown, will be catch by enclosing catch
	// and a skip is done to the next var.
	//
	entryoid = getNextOid(entryoid, data);
	} finally {
	// Clean the checker.
	//
	checker.remove(depth,elength+2);
	}
	} catch(SnmpStatusException e) {
	// Catching an exception here means we have to skip to the
	// next column.
	//
	// Back to the first row.
	entryoid = getNextOid(data);

	// Find out the next column.
	//
	var = getNextVarEntryId(entryoid,var,data,pduVersion);

	}

	// This should not happen. If it happens, (bug, or customized
	// methods returning garbage instead of raising an exception),
	// it probably means that there is nothing to return anyway.
	// No need to continue, we throw an exception.
	// => will skip to next node in the MIB tree.
	//
	if (entryoid == null \|\| var == -1 ) {
	throw new SnmpStatusException(SnmpStatusException.noSuchObject);
	}
	}
	}


	/**
	* Validate the specified OID.
	*
	* <p>
	* @param oid The OID array.
	*
	* @param pos The position in the array.
	*
	* @exception SnmpStatusException If the validation fails.
	*/
	final void validateOid(long[] oid, int pos) throws SnmpStatusException {
	final int length= oid.length;

	// Control the length of the oid
	//
	if (pos +2 >= length) {
	throw new SnmpStatusException(SnmpStatusException.noSuchInstance);
	}

	// Check that the entry identifier is specified
	//
	if (oid[pos] != nodeId) {
	throw new SnmpStatusException(SnmpStatusException.noSuchObject);
	}
	}

	// ----------------------------------------------------------------------
	// PRIVATE METHODS
	// ----------------------------------------------------------------------

	/**
	* Enable this <CODE>SnmpMibTable</CODE> to send a notification.
	*
	* <p>
	* @param notification The notification to send.
	*/
	private synchronized void sendNotification(Notification notification) {

	// loop on listener
	//
	for(java.util.Enumeration<NotificationListener> k = handbackTable.keys();
	k.hasMoreElements(); ) {

	NotificationListener listener = k.nextElement();

	// Get the associated handback list and the associated filter list
	//
	java.util.Vector<?> handbackList = handbackTable.get(listener) ;
	java.util.Vector<NotificationFilter> filterList =
	filterTable.get(listener) ;

	// loop on handback
	//
	java.util.Enumeration<NotificationFilter> f = filterList.elements();
	for(java.util.Enumeration<?> h = handbackList.elements();
	h.hasMoreElements(); ) {

	Object handback = h.nextElement();
	NotificationFilter filter = f.nextElement();

	if ((filter == null) \|\|
	(filter.isNotificationEnabled(notification))) {

	listener.handleNotification(notification,handback) ;
	}
	}
	}
	}

	/**
	* This method is used by the SnmpMibTable to create and send a table
	* entry notification to all the listeners registered for this kind of
	* notification.
	*
	* <p>
	* @param type The notification type.
	*
	* @param timeStamp The notification emission date.
	*
	* @param entry The entry object.
	*/
	private void sendNotification(String type, long timeStamp,
	Object entry, ObjectName name) {

	synchronized(this) {
	sequenceNumber = sequenceNumber + 1;
	}

	SnmpTableEntryNotification notif =
	new SnmpTableEntryNotification(type, this, sequenceNumber,
	timeStamp, entry, name);

	this.sendNotification(notif) ;
	}

	/**
	* Return true if the entry identified by the given OID index
	* is contained in this table.
	* <p>
	* <b>Do not call this method directly</b>.
	* <p>
	* This method is provided has a hook for subclasses.
	* It is called when a get/set request is received in order to
	* determine whether the specified entry is contained in the table.
	* You may want to override this method if you need to perform e.g.
	* lazy evaluation of tables (you need to update the table when a
	* request is received) or if your table is virtual.
	* <p>
	* Note that this method is called by the Runtime from within a
	* synchronized block.
	*
	* @param oid The index part of the OID we're looking for.
	* @param userData A contextual object containing user-data.
	* This object is allocated through the <code>
	* {@link com.sun.jmx.snmp.agent.SnmpUserDataFactory}</code>
	* for each incoming SNMP request.
	*
	* @return <code>true</code> if the entry is found, <code>false</code>
	* otherwise.
	*
	* @since 1.5
	**/
	protected boolean contains(SnmpOid oid, Object userData) {
	return (findObject(oid) > -1);
	}

	/**
	* Look for the given oid in the OID table (tableoids) and returns
	* its position.
	*
	* <p>
	* @param oid The OID we're looking for.
	*
	* @return The position of the OID in the table. -1 if the given
	* OID was not found.
	*
	**/
	private int findObject(SnmpOid oid) {
	int low= 0;
	int max= size - 1;
	SnmpOid pos;
	int comp;
	int curr= low + (max-low)/2;
	//System.out.println("Try to retrieve: " + oid.toString());
	while (low <= max) {

	// XX pos = (SnmpOid) oids.elementAt(curr);
	pos = tableoids[curr];

	//System.out.println("Compare with" + pos.toString());
	// never know ...we might find something ...
	//
	comp = oid.compareTo(pos);
	if (comp == 0)
	return curr;

	if (oid.equals(pos) == true) {
	return curr;
	}
	if (comp > 0) {
	low = curr + 1;
	} else {
	max = curr - 1;
	}
	curr = low + (max-low)/2;
	}
	return -1;
	}

	/**
	* Search the position at which the given oid should be inserted
	* in the OID table (tableoids).
	*
	* <p>
	* @param oid The OID we would like to insert.
	*
	* @param fail Tells whether a SnmpStatusException must be generated
	* if the given OID is already present in the table.
	*
	* @return The position at which the OID should be inserted in
	* the table. When the OID is found, it returns the next
	* position. Note that it is not valid to insert twice the
	* same OID. This feature is only an optimization to improve
	* the getNextOid() behaviour.
	*
	* @exception SnmpStatusException if the OID is already present in the
	* table and <code>fail</code> is <code>true</code>.
	*
	**/
	private int getInsertionPoint(SnmpOid oid, boolean fail)
	throws SnmpStatusException {

	final int failStatus = SnmpStatusException.snmpRspNotWritable;
	int low= 0;
	int max= size - 1;
	SnmpOid pos;
	int comp;
	int curr= low + (max-low)/2;
	while (low <= max) {

	// XX pos= (SnmpOid) oids.elementAt(curr);
	pos= tableoids[curr];

	// never know ...we might find something ...
	//
	comp= oid.compareTo(pos);

	if (comp == 0) {
	if (fail)
	throw new SnmpStatusException(failStatus,curr);
	else
	return curr+1;
	}

	if (comp>0) {
	low= curr +1;
	} else {
	max= curr -1;
	}
	curr= low + (max-low)/2;
	}
	return curr;
	}

	/**
	* Remove the OID located at the given position.
	*
	* <p>
	* @param pos The position at which the OID to be removed is located.
	*
	**/
	private void removeOid(int pos) {
	if (pos >= tablecount) return;
	if (pos < 0) return;
	final int l1 = --tablecount-pos;
	tableoids[pos] = null;
	if (l1 > 0)
	java.lang.System.arraycopy(tableoids,pos+1,tableoids,pos,l1);
	tableoids[tablecount] = null;
	}

	/**
	* Insert an OID at the given position.
	*
	* <p>
	* @param oid The OID to be inserted in the table
	* @param pos The position at which the OID to be added is located.
	*
	**/
	private void insertOid(int pos, SnmpOid oid) {
	if (pos >= tablesize \|\| tablecount == tablesize) {
	// Vector must be enlarged

	// Save old vector
	final SnmpOid[] olde = tableoids;

	// Allocate larger vectors
	tablesize += Delta;
	tableoids = new SnmpOid[tablesize];

	// Check pos validity
	if (pos > tablecount) pos = tablecount;
	if (pos < 0) pos = 0;

	final int l1 = pos;
	final int l2 = tablecount - pos;

	// Copy original vector up to `pos'
	if (l1 > 0)
	java.lang.System.arraycopy(olde,0,tableoids,0,l1);

	// Copy original vector from `pos' to end, leaving
	// an empty room at `pos' in the new vector.
	if (l2 > 0)
	java.lang.System.arraycopy(olde,l1,tableoids,
	l1+1,l2);

	} else if (pos < tablecount) {
	// Vector is large enough to accommodate one additional
	// entry.
	//
	// Shift vector, making an empty room at `pos'

	java.lang.System.arraycopy(tableoids,pos,tableoids,
	pos+1,tablecount-pos);
	}

	// Fill the gap at `pos'
	tableoids[pos] = oid;
	tablecount++;
	}


	// ----------------------------------------------------------------------
	// PROTECTED VARIABLES
	// ----------------------------------------------------------------------

	/**
	* The id of the contained entry object.
	* @serial
	*/
	protected int nodeId=1;

	/**
	* The MIB to which the metadata is linked.
	* @serial
	*/
	protected SnmpMib theMib;

	/**
	* <CODE>true</CODE> if remote creation of entries via SET operations
	* is enabled.
	* [default value is <CODE>false</CODE>]
	* @serial
	*/
	protected boolean creationEnabled = false;

	/**
	* The entry factory
	*/
	protected SnmpTableEntryFactory factory = null;

	// ----------------------------------------------------------------------
	// PRIVATE VARIABLES
	// ----------------------------------------------------------------------

	/**
	* The number of elements in the table.
	* @serial
	*/
	private int size=0;

	/**
	* The list of indexes.
	* @serial
	*/
	// private Vector indexes= new Vector();

	/**
	* The list of OIDs.
	* @serial
	*/
	// private Vector oids= new Vector();
	private final static int Delta = 16;
	private int tablecount = 0;
	private int tablesize = Delta;
	private SnmpOid tableoids[] = new SnmpOid[tablesize];

	/**
	* The list of entries.
	* @serial
	*/
	private final Vector<Object> entries= new Vector<>();

	/**
	* The list of object names.
	* @serial
	*/
	private final Vector<ObjectName> entrynames= new Vector<>();

	/**
	* Callback handlers
	*/
	// final Vector callbacks = new Vector();

	/**
	* Listener hashtable containing the hand-back objects.
	*/
	private Hashtable<NotificationListener, Vector<Object>> handbackTable =
	new Hashtable<>();

	/**
	* Listener hashtable containing the filter objects.
	*/
	private Hashtable<NotificationListener, Vector<NotificationFilter>>
	filterTable = new Hashtable<>();

	// PACKAGE VARIABLES
	//------------------
	/**
	* SNMP table sequence number.
	* The default value is set to 0.
	*/
	transient long sequenceNumber = 0;
	}

Back to index...