rucades 0.3.0 → 0.4.0

data/ext/rucades/rucades_eku.h

@@ -10,10 +10,10 @@
 namespace rucades {
 class pre_rb_EKU {
   protected:
-    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPEKUObject> m_pCppCadesImpl;
+    NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPEKUObject> m_pCppCadesImpl;
   public:
     pre_rb_EKU(void);
-    pre_rb_EKU(boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPEKUObject> pCppCadesEKU);
+    pre_rb_EKU(NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPEKUObject> pCppCadesEKU);
     long get_name(void);
     void set_name (long name);
     std::string get_oid(void);

data/ext/rucades/rucades_ekus.cpp

@@ -13,9 +13,9 @@ using namespace CryptoPro::PKI::CAdES;
 
 namespace rucades {
 pre_rb_EKUs::pre_rb_EKUs(void):
-      m_pCppCadesImpl(boost::shared_ptr<CPPCadesCPEKUsObject>(new CPPCadesCPEKUsObject())) { }
+      m_pCppCadesImpl(NS_SHARED_PTR::shared_ptr<CPPCadesCPEKUsObject>(new CPPCadesCPEKUsObject())) { }
 
-pre_rb_EKUs::pre_rb_EKUs(boost::shared_ptr<CPPCadesCPEKUsObject> other):
+pre_rb_EKUs::pre_rb_EKUs(NS_SHARED_PTR::shared_ptr<CPPCadesCPEKUsObject> other):
       m_pCppCadesImpl(other) { }
 
 long pre_rb_EKUs::get_count(void)
@@ -27,7 +27,7 @@ long pre_rb_EKUs::get_count(void)
 
 pre_rb_EKU pre_rb_EKUs::get_item(long index)
 {
-  boost::shared_ptr<CPPCadesCPEKUObject> pCppCadesEKU = boost::shared_ptr<CPPCadesCPEKUObject>(new CPPCadesCPEKUObject());
+  NS_SHARED_PTR::shared_ptr<CPPCadesCPEKUObject> pCppCadesEKU = NS_SHARED_PTR::shared_ptr<CPPCadesCPEKUObject>(new CPPCadesCPEKUObject());
   hr_method_check(m_pCppCadesImpl->get_Item(index, pCppCadesEKU));
   return pre_rb_EKU(pCppCadesEKU);
 }

data/ext/rucades/rucades_ekus.h

@@ -13,10 +13,10 @@
 namespace rucades {
 class pre_rb_EKUs {
   protected:
-    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPEKUsObject> m_pCppCadesImpl;
+    NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPEKUsObject> m_pCppCadesImpl;
   public:
     pre_rb_EKUs(void);
-    pre_rb_EKUs(boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPEKUsObject> pCppCadesEKUs);
+    pre_rb_EKUs(NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPEKUsObject> pCppCadesEKUs);
     long get_count(void);
     pre_rb_EKU get_item(long index);
 

data/ext/rucades/rucades_encoded_data.cpp

@@ -13,7 +13,7 @@ using namespace CryptoPro::PKI::CAdES;
 
 namespace rucades {
 pre_rb_EncodedData::pre_rb_EncodedData(void):
-      m_pCppCadesImpl(boost::shared_ptr<CPPCadesCPEncodedDataObject>(new CPPCadesCPEncodedDataObject())) { }
+      m_pCppCadesImpl(NS_SHARED_PTR::shared_ptr<CPPCadesCPEncodedDataObject>(new CPPCadesCPEncodedDataObject())) { }
 
 std::string pre_rb_EncodedData::value(long type)
 {

data/ext/rucades/rucades_encoded_data.h

@@ -10,7 +10,7 @@
 namespace rucades {
 class pre_rb_EncodedData {
   protected:
-    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPEncodedDataObject> m_pCppCadesImpl;
+    NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPEncodedDataObject> m_pCppCadesImpl;
   public:
     pre_rb_EncodedData(void);
     std::string value(long format);

data/ext/rucades/rucades_enveloped_data.cpp

@@ -13,7 +13,7 @@ using namespace CryptoPro::PKI::CAdES;
 
 namespace rucades {
 pre_rb_EnvelopedData::pre_rb_EnvelopedData(void):
-      m_pCppCadesImpl(boost::shared_ptr<CPPCadesCPEnvelopedDataObject>(new CPPCadesCPEnvelopedDataObject())) { }
+      m_pCppCadesImpl(NS_SHARED_PTR::shared_ptr<CPPCadesCPEnvelopedDataObject>(new CPPCadesCPEnvelopedDataObject())) { }
 
 std::string pre_rb_EnvelopedData::get_content(void)
 {

data/ext/rucades/rucades_enveloped_data.h

@@ -12,7 +12,7 @@
 namespace rucades {
 class pre_rb_EnvelopedData {
   protected:
-    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPEnvelopedDataObject> m_pCppCadesImpl;
+    NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPEnvelopedDataObject> m_pCppCadesImpl;
   public:
     pre_rb_EnvelopedData(void);
 

data/ext/rucades/rucades_extended_key_usage.cpp

@@ -15,7 +15,7 @@ namespace rucades {
 pre_rb_ExtendedKeyUsage::pre_rb_ExtendedKeyUsage(void):
   m_pCppCadesImpl(new CPPCadesCPExtendedKeyUsageObject()) { }
 
-pre_rb_ExtendedKeyUsage::pre_rb_ExtendedKeyUsage(boost::shared_ptr<CPPCadesCPExtendedKeyUsageObject> other):
+pre_rb_ExtendedKeyUsage::pre_rb_ExtendedKeyUsage(NS_SHARED_PTR::shared_ptr<CPPCadesCPExtendedKeyUsageObject> other):
       m_pCppCadesImpl(other) { }
 
 bool pre_rb_ExtendedKeyUsage::is_present(void)
@@ -35,7 +35,7 @@ bool pre_rb_ExtendedKeyUsage::is_critical(void)
 pre_rb_EKUs pre_rb_ExtendedKeyUsage::get_ekus(void)
 {
 
-    boost::shared_ptr<CPPCadesCPEKUsObject> pCppCadesEKUs(new CPPCadesCPEKUsObject());
+    NS_SHARED_PTR::shared_ptr<CPPCadesCPEKUsObject> pCppCadesEKUs(new CPPCadesCPEKUsObject());
     hr_method_check(m_pCppCadesImpl->get_EKUs(pCppCadesEKUs));
 
     return pre_rb_EKUs(pCppCadesEKUs);

data/ext/rucades/rucades_extended_key_usage.h

@@ -12,10 +12,10 @@
 namespace rucades {
 class pre_rb_ExtendedKeyUsage {
   protected:
-    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPExtendedKeyUsageObject> m_pCppCadesImpl;
+    NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPExtendedKeyUsageObject> m_pCppCadesImpl;
   public:
     pre_rb_ExtendedKeyUsage(void);
-    pre_rb_ExtendedKeyUsage(boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPExtendedKeyUsageObject> other);
+    pre_rb_ExtendedKeyUsage(NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPExtendedKeyUsageObject> other);
     bool is_present(void);
     bool is_critical(void);
     pre_rb_EKUs get_ekus(void);

data/ext/rucades/rucades_hashed_data.cpp

@@ -13,7 +13,7 @@ using namespace CryptoPro::PKI::CAdES;
 
 namespace rucades {
 pre_rb_HashedData::pre_rb_HashedData(void)
-      : m_pCppCadesImpl(boost::shared_ptr<CPPCadesCPHashedDataObject>(new CPPCadesCPHashedDataObject())) { }
+      : m_pCppCadesImpl(NS_SHARED_PTR::shared_ptr<CPPCadesCPHashedDataObject>(new CPPCadesCPHashedDataObject())) { }
 
 std::string pre_rb_HashedData::get_key(void)
 {

data/ext/rucades/rucades_hashed_data.h

@@ -10,7 +10,7 @@
 namespace rucades {
 class pre_rb_HashedData {
   protected:
-    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPHashedDataObject> m_pCppCadesImpl;
+    NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPHashedDataObject> m_pCppCadesImpl;
   public:
     pre_rb_HashedData(void);
     std::string get_key(void);

data/ext/rucades/rucades_key_usage.cpp

@@ -13,9 +13,9 @@ using namespace CryptoPro::PKI::CAdES;
 
 namespace rucades {
 pre_rb_KeyUsage::pre_rb_KeyUsage(void):
-      m_pCppCadesImpl(boost::shared_ptr<CPPCadesCPKeyUsageObject>(new CPPCadesCPKeyUsageObject())) { }
+      m_pCppCadesImpl(NS_SHARED_PTR::shared_ptr<CPPCadesCPKeyUsageObject>(new CPPCadesCPKeyUsageObject())) { }
 
-pre_rb_KeyUsage::pre_rb_KeyUsage(boost::shared_ptr<CPPCadesCPKeyUsageObject> other):
+pre_rb_KeyUsage::pre_rb_KeyUsage(NS_SHARED_PTR::shared_ptr<CPPCadesCPKeyUsageObject> other):
       m_pCppCadesImpl(other) { }
 
 bool pre_rb_KeyUsage::is_present(void)
@@ -102,7 +102,7 @@ void pre_rb_KeyUsage::define_ruby_class(VALUE module)
     .define_constructor(Constructor<pre_rb_KeyUsage>())
     .define_method("present?", &pre_rb_KeyUsage::is_present)
     .define_method("critical?", &pre_rb_KeyUsage::is_critical)
-    .define_method("digital_ignature_enabled?", &pre_rb_KeyUsage::is_digital_signature_enabled)
+    .define_method("digital_signature_enabled?", &pre_rb_KeyUsage::is_digital_signature_enabled)
     .define_method("non_repudiation_enabled?", &pre_rb_KeyUsage::is_non_repudiation_enabled)
     .define_method("key_encipherment_enabled?", &pre_rb_KeyUsage::is_key_encipherment_enabled)
     .define_method("key_agreement_enabled?", &pre_rb_KeyUsage::is_key_agreement_enabled)

data/ext/rucades/rucades_key_usage.h

@@ -10,10 +10,10 @@
 namespace rucades {
 class pre_rb_KeyUsage {
   protected:
-    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPKeyUsageObject> m_pCppCadesImpl;
+    NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPKeyUsageObject> m_pCppCadesImpl;
   public:
     pre_rb_KeyUsage(void);
-    pre_rb_KeyUsage(boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPKeyUsageObject> other);
+    pre_rb_KeyUsage(NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPKeyUsageObject> other);
     bool is_present(void);
     bool is_critical(void);
     bool is_digital_signature_enabled(void);

data/ext/rucades/rucades_oid.cpp

@@ -14,14 +14,14 @@ using namespace CryptoPro::PKI::CAdES;
 namespace rucades {
 
 pre_rb_OID::pre_rb_OID(void):
-      m_pCppCadesImpl(boost::shared_ptr<CPPCadesCPOIDObject>(new CPPCadesCPOIDObject())) { }
+      m_pCppCadesImpl(NS_SHARED_PTR::shared_ptr<CPPCadesCPOIDObject>(new CPPCadesCPOIDObject())) { }
 
-pre_rb_OID::pre_rb_OID(boost::shared_ptr<CPPCadesCPOIDObject> other):
+pre_rb_OID::pre_rb_OID(NS_SHARED_PTR::shared_ptr<CPPCadesCPOIDObject> other):
       m_pCppCadesImpl(other) { }
 
 std::string pre_rb_OID::get_value(void)
 {
-  boost::shared_ptr<CAtlStringA> pValue;
+  NS_SHARED_PTR::shared_ptr<CAtlStringA> pValue;
   hr_method_check(m_pCppCadesImpl->get_Value(pValue));
   return std::string((*pValue).GetString());
 }

data/ext/rucades/rucades_oid.h

@@ -11,10 +11,10 @@ namespace rucades {
 
 class pre_rb_OID {
   protected:
-    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPOIDObject> m_pCppCadesImpl;
+    NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPOIDObject> m_pCppCadesImpl;
   public:
     pre_rb_OID(void);
-    pre_rb_OID(boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPOIDObject> other);
+    pre_rb_OID(NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPOIDObject> other);
     std::string get_value(void);
     void set_value(std::string& value);
     long get_name(void);

data/ext/rucades/rucades_private_key.cpp

@@ -13,9 +13,9 @@ using namespace CryptoPro::PKI::CAdES;
 
 namespace rucades {
 pre_rb_PrivateKey::pre_rb_PrivateKey(void):
-          m_pCppCadesImpl(boost::shared_ptr<CPPCadesCPPrivateKeyObject>(new CPPCadesCPPrivateKeyObject())) { }
+          m_pCppCadesImpl(NS_SHARED_PTR::shared_ptr<CPPCadesCPPrivateKeyObject>(new CPPCadesCPPrivateKeyObject())) { }
 
-pre_rb_PrivateKey::pre_rb_PrivateKey(boost::shared_ptr<CPPCadesCPPrivateKeyObject> other):
+pre_rb_PrivateKey::pre_rb_PrivateKey(NS_SHARED_PTR::shared_ptr<CPPCadesCPPrivateKeyObject> other):
       m_pCppCadesImpl(other) { }
 
 std::string pre_rb_PrivateKey::get_container_name(void)
@@ -77,7 +77,7 @@ void pre_rb_PrivateKey::define_ruby_class(VALUE module)
     .define_method("container_name", &pre_rb_PrivateKey::get_container_name)
     .define_method("unique_container_name", &pre_rb_PrivateKey::get_unique_container_name)
     .define_method("provider_name", &pre_rb_PrivateKey::get_provider_name)
-    .define_method("provier_type", &pre_rb_PrivateKey::get_provider_type)
+    .define_method("provider_type", &pre_rb_PrivateKey::get_provider_type)
     .define_method("key_spec", &pre_rb_PrivateKey::get_key_spec)
     .define_method("cache_pin=", &pre_rb_PrivateKey::set_cache_pin)
     .define_method("key_pin=", &pre_rb_PrivateKey::set_key_pin)

data/ext/rucades/rucades_private_key.h

@@ -11,10 +11,10 @@ namespace rucades {
 
 class pre_rb_PrivateKey {
   protected:
-    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPPrivateKeyObject> m_pCppCadesImpl;
+    NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPPrivateKeyObject> m_pCppCadesImpl;
   public:
     pre_rb_PrivateKey(void);
-    pre_rb_PrivateKey(boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPPrivateKeyObject> other);
+    pre_rb_PrivateKey(NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPPrivateKeyObject> other);
     std::string get_container_name(void);
     std::string get_unique_container_name(void);
     std::string get_provider_name(void);

data/ext/rucades/rucades_public_key.cpp

@@ -13,9 +13,9 @@ using namespace CryptoPro::PKI::CAdES;
 
 namespace rucades {
 pre_rb_PublicKey::pre_rb_PublicKey(void):
-          m_pCppCadesImpl(boost::shared_ptr<CPPCadesCPPublicKeyObject>(new CPPCadesCPPublicKeyObject())) { }
+          m_pCppCadesImpl(NS_SHARED_PTR::shared_ptr<CPPCadesCPPublicKeyObject>(new CPPCadesCPPublicKeyObject())) { }
 
-pre_rb_PublicKey::pre_rb_PublicKey(boost::shared_ptr<CPPCadesCPPublicKeyObject> other):
+pre_rb_PublicKey::pre_rb_PublicKey(NS_SHARED_PTR::shared_ptr<CPPCadesCPPublicKeyObject> other):
       m_pCppCadesImpl(other) { }
 
 pre_rb_OID* pre_rb_PublicKey::get_algorithm(void)

data/ext/rucades/rucades_public_key.h

@@ -12,10 +12,10 @@
 namespace rucades {
 class pre_rb_PublicKey {
   protected:
-    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPPublicKeyObject> m_pCppCadesImpl;
+    NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPPublicKeyObject> m_pCppCadesImpl;
   public:
     pre_rb_PublicKey(void);
-    pre_rb_PublicKey(boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPPublicKeyObject> other);
+    pre_rb_PublicKey(NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPPublicKeyObject> other);
     pre_rb_OID* get_algorithm(void);
     pre_rb_EncodedData get_encoded_key(void);
     pre_rb_EncodedData get_encoded_parameters(void);

data/ext/rucades/rucades_raw_signature.cpp

@@ -13,9 +13,9 @@ using namespace CryptoPro::PKI::CAdES;
 
 namespace rucades {
 pre_rb_RawSignature::pre_rb_RawSignature(void):
-    m_pCppCadesImpl(boost::shared_ptr<CPPCadesRawSignatureObject>(new CPPCadesRawSignatureObject())) { }
+    m_pCppCadesImpl(NS_SHARED_PTR::shared_ptr<CPPCadesRawSignatureObject>(new CPPCadesRawSignatureObject())) { }
 
-pre_rb_RawSignature::pre_rb_RawSignature(boost::shared_ptr<CPPCadesRawSignatureObject> other):
+pre_rb_RawSignature::pre_rb_RawSignature(NS_SHARED_PTR::shared_ptr<CPPCadesRawSignatureObject> other):
     m_pCppCadesImpl(other) { }
 
 std::string pre_rb_RawSignature::sign_hash(pre_rb_HashedData& data, pre_rb_Certificate& cert)

data/ext/rucades/rucades_raw_signature.h

@@ -13,10 +13,10 @@ namespace rucades {
 
 class pre_rb_RawSignature {
   protected:
-    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesRawSignatureObject> m_pCppCadesImpl;
+    NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesRawSignatureObject> m_pCppCadesImpl;
   public:
     pre_rb_RawSignature(void);
-    pre_rb_RawSignature(boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesRawSignatureObject> other);
+    pre_rb_RawSignature(NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesRawSignatureObject> other);
     std::string sign_hash(pre_rb_HashedData& data, pre_rb_Certificate& cert);
     void verify_hash(pre_rb_HashedData& data, pre_rb_Certificate& cert, std::string signature);
 

data/ext/rucades/rucades_recipients.cpp

@@ -14,9 +14,9 @@ using namespace CryptoPro::PKI::CAdES;
 
 namespace rucades {
 pre_rb_Recipients::pre_rb_Recipients(void):
-      m_pCppCadesImpl(boost::shared_ptr<CPPCadesCPRecipientsObject>(new CPPCadesCPRecipientsObject())) { }
+      m_pCppCadesImpl(NS_SHARED_PTR::shared_ptr<CPPCadesCPRecipientsObject>(new CPPCadesCPRecipientsObject())) { }
 
-pre_rb_Recipients::pre_rb_Recipients(boost::shared_ptr<CPPCadesCPRecipientsObject> other):
+pre_rb_Recipients::pre_rb_Recipients(NS_SHARED_PTR::shared_ptr<CPPCadesCPRecipientsObject> other):
       m_pCppCadesImpl(other) { }
 
 void pre_rb_Recipients::add(pre_rb_Certificate& attrb)

data/ext/rucades/rucades_recipients.h

@@ -11,10 +11,10 @@
 namespace rucades {
 class pre_rb_Recipients {
   protected:
-    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPRecipientsObject> m_pCppCadesImpl;
+    NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPRecipientsObject> m_pCppCadesImpl;
   public:
     pre_rb_Recipients(void);
-    pre_rb_Recipients(boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPRecipientsObject> other);
+    pre_rb_Recipients(NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPRecipientsObject> other);
     void add(pre_rb_Certificate& attrb);
     void clear(void);
     long get_count(void);

data/ext/rucades/rucades_signature_status.cpp

@@ -13,9 +13,9 @@ using namespace CryptoPro::PKI::CAdES;
 
 namespace rucades {
 pre_rb_SignatureStatus::pre_rb_SignatureStatus(void):
-    m_pCppCadesImpl(boost::shared_ptr<CPPCadesSignatureStatusObject>(new CPPCadesSignatureStatusObject())) { }
+    m_pCppCadesImpl(NS_SHARED_PTR::shared_ptr<CPPCadesSignatureStatusObject>(new CPPCadesSignatureStatusObject())) { }
 
-pre_rb_SignatureStatus::pre_rb_SignatureStatus(boost::shared_ptr<CPPCadesSignatureStatusObject> other):
+pre_rb_SignatureStatus::pre_rb_SignatureStatus(NS_SHARED_PTR::shared_ptr<CPPCadesSignatureStatusObject> other):
     m_pCppCadesImpl(other) { }
 
 bool pre_rb_SignatureStatus::is_valid(void)

data/ext/rucades/rucades_signature_status.h

@@ -10,10 +10,10 @@
 namespace rucades {
 class pre_rb_SignatureStatus {
   protected:
-    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesSignatureStatusObject> m_pCppCadesImpl;
+    NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesSignatureStatusObject> m_pCppCadesImpl;
   public:
     pre_rb_SignatureStatus(void);
-    pre_rb_SignatureStatus(boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesSignatureStatusObject> other);
+    pre_rb_SignatureStatus(NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesSignatureStatusObject> other);
     bool is_valid(void);
 
     static void define_ruby_class(VALUE module);

data/ext/rucades/rucades_signed_data.cpp

@@ -13,7 +13,7 @@ using namespace CryptoPro::PKI::CAdES;
 
 namespace rucades {
 pre_rb_SignedData::pre_rb_SignedData(void):
-    m_pCppCadesImpl(boost::shared_ptr<CPPCadesSignedDataObject>(new CPPCadesSignedDataObject())) { }
+    m_pCppCadesImpl(NS_SHARED_PTR::shared_ptr<CPPCadesSignedDataObject>(new CPPCadesSignedDataObject())) { }
 
 long pre_rb_SignedData::get_content_encoding(void)
 {
@@ -63,7 +63,7 @@ std::string pre_rb_SignedData::sign_cades(pre_rb_Signer* signer, long type, bool
     CADESCOM_CADES_TYPE CadesType = static_cast<CADESCOM_CADES_TYPE>(type);
     CryptoPro::CBlob blobSignedMessage;
 
-    boost::shared_ptr<CPPCadesCPSignerObject> pSignerCppCadesImpl;
+    NS_SHARED_PTR::shared_ptr<CPPCadesCPSignerObject> pSignerCppCadesImpl;
     if (signer) {
         pSignerCppCadesImpl = signer->m_pCppCadesImpl;
     }
@@ -82,7 +82,7 @@ std::string pre_rb_SignedData::cosign_cades(pre_rb_Signer* signer, long type, lo
     CADESCOM_CADES_TYPE CadesType = static_cast<CADESCOM_CADES_TYPE>(type);
     CryptoPro::CBlob blobSignedMessage;
 
-    boost::shared_ptr<CPPCadesCPSignerObject> pSignerCppCadesImpl;
+    NS_SHARED_PTR::shared_ptr<CPPCadesCPSignerObject> pSignerCppCadesImpl;
     if (signer) {
         pSignerCppCadesImpl = signer->m_pCppCadesImpl;
     }
@@ -99,7 +99,7 @@ std::string pre_rb_SignedData::sign_hash(pre_rb_HashedData& hash, pre_rb_Signer*
     CADESCOM_CADES_TYPE CadesType = static_cast<CADESCOM_CADES_TYPE>(type);
     CryptoPro::CBlob blobSignedMessage;
 
-    boost::shared_ptr<CPPCadesCPSignerObject> pSignerCppCadesImpl;
+    NS_SHARED_PTR::shared_ptr<CPPCadesCPSignerObject> pSignerCppCadesImpl;
     if (signer) {
         pSignerCppCadesImpl = signer->m_pCppCadesImpl;
     }
@@ -117,7 +117,7 @@ std::string pre_rb_SignedData::cosign_hash(pre_rb_HashedData& hash, pre_rb_Signe
     CADESCOM_CADES_TYPE CadesType = static_cast<CADESCOM_CADES_TYPE>(type);
     CryptoPro::CBlob blobSignedMessage;
 
-    boost::shared_ptr<CPPCadesCPSignerObject> pSignerCppCadesImpl;
+    NS_SHARED_PTR::shared_ptr<CPPCadesCPSignerObject> pSignerCppCadesImpl;
     if (signer) {
         pSignerCppCadesImpl = signer->m_pCppCadesImpl;
     }
@@ -134,7 +134,7 @@ std::string pre_rb_SignedData::sign(pre_rb_Signer* signer, bool detached, long e
     CAPICOM_ENCODING_TYPE EncodingType = static_cast<CAPICOM_ENCODING_TYPE>(enc);
     CryptoPro::CBlob blobSignedMessage;
 
-    boost::shared_ptr<CPPCadesCPSignerObject> pSignerCppCadesImpl;
+    NS_SHARED_PTR::shared_ptr<CPPCadesCPSignerObject> pSignerCppCadesImpl;
     if (signer) {
         pSignerCppCadesImpl = signer->m_pCppCadesImpl;
     }
@@ -150,7 +150,7 @@ std::string pre_rb_SignedData::cosign(pre_rb_Signer* signer, long enc)
     CAPICOM_ENCODING_TYPE EncodingType = static_cast<CAPICOM_ENCODING_TYPE>(enc);
     CryptoPro::CBlob blobSignedMessage;
 
-    boost::shared_ptr<CPPCadesCPSignerObject> pSignerCppCadesImpl;
+    NS_SHARED_PTR::shared_ptr<CPPCadesCPSignerObject> pSignerCppCadesImpl;
     if (signer) {
         pSignerCppCadesImpl = signer->m_pCppCadesImpl;
     }

data/ext/rucades/rucades_signed_data.h

@@ -14,7 +14,7 @@
 namespace rucades {
 class pre_rb_SignedData {
   protected:
-    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesSignedDataObject> m_pCppCadesImpl;
+    NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesSignedDataObject> m_pCppCadesImpl;
   public:
     pre_rb_SignedData(void);
     long get_content_encoding(void);

data/ext/rucades/rucades_signed_xml.cpp

@@ -13,7 +13,7 @@ using namespace CryptoPro::PKI::CAdES;
 
 namespace rucades {
 pre_rb_SignedXML::pre_rb_SignedXML(void):
-    m_pCppCadesImpl(boost::shared_ptr<CPPCadesSignedXMLObject>(new CPPCadesSignedXMLObject())) { }
+    m_pCppCadesImpl(NS_SHARED_PTR::shared_ptr<CPPCadesSignedXMLObject>(new CPPCadesSignedXMLObject())) { }
 
 std::string pre_rb_SignedXML::get_content(void)
 {
@@ -48,7 +48,7 @@ void pre_rb_SignedXML::set_signature_method(std::string method)
 
 pre_rb_Signers pre_rb_SignedXML::get_signers(void)
 {
-    boost::shared_ptr<CPPCadesCPSignersObject> pSigners = boost::shared_ptr<CPPCadesCPSignersObject>(new CPPCadesCPSignersObject());
+    NS_SHARED_PTR::shared_ptr<CPPCadesCPSignersObject> pSigners = NS_SHARED_PTR::shared_ptr<CPPCadesCPSignersObject>(new CPPCadesCPSignersObject());
     hr_method_check(m_pCppCadesImpl->get_Signers(pSigners));
     return pre_rb_Signers(pSigners);
 }

data/ext/rucades/rucades_signed_xml.h

@@ -12,7 +12,7 @@
 namespace rucades {
 class pre_rb_SignedXML {
   protected:
-    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesSignedXMLObject> m_pCppCadesImpl;
+    NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesSignedXMLObject> m_pCppCadesImpl;
   public:
     pre_rb_SignedXML(void);
     std::string get_content(void);

data/ext/rucades/rucades_signer.cpp

@@ -13,14 +13,14 @@ using namespace CryptoPro::PKI::CAdES;
 
 namespace rucades {
 pre_rb_Signer::pre_rb_Signer(void):
-      m_pCppCadesImpl(boost::shared_ptr<CPPCadesCPSignerObject>(new CPPCadesCPSignerObject())) { }
+      m_pCppCadesImpl(NS_SHARED_PTR::shared_ptr<CPPCadesCPSignerObject>(new CPPCadesCPSignerObject())) { }
 
-pre_rb_Signer::pre_rb_Signer(boost::shared_ptr<CPPCadesCPSignerObject> other):
+pre_rb_Signer::pre_rb_Signer(NS_SHARED_PTR::shared_ptr<CPPCadesCPSignerObject> other):
         m_pCppCadesImpl(other) { }
 
 pre_rb_Certificate* pre_rb_Signer::get_certificate(void)
 {
-    boost::shared_ptr<CPPCadesCPCertificateObject> pCert = boost::shared_ptr<CPPCadesCPCertificateObject>(new CPPCadesCPCertificateObject());
+    NS_SHARED_PTR::shared_ptr<CPPCadesCPCertificateObject> pCert = NS_SHARED_PTR::shared_ptr<CPPCadesCPCertificateObject>(new CPPCadesCPCertificateObject());
     hr_method_check(m_pCppCadesImpl->get_Certificate(pCert));
     return new pre_rb_Certificate(pCert);
 }
@@ -29,7 +29,7 @@ void pre_rb_Signer::set_certificate(pre_rb_Certificate& cert)
 {
     CCertContext certContext;
     hr_method_check(cert.m_pCppCadesImpl->get_CertContext(certContext));
-    boost::shared_ptr<CPPCadesCPCertificateObject> pCPPCadesCPCert(new CPPCadesCPCertificateObject());
+    NS_SHARED_PTR::shared_ptr<CPPCadesCPCertificateObject> pCPPCadesCPCert(new CPPCadesCPCertificateObject());
     pCPPCadesCPCert->put_CertContext(certContext);
     hr_method_check(m_pCppCadesImpl->put_Certificate(pCPPCadesCPCert));
 }
@@ -71,7 +71,7 @@ void pre_rb_Signer::set_tsa_address(std::string addr)
 
 pre_rb_Attributes pre_rb_Signer::get_unauthenticated_attributes(void)
 {
-    boost::shared_ptr<CPPCadesCPAttributesObject> pAttrs = boost::shared_ptr<CPPCadesCPAttributesObject>(new CPPCadesCPAttributesObject());
+    NS_SHARED_PTR::shared_ptr<CPPCadesCPAttributesObject> pAttrs = NS_SHARED_PTR::shared_ptr<CPPCadesCPAttributesObject>(new CPPCadesCPAttributesObject());
     hr_method_check(m_pCppCadesImpl->get_UnauthenticatedAttributes(pAttrs));
     return pre_rb_Attributes(pAttrs);
 }
@@ -83,7 +83,7 @@ void pre_rb_Signer::set_unauthenticated_attributes(pre_rb_Attributes& attrb)
 
 pre_rb_Attributes pre_rb_Signer::get_authenticated_attributes(void)
 {
-    boost::shared_ptr<CPPCadesCPAttributesObject> pAttrs = boost::shared_ptr<CPPCadesCPAttributesObject>(new CPPCadesCPAttributesObject());
+    NS_SHARED_PTR::shared_ptr<CPPCadesCPAttributesObject> pAttrs = NS_SHARED_PTR::shared_ptr<CPPCadesCPAttributesObject>(new CPPCadesCPAttributesObject());
     hr_method_check(m_pCppCadesImpl->get_AuthenticatedAttributes(pAttrs));
     return pre_rb_Attributes(pAttrs);
 }
@@ -95,14 +95,14 @@ void pre_rb_Signer::set_authenticated_attributes(pre_rb_Attributes& attrb)
 
 pre_rb_Blobs pre_rb_Signer::get_crls(void)
 {
-    boost::shared_ptr<CPPCadesCPBlobsObject> pBlobs = boost::shared_ptr<CPPCadesCPBlobsObject>(new CPPCadesCPBlobsObject());
+    NS_SHARED_PTR::shared_ptr<CPPCadesCPBlobsObject> pBlobs = NS_SHARED_PTR::shared_ptr<CPPCadesCPBlobsObject>(new CPPCadesCPBlobsObject());
     hr_method_check(m_pCppCadesImpl->get_CRLs(pBlobs));
     return pre_rb_Blobs(pBlobs);
 }
 
 pre_rb_Blobs pre_rb_Signer::get_ocsp_responses(void)
 {
-    boost::shared_ptr<CPPCadesCPBlobsObject> pBlobs = boost::shared_ptr<CPPCadesCPBlobsObject>(new CPPCadesCPBlobsObject());
+    NS_SHARED_PTR::shared_ptr<CPPCadesCPBlobsObject> pBlobs = NS_SHARED_PTR::shared_ptr<CPPCadesCPBlobsObject>(new CPPCadesCPBlobsObject());
     hr_method_check(m_pCppCadesImpl->get_OCSPResponses(pBlobs));
     return pre_rb_Blobs(pBlobs);
 }

data/ext/rucades/rucades_signer.h

@@ -13,10 +13,10 @@
 namespace rucades {
 class pre_rb_Signer {
   protected:
-    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPSignerObject> m_pCppCadesImpl;
+    NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPSignerObject> m_pCppCadesImpl;
   public:
     pre_rb_Signer(void);
-    pre_rb_Signer(boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPSignerObject> other);
+    pre_rb_Signer(NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPSignerObject> other);
 
     pre_rb_Certificate* get_certificate(void);
     void set_certificate(pre_rb_Certificate& crt);

data/ext/rucades/rucades_signers.cpp

@@ -14,9 +14,9 @@ using namespace CryptoPro::PKI::CAdES;
 
 namespace rucades {
 pre_rb_Signers::pre_rb_Signers(void):
-      m_pCppCadesImpl(boost::shared_ptr<CPPCadesCPSignersObject>(new CPPCadesCPSignersObject())) { }
+      m_pCppCadesImpl(NS_SHARED_PTR::shared_ptr<CPPCadesCPSignersObject>(new CPPCadesCPSignersObject())) { }
 
-pre_rb_Signers::pre_rb_Signers(boost::shared_ptr<CPPCadesCPSignersObject> other):
+pre_rb_Signers::pre_rb_Signers(NS_SHARED_PTR::shared_ptr<CPPCadesCPSignersObject> other):
       m_pCppCadesImpl(other) { }
 
 long pre_rb_Signers::get_count(void){

data/ext/rucades/rucades_signers.h

@@ -12,10 +12,10 @@
 namespace rucades {
 class pre_rb_Signers {
   protected:
-    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPSignersObject> m_pCppCadesImpl;
+    NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPSignersObject> m_pCppCadesImpl;
   public:
     pre_rb_Signers(void);
-    pre_rb_Signers(boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPSignersObject> other);
+    pre_rb_Signers(NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPSignersObject> other);
     void add(pre_rb_Signers& signer);
     long get_count(void);
     pre_rb_Signer get_item(long index);

data/ext/rucades/rucades_store.cpp

@@ -13,7 +13,7 @@ using namespace CryptoPro::PKI::CAdES;
 
 namespace rucades {
 pre_rb_Store::pre_rb_Store(void):
-      m_pCppCadesImpl(boost::shared_ptr<CPPCadesCPStoreObject>(new CPPCadesCPStoreObject())) { }
+      m_pCppCadesImpl(NS_SHARED_PTR::shared_ptr<CPPCadesCPStoreObject>(new CPPCadesCPStoreObject())) { }
 
 std::string pre_rb_Store::get_name(void)
 {
@@ -24,7 +24,7 @@ std::string pre_rb_Store::get_name(void)
 
 pre_rb_Certificates pre_rb_Store::get_certificates(void)
 {
-    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPCertificatesObject> pCertificates;
+    NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPCertificatesObject> pCertificates;
     hr_method_check(m_pCppCadesImpl->get_Certificates(pCertificates));
     return pre_rb_Certificates(pCertificates);
 }

data/ext/rucades/rucades_store.h

@@ -14,7 +14,7 @@
 namespace rucades {
 class pre_rb_Store {
   protected:
-    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPStoreObject> m_pCppCadesImpl;
+    NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesCPStoreObject> m_pCppCadesImpl;
   public:
     pre_rb_Store(void);
 

data/ext/rucades/rucades_symmetric_algorithm.cpp

@@ -14,9 +14,9 @@ using namespace CryptoPro::PKI::CAdES;
 
 namespace rucades {
 pre_rb_SymmetricAlgorithm::pre_rb_SymmetricAlgorithm(void):
-      m_pCppCadesImpl(boost::shared_ptr<CPPCadesSymmetricAlgorithmObject>(new CPPCadesSymmetricAlgorithmObject())) { }
+      m_pCppCadesImpl(NS_SHARED_PTR::shared_ptr<CPPCadesSymmetricAlgorithmObject>(new CPPCadesSymmetricAlgorithmObject())) { }
 
-pre_rb_SymmetricAlgorithm::pre_rb_SymmetricAlgorithm(boost::shared_ptr<CPPCadesSymmetricAlgorithmObject> other):
+pre_rb_SymmetricAlgorithm::pre_rb_SymmetricAlgorithm(NS_SHARED_PTR::shared_ptr<CPPCadesSymmetricAlgorithmObject> other):
       m_pCppCadesImpl(other) { }
 
 std::string pre_rb_SymmetricAlgorithm::get_divers_data(void)
@@ -59,7 +59,7 @@ std::string pre_rb_SymmetricAlgorithm::decrypt(std::string data, bool final)
 
 pre_rb_SymmetricAlgorithm pre_rb_SymmetricAlgorithm::diversify_key(void)
 {
-    boost::shared_ptr<CPPCadesSymmetricAlgorithmObject> pCPPCadesSymAlg;
+    NS_SHARED_PTR::shared_ptr<CPPCadesSymmetricAlgorithmObject> pCPPCadesSymAlg;
     hr_method_check(m_pCppCadesImpl->DiversifyKey(pCPPCadesSymAlg));
     return pre_rb_SymmetricAlgorithm(pCPPCadesSymAlg);
 }

data/ext/rucades/rucades_symmetric_algorithm.h

@@ -11,10 +11,10 @@
 namespace rucades {
 class pre_rb_SymmetricAlgorithm {
   protected:
-    boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesSymmetricAlgorithmObject> m_pCppCadesImpl;
+    NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesSymmetricAlgorithmObject> m_pCppCadesImpl;
   public:
     pre_rb_SymmetricAlgorithm(void);
-    pre_rb_SymmetricAlgorithm(boost::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesSymmetricAlgorithmObject> other);
+    pre_rb_SymmetricAlgorithm(NS_SHARED_PTR::shared_ptr<CryptoPro::PKI::CAdES::CPPCadesSymmetricAlgorithmObject> other);
     std::string get_divers_data(void);
     void set_divers_data(std::string data);
     std::string get_iv(void);