memory-identity-storage.hpp

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil -*- */
#ifndef NDN_MEMORY_IDENTITY_STORAGE_HPP
#define NDN_MEMORY_IDENTITY_STORAGE_HPP

#include <vector>
#include <map>
#include "identity-storage.hpp"

namespace ndn {

class MemoryIdentityStorage : public IdentityStorage {
public:
  virtual
  ~MemoryIdentityStorage();

  virtual bool
  doesIdentityExist(const Name& identityName);

  virtual void
  addIdentity(const Name& identityName);

  virtual bool
  revokeIdentity();

  virtual bool
  doesKeyExist(const Name& keyName);

  virtual void
  addKey(const Name& keyName, KeyType keyType, const Blob& publicKeyDer);

  virtual Blob
  getKey(const Name& keyName);

  virtual void
  activateKey(const Name& keyName);

  virtual void
  deactivateKey(const Name& keyName);

  virtual bool
  doesCertificateExist(const Name& certificateName);

  virtual void
  addCertificate(const IdentityCertificate& certificate);

  virtual ptr_lib::shared_ptr<IdentityCertificate>
  getCertificate(const Name &certificateName);


  /*****************************************
   *           Get/Set Default             *
   *****************************************/

  virtual Name
  getDefaultIdentity();

  virtual Name
  getDefaultKeyNameForIdentity(const Name& identityName);

  virtual Name
  getDefaultCertificateNameForKey(const Name& keyName);

  virtual void
  getAllIdentities(std::vector<Name>& nameList, bool isDefault);

  virtual void
  getAllKeyNamesOfIdentity
    (const Name& identityName, std::vector<Name>& nameList, bool isDefault);

  virtual void
  getAllCertificateNamesOfKey
    (const Name& keyName, std::vector<Name>& nameList, bool isDefault);

  virtual void
  setDefaultIdentity(const Name& identityName);

  virtual void
  setDefaultKeyNameForIdentity(const Name& keyName, const Name& identityNameCheck = Name());

  virtual void
  setDefaultCertificateNameForKey(const Name& keyName, const Name& certificateName);

  /*****************************************
   *            Delete Methods             *
   *****************************************/

  virtual void
  deleteCertificateInfo(const Name& certificateName);

  virtual void
  deletePublicKeyInfo(const Name& keyName);

  virtual void
  deleteIdentityInfo(const Name& identity);

private:
  class IdentityRecord {
  public:
    void
    setDefaultKey(const ptr_lib::shared_ptr<Name>& key) { defaultKey_ = key; }

    bool
    hasDefaultKey() const { return !!defaultKey_; }

    const Name&
    getDefaultKey() const { return *defaultKey_; }

  private:
    ptr_lib::shared_ptr<Name> defaultKey_;
  };

  class KeyRecord {
  public:
    KeyRecord(KeyType keyType, const Blob &keyDer)
    : keyType_(keyType), keyDer_(keyDer)
    {
    }

    const KeyType getKeyType() const { return keyType_; }

    const Blob& getKeyDer() { return keyDer_; }

    void
    setDefaultCertificate(const ptr_lib::shared_ptr<Name>& certificate)
    {
      defaultCertificate_ = certificate;
    }

    bool
    hasDefaultCertificate() const { return !!defaultCertificate_; }

    const Name&
    getDefaultCertificate() const { return *defaultCertificate_; }

  private:
    KeyType keyType_;
    Blob keyDer_;
    ptr_lib::shared_ptr<Name> defaultCertificate_;
  };

  std::map<std::string, IdentityRecord>
    identityStore_; 
  std::string defaultIdentity_;            
  std::map<std::string, ptr_lib::shared_ptr<KeyRecord> > keyStore_; 
  std::map<std::string, Blob> certificateStore_;                    
};

}

#endif