PKIFdll.h

Go to the documentation of this file.

#ifndef _PKIFDLL_H_
#define _PKIFDLL_H_

#include "config.h"

#if defined(WIN32) || defined(_WIN32)
    #define WIN32_LEAN_AND_MEAN
#if !defined(_WIN32_WINNT)
    #define _WIN32_WINNT 0x0500
#endif
    #include "windows.h"  //need this for stuff like synchronization stuff
#endif //defined(WIN32) || defined(_WIN32)

#include <string>
#include <limits>

#include "PKIFString.h"
#include "boost/shared_ptr.hpp"
#include "pkif_shared_ptr.hpp"
//using namespace boost;

// LOKI is being removed and should not be used
#define NO_LOKI 1

#if defined(WIN32) || defined(_WIN32)
#pragma warning(disable: 4251) 
#pragma warning( disable : 4786 ) 
#endif //defined(WIN32) || defined(_WIN32)

#ifdef NO_NAMESPACE
    #define std
    #define CAC
    #define USING_NAMESPACE(x)
    #define BEGIN_NAMESPACE(x)
    #define END_NAMESPACE
    #define ANONYMOUS_NAMESPACE_BEGIN
#else
    #define USING_NAMESPACE(x) using namespace x;
    #define BEGIN_NAMESPACE(x) namespace x {
    #define ANONYMOUS_NAMESPACE_BEGIN namespace {
    #define END_NAMESPACE }
#endif

#if defined(WIN32) || defined(_WIN32)
    #define CAC_NO_VTABLE __declspec(novtable)
#else
    #define CAC_NO_VTABLE
#endif

#ifdef CAC_EXPORTS 
    #if defined(WIN32) || defined(_WIN32)
    #define CAC_API __declspec(dllexport)
    #define EXPIMP_TEMPLATE
    #endif //defined(WIN32) || defined(_WIN32)
#else
    #if defined(WIN32) || defined(_WIN32)
        #ifndef CAC_STATIC
            #define CAC_API __declspec(dllimport)
            #define EXPIMP_TEMPLATE extern
        #else
            #define CAC_API 
            #define EXPIMP_TEMPLATE extern
        #endif //CAC_STATIC
    #else
        #define CAC_API 
        #define EXPIMP_TEMPLATE extern
    #endif //defined(WIN32) || defined(_WIN32)
#endif

#ifdef CAC_COVERAGE_TEST
    #if defined(WIN32) || defined(_WIN32)
    #define CAC_TEST_API __declspec(dllexport)
    #endif //defined(WIN32) || defined(_WIN32)
#else
    #define CAC_TEST_API 
#endif

// This is in windef.h on windows and is 
//#define NULL    0

#define DECLARE_SMART_POINTERS(c) \
    typedef boost::shared_ptr<c> c##Ptr;

#define FD_SMART_PTR(c) \
    class c; \
    typedef boost::shared_ptr<c> c##Ptr

#define FD_LIST_PTR(c) \
    class c; \
    FD_SMART_PTR(c); \
    typedef std::vector<c##Ptr, PKIFAlloc<c##Ptr> > c##List; \
    DECLARE_SMART_POINTERS(c##List)

//for CPKIFCertificateNodeEntry, CPKIFCertificateNodeEntryPtr, CPKIFCertificateNodeList and CPKIFCertificateNodeListPtr
#define FD_NODE_LIST_PTR(c) \
    class c; \
    FD_SMART_PTR(c); \
    typedef std::vector<c##Ptr, PKIFAlloc<c##Ptr> > CPKIFCertificateNodeList; \
    DECLARE_SMART_POINTERS(CPKIFCertificateNodeList)

//for CPKIFCRLNodeEntry, CPKIFCRLNodeEntryPtr, CPKIFCRLNodeList and CPKIFCRLNodeListPtr
#define FD_CRL_NODE_LIST_PTR(c) \
    class c; \
    FD_SMART_PTR(c); \
    typedef std::vector<c##Ptr, PKIFAlloc<c##Ptr> > CPKIFCRLNodeList; \
    DECLARE_SMART_POINTERS(CPKIFCRLNodeList)
        
// forward declare mediator and colleague base class smart pointers. this is
// a special case since mediator became a typedef for colleague.
#define FD_MC_PTR() \
    FD_SMART_PTR(IPKIFColleague); \
    typedef IPKIFColleague IPKIFMediator; \
    typedef boost::shared_ptr<IPKIFMediator> IPKIFMediatorPtr

#if defined(WIN32) || defined(_WIN32)
CAC_API void* PKIFNew(size_t size);
void CAC_API PKIFDelete(void* p);
#else
void * PKIFNew(size_t size);
void PKIFDelete(void *p);
#endif //defined(WIN32) || defined(_WIN32)
template <class T>
class PKIFAlloc {
public:
    // type definitions
    typedef T        value_type;
    typedef T*       pointer;
    typedef const T* const_pointer;
    typedef T&       reference;
    typedef const T& const_reference;
    typedef std::size_t    size_type;
    typedef std::ptrdiff_t difference_type;

    // rebind allocator to type U
    template <class U>
    struct rebind {
        typedef PKIFAlloc<U> other;
    };

    
    pointer address (reference value) const {
        return &value;
    }
    const_pointer address (const_reference value) const {
        return &value;
    }

    /* constructors and destructor
    * - nothing to do because the allocator has no state
    */
    PKIFAlloc() throw() {
    }
    PKIFAlloc(const PKIFAlloc&) throw() {
    }
#if _MSC_VER > 1200
    template <class U>
    PKIFAlloc (const PKIFAlloc<U>&) throw() {
    }
#endif

    ~PKIFAlloc() throw() {
    }


    size_type max_size () const throw() {
        return (std::numeric_limits<std::size_t>::max)() / sizeof(T);
    }

    pointer allocate (size_type num, const void* = 0) {
        // print message and allocate memory with global new
        pointer ret = (pointer)(PKIFNew(num*sizeof(T)));
        return ret;
    }


    void construct (
        pointer p, 
        const T& value) {
            // initialize memory with placement new
            new((void*)p)T(value);
    }

    void destroy (
        pointer p) {
            // destroy objects by calling their destructor
            p->~T();
    }


    void deallocate (
        pointer p,
        size_type num) {
            // print message and deallocate memory with global delete
            PKIFDelete((void*)p);
    }
};

    // return that all specializations of this allocator are interchangeable
    template <class T1, class T2>
    bool operator== (const PKIFAlloc<T1>&,
        const PKIFAlloc<T2>&) throw() {
            return true;
    }
    template <class T1, class T2>
    bool operator!= (const PKIFAlloc<T1>&,
        const PKIFAlloc<T2>&) throw() {
            return false;
    }

#endif /* _PKIFDLL_H_ */