stlstream.hpp

模糊聚類分析源碼。包含教學文件

/*
  
  Context       : Basic Utility Files

  Author        : Frank Hoeppner, see also AUTHORS file 

  Description   : header of function module stlstream
                  Source Documentation Handbook: tutorial-UTIL
  History       : see source file

  Comment       : 
    This file was generated automatically. DO NOT EDIT.

  Copyright     : Copyright (C) 1999-2000 Frank Hoeppner

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#ifndef stlstream_HEADER
#define stlstream_HEADER

/* configuration include */
#ifdef HAVE_CONFIG_H
/*
//FILETREE_IFDEF HAVE_CONFIG_H
*/
#include "config.h"
/*
//FILETREE_ENDIF
*/
#endif



/* necessary includes */
#include <list.h>
#include <vector.h>
#include <set.h>
#include <map.h>
#include <multimap.h>
#include <multiset.h>
//#define INLINE inline

/* global types and constants */

extern const char KEYWORD_STL_START[];
extern const char KEYWORD_STL_INTER[];
extern const char KEYWORD_STL_FINAL[];

/* data interface */


/* STLStream interface */
template <class CONTAINER> inline
  void write(ostream&,const CONTAINER&);
template <class CONTAINER> inline
  void write_dereference(ostream&,const CONTAINER&);

/* inline implementation */

template <class T1, class T2> inline
ostream& operator<<(ostream& os, const pair<T1,T2>& a_pair)
  { return os << "(" << a_pair.first << "," << a_pair.second << ")"; }
template <class T1, class T2> inline
istream& operator>>(istream& is, pair<T1,T2>& a_pair)
  { 
  read_until(is,"(");
  is >> a_pair.first;
  read_until(is,",");
  is >> a_pair.second;
  read_until(is,")"); 
  return is;
  }
template <class ITERATOR> inline
ostream& 
stl_container_output
  (
  ostream& os,
  const ITERATOR& a_container_begin,
  const ITERATOR& a_container_end,
  const char * const a_start = KEYWORD_STL_START,
  const char * const a_inter = KEYWORD_STL_INTER,
  const char * const a_final = KEYWORD_STL_FINAL 
  )
  {
  os << a_start;
  ITERATOR i;
  for (i=a_container_begin;i!=a_container_end;++i)
    {
    os << a_inter << (*i);
    }
  os << " " << a_final;
  return os;
  }
template <class CONTAINER> inline
ostream& 
stl_container_output
  (
  ostream& os,
  const CONTAINER& a_container,
  const char * const a_start = KEYWORD_STL_START,
  const char * const a_inter = KEYWORD_STL_INTER,
  const char * const a_final = KEYWORD_STL_FINAL 
  )
  {
  return stl_container_output(os,a_container.begin(),a_container.end(),
    a_start,a_inter,a_final);
  }
template <class CONTAINER> inline
istream& 
stl_container_input
  (
  istream& is,
  CONTAINER& a_container,
  const char * const a_start = KEYWORD_STL_START,
  const char * const a_inter = KEYWORD_STL_INTER,
  const char * const a_final = KEYWORD_STL_FINAL 
  )
  {
  read_until(is,a_start);
  while (!is_followed_by(is,a_final,false)) 
    {
    typename CONTAINER::value_type element;
    is >> element;
    a_container.insert(a_container.end(),element);
    is_followed_by(is,a_inter,false); // remove if found
    }
  return is;
  }

template <class T> inline
ostream& operator<<(ostream& os, const list<T>& a_list)
  { return stl_container_output(os,a_list); }

template <class T> inline
istream& operator>>(istream& is, list<T>& a_list)
  { return stl_container_input(is,a_list); }

template <class T> inline
ostream& operator<<(ostream& os, const vector<T>& a_vector)
  { return stl_container_output(os,a_vector); }

template <class T> inline
istream& operator>>(istream& is, vector<T>& a_vector)
  { return stl_container_input(is,a_vector); }

template <class T1,class T2> inline
ostream& operator<<(ostream& os, const set<T1,T2>& a_set)
  { return stl_container_output(os,a_set); }

template <class T1,class T2> inline
istream& operator>>(istream& is, set<T1,T2>& a_set)
  { return stl_container_input(is,a_set); }

template <class T1,class T2> inline
ostream& operator<<(ostream& os, const multiset<T1,T2>& a_set)
  { return stl_container_output(os,a_set); }

template <class T1,class T2> inline
istream& operator>>(istream& is, multiset<T1,T2>& a_set)
  { return stl_container_input(is,a_set); }

template <class T1,class T2,class T3> inline
ostream& operator<<(ostream& os, const map<T1,T2,T3>& a_map)
  { return stl_container_output(os,a_map); }

template <class T1,class T2,class T3> inline
istream& operator>>(istream& is, map<T1,T2,T3>& a_map)
  { return stl_container_input(is,a_map); }

template <class T1,class T2,class T3> inline
ostream& operator<<(ostream& os, const multimap<T1,T2,T3>& a_map)
  { return stl_container_output(os,a_map); }

template <class T1,class T2,class T3> inline
istream& operator<<(istream& is, multimap<T1,T2,T3>& a_map)
  { return stl_container_input(is,a_map); }

template <class CONTAINER> inline
void write(ostream& os,const CONTAINER& a_container)
  {
  os << "{";
  typename CONTAINER::const_iterator i;
  for (i=a_container.begin();i!=a_container.end();++i)
    {
    os << " ";
    (*i).write(os);
    }
  os << " }";
  }

template <class CONTAINER> inline
void write_dereference(ostream& os,const CONTAINER& a_container)
  {
  os << "{";
  typename CONTAINER::const_iterator i;
  for (i=a_container.begin();i!=a_container.end();++i)
    {
    os << " ";
    (*i)->write(os);
    }
  os << " }";
  }



#endif /* stlstream_HEADER */