collect.cpp
上传用户:ets1996
上传日期:2014-09-30
资源大小:353k
文件大小:8k
源码类别:

SNMP编程

开发平台:

Visual C++

  1. /*_############################################################################
  2.   _## 
  3.   _##  collect.cpp  
  4.   _##
  5.   _##  SNMP++v3.2.22
  6.   _##  -----------------------------------------------
  7.   _##  Copyright (c) 2001-2007 Jochen Katz, Frank Fock
  8.   _##
  9.   _##  This software is based on SNMP++2.6 from Hewlett Packard:
  10.   _##  
  11.   _##    Copyright (c) 1996
  12.   _##    Hewlett-Packard Company
  13.   _##  
  14.   _##  ATTENTION: USE OF THIS SOFTWARE IS SUBJECT TO THE FOLLOWING TERMS.
  15.   _##  Permission to use, copy, modify, distribute and/or sell this software 
  16.   _##  and/or its documentation is hereby granted without fee. User agrees 
  17.   _##  to display the above copyright notice and this license notice in all 
  18.   _##  copies of the software and any documentation of the software. User 
  19.   _##  agrees to assume all liability for the use of the software; 
  20.   _##  Hewlett-Packard and Jochen Katz make no representations about the 
  21.   _##  suitability of this software for any purpose. It is provided 
  22.   _##  "AS-IS" without warranty of any kind, either express or implied. User 
  23.   _##  hereby grants a royalty-free license to any and all derivatives based
  24.   _##  upon this software code base. 
  25.   _##  
  26.   _##  Stuttgart, Germany, Wed May  2 23:22:30 CEST 2007 
  27.   _##  
  28.   _##########################################################################*/
  29. /*===================================================================
  30.   Copyright (c) 1999
  31.   Hewlett-Packard Company
  32.   ATTENTION: USE OF THIS SOFTWARE IS SUBJECT TO THE FOLLOWING TERMS.
  33.   Permission to use, copy, modify, distribute and/or sell this software
  34.   and/or its documentation is hereby granted without fee. User agrees
  35.   to display the above copyright notice and this license notice in all
  36.   copies of the software and any documentation of the software. User
  37.   agrees to assume all liability for the use of the software; Hewlett-Packard
  38.   makes no representations about the suitability of this software for any
  39.   purpose. It is provided "AS-IS" without warranty of any kind,either express
  40.   or implied. User hereby grants a royalty-free license to any and all
  41.   derivatives based upon this software code base.
  42.   SNMP++ C O L L E C T . C P P
  43.   COLLECTION CLASS DEFINITION
  44.   DESIGN + AUTHOR:
  45.   Peter E Mellquist
  46.   LANGUAGE:
  47.   ANSI C++
  48.   OPERATING SYSTEMS:
  49.   Win 32
  50.   BSD UNIX
  51.   DESCRIPTION:
  52.   Simple Collection classes for SNMP++ classes.
  53. =====================================================================*/
  54. char collect_cpp_version[]="#(@) SNMP++ $Id: collect.cpp 105 2004-09-05 18:59:48Z katz $";
  55. #include "snmp_pp/collect.h"
  56. #ifdef SNMP_PP_NAMESPACE
  57. namespace Snmp_pp {
  58. #endif
  59. #ifdef _OLD_TEMPLATE_COLLECTION
  60. // create an empty collection
  61. template <class T>
  62. SnmpCollection<T>::SnmpCollection()
  63.     : count(0), data(0,0) {};
  64. // create a collection using a single template object
  65. template <class T>
  66. SnmpCollection<T>::SnmpCollection(const T &t)
  67.     : count(1), data(0, 0)
  68.   {
  69.     data.item[0] = (T*) (t.clone());
  70.   };
  71. // create a collection with another collection
  72. // copy constructor
  73. template <class T>
  74. SnmpCollection<T>::SnmpCollection( const SnmpCollection<T> &c)
  75.     : count(0), data(0, 0)
  76.   {
  77.     if (c.count == 0) return;
  78.     // load up the new collection
  79.     cBlock *current = &data;
  80.     cBlock *nextBlock;
  81.     int cn = 0;
  82.     while (count < c.count)
  83.     {
  84.       if (cn >= MAXT)
  85.       {
  86. nextBlock = new cBlock(current, 0);
  87. current->next = nextBlock;
  88. current = nextBlock;
  89. cn=0;
  90.       }
  91.       T *tmp;
  92.       c.get_element(tmp, count);
  93.       current->item[cn] = (T*) (tmp->clone());
  94.       count++;
  95.       cn++;
  96.     }
  97.   };
  98. // destroy the collection
  99. template <class T>
  100. SnmpCollection<T>::~SnmpCollection()
  101.   {
  102.     clear();  // just delete the data
  103.   };
  104. // get the size of the collection
  105. template <class T>
  106. int SnmpCollection<T>::size() const
  107.   {
  108.     return count;
  109.   };
  110. // append an item to the collection
  111. template <class T>
  112. SnmpCollection<T>& SnmpCollection<T>::operator +=( const T &i)
  113.   {
  114.     cBlock *current = &data;
  115.     int cn = (int) count % MAXT;
  116.     while (current->next)
  117.       current = current->next;
  118.     if ((count > 0) && ((count % MAXT) == 0))
  119.     {
  120.       cBlock *add = new cBlock(current, 0);
  121.       if (!add) return *this;
  122.       current->next = add;
  123.       add->item[0] = (T*) (i.clone());
  124.     }
  125.     else
  126.     {
  127.       current->item[cn] = (T*) (i.clone());
  128.     }
  129.     count++;
  130.     return *this;
  131.   };
  132. // assign one collection to another
  133. template <class T>
  134. SnmpCollection<T>& SnmpCollection<T>::operator = ( const SnmpCollection<T> &c)
  135.   {
  136.     if (this == &c) return *this;  // check for self assignment
  137.     clear(); // delete the data
  138.     if (c.count == 0) return *this;
  139.     // load up the new collection
  140.     cBlock *current = &data;
  141.     cBlock *nextBlock;
  142.     int cn = 0;
  143.     count = 0;
  144.     while (count < c.count)
  145.     {
  146.       if (cn >= MAXT)
  147.       {
  148. nextBlock = new cBlock(current, 0);
  149. current->next = nextBlock;
  150. current = nextBlock;
  151. cn=0;
  152.       }
  153.       T *tmp;
  154.       c.get_element(tmp, count);
  155.       current->item[cn] = (T*) (tmp->clone());
  156.       count++;
  157.       cn++;
  158.     }
  159.     return *this;
  160.   };
  161. // access an element in the collection
  162. template <class T>
  163. T SnmpCollection<T>::operator[](const int p) const
  164.   {
  165.     if ((p < count) && (p >= 0))
  166.     {
  167.       cBlock const *current = &data;
  168.       int bn = (int) (p / MAXT);
  169.       int cn = (int) p % MAXT;
  170.       for (int z=0; z<bn; z++)
  171. current = current->next;
  172.       return *(current->item[cn]);
  173.     }
  174.     else
  175.     {
  176.       // return an instance of nothing!!
  177.       T t;
  178.       return t;
  179.     }
  180.   };
  181. // set an element in the collection
  182. template <class T>
  183. int SnmpCollection<T>::set_element( const T& i, const int p)
  184.   {
  185.     if ((p < 0) || (p > count)) return -1; // not found!
  186.     cBlock *current = &data;
  187.     int bn = (int) p / MAXT;
  188.     int cn = (int) p % MAXT;
  189.     for (int z=0; z<bn; z++)
  190.       current = current->next;
  191.     delete current->item[cn];
  192.     current->item[cn] = (T*) (i.clone());
  193.     return 0;
  194.   };
  195. // get an element in the collection
  196. template <class T>
  197. int SnmpCollection<T>::get_element(T& t, const int p) const
  198.   {
  199.     if ((p < 0) || (p > count)) return -1; // not found!
  200.     cBlock const *current = &data;
  201.     int bn = (int) p / MAXT;
  202.     int cn = (int) p % MAXT;
  203.     for (int z=0; z<bn; z++)
  204.       current = current->next;
  205.     t = *(current->item[cn]);
  206.     return 0;
  207.   };
  208. // get a pointer to an element in the collection
  209. template <class T>
  210. int SnmpCollection<T>::get_element(T *&t, const int p) const
  211.   {
  212.     if ((p < 0) || (p > count)) return -1; // not found!
  213.     cBlock const *current = &data;
  214.     int bn = (int) p / MAXT;
  215.     int cn = (int) p % MAXT;
  216.     for (int z=0; z<bn; z++)
  217.       current = current->next;
  218.     t = current->item[cn];
  219.     return 0;
  220.   };
  221. // apply an function to the entire collection, iterator
  222. template <class T>
  223. void SnmpCollection<T>::apply( void f( T&))
  224.   {
  225.     T temp;
  226.     for ( int z=0; z<count; z++)
  227.     {
  228.       this->get_element(temp, z);
  229.       f(temp);
  230.     }
  231.   };
  232. // looks for an element in the collection
  233. // returns TRUE if found
  234. template <class T>
  235. int SnmpCollection<T>::find( const T& i,int &pos) const
  236.   {
  237.     T temp;
  238.     for (int z=0; z<count; z++)
  239.     {
  240.       this->get_element(temp, z);
  241.       if ( temp == i) {
  242. pos = z;
  243. return TRUE;
  244.       }
  245.     }
  246.     return FALSE;
  247.   };
  248. // delete an element in the collection
  249. template <class T>
  250. int SnmpCollection<T>::remove( const T& i)
  251.   {
  252.     // first see if we have it
  253.     int pos;
  254.     if (find(i, pos))
  255.     {
  256.       SnmpCollection<T> newCollection;
  257.       for (int z=0; z<count; z++)
  258.       {
  259. if (z != pos)
  260. {
  261.   T item;
  262.   get_element(item, z);
  263.   newCollection += item;
  264. }
  265.       }
  266.       // assign new collection to 'this'
  267.       operator =(newCollection);
  268.       return TRUE;
  269.     }
  270.     return FALSE;   // not found thus not removed
  271.   };
  272. // delete all elements within the collection
  273. template <class T>
  274. void SnmpCollection<T>::clear()
  275.   {
  276.     if (count == 0) return;
  277.     cBlock *current = &data;
  278.     int z=0;
  279.     int cn=0;
  280.     while ( z< count)
  281.     {
  282.       if (cn >= MAXT)
  283.       {
  284. cn =0;
  285. current = current->next;
  286.       }
  287.       delete current->item[cn];
  288.       cn++;
  289.       z++;
  290.     }
  291.     // delete the blocks
  292.     while (current->next)
  293.       current = current->next;
  294.     while (current->prev)
  295.     {
  296.       current = current->prev;
  297.       delete current->next;
  298.     }
  299.     count = 0;
  300.     data.next=0;
  301.     data.prev=0;
  302.   };
  303. #endif  // _OLD_TEMPLATE_COLLECTION
  304. #ifdef SNMP_PP_NAMESPACE
  305. }; // end of namespace Snmp_pp
  306. #endif