--- trunk/OOPSE-3.0/src/brains/DataStorage.cpp	2005/02/13 21:18:27	2015
+++ trunk/OOPSE-3.0/src/brains/DataStorage.cpp	2005/04/15 22:04:00	2204
@@ -1,4 +1,4 @@
- /*
+/*
  * Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
  *
  * The University of Notre Dame grants you ("Licensee") a
@@ -39,280 +39,280 @@
  * such damages.
  */
  
- /**
-  * @file DataStorage.cpp
-  * @author tlin
-  * @date 10/26/2004
-  * @time 11:56am
-  * @version 1.0
-  */
+/**
+ * @file DataStorage.cpp
+ * @author tlin
+ * @date 10/26/2004
+ * @time 11:56am
+ * @version 1.0
+ */
 
 #include "brains/DataStorage.hpp"
 
 namespace oopse {
 
-DataStorage::DataStorage() : size_(0), storageLayout_(0){
+  DataStorage::DataStorage() : size_(0), storageLayout_(0){
 
-}
+  }
 
-DataStorage::DataStorage(int size, int storageLayout) : size_(size){
+  DataStorage::DataStorage(int size, int storageLayout) : size_(size){
     setStorageLayout(storageLayout);
     resize(size);
-}
+  }
 
-int DataStorage::getSize() {
+  int DataStorage::getSize() {
 
     if (storageLayout_ & dslPosition && position.size() != size_) {
-        //error
-        std::cerr << "size does not match"<< std::endl;
+      //error
+      std::cerr << "size does not match"<< std::endl;
     }
 
     if (storageLayout_ & dslVelocity && velocity.size() != size_) {
-        //error
-        std::cerr << "size does not match"<< std::endl;        
+      //error
+      std::cerr << "size does not match"<< std::endl;        
     }
 
     if (storageLayout_ & dslAmat && aMat.size() != size_) {
-        //error
-        std::cerr << "size does not match"<< std::endl;        
+      //error
+      std::cerr << "size does not match"<< std::endl;        
     }
 
     if (storageLayout_ & dslAngularMomentum && angularMomentum.size() != size_) {
-        //error
-        std::cerr << "size does not match"<< std::endl;        
+      //error
+      std::cerr << "size does not match"<< std::endl;        
     }
 
     if (storageLayout_ & dslElectroFrame && electroFrame.size() != size_) {
-        //error
-        std::cerr << "size does not match"<< std::endl;        
+      //error
+      std::cerr << "size does not match"<< std::endl;        
     }
 
     if (storageLayout_ & dslZAngle && zAngle.size() != size_) {
-        //error
-        std::cerr << "size does not match"<< std::endl;        
+      //error
+      std::cerr << "size does not match"<< std::endl;        
     }
 
     if (storageLayout_ & dslForce && force.size() != size_) {
-        //error
-        std::cerr << "size does not match"<< std::endl;        
+      //error
+      std::cerr << "size does not match"<< std::endl;        
     }
 
     if (storageLayout_ & dslTorque && torque.size() != size_) {
-        //error
-        std::cerr << "size does not match"<< std::endl;        
+      //error
+      std::cerr << "size does not match"<< std::endl;        
     }
 
     return size_;
 
-}
+  }
 
-void DataStorage::resize(int newSize) {
+  void DataStorage::resize(int newSize) {
 
     if (storageLayout_ & dslPosition) {
-        internalResize(position, newSize);
+      internalResize(position, newSize);
     }
 
     if (storageLayout_ & dslVelocity) {
-        internalResize(velocity, newSize);
+      internalResize(velocity, newSize);
     }
 
     if (storageLayout_ & dslAmat) {
-        internalResize(aMat, newSize);
+      internalResize(aMat, newSize);
     }
 
     if (storageLayout_ & dslAngularMomentum) {
-        internalResize(angularMomentum, newSize);
+      internalResize(angularMomentum, newSize);
     }
 
     if (storageLayout_ & dslElectroFrame) {
-        internalResize(electroFrame, newSize);
+      internalResize(electroFrame, newSize);
     }
     
     if (storageLayout_ & dslZAngle) {
-        internalResize(zAngle, newSize);
+      internalResize(zAngle, newSize);
     }
 
     if (storageLayout_ & dslForce) {
-        internalResize(force, newSize);
+      internalResize(force, newSize);
     }
 
     if (storageLayout_ & dslTorque) {
-        internalResize(torque, newSize);
+      internalResize(torque, newSize);
     }
 
     size_ = newSize;
-}
+  }
 
-void DataStorage::reserve(int size) {
+  void DataStorage::reserve(int size) {
     if (storageLayout_ & dslPosition) {
-        position.reserve(size);
+      position.reserve(size);
     } 
 
     if (storageLayout_ & dslVelocity) {
-        velocity.reserve(size);
+      velocity.reserve(size);
     } 
 
     if (storageLayout_ & dslAmat) {
-        aMat.reserve(size);
+      aMat.reserve(size);
     } 
 
     if (storageLayout_ & dslAngularMomentum) {
-        angularMomentum.reserve(size);
+      angularMomentum.reserve(size);
     } 
 
     if (storageLayout_ & dslElectroFrame) {
-        electroFrame.reserve(size);
+      electroFrame.reserve(size);
     }
     
     if (storageLayout_ & dslZAngle) {
-        zAngle.reserve(size);
+      zAngle.reserve(size);
     }
 
     if (storageLayout_ & dslForce) {
-        force.reserve(size);
+      force.reserve(size);
     } 
 
     if (storageLayout_ & dslTorque) {
-        torque.reserve(size);
+      torque.reserve(size);
     }
 
-}
+  }
 
-void DataStorage::copy(int source, int num, int target) {
+  void DataStorage::copy(int source, int num, int target) {
     if (num + target > size_ ) {
-        //error
+      //error
     }
     
     if (storageLayout_ & dslPosition) {
-        internalCopy(position, source, num, target);
+      internalCopy(position, source, num, target);
     } 
 
     if (storageLayout_ & dslVelocity) {
-        internalCopy(velocity, source, num, target);
-  } 
+      internalCopy(velocity, source, num, target);
+    } 
 
     if (storageLayout_ & dslAmat) {
-        internalCopy(aMat, source, num, target);
-   } 
+      internalCopy(aMat, source, num, target);
+    } 
 
     if (storageLayout_ & dslAngularMomentum) {
-        internalCopy(angularMomentum, source, num, target);
+      internalCopy(angularMomentum, source, num, target);
     } 
 
     if (storageLayout_ & dslElectroFrame) {
-        internalCopy(electroFrame, source, num, target);
+      internalCopy(electroFrame, source, num, target);
     }
     
     if (storageLayout_ & dslZAngle) {
-        internalCopy(zAngle, source, num, target);
+      internalCopy(zAngle, source, num, target);
     }
 
     if (storageLayout_ & dslForce) {
-        internalCopy(force, source, num, target);
+      internalCopy(force, source, num, target);
     } 
 
     if (storageLayout_ & dslTorque) {
-        internalCopy(torque, source, num, target); 
+      internalCopy(torque, source, num, target); 
     }
     
 
-}
+  }
 
-int DataStorage::getStorageLayout() {
+  int DataStorage::getStorageLayout() {
     return storageLayout_;
-}
+  }
 
-void DataStorage::setStorageLayout(int layout) {
+  void DataStorage::setStorageLayout(int layout) {
     storageLayout_ = layout;
     resize(size_);
-}
+  }
 
-double* DataStorage::getArrayPointer(int whichArray) {
+  double* DataStorage::getArrayPointer(int whichArray) {
 
     switch (whichArray) {
-        case dslPosition:
-            return internalGetArrayPointer(position);
-            break;
+    case dslPosition:
+      return internalGetArrayPointer(position);
+      break;
             
-        case dslVelocity:
-            return internalGetArrayPointer(velocity);
-            break;
+    case dslVelocity:
+      return internalGetArrayPointer(velocity);
+      break;
             
-        case dslAmat:
-            return internalGetArrayPointer(aMat);
-            break;            
-            
-        case dslAngularMomentum:
-            return internalGetArrayPointer(angularMomentum);
-            break;
+    case dslAmat:
+      return internalGetArrayPointer(aMat);
+      break;            
             
-        case dslElectroFrame:
-            return internalGetArrayPointer(electroFrame);
-            break;
+    case dslAngularMomentum:
+      return internalGetArrayPointer(angularMomentum);
+      break;
             
-        case dslZAngle:
-            return internalGetArrayPointer(zAngle);
-            break;
+    case dslElectroFrame:
+      return internalGetArrayPointer(electroFrame);
+      break;
+            
+    case dslZAngle:
+      return internalGetArrayPointer(zAngle);
+      break;
 
-        case dslForce:
-            return internalGetArrayPointer(force);
-            break;            
+    case dslForce:
+      return internalGetArrayPointer(force);
+      break;            
 
-        case dslTorque:
-            return internalGetArrayPointer(torque);
-            break;  
+    case dslTorque:
+      return internalGetArrayPointer(torque);
+      break;  
             
-        default:
-            //error message
-            return NULL;
+    default:
+      //error message
+      return NULL;
 
     }
-}    
+  }    
 
-double* DataStorage::internalGetArrayPointer(std::vector<Vector3d>& v) {
+  double* DataStorage::internalGetArrayPointer(std::vector<Vector3d>& v) {
     if (v.size() == 0) {
-        return NULL;
+      return NULL;
     } else {
-        return v[0].getArrayPointer();
+      return v[0].getArrayPointer();
     }
-}
+  }
 
-double* DataStorage::internalGetArrayPointer(std::vector<RotMat3x3d>& v) {
+  double* DataStorage::internalGetArrayPointer(std::vector<RotMat3x3d>& v) {
     if (v.size() == 0) {
-        return NULL;
+      return NULL;
     } else {
-        return v[0].getArrayPointer();
+      return v[0].getArrayPointer();
     }
 
-}
+  }
 
-double* DataStorage::internalGetArrayPointer(std::vector<double>& v) {
+  double* DataStorage::internalGetArrayPointer(std::vector<double>& v) {
     if (v.size() == 0) {
-        return NULL;
+      return NULL;
     } else {
-        return &(v[0]);
+      return &(v[0]);
     }
 
-}    
+  }    
 
-template<typename T>
-void DataStorage::internalResize(std::vector<T>& v, int newSize){
+  template<typename T>
+  void DataStorage::internalResize(std::vector<T>& v, int newSize){
     int oldSize = v.size();
 
     if (oldSize == newSize) {
-        return;
+      return;
     } else if (oldSize < newSize) {
-        v.insert(v.end(), newSize-oldSize, T());
+      v.insert(v.end(), newSize-oldSize, T());
     } else {
-        typename std::vector<T>::iterator i;
-        i = v.begin();
-        std::advance(i, newSize);        
-        v.erase(i, v.end());
+      typename std::vector<T>::iterator i;
+      i = v.begin();
+      std::advance(i, newSize);        
+      v.erase(i, v.end());
     }
-}
+  }
 
-template<typename T>
-void DataStorage::internalCopy(std::vector<T>& v, int source,  int num, int target) {
+  template<typename T>
+  void DataStorage::internalCopy(std::vector<T>& v, int source,  int num, int target) {
     typename std::vector<T>::iterator first;
     typename std::vector<T>::iterator last;
     typename std::vector<T>::iterator result;
@@ -327,35 +327,35 @@ void DataStorage::internalCopy(std::vector<T>& v, int 
     std::advance(result, target );
 
     std::copy(first, last, result);
-}
+  }
 
-int DataStorage::getBytesPerStuntDouble(int layout) {
+  int DataStorage::getBytesPerStuntDouble(int layout) {
     int bytes = 0;
     if (layout & dslPosition) {
-        bytes += sizeof(Vector3d);
+      bytes += sizeof(Vector3d);
     }
     if (layout & dslVelocity) {
-        bytes += sizeof(Vector3d);
+      bytes += sizeof(Vector3d);
     }
     if (layout & dslAmat) {
-        bytes += sizeof(Mat3x3d);    
+      bytes += sizeof(Mat3x3d);    
     }
     if (layout & dslAngularMomentum) {
-        bytes += sizeof(Vector3d);
+      bytes += sizeof(Vector3d);
     }
     if (layout & dslElectroFrame) {
-        bytes += sizeof(Mat3x3d);
+      bytes += sizeof(Mat3x3d);
     }
     if (layout & dslZAngle) {
-        bytes += sizeof(Vector3d);
+      bytes += sizeof(Vector3d);
     }
     if (layout & dslForce) {
-        bytes += sizeof(Vector3d);
+      bytes += sizeof(Vector3d);
     }
     if (layout & dslTorque) {
-        bytes += sizeof(Vector3d);
+      bytes += sizeof(Vector3d);
     }
     return bytes;
-}
+  }
 
 }