www.pudn.com > javasnmpv3.rar > collect1.h
/*_############################################################################
_##
_## collect1.h
_##
_## SNMP++v3.2.22
_## -----------------------------------------------
_## Copyright (c) 2001-2007 Jochen Katz, Frank Fock
_##
_## This software is based on SNMP++2.6 from Hewlett Packard:
_##
_## Copyright (c) 1996
_## Hewlett-Packard Company
_##
_## ATTENTION: USE OF THIS SOFTWARE IS SUBJECT TO THE FOLLOWING TERMS.
_## Permission to use, copy, modify, distribute and/or sell this software
_## and/or its documentation is hereby granted without fee. User agrees
_## to display the above copyright notice and this license notice in all
_## copies of the software and any documentation of the software. User
_## agrees to assume all liability for the use of the software;
_## Hewlett-Packard and Jochen Katz make no representations about the
_## suitability of this software for any purpose. It is provided
_## "AS-IS" without warranty of any kind, either express or implied. User
_## hereby grants a royalty-free license to any and all derivatives based
_## upon this software code base.
_##
_## Stuttgart, Germany, Wed May 2 23:22:30 CEST 2007
_##
_##########################################################################*/
// $Id: collect1.h 287 2007-03-22 22:37:09Z katz $
#ifdef SNMP_PP_NAMESPACE
namespace Snmp_pp {
#endif
template class SnmpCollection
{
class cBlock
{
public:
cBlock(cBlock *p, cBlock *n) : prev(p), next(n) {};
T *item[MAXT];
cBlock *prev;
cBlock *next;
};
public:
/**
* Create an empty collection.
*/
SnmpCollection()
: count(0), data(0,0) {};
/**
* Create a collection using a single template object.
*/
SnmpCollection(const T &t)
: count(1), data(0, 0)
{
data.item[0] = (T*) (t.clone());
};
/**
* Create a collection with another collection (copy constructor).
*/
SnmpCollection(const SnmpCollection &c)
: count(0), data(0, 0)
{
if (c.count == 0) return;
// load up the new collection
cBlock *current = &data;
cBlock *nextBlock;
int cn = 0;
while (count < c.count)
{
if (cn >= MAXT)
{
nextBlock = new cBlock(current, 0);
current->next = nextBlock;
current = nextBlock;
cn=0;
}
T *tmp;
c.get_element(tmp, count);
current->item[cn] = (T*) (tmp->clone());
count++;
cn++;
}
};
/**
* Destroy the collection.
*/
~SnmpCollection()
{
clear(); // just delete the data
};
/**
* Get the size of the collection.
*/
int size() const
{
return count;
};
/**
* Append an item to the collection.
*/
SnmpCollection& operator +=(const T &i)
{
cBlock *current = &data;
int cn = (int) count % MAXT;
while (current->next)
current = current->next;
if ((count > 0) && ((count % MAXT) == 0))
{
cBlock *add = new cBlock(current, 0);
if (!add) return *this;
current->next = add;
add->item[0] = (T*) (i.clone());
}
else
{
current->item[cn] = (T*) (i.clone());
}
count++;
return *this;
};
/**
* Assign one collection to another.
*/
SnmpCollection &operator =(const SnmpCollection &c)
{
if (this == &c) return *this; // check for self assignment
clear(); // delete the data
if (c.count == 0) return *this;
// load up the new collection
cBlock *current = &data;
cBlock *nextBlock;
int cn = 0;
count = 0;
while (count < c.count)
{
if (cn >= MAXT)
{
nextBlock = new cBlock(current, 0);
current->next = nextBlock;
current = nextBlock;
cn=0;
}
T *tmp;
c.get_element(tmp, count);
current->item[cn] = (T*) (tmp->clone());
count++;
cn++;
}
return *this;
};
/**
* Access an element in the collection.
*
* @return The requestet element or an empty element if out of bounds.
*/
T operator[](const int p) const
{
if ((p < count) && (p >= 0))
{
cBlock const *current = &data;
int bn = (int) (p / MAXT);
int cn = (int) p % MAXT;
for (int z=0; znext;
return *(current->item[cn]);
}
else
{
// return an instance of nothing!!
T t;
return t;
}
};
/**
* Set an element in the collection.
*
* @return 0 on success and -1 on failure.
*/
int set_element( const T& i, const int p)
{
if ((p < 0) || (p > count)) return -1; // not found!
cBlock *current = &data;
int bn = (int) p / MAXT;
int cn = (int) p % MAXT;
for (int z=0; znext;
delete current->item[cn];
current->item[cn] = (T*) (i.clone());
return 0;
};
/**
* Get an element in the collection.
*
* @return 0 on success and -1 on failure.
*/
int get_element(T &t, const int p) const
{
if ((p < 0) || (p > count)) return -1; // not found!
cBlock const *current = &data;
int bn = (int) p / MAXT;
int cn = (int) p % MAXT;
for (int z=0; znext;
t = *(current->item[cn]);
return 0;
};
/**
* Get a pointer to an element in the collection.
*
* @return 0 on success and -1 on failure.
*/
int get_element(T *&t, const int p) const
{
if ((p < 0) || (p > count)) return -1; // not found!
cBlock const *current = &data;
int bn = (int) p / MAXT;
int cn = (int) p % MAXT;
for (int z=0; znext;
t = current->item[cn];
return 0;
};
/**
* Apply an function to the entire collection, iterator.
*/
void apply(void f(T&))
{
T temp;
for ( int z=0; zget_element(temp, z);
f(temp);
}
};
/**
* Looks for an element in the collection.
*
* @return TRUE if found.
*/
int find(const T& i, int &pos) const
{
T temp;
for (int z=0; zget_element(temp, z);
if ( temp == i) {
pos = z;
return TRUE;
}
}
return FALSE;
};
/**
* Delete an element in the collection.
*/
int remove(const T& i)
{
// first see if we have it
int pos;
if (find(i, pos))
{
SnmpCollection newCollection;
for (int z=0; z= MAXT)
{
cn =0;
current = current->next;
}
delete current->item[cn];
cn++;
z++;
}
// delete the blocks
while (current->next)
current = current->next;
while (current->prev)
{
current = current->prev;
delete current->next;
}
count = 0;
data.next=0;
data.prev=0;
};
private:
int count;
cBlock data;
};
#ifdef SNMP_PP_NAMESPACE
} // end of namespace Snmp_pp
#endif