srcnativelibs.Include.OpenCV.opencv2.flann.any.h Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of sikulixlibslux Show documentation
... for visual testing and automation (Linux native support)
The newest version!
#ifndef OPENCV_FLANN_ANY_H_
#define OPENCV_FLANN_ANY_H_
/*
 * (C) Copyright Christopher Diggins 2005-2011
 * (C) Copyright Pablo Aguilar 2005
 * (C) Copyright Kevlin Henney 2001
 *
 * Distributed under the Boost Software License, Version 1.0. (See
 * accompanying file LICENSE_1_0.txt or copy at
 * http://www.boost.org/LICENSE_1_0.txt
 *
 * Adapted for FLANN by Marius Muja
 */

#include "defines.h"
#include 
#include 
#include 

namespace cvflann
{

namespace anyimpl
{

struct bad_any_cast
{
};

struct empty_any
{
};

inline std::ostream& operator <<(std::ostream& out, const empty_any&)
{
    out << "[empty_any]";
    return out;
}

struct base_any_policy
{
    virtual void static_delete(void** x) = 0;
    virtual void copy_from_value(void const* src, void** dest) = 0;
    virtual void clone(void* const* src, void** dest) = 0;
    virtual void move(void* const* src, void** dest) = 0;
    virtual void* get_value(void** src) = 0;
    virtual ::size_t get_size() = 0;
    virtual const std::type_info& type() = 0;
    virtual void print(std::ostream& out, void* const* src) = 0;

#ifdef OPENCV_CAN_BREAK_BINARY_COMPATIBILITY
    virtual ~base_any_policy() {}
#endif
};

template
struct typed_base_any_policy : base_any_policy
{
    virtual ::size_t get_size() { return sizeof(T); }
    virtual const std::type_info& type() { return typeid(T); }

};

template
struct small_any_policy : typed_base_any_policy
{
    virtual void static_delete(void**) { }
    virtual void copy_from_value(void const* src, void** dest)
    {
        new (dest) T(* reinterpret_cast(src));
    }
    virtual void clone(void* const* src, void** dest) { *dest = *src; }
    virtual void move(void* const* src, void** dest) { *dest = *src; }
    virtual void* get_value(void** src) { return reinterpret_cast(src); }
    virtual void print(std::ostream& out, void* const* src) { out << *reinterpret_cast(src); }
};

template
struct big_any_policy : typed_base_any_policy
{
    virtual void static_delete(void** x)
    {
        if (* x) delete (* reinterpret_cast(x)); *x = NULL;
    }
    virtual void copy_from_value(void const* src, void** dest)
    {
        *dest = new T(*reinterpret_cast(src));
    }
    virtual void clone(void* const* src, void** dest)
    {
        *dest = new T(**reinterpret_cast(src));
    }
    virtual void move(void* const* src, void** dest)
    {
        (*reinterpret_cast(dest))->~T();
        **reinterpret_cast(dest) = **reinterpret_cast(src);
    }
    virtual void* get_value(void** src) { return *src; }
    virtual void print(std::ostream& out, void* const* src) { out << *reinterpret_cast(*src); }
};

template<> inline void big_any_policy::print(std::ostream& out, void* const* src)
{
    out << int(*reinterpret_cast(*src));
}

template<> inline void big_any_policy::print(std::ostream& out, void* const* src)
{
    out << int(*reinterpret_cast(*src));
}

template
struct choose_policy
{
    typedef big_any_policy type;
};

template
struct choose_policy
{
    typedef small_any_policy type;
};

struct any;

/// Choosing the policy for an any type is illegal, but should never happen.
/// This is designed to throw a compiler error.
template<>
struct choose_policy
{
    typedef void type;
};

/// Specializations for small types.
#define SMALL_POLICY(TYPE) \
    template<> \
    struct choose_policy { typedef small_any_policy type; \
    }

SMALL_POLICY(signed char);
SMALL_POLICY(unsigned char);
SMALL_POLICY(signed short);
SMALL_POLICY(unsigned short);
SMALL_POLICY(signed int);
SMALL_POLICY(unsigned int);
SMALL_POLICY(signed long);
SMALL_POLICY(unsigned long);
SMALL_POLICY(float);
SMALL_POLICY(bool);

#undef SMALL_POLICY

/// This function will return a different policy for each type.
template
base_any_policy* get_policy()
{
    static typename choose_policy::type policy;
    return &policy;
}
} // namespace anyimpl

struct any
{
private:
    // fields
    anyimpl::base_any_policy* policy;
    void* object;

public:
    /// Initializing constructor.
    template 
    any(const T& x)
        : policy(anyimpl::get_policy()), object(NULL)
    {
        assign(x);
    }

    /// Empty constructor.
    any()
        : policy(anyimpl::get_policy()), object(NULL)
    { }

    /// Special initializing constructor for string literals.
    any(const char* x)
        : policy(anyimpl::get_policy()), object(NULL)
    {
        assign(x);
    }

    /// Copy constructor.
    any(const any& x)
        : policy(anyimpl::get_policy()), object(NULL)
    {
        assign(x);
    }

    /// Destructor.
    ~any()
    {
        policy->static_delete(&object);
    }

    /// Assignment function from another any.
    any& assign(const any& x)
    {
        reset();
        policy = x.policy;
        policy->clone(&x.object, &object);
        return *this;
    }

    /// Assignment function.
    template 
    any& assign(const T& x)
    {
        reset();
        policy = anyimpl::get_policy();
        policy->copy_from_value(&x, &object);
        return *this;
    }

    /// Assignment operator.
    template
    any& operator=(const T& x)
    {
        return assign(x);
    }

    /// Assignment operator, specialed for literal strings.
    /// They have types like const char [6] which don't work as expected.
    any& operator=(const char* x)
    {
        return assign(x);
    }

    /// Utility functions
    any& swap(any& x)
    {
        std::swap(policy, x.policy);
        std::swap(object, x.object);
        return *this;
    }

    /// Cast operator. You can only cast to the original type.
    template
    T& cast()
    {
        if (policy->type() != typeid(T)) throw anyimpl::bad_any_cast();
        T* r = reinterpret_cast(policy->get_value(&object));
        return *r;
    }

    /// Cast operator. You can only cast to the original type.
    template
    const T& cast() const
    {
        if (policy->type() != typeid(T)) throw anyimpl::bad_any_cast();
        T* r = reinterpret_cast(policy->get_value(const_cast(&object)));
        return *r;
    }

    /// Returns true if the any contains no value.
    bool empty() const
    {
        return policy->type() == typeid(anyimpl::empty_any);
    }

    /// Frees any allocated memory, and sets the value to NULL.
    void reset()
    {
        policy->static_delete(&object);
        policy = anyimpl::get_policy();
    }

    /// Returns true if the two types are the same.
    bool compatible(const any& x) const
    {
        return policy->type() == x.policy->type();
    }

    /// Returns if the type is compatible with the policy
    template
    bool has_type()
    {
        return policy->type() == typeid(T);
    }

    const std::type_info& type() const
    {
        return policy->type();
    }

    friend std::ostream& operator <<(std::ostream& out, const any& any_val);
};

inline std::ostream& operator <<(std::ostream& out, const any& any_val)
{
    any_val.policy->print(out,&any_val.object);
    return out;
}

}

#endif // OPENCV_FLANN_ANY_H_