jot: net_types.H Source File

00001 /* Copyright 1995, Brown Computer Graphics Group.  All Rights Reserved. */
00002 
00003 /* -------------------------------------------------------------------------
00004  *
00005  *                <     File description here    >
00006  *
00007  * ------------------------------------------------------------------------- */
00008 
00009 #ifndef NET_TYPES_HAS_BEEN_INCLUDED
00010 #define NET_TYPES_HAS_BEEN_INCLUDED
00011 
00012 #include "std/support.H"
00013 #include "mlib/points.H"
00014 #include "mlib/point2i.H"
00015 #include "mlib/point3i.H"
00016 #include "stream.H"
00017 #include "net.H"
00018 
00019 STDdstream & operator >> (STDdstream &,  HASH          &);
00020 STDdstream & operator << (STDdstream &, CHASH          &);
00021 
00022 template <class V>
00023 inline STDdstream &operator<<(STDdstream &ds, const mlib::Vec2<V> &v) 
00024        { if (ds.ascii()) ds << "{" << v[0] << v[1] << "}";
00025          else ds << v[0] << v[1];
00026          return ds; }
00027 
00028 template <class V>
00029 inline STDdstream &operator>>(STDdstream &ds, mlib::Vec2<V> &v) 
00030        { if (ds.ascii()) {char brace; ds >> brace >> v[0] >> v[1] >> brace;}
00031          else ds >> v[0] >> v[1];
00032          return ds; }
00033 
00034 template <class V>
00035 inline STDdstream &operator<<(STDdstream &ds, const mlib::Vec3<V> &v)
00036        { if (ds.ascii()) ds <<"{"<< v[0] << v[1] << v[2]<<"}";
00037          else ds << v[0] << v[1] << v[2];
00038          return ds; }
00039 
00040 template <class V>
00041 inline STDdstream &operator>>(STDdstream &ds, mlib::Vec3<V> &v)
00042        { if (ds.ascii()) { char brace; 
00043               ds >> brace >> v[0] >> v[1] >> v[2] >> brace; }
00044          else ds >> v[0] >> v[1] >> v[2];
00045          return ds;}
00046 
00047 template <class P, class V>
00048 inline STDdstream &operator<<(STDdstream &ds, const mlib::Point3<P,V> &v) 
00049        { if (ds.ascii()) ds << "{" << v[0]<< v[1]<< v[2]<<"}";
00050          else ds << v[0] << v[1] << v[2];
00051          return ds; }
00052 
00053 template <class P, class V>
00054 inline STDdstream &operator>>(STDdstream &ds, mlib::Point3<P,V> &v) 
00055        { if (ds.ascii()) { char brace;
00056               ds >> brace >> v[0] >> v[1] >> v[2] >> brace;}
00057          else ds >> v[0] >> v[1] >> v[2];
00058          return ds;}
00059 
00060 inline STDdstream &operator<<(STDdstream &ds, const mlib::Point3i  &v) 
00061        { if (ds.ascii()) ds << "{" << v[0]<< v[1]<< v[2]<<"}";
00062          else ds << v[0] << v[1] << v[2];
00063          return ds; }
00064 
00065 inline STDdstream &operator>>(STDdstream &ds, mlib::Point3i &v) 
00066        { if (ds.ascii()) { char brace;
00067               ds >> brace >> v[0] >> v[1] >> v[2] >> brace;}
00068          else ds >> v[0] >> v[1] >> v[2];
00069          return ds;}
00070 
00071 
00072 inline STDdstream &operator<<(STDdstream &ds, const mlib::Point2i  &v) 
00073        { if (ds.ascii()) ds << "{" << v[0]<< v[1]<<"}";
00074          else ds << v[0] << v[1];
00075          return ds; }
00076 
00077 inline STDdstream &operator>>(STDdstream &ds, mlib::Point2i &v) 
00078        { if (ds.ascii()) { char brace;
00079               ds >> brace >> v[0] >> v[1] >> brace;}
00080          else ds >> v[0] >> v[1];
00081          return ds;}
00082 
00083 inline STDdstream &operator<<(STDdstream &ds, const bool &b) 
00084       { int val = (b)?(1):(0);
00085          if (ds.ascii()) ds << "{" << val << "}";
00086          else ds << val;
00087          return ds; }
00088 
00089 inline STDdstream &operator>>(STDdstream &ds, bool &b) 
00090        { int val;
00091          if (ds.ascii()) { char brace;
00092               ds >> brace >> val >> brace;}
00093          else ds >> val;
00094          b = (val==1)?(true):(false);
00095          return ds;}
00096 
00097 
00098 template <class P, class V>
00099 inline STDdstream &operator<<(STDdstream &ds, const mlib::Point2<P,V> &v) 
00100        { if (ds.ascii()) ds << "{" << v[0] << v[1] << "}";
00101          else ds << v[0] << v[1];
00102          return ds; }
00103 
00104 template <class P, class V>
00105 inline STDdstream &operator>>(STDdstream &ds, mlib::Point2<P,V> &v) 
00106        { if (ds.ascii()) { char brace; ds >> brace >>v[0] >> v[1] >> brace;}
00107          else ds >> v[0] >> v[1];
00108          return ds; }
00109 
00110 
00111 
00112 
00113 template <class L, class P, class V>
00114 inline STDdstream &operator>>(STDdstream &ds, mlib::Line<L,P,V> &l)
00115        { return ds >> l.point() >> l.vector(); }
00116  
00117 template <class L, class P, class V>
00118 inline STDdstream &operator<<(STDdstream &ds, const mlib::Line<L,P,V> &l)
00119        { return ds << l.point() << l.vector(); }
00120 
00121 template <class M, class P, class V, class L, class Q>
00122 inline STDdstream &operator>>(STDdstream &ds,  mlib::Mat4<M,P,V,L,Q> &mat)
00123        { if (ds.ascii()) {
00124             char brace;
00125             ds >> brace;
00126             for (int i=0; i < 4; i++)  {
00127                  ds >> brace;
00128                  for (int j=0; j < 4; j++)
00129                     ds >> mat(i,j);
00130                  ds >> brace;
00131             }
00132             ds >> brace;
00133          } else 
00134              for (int i=0; i < 4; i++) for (int j=0; j < 4; j++) ds >> mat(i,j);
00135          return ds; }
00136 
00137 template <class M, class P, class V, class L, class Q>
00138 inline STDdstream &operator<<(STDdstream &ds, const mlib::Mat4<M,P,V,L,Q> &mat)
00139      { if (ds.ascii()) {
00140           ds << "{";
00141           for (int i=0; i < 4; i++) {
00142               ds << "{";
00143               for (int j=0; j < 4; j++) 
00144                   ds << mat(i,j);
00145               ds << "}";
00146           }
00147           ds << "}";
00148        } else 
00149           for (int i=0; i < 4; i++) for (int j=0; j < 4; j++) ds << mat(i,j);
00150        return ds; }
00151         
00152 template <class Q, class M, class P, class V, class L>
00153 inline STDdstream  &operator<<(STDdstream &ds, const mlib::Quat<Q,M,P,V,L> &quat)
00154                                   { return ds << quat.v() << quat.w(); }
00155 
00156 template <class Q, class M, class P, class V, class L>
00157 inline STDdstream &operator>>(STDdstream &ds, mlib::Quat<Q,M,P,V,L> &quat)
00158                                   { return ds >> quat.v() >> quat.w(); }
00159 
00160 template <class PLANE, class P, class V, class L>
00161 inline STDdstream  &operator<<(STDdstream &ds, const mlib::Plane<PLANE,P,V,L> &plane)
00162      { if (ds.ascii()) 
00163             return ds << "{" << plane.normal() << plane.d()<< "}"; 
00164        else return ds << plane.normal() << plane.d(); }
00165 
00166 template <class PLANE, class P, class V, class L>
00167 inline STDdstream &operator>>(STDdstream &ds, mlib::Plane<PLANE,P,V,L> &plane)
00168      { if (ds.ascii()) { char brace; 
00169             return ds >> brace >> plane.normal() >> plane.d() >> brace; }
00170        else return ds >> plane.normal() >> plane.d(); }
00171 
00172 template <class T>
00173 inline STDdstream  &operator<<(STDdstream &ds, const ARRAY<T> &list) {
00174    if (ds.ascii())
00175       ds << "{";
00176    else
00177       ds << list.num();
00178    for (int i=0; i<list.num();i++) {
00179       ds << list[i];
00180    }
00181    if (ds.ascii())
00182       ds << "}"; 
00183    return ds; 
00184 }
00185 
00186 template <class T>
00187 inline STDdstream &operator>>(STDdstream &ds, ARRAY<T> &list) {
00188    if (ds.ascii()) { 
00189       char brace; ds >> brace;  
00190       while (ds.check()) {
00191          // Declare 'var' inside this loop (not outside) in case it is
00192          // an ARRAY type. Since the list is not being cleared before
00193          // we read from the stream, we want it to start out empty
00194          // each time thru this loop.
00195          T var; 
00196          ds >> var;
00197          list.add(var);
00198       } 
00199       return ds >> brace; 
00200    } else {
00201       int num;  ds >> num;
00202       for (int i = 0; i < num; i++) {
00203          T var;         // See comment above.
00204          ds >> var;
00205          list.add(var);
00206       } 
00207       return ds;
00208    } 
00209 }
00210 
00211 // XXX - should move to mlib Point2.H and Vec2.H
00212 template <class P, class V>
00213 inline istream&
00214 operator>>(istream &is, mlib::Point2<P,V> &v) {
00215    char foo;
00216    return is >> foo >> v[0] >> v[1] >> foo;
00217 }
00218 
00219 template <class V>
00220 inline istream &
00221 operator>>(istream &is, mlib::Vec2<V> &v) 
00222 { 
00223    char dummy;
00224    return is >> dummy >> v[0] >> dummy >> v[1] >> dummy;
00225 }
00226 
00227 
00228 #endif  /* NETWORK_HAS_BEEN_INCLUDED */