vtkStateStorage.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
 
  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
 
     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.
 
=========================================================================*/
#ifndef vtkStateStorage_h
#define vtkStateStorage_h
 
#include <algorithm>
#include <string>
#include <vector>
 
// uncomment the following line to add in state debugging information
//#define USE_STATE_DEBUGGING 1
#ifdef USE_STATE_DEBUGGING
 
class vtkStateStorage
{
public:
  vtkStateStorage() {}
 
  // clear the storage
  void Clear()
  {
    this->Storage.clear();
    this->StorageOffsets.clear();
    this->StorageNames.clear();
  }
 
  // append a data item to the state
  template <class T>
  void Append(const T& value, const char* name);
 
  bool operator!=(const vtkStateStorage& b) const
  {
    // for debug we also lookup the name of what was different
    this->WhatWasDifferent = "";
    if (this->Storage.size() != b.Storage.size())
    {
      this->WhatWasDifferent = "Different state sizes";
      return true;
    }
    for (size_t i = 0; i < this->Storage.size(); ++i)
    {
      if (this->Storage[i] != b.Storage[i])
      {
        size_t block = 0;
        while (this->StorageOffsets.size() > block + 1 && this->StorageOffsets[block + 1] >= i)
        {
          block++;
        }
        this->WhatWasDifferent = this->StorageNames[block] + " was different";
        return true;
      }
    }
    return false;
  }
 
  vtkStateStorage& operator=(const vtkStateStorage& b)
  {
    this->Storage = b.Storage;
    this->StorageNames = b.StorageNames;
    this->StorageOffsets = b.StorageOffsets;
    return *this;
  }
 
protected:
  std::vector<unsigned char> Storage;
  std::vector<std::string> StorageNames;
  std::vector<size_t> StorageOffsets;
  mutable std::string WhatWasDifferent;
 
private:
  vtkStateStorage(const vtkStateStorage&) = delete;
};
 
template <class T>
inline void vtkStateStorage::Append(const T& value, const char* name)
{
  this->StorageOffsets.push_back(this->Storage.size());
  this->StorageNames.push_back(name);
  const char* start = reinterpret_cast<const char*>(&value);
  this->Storage.insert(this->Storage.end(), start, start + sizeof(T));
}
 
#else // normal implementation
 
class vtkStateStorage
{
public:
  vtkStateStorage() = default;
 
  // clear the storage
  void Clear() { this->Storage.clear(); }
 
  // append a data item to the state
  template <class T>
  void Append(const T& value, const char* name);
 
  bool operator!=(const vtkStateStorage& b) const { return this->Storage != b.Storage; }
 
  vtkStateStorage& operator=(const vtkStateStorage& b) = default;
 
protected:
  std::vector<unsigned char> Storage;
 
private:
  vtkStateStorage(const vtkStateStorage&) = delete;
};
 
template <class T>
inline void vtkStateStorage::Append(const T& value, const char*)
{
  const char* start = reinterpret_cast<const char*>(&value);
  this->Storage.insert(this->Storage.end(), start, start + sizeof(T));
}
 
#endif // normal implementation
 
#endif // vtkStateStorage_h
 
// VTK-HeaderTest-Exclude: vtkStateStorage.h