basic_metadata.h

Go to the documentation of this file.

/*
 * (c) 2014 Good Technology Corporation. All rights reserved.
 */

#ifndef BASIC_METADATA_H
#define BASIC_METADATA_H

#include "DigitalAuthenticationFramework.h"

#include <map>

#include "basic_error.h"

class BasicMetaData : public DAMetaData
{
public:
  typedef std::vector<DAData> DADataList; 

  BasicMetaData(BasicError &err)
    : m_error(err)
    , m_strings()
    , m_flags()
    , m_datas()
  {}

  void copyFrom(const DAMetaData &meta)
  {
    const BasicMetaData *other = dynamic_cast<const BasicMetaData *>(&meta);
    if (other)
    {
      m_strings = other->m_strings;
      m_flags = other->m_flags;
      m_datas = other->m_datas;
    }
  }

  void setString(DAAttrib which, const std::string &value)
  {
    m_strings[which] = value;
  }

  void setFlag(DAAttrib which, bool value=true)
  {
    m_flags[which] = value;
  }

  void setData(DAAttrib which, const DAData &value)
  {
    DADataList dlist;
    dlist.push_back(value);
    m_datas[which] = dlist;
  }

  void setData(DAAttrib which, const DADataList &values)
  {
    m_datas[which] = values;
  }

  void setSize(DAAttrib which, size_t len)
  {
    m_sizes[which] = len;
  }
  
  virtual bool getString(DAAttrib which, std::string &out)
  {
    string_map::iterator it = m_strings.find(which);

    if (it != m_strings.end())
    {
      out = it->second;
      m_error.clear();
      return true;
    }
  
    out = "";
    m_error.setCode(DAError::ATTRIB_NOT_FOUND);
    return false;
  }

  virtual bool getFlag(DAAttrib which)
  {
    flag_map::iterator it = m_flags.find(which);

    if (it != m_flags.end())
    {
      m_error.clear();
      return it->second;
    }
    
    m_error.setCode(DAError::ATTRIB_NOT_FOUND);
    return false;
  }

  virtual bool getData(DAAttrib which, DAData &out, size_t index)
  {
    data_map::iterator it = m_datas.find(which);

    out.clear();
    if (it == m_datas.end())
    {
      m_error.setCode(DAError::ATTRIB_NOT_FOUND);
      return false;
    }
    
    DADataList &dlist = it->second;
    if ( index >= dlist.size() )
    {
      m_error.setCode(DAError::ATTRIB_NOT_FOUND);
      return false;
    }

    out = dlist.at(index);
    m_error.clear();
    return true;
  }

  virtual bool getSize(DAAttrib which, size_t &len_r)
  {
    size_map::iterator it = m_sizes.find(which);
    
    if ( it != m_sizes.end() )
    {
      m_error.clear();
      len_r = it->second;
      return true;
    }
    
    len_r = 0;
    m_error.setCode(DAError::ATTRIB_NOT_FOUND);
    return false;
  }
  
protected:
  BasicError &m_error;  
  
  typedef std::map<DAAttrib, std::string> string_map; 
  typedef std::map<DAAttrib, bool> flag_map;          
  typedef std::map<DAAttrib, DADataList> data_map;        
  typedef std::map<DAAttrib, size_t> size_map;        

  string_map m_strings; 
  flag_map m_flags;     
  data_map m_datas;     
  size_map m_sizes;     
};

#endif