/home/laradmin/lar/utils/database_interface/include/database_interface/db_field.h

Go to the documentation of this file.

/*********************************************************************
 * Software License Agreement (BSD License)
 *
 *  Copyright (c) 2009, Willow Garage, Inc.
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions
 *  are met:
 *
 *   * Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *   * Redistributions in binary form must reproduce the above
 *     copyright notice, this list of conditions and the following
 *     disclaimer in the documentation and/or other materials provided
 *     with the distribution.
 *   * Neither the name of the Willow Garage nor the names of its
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 *********************************************************************/

// Author(s): Matei Ciocarlie

#ifndef _DB_FIELD_H_
#define _DB_FIELD_H_

#include <stdio.h>

#include <vector>
#include <map>
#include <string>
#include <sstream>
#include <iostream>
#include <iomanip>

#include <boost/format.hpp>

//for memcpy
#include <cstring>

namespace database_interface {

class DBClass;


class DBFieldBase
{
 private:

  const DBFieldBase& operator = (const DBFieldBase &rhs);
 public:
  enum Type{TEXT, BINARY};
 protected:
  Type type_;
  DBClass* owner_;

  bool write_permission_;
  bool read_from_database_;
  bool write_to_database_;
  std::string name_;
  std::string table_name_;
  std::string sequence_name_;

 DBFieldBase(DBClass *owner, const DBFieldBase *other) : 
  type_(other->type_), owner_(owner),
    write_permission_(other->write_permission_), read_from_database_(other->read_from_database_), 
    write_to_database_(other->write_to_database_), 
    name_(other->name_), table_name_(other->table_name_) {}

 public:
 DBFieldBase(Type type, DBClass* owner, std::string name, std::string table_name, bool write_permission) : 
    type_(type), owner_(owner),
    write_permission_(write_permission), read_from_database_(true), write_to_database_(true), 
    name_(name), table_name_(table_name) {}

  Type getType() const {return type_;}

  virtual bool fromString(const std::string &str) = 0;
  virtual bool toString(std::string &str) const = 0;

  virtual bool fromBinary(const char* binary, size_t length) = 0;

  virtual bool toBinary(const char* &binary, size_t &length) const = 0;

  DBClass* getOwner(){return owner_;}
  const DBClass* getOwner() const {return owner_;}

  bool getReadFromDatabase() const {return read_from_database_;}
  void setReadFromDatabase(bool sync) {read_from_database_ = sync;}

  bool getWriteToDatabase() const {return write_to_database_;}
  void setWriteToDatabase(bool sync) {write_to_database_ = sync;}

  bool getWritePermission() const {return write_permission_;}

  void setReadWrite(bool sync) 
  {
    setReadFromDatabase(sync);
    setWriteToDatabase(sync);
  }

  std::string getName() const {return name_;}
  std::string getTableName() const {return table_name_;}
  std::string getSequenceName() const {return sequence_name_;}

  void setSequenceName(std::string seq) {sequence_name_ = seq;}
};

template<class V>
std::istream& operator >> (std::istream &iss, std::vector<V> &vec)
{
  char c;
  iss >> c;
  if (iss.eof()) 
  {
    iss.clear();
    return iss;
  }
  if (iss.fail() || c != '{') 
  {
    iss.clear(std::ios::failbit);
    return iss;
  }
  
  while(1)
  {
    V val;
    iss >> val;
    if (iss.eof() || iss.fail()) 
    {
      iss.clear(std::ios::failbit);      
      return iss;
    }
    vec.push_back(val);
    
    iss >> c;
    if (iss.eof() || iss.fail()) 
    {
      iss.clear(std::ios::failbit);      
      return iss;
    }
    if (c == '}') break;
    if (c != ',') 
    {
      iss.clear(std::ios::failbit);      
      return iss;
    }
  }
  return iss;  
}

template <class V>
std::ostream& operator << (std::ostream &str, const std::vector<V> &vec)
{
  str << "{";
  for (size_t i=0; i<vec.size(); i++)
  {
    if (i!=0) str << ",";
    str << vec[i];
    if (str.fail()) return str;
  }
  str << "}";
  return str;
}

// We need to use a trait class here. Templated functions are not
// flexible enough since they do not support partial specialization.
template<typename T>
struct DBStreamable
{
  static bool streamableFromString(T &data, const std::string &str)
  {
    std::istringstream iss(str);
    return !(iss >> data).fail();
  }

  static bool streamableToString(const T &data, std::string &str)
  {
    std::ostringstream oss;
    // Only use 5 digits after the comma. Hopefully this solves an
    // issue with reading data from the database and comparing against
    // it later.
    oss << std::setprecision(30) << data;
    if (oss.fail()) return false;
    str = oss.str();
    return true;
  }
};

template<>
struct DBStreamable<double>
{
  static bool streamableFromString(double &data, const std::string &str)
  {
    // We need to restrict to only 5 digits after point. Otherwise
    // comparison is hell. Serialization uses only 5 digits.
    size_t point_pos = str.find('.');
    std::istringstream iss(str.substr(0, point_pos == std::string::npos ? point_pos : point_pos + 6));
    return !(iss >> data).fail();
  }

  static bool streamableToString(double data, std::string &str)
  {
    std::ostringstream oss;
    // Only use 5 digits after the comma. Hopefully this solves an
    // issue with reading data from the database and comparing against
    // it later.
    oss << boost::format("%.5f") % data;
    if (oss.fail()) return false;
    str = oss.str();
    return true;
  }
};


template <class T>
class DBFieldData : public DBFieldBase
{
 protected:
  T data_;


 DBFieldData(DBClass *owner, const DBFieldData *other) : DBFieldBase(owner, other) 
    {}

  void copy(const DBFieldData<T> *other)
  {
    if (this->type_==DBFieldBase::TEXT)
    {
      //hmm.. these can technically fail. What then?
      std::string copy_str;
      if (!other->toString(copy_str) || !this->fromString(copy_str))
      {
        std::cerr << "ERROR: database field ASCII copy failed during copy constructor of field " 
                  << this->name_ 
                  << ". This is currently an unhandled error, and will probably have serious effects.\n";
      }
      //std::cerr << "Copying field " << this->name_ << ". String: " << copy_str << "\n";
    }
    else if (this->type_==DBFieldBase::BINARY)
    {
      //hmm.. these can technically fail. What then?
      const char *copy_bin; size_t length;
      if (!other->toBinary(copy_bin, length) || !this->fromBinary(copy_bin, length))
      {
        std::cerr << "ERROR: database field BINARY copy failed during copy constructor of field " 
                  << this->name_ 
                  << ". This is currently an unhandled error, and will probably have serious effects.\n";
      }
    }
  }

 public:
  DBFieldData(Type type, DBClass* owner, std::string name, std::string table_name, bool write_permission) : 
    DBFieldBase(type, owner, name, table_name, write_permission){}

  const T& get() const {return data_;}

  T& get() {return data_;}

  const T& data() const {return data_;}

  T& data() {return data_;}

  virtual bool fromString(const std::string &str)
  {
    return DBStreamable<T>::streamableFromString(this->data_, str);
  }

  virtual bool toString(std::string &str) const
  {
    return DBStreamable<T>::streamableToString(this->data_, str);
  }

  virtual bool fromBinary(const char* /*binary*/, size_t /*length*/) {return false;}
  virtual bool toBinary(const char* &/*binary*/, size_t &/*length*/) const {return false;}
};


template <class T>
class DBField : public DBFieldData<T>
{
 public:
  DBField(DBFieldBase::Type type, DBClass *owner, std::string name, std::string table_name, bool write_permission) : 
    DBFieldData<T>(type, owner, name, table_name, write_permission) {}

 DBField(DBClass *owner, const DBField<T> *other) : DBFieldData<T>(owner, other) 
 {
   this->copy(other);
 }

};

template <>
class DBField<bool> : public DBFieldData<bool>
{
 public:
  DBField(Type type, DBClass *owner, std::string name, std::string table_name, bool write_permission) : 
    DBFieldData<bool>(type, owner, name, table_name, write_permission) {}

  DBField(DBClass *owner, const DBField<bool> *other) : DBFieldData<bool>(owner, other) 
  {
    this->copy(other);
  }

  virtual bool fromString(const std::string &str) 
  {
    if (str=="true" || str=="t" || str == "True" || str == "TRUE") this->data_ = true;
    else if (str=="false" || str=="f" || str == "False" || str == "FALSE") this->data_ = false;
    else return false;
    return true;
  }

  virtual bool toString(std::string &str) const 
  {
    if (this->data_) str="true";
    else str = "false";
    return true;
  }
};


template <>
class DBField< std::vector<char> > : public DBFieldData< std::vector<char> >
{
 public:
  DBField(Type type, DBClass *owner, std::string name, std::string table_name, bool write_permission) : 
    DBFieldData< std::vector<char> >(type, owner, name, table_name, write_permission) {}

 DBField(DBClass *owner, const DBField< std::vector<char> > *other) : DBFieldData< std::vector<char> >(owner, other) 
      {
        this->copy(other);
      }
  
  virtual bool fromBinary(const char* binary, size_t length) 
  {
    data_.resize(length);
    memcpy(&(data_[0]), binary, length);
    return true;
  }

  virtual bool toBinary(const char* &binary, size_t &length) const 
  {
    length = data_.size();
    if (!data_.empty())
    {
      binary = &(data_[0]);
    }
    return true;
  }
};

template <>
class DBField<std::string> : public DBFieldData<std::string>
{
 public:

  DBField(Type type, DBClass *owner, std::string name, std::string table_name, bool write_permission) : 
    DBFieldData<std::string>(type, owner, name, table_name, write_permission) {}

  DBField(DBClass *owner, const DBField< std::string > *other) : DBFieldData< std::string >(owner, other) 
      {
        this->copy(other);
      }

  virtual bool fromString(const std::string &str) {data_ = str; return true;}
  virtual bool toString(std::string &str) const {str = data_; return true;}
};

template <>
class DBField< std::vector<std::string> > : public DBFieldData< std::vector<std::string> >
{
 public:
  DBField(Type type, DBClass *owner, std::string name, std::string table_name, bool write_permission) : 
    DBFieldData< std::vector<std::string> >(type, owner, name, table_name, write_permission) {}

 DBField(DBClass *owner, const DBField< std::vector<std::string> > *other) : 
    DBFieldData< std::vector<std::string> >(owner, other) 
      {
        this->copy(other);
      }

  virtual bool fromString(const std::string &str) 
  {
    if (str.empty()) return true;
    if (str.at(0) != '{') return false;

    size_t pos = 1;
    bool done = false;
    while (!done)
    {
      if (pos >= str.size()) return false;
      size_t new_pos = str.find(',',pos);
      if (new_pos == std::string::npos)
      {
        new_pos = str.find('}',pos);
        if (new_pos == std::string::npos) return false;
        done = true;
      }
      if (new_pos == pos) return false;
      this->data_.push_back(str.substr(pos, new_pos-pos));
      pos = new_pos + 1;
    }
    return true;
  }
};

} //namespace database_interface

#endif

---

database_interface
Author(s): Matei Ciocarlie and Lorenz Mosenlechner
autogenerated on Wed Jul 23 04:34:21 2014