pghs975uc
/
infer_clone
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Create initial vector header for models

Browse Source 
Summary: Create "empty" vector model header. The actual model implementation will come in next diffs to simplify review process.

Reviewed By: dulmarod

Differential Revision: D3240683

fb-gh-sync-id: 03ee002
fbshipit-source-id: 03ee002
master
Andrzej Kotulski 9 years ago committed by Facebook Github Bot 8
parent 6f6da12b2c
commit 3340a9e8a5
3 changed files with 531 additions and 0 deletions
Show Stats Download Patch File Download Diff File

3
infer/models/cpp/include/infer_model/portability.h
Unescape View File

@ -40,11 +40,14 @@
// llvm's libc++. This way folly can forward declare decls from std library
// even when they are infer models
// https://github.com/facebook/folly/blob/b1eb6819f3ffe6b645f39d505ca8ace3116b7873/folly/Portability.h#L253-L255
// On top of that, define platform-dependent STL iterators.
#if INFER_USE_LIBCPP
#include <__config>
#define INFER_NAMESPACE_STD_BEGIN _LIBCPP_BEGIN_NAMESPACE_STD
#define INFER_NAMESPACE_STD_END _LIBCPP_END_NAMESPACE_STD
#define STD_ITER(T, C) __wrap_iter<T>
#else
#define INFER_NAMESPACE_STD_BEGIN namespace std {
#define INFER_NAMESPACE_STD_END }
#define STD_ITER(T, C) __gnu_cxx::__normal_iterator<T, C>
#endif

518
infer/models/cpp/include/infer_model/vector.h
Unescape View File

@ -0,0 +1,518 @@
/*
* Copyright (c) 2016 - present Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*/
#pragma once
#include <type_traits>
#include <climits>
#include <limits>
#include <initializer_list>
#include <stdexcept>
#include <memory>
#include <cstring>
#include <cassert>
#include <infer_model/common.h>
#ifdef INFER_USE_LIBCPP
// libc++ vector header includes it, but it breaks
// compilation with stdlibc++ implementation
#include <algorithm>
#endif
INFER_NAMESPACE_STD_BEGIN
struct bool_ref {
bool_ref& operator=(bool x) {}
bool_ref& operator=(const bool_ref& x) {}
operator bool() const noexcept {}
void flip() noexcept {}
// not part of C++ std, but required for model implementation to compile
explicit bool_ref(bool x) {}
};
template <class T>
struct vector_ref {
typedef T& ref;
};
template <>
struct vector_ref<bool> {
typedef bool_ref ref;
};
// WARNING: do not add any new fields to std::vector model. sizeof(std::vector)
// = 24 !!
template <class _Tp, class _Allocator = allocator<_Tp>>
class vector {
public:
typedef vector __self;
typedef _Tp value_type;
typedef _Allocator allocator_type;
typedef allocator_traits<allocator_type> __alloc_traits;
typedef typename vector_ref<value_type>::ref reference;
typedef const value_type& const_reference;
typedef typename __alloc_traits::size_type size_type;
typedef typename __alloc_traits::difference_type difference_type;
typedef typename __alloc_traits::pointer pointer;
typedef typename __alloc_traits::const_pointer const_pointer;
typedef STD_ITER(pointer, vector) iterator;
typedef STD_ITER(const_pointer, vector) const_iterator;
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
bool isEmpty = true;
mutable value_type* modelPtr = nullptr;
// intended to keep semantics of empty vector
// vector.begin() == vector.end() <=> vector.empty()
// also required to keep sizeof(std::vector) same.
value_type* endPtr = nullptr;
~vector() {}
vector() noexcept(is_nothrow_default_constructible<allocator_type>::value) {}
explicit vector(const allocator_type& __a) noexcept {}
explicit vector(size_type __n);
// introduced in C++14
explicit vector(size_type __n, const allocator_type& __a);
vector(size_type __n, const_reference __x);
vector(size_type __n, const_reference __x, const allocator_type& __a);
template <class _ForwardIterator>
vector(_ForwardIterator __first,
typename enable_if<
is_constructible<
value_type,
typename iterator_traits<_ForwardIterator>::reference>::value,
_ForwardIterator>::type __last);
template <class _ForwardIterator>
vector(_ForwardIterator __first,
_ForwardIterator __last,
const allocator_type& __a,
typename enable_if<is_constructible<
value_type,
typename iterator_traits<_ForwardIterator>::reference>::value>::
type* = 0);
vector(initializer_list<value_type> __il);
vector(initializer_list<value_type> __il, const allocator_type& __a);
vector(const vector& __x);
vector(const vector& __x, const allocator_type& __a);
vector& operator=(const vector& __x);
vector(vector&& __x) noexcept;
vector(vector&& __x, const allocator_type& __a);
vector& operator=(vector&& __x) noexcept;
/*((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value)); */
vector& operator=(initializer_list<value_type> __il) {
assign(__il.begin(), __il.end());
return *this;
}
template <class _ForwardIterator>
typename enable_if<is_constructible<value_type,
typename iterator_traits<
_ForwardIterator>::reference>::value,
void>::type
assign(_ForwardIterator __first, _ForwardIterator __last);
void assign(size_type __n, const_reference __u);
void assign(initializer_list<value_type> __il) {
assign(__il.begin(), __il.end());
}
allocator_type get_allocator() const {}
iterator begin() noexcept;
const_iterator begin() const noexcept;
iterator end() noexcept;
const_iterator end() const noexcept;
reverse_iterator rbegin() noexcept { return reverse_iterator(end()); }
const_reverse_iterator rbegin() const noexcept {
return const_reverse_iterator(end());
}
reverse_iterator rend() noexcept { return reverse_iterator(begin()); }
const_reverse_iterator rend() const noexcept {
return const_reverse_iterator(begin());
}
const_iterator cbegin() const noexcept { return begin(); }
const_iterator cend() const noexcept { return end(); }
const_reverse_iterator crbegin() const noexcept { return rbegin(); }
const_reverse_iterator crend() const noexcept { return rend(); }
size_type size() const noexcept { /* TODO */
}
size_type capacity() const noexcept { /* TODO */
}
bool empty() const noexcept { /* TODO */
}
size_type max_size() const noexcept;
void reserve(size_type __n);
void shrink_to_fit() noexcept;
reference operator[](size_type __n);
const_reference operator[](size_type __n) const;
reference at(size_type __n);
const_reference at(size_type __n) const;
reference front() {}
const_reference front() const {}
reference back() {}
const_reference back() const {}
value_type* data() noexcept {}
const value_type* data() const noexcept {}
void push_back(const_reference __x);
void push_back(value_type&& __x);
template <class... _Args>
void emplace_back(_Args&&... __args);
void pop_back();
iterator insert(const_iterator __position, const_reference __x);
iterator insert(const_iterator __position, value_type&& __x);
template <class... _Args>
iterator emplace(const_iterator __position, _Args&&... __args);
iterator insert(const_iterator __position,
size_type __n,
const_reference __x);
template <class _ForwardIterator>
typename enable_if<is_constructible<value_type,
typename iterator_traits<
_ForwardIterator>::reference>::value,
iterator>::type
insert(const_iterator __position,
_ForwardIterator __first,
_ForwardIterator __last);
iterator insert(const_iterator __position,
initializer_list<value_type> __il) {
return insert(__position, __il.begin(), __il.end());
}
iterator erase(const_iterator __position);
iterator erase(const_iterator __first, const_iterator __last);
void clear() noexcept { /* TODO */
}
void resize(size_type __sz);
void resize(size_type __sz, const_reference __x);
// NOTE c++17 adds noexcept
void swap(vector&);
private:
iterator __make_iter(pointer __p) noexcept;
const_iterator __make_iter(const_pointer __p) const noexcept;
};
template <class _Tp, class _Allocator>
typename vector<_Tp, _Allocator>::size_type vector<_Tp, _Allocator>::max_size()
const noexcept {
/*TODO*/
}
template <class _Tp, class _Allocator>
vector<_Tp, _Allocator>::vector(size_type __n) {}
template <class _Tp, class _Allocator>
vector<_Tp, _Allocator>::vector(size_type __n, const allocator_type& __a) {}
template <class _Tp, class _Allocator>
vector<_Tp, _Allocator>::vector(size_type __n, const_reference __x) {}
template <class _Tp, class _Allocator>
vector<_Tp, _Allocator>::vector(size_type __n,
const_reference __x,
const allocator_type& __a) {}
template <class _Tp, class _Allocator>
template <class _ForwardIterator>
vector<_Tp, _Allocator>::vector(
_ForwardIterator __first,
typename enable_if<
is_constructible<
value_type,
typename iterator_traits<_ForwardIterator>::reference>::value,
_ForwardIterator>::type __last) {}
template <class _Tp, class _Allocator>
template <class _ForwardIterator>
vector<_Tp, _Allocator>::vector(
_ForwardIterator __first,
_ForwardIterator __last,
const allocator_type& __a,
typename enable_if<is_constructible<
value_type,
typename iterator_traits<_ForwardIterator>::reference>::value>::type*) {
}
template <class _Tp, class _Allocator>
vector<_Tp, _Allocator>::vector(const vector& __x) {}
template <class _Tp, class _Allocator>
vector<_Tp, _Allocator>::vector(const vector& __x, const allocator_type& __a) {}
template <class _Tp, class _Allocator>
inline vector<_Tp, _Allocator>::vector(vector&& __x) noexcept {
/* TODO - this->data = __x.data; __x.data = nullptr;
*/
}
template <class _Tp, class _Allocator>
inline vector<_Tp, _Allocator>::vector(vector&& __x,
const allocator_type& __a) {
/* TODO - see above */
}
template <class _Tp, class _Allocator>
inline vector<_Tp, _Allocator>::vector(initializer_list<value_type> __il) {}
template <class _Tp, class _Allocator>
inline vector<_Tp, _Allocator>::vector(initializer_list<value_type> __il,
const allocator_type& __a) {}
template <class _Tp, class _Allocator>
inline vector<_Tp, _Allocator>& vector<_Tp, _Allocator>::operator=(
vector&& __x) noexcept /*((__noexcept_move_assign_container<_Allocator,
__alloc_traits>::value)) */
{
/* TODO - see above */
}
template <class _Tp, class _Allocator>
inline vector<_Tp, _Allocator>& vector<_Tp, _Allocator>::operator=(
const vector& __x) {
if (this != &__x) {
// assign(__x.__begin_, __x.__end_);
}
return *this;
}
template <class _Tp, class _Allocator>
template <class _ForwardIterator>
typename enable_if<is_constructible<_Tp,
typename iterator_traits<
_ForwardIterator>::reference>::value,
void>::type
vector<_Tp, _Allocator>::assign(_ForwardIterator __first,
_ForwardIterator __last) {}
template <class _Tp, class _Allocator>
void vector<_Tp, _Allocator>::assign(size_type __n, const_reference __u) {}
template <class _Tp, class _Allocator>
inline typename vector<_Tp, _Allocator>::iterator
vector<_Tp, _Allocator>::__make_iter(pointer __p) noexcept {
return iterator(__p);
}
template <class _Tp, class _Allocator>
inline typename vector<_Tp, _Allocator>::const_iterator
vector<_Tp, _Allocator>::__make_iter(const_pointer __p) const noexcept {
return const_iterator(__p);
}
template <class _Tp, class _Allocator>
inline typename vector<_Tp, _Allocator>::iterator
vector<_Tp, _Allocator>::begin() noexcept {
// return __make_iter(this->__begin_);
}
template <class _Tp, class _Allocator>
inline typename vector<_Tp, _Allocator>::const_iterator
vector<_Tp, _Allocator>::begin() const noexcept {
// return __make_iter(this->__begin_);
}
template <class _Tp, class _Allocator>
inline typename vector<_Tp, _Allocator>::iterator
vector<_Tp, _Allocator>::end() noexcept {
// return __make_iter(this->__end_);
}
template <class _Tp, class _Allocator>
inline typename vector<_Tp, _Allocator>::const_iterator
vector<_Tp, _Allocator>::end() const noexcept {
// return __make_iter(this->__end_);
}
template <class _Tp, class _Allocator>
inline typename vector<_Tp, _Allocator>::reference vector<_Tp, _Allocator>::
operator[](size_type __n) {}
template <class _Tp, class _Allocator>
inline typename vector<_Tp, _Allocator>::const_reference
vector<_Tp, _Allocator>::operator[](size_type __n) const {}
template <class _Tp, class _Allocator>
typename vector<_Tp, _Allocator>::reference vector<_Tp, _Allocator>::at(
size_type __n) {}
template <class _Tp, class _Allocator>
typename vector<_Tp, _Allocator>::const_reference vector<_Tp, _Allocator>::at(
size_type __n) const {}
template <class _Tp, class _Allocator>
void vector<_Tp, _Allocator>::reserve(size_type __n) {}
template <class _Tp, class _Allocator>
void vector<_Tp, _Allocator>::shrink_to_fit() noexcept {}
template <class _Tp, class _Allocator>
inline void vector<_Tp, _Allocator>::push_back(const_reference __x) {}
template <class _Tp, class _Allocator>
inline void vector<_Tp, _Allocator>::push_back(value_type&& __x) {}
template <class _Tp, class _Allocator>
template <class... _Args>
inline void vector<_Tp, _Allocator>::emplace_back(_Args&&... __args) {
/* TODO - consider constructing the object
__alloc_traits::construct(this->__alloc(),
_VSTD::__to_raw_pointer(this->__end_),
_VSTD::forward<_Args>(__args)...);
*/
}
template <class _Tp, class _Allocator>
inline void vector<_Tp, _Allocator>::pop_back() {
// dereference the object
}
template <class _Tp, class _Allocator>
inline typename vector<_Tp, _Allocator>::iterator
vector<_Tp, _Allocator>::erase(const_iterator __position) {
// dereference the object
/* TODO return __r;*/
}
template <class _Tp, class _Allocator>
typename vector<_Tp, _Allocator>::iterator vector<_Tp, _Allocator>::erase(
const_iterator __first, const_iterator __last) {
// dereference the object
/* TODO return __r;*/
}
template <class _Tp, class _Allocator>
typename vector<_Tp, _Allocator>::iterator vector<_Tp, _Allocator>::insert(
const_iterator __position, const_reference __x) {}
template <class _Tp, class _Allocator>
typename vector<_Tp, _Allocator>::iterator vector<_Tp, _Allocator>::insert(
const_iterator __position, value_type&& __x) {}
template <class _Tp, class _Allocator>
template <class... _Args>
typename vector<_Tp, _Allocator>::iterator vector<_Tp, _Allocator>::emplace(
const_iterator __position, _Args&&... __args) {
// TODO consider constructing the object
}
template <class _Tp, class _Allocator>
typename vector<_Tp, _Allocator>::iterator vector<_Tp, _Allocator>::insert(
const_iterator __position, size_type __n, const_reference __x) {}
template <class _Tp, class _Allocator>
template <class _ForwardIterator>
typename enable_if<is_constructible<_Tp,
typename iterator_traits<
_ForwardIterator>::reference>::value,
typename vector<_Tp, _Allocator>::iterator>::type
vector<_Tp, _Allocator>::insert(const_iterator __position,
_ForwardIterator __first,
_ForwardIterator __last) {
// TODO return __make_iter(__p);
}
template <class _Tp, class _Allocator>
void vector<_Tp, _Allocator>::resize(size_type __sz) {}
template <class _Tp, class _Allocator>
void vector<_Tp, _Allocator>::resize(size_type __sz, const_reference __x) {}
template <class _Tp, class _Allocator>
void vector<_Tp, _Allocator>::swap(vector& __x) {}
template <class _Allocator>
struct hash<vector<bool, _Allocator>>
: public unary_function<vector<bool, _Allocator>, size_t> {
size_t operator()(const vector<bool, _Allocator>& __vec) const noexcept {}
};
template <class _Tp, class _Allocator>
inline bool operator==(const vector<_Tp, _Allocator>& __x,
const vector<_Tp, _Allocator>& __y) {
const typename vector<_Tp, _Allocator>::size_type __sz = __x.size();
return __sz == __y.size() && equal(__x.begin(), __x.end(), __y.begin());
}
template <class _Tp, class _Allocator>
inline bool operator!=(const vector<_Tp, _Allocator>& __x,
const vector<_Tp, _Allocator>& __y) {
return !(__x == __y);
}
template <class _Tp, class _Allocator>
inline bool operator<(const vector<_Tp, _Allocator>& __x,
const vector<_Tp, _Allocator>& __y) {
return lexicographical_compare(
__x.begin(), __x.end(), __y.begin(), __y.end());
}
template <class _Tp, class _Allocator>
inline bool operator>(const vector<_Tp, _Allocator>& __x,
const vector<_Tp, _Allocator>& __y) {
return __y < __x;
}
template <class _Tp, class _Allocator>
inline bool operator>=(const vector<_Tp, _Allocator>& __x,
const vector<_Tp, _Allocator>& __y) {
return !(__x < __y);
}
template <class _Tp, class _Allocator>
inline bool operator<=(const vector<_Tp, _Allocator>& __x,
const vector<_Tp, _Allocator>& __y) {
return !(__y < __x);
}
template <class _Tp, class _Allocator>
inline void swap(vector<_Tp, _Allocator>& __x, vector<_Tp, _Allocator>& __y) {
__x.swap(__y);
}
INFER_NAMESPACE_STD_END

10
infer/models/cpp/include/vector
Unescape View File

@ -0,0 +1,10 @@
#include <infer_model/portability.h>
#ifdef INFER_CPP11_ON
#include<infer_model/vector.h>
#else
// don't model std::vector pre-c++11 to
// simplify implementation
#include_next <vector>
#endif
Write Preview
Loading…
Cancel
Save