Skip to content
GitLab
Projects
Groups
Snippets
/
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in
Toggle navigation
Menu
Open sidebar
Gauthier Quesnel
irritator
Commits
caa44d5c
Commit
caa44d5c
authored
Sep 18, 2020
by
Gauthier Quesnel
Browse files
core: remove array and vector container
parent
adadac76
Changes
4
Hide whitespace changes
Inline
Side-by-side
app/gui/node-editor.hpp
View file @
caa44d5c
...
...
@@ -63,6 +63,7 @@ status_string(const status s) noexcept
"model_flow_bad_samplerate"
,
"model_flow_bad_data"
,
"gui_not_enough_memory"
,
"io_not_enough_memory"
,
"io_file_format_error"
,
"io_file_format_model_error"
,
"io_file_format_model_number_error"
,
...
...
lib/include/irritator/core.hpp
View file @
caa44d5c
...
...
@@ -166,6 +166,7 @@ enum class status
model_flow_bad_samplerate
,
model_flow_bad_data
,
gui_not_enough_memory
,
io_not_enough_memory
,
io_file_format_error
,
io_file_format_model_error
,
io_file_format_model_number_error
,
...
...
@@ -1456,372 +1457,6 @@ public:
}
};
template
<
typename
T
>
class
vector
{
public:
using
value_type
=
T
;
using
reference
=
T
&
;
using
const_reference
=
const
T
&
;
using
pointer
=
T
*
;
using
const_pointer
=
const
T
*
;
using
difference_type
=
std
::
ptrdiff_t
;
using
size_type
=
std
::
size_t
;
using
iterator
=
T
*
;
using
const_iterator
=
const
T
*
;
private:
value_type
*
m_items
{
nullptr
};
unsigned
m_capacity
=
0u
;
unsigned
m_size
=
0u
;
public:
vector
()
=
default
;
~
vector
()
noexcept
{
clear
();
if
(
m_items
)
std
::
free
(
m_items
);
}
vector
(
const
vector
&
)
noexcept
=
delete
;
vector
&
operator
=
(
const
vector
&
)
noexcept
=
delete
;
vector
(
vector
&&
)
noexcept
=
delete
;
vector
&
operator
=
(
vector
&&
)
noexcept
=
delete
;
status
init
(
std
::
size_t
new_capacity_
)
noexcept
{
if
(
new_capacity_
>
std
::
numeric_limits
<
unsigned
>::
max
())
return
status
::
vector_init_capacity_too_big
;
if
(
new_capacity_
==
0
)
return
status
::
vector_init_capacity_zero
;
clear
();
const
auto
new_capacity
=
static_cast
<
unsigned
int
>
(
new_capacity_
);
if
(
new_capacity
>
m_capacity
)
{
if
(
m_items
)
std
::
free
(
m_items
);
m_items
=
static_cast
<
value_type
*>
(
std
::
malloc
(
new_capacity
*
sizeof
(
value_type
)));
if
(
m_items
==
nullptr
)
return
status
::
vector_init_not_enough_memory
;
m_capacity
=
new_capacity
;
}
return
status
::
success
;
}
status
resize
(
std
::
size_t
new_capacity_
)
noexcept
{
static_assert
(
std
::
is_trivial_v
<
T
>
,
"vector::resize only for trivial data"
);
irt_return_if_bad
(
init
(
new_capacity_
));
m_size
=
m_capacity
;
return
status
::
success
;
}
void
clear
()
noexcept
{
if
constexpr
(
!
std
::
is_trivial_v
<
T
>
)
for
(
auto
i
=
0u
;
i
!=
m_size
;
++
i
)
m_items
[
i
].
~
T
();
m_size
=
0
;
}
bool
can_alloc
(
size_type
number
)
const
noexcept
{
return
number
+
m_size
<=
m_capacity
;
}
template
<
typename
...
Args
>
std
::
pair
<
bool
,
iterator
>
try_emplace_back
(
Args
&&
...
args
)
noexcept
{
if
(
!
can_alloc
(
1u
))
return
std
::
make_pair
(
false
,
end
());
unsigned
ret
=
m_size
++
;
new
(
&
m_items
[
ret
])
T
(
std
::
forward
<
Args
>
(
args
)...);
return
std
::
pair
(
true
,
begin
()
+
ret
);
}
template
<
typename
...
Args
>
iterator
emplace_back
(
Args
&&
...
args
)
noexcept
{
irt_assert
(
m_size
<
m_capacity
);
unsigned
ret
=
m_size
++
;
new
(
&
m_items
[
ret
])
T
(
std
::
forward
<
Args
>
(
args
)...);
return
begin
()
+
ret
;
}
void
pop_back
()
noexcept
{
if
(
m_size
==
0
)
return
;
--
m_size
;
if
constexpr
(
!
std
::
is_trivial_v
<
T
>
)
m_items
[
m_size
].
~
T
();
}
iterator
erase_and_swap
(
const_iterator
it
)
noexcept
{
auto
diff
=
std
::
distance
(
cbegin
(),
it
);
irt_assert
(
diff
<
std
::
numeric_limits
<
unsigned
>::
max
());
auto
i
=
static_cast
<
unsigned
>
(
diff
);
irt_assert
(
i
<
m_size
);
if
(
m_size
-
1
==
i
)
{
pop_back
();
return
end
();
}
else
{
using
std
::
swap
;
swap
(
m_items
[
m_size
-
1
],
m_items
[
i
]);
pop_back
();
return
begin
()
+
i
;
}
}
reference
operator
[](
size_type
i
)
noexcept
{
irt_assert
(
i
<
m_size
);
return
m_items
[
i
];
}
const_reference
operator
[](
size_type
i
)
const
noexcept
{
irt_assert
(
i
<
m_size
);
return
m_items
[
i
];
}
pointer
data
()
noexcept
{
return
m_items
;
}
const_pointer
data
()
const
noexcept
{
return
m_items
;
}
iterator
begin
()
noexcept
{
return
m_items
;
}
iterator
end
()
noexcept
{
return
m_items
+
m_size
;
}
const_iterator
begin
()
const
noexcept
{
return
m_items
;
}
const_iterator
end
()
const
noexcept
{
return
m_items
+
m_size
;
}
const_iterator
cbegin
()
const
noexcept
{
return
m_items
;
}
const_iterator
cend
()
const
noexcept
{
return
m_items
+
m_size
;
}
size_t
size
()
const
noexcept
{
return
m_size
;
}
size_type
capacity
()
const
noexcept
{
return
m_capacity
;
}
reference
front
()
noexcept
{
irt_assert
(
m_size
>
0
);
return
m_items
[
0
];
}
const_reference
front
()
const
noexcept
{
irt_assert
(
m_size
>
0
);
return
m_items
[
0
];
}
reference
back
()
noexcept
{
irt_assert
(
m_size
>
0
);
return
m_items
[
m_size
-
1
];
}
const_reference
back
()
const
noexcept
{
irt_assert
(
m_size
>
0
);
return
m_items
[
m_size
-
1
];
}
};
template
<
typename
T
>
class
array
{
public:
using
value_type
=
T
;
using
reference
=
T
&
;
using
const_reference
=
const
T
&
;
using
pointer
=
T
*
;
using
const_pointer
=
const
T
*
;
using
difference_type
=
std
::
ptrdiff_t
;
using
size_type
=
std
::
size_t
;
using
iterator
=
T
*
;
using
const_iterator
=
const
T
*
;
private:
value_type
*
m_items
{
nullptr
};
unsigned
m_capacity
{
0
};
public:
array
()
=
default
;
~
array
()
noexcept
{
clear
();
if
(
m_items
)
std
::
free
(
m_items
);
}
array
(
const
array
&
)
noexcept
=
delete
;
array
&
operator
=
(
const
array
&
)
noexcept
=
delete
;
array
(
array
&&
)
noexcept
=
delete
;
array
&
operator
=
(
array
&&
)
noexcept
=
delete
;
status
init
(
std
::
size_t
new_capacity
)
noexcept
{
if
(
new_capacity
>
std
::
numeric_limits
<
unsigned
>::
max
())
return
status
::
array_init_capacity_too_big
;
if
(
new_capacity
==
0
)
return
status
::
array_init_capacity_zero
;
if
(
new_capacity
!=
m_capacity
)
{
if
(
m_items
)
{
if
constexpr
(
!
std
::
is_trivial_v
<
T
>
)
for
(
auto
i
=
0u
;
i
!=
m_capacity
;
++
i
)
m_items
[
i
].
~
T
();
std
::
free
(
m_items
);
}
m_items
=
static_cast
<
value_type
*>
(
std
::
malloc
(
new_capacity
*
sizeof
(
value_type
)));
if
constexpr
(
!
std
::
is_trivial_v
<
T
>
)
for
(
auto
i
=
0u
;
i
!=
m_capacity
;
++
i
)
new
(
&
m_items
[
i
])
T
();
if
(
m_items
==
nullptr
)
return
status
::
array_init_not_enough_memory
;
}
m_capacity
=
static_cast
<
unsigned
>
(
new_capacity
);
return
status
::
success
;
}
void
clear
()
noexcept
{
if
constexpr
(
!
std
::
is_trivial_v
<
T
>
)
for
(
auto
i
=
0u
;
i
!=
m_capacity
;
++
i
)
m_items
[
i
].
~
T
();
}
reference
operator
[](
size_type
i
)
noexcept
{
irt_assert
(
i
<
m_capacity
);
return
m_items
[
i
];
}
const_reference
operator
[](
size_type
i
)
const
noexcept
{
irt_assert
(
i
<
m_capacity
);
return
m_items
[
i
];
}
pointer
data
()
noexcept
{
return
m_items
;
}
const_pointer
data
()
const
noexcept
{
return
m_items
;
}
iterator
begin
()
noexcept
{
return
m_items
;
}
iterator
end
()
noexcept
{
return
m_items
+
m_capacity
;
}
const_iterator
begin
()
const
noexcept
{
return
m_items
;
}
const_iterator
end
()
const
noexcept
{
return
m_items
+
m_capacity
;
}
const_iterator
cbegin
()
const
noexcept
{
return
m_items
;
}
const_iterator
cend
()
const
noexcept
{
return
m_items
+
m_capacity
;
}
size_t
size
()
const
noexcept
{
return
m_capacity
;
}
size_t
capacity
()
const
noexcept
{
return
m_capacity
;
}
};
/*****************************************************************************
*
* data-array
...
...
lib/include/irritator/io.hpp
View file @
caa44d5c
...
...
@@ -18,7 +18,7 @@ class reader
private:
std
::
istream
&
is
;
array
<
model_id
>
map
;
std
::
vector
<
model_id
>
map
;
int
model_error
=
0
;
int
connection_error
=
0
;
...
...
@@ -40,9 +40,11 @@ public:
irt_return_if_fail
(
model_number
>
0
,
status
::
io_file_format_model_number_error
);
irt_return_if_bad
(
map
.
init
(
model_number
));
std
::
fill_n
(
std
::
begin
(
map
),
std
::
size
(
map
),
static_cast
<
model_id
>
(
0
));
try
{
map
.
resize
(
model_number
,
model_id
{
0
});
}
catch
(
const
std
::
bad_alloc
&
/*e*/
)
{
return
status
::
io_not_enough_memory
;
}
int
id
;
...
...
@@ -547,7 +549,7 @@ struct writer
{
std
::
ostream
&
os
;
array
<
model_id
>
map
;
std
::
vector
<
model_id
>
map
;
writer
(
std
::
ostream
&
os_
)
noexcept
:
os
(
os_
)
...
...
@@ -557,9 +559,11 @@ struct writer
{
os
<<
sim
.
models
.
size
()
<<
'\n'
;
irt_return_if_bad
(
map
.
init
(
sim
.
models
.
size
()));
std
::
fill_n
(
std
::
begin
(
map
),
std
::
size
(
map
),
static_cast
<
model_id
>
(
0
));
try
{
map
.
resize
(
sim
.
models
.
size
(),
model_id
{
0
});
}
catch
(
const
std
::
bad_alloc
&
/*e*/
)
{
return
status
::
io_not_enough_memory
;
}
model
*
mdl
=
nullptr
;
int
id
=
0
;
...
...
lib/test/public-api.cpp
View file @
caa44d5c
...
...
@@ -300,105 +300,6 @@ main()
}
};
"array_api"
_test
=
[]
{
struct
position
{
position
()
noexcept
=
default
;
position
(
int
x_
,
int
y_
)
:
x
(
x_
)
,
y
(
y_
)
{}
int
x
=
0
,
y
=
0
;
};
irt
::
array
<
position
>
positions
;
!
expect
(
irt
::
status
::
success
==
positions
.
init
(
16u
));
expect
(
positions
.
size
()
==
16
_u
);
expect
(
positions
.
capacity
()
==
16u
);
for
(
int
i
=
0
;
i
!=
16
;
++
i
)
{
positions
[
i
].
x
=
i
;
positions
[
i
].
y
=
i
;
}
for
(
int
i
=
0
;
i
!=
16
;
++
i
)
{
expect
(
positions
[
i
].
x
==
i
);
expect
(
positions
[
i
].
y
==
i
);
}
};
"vector_api"
_test
=
[]
{
struct
position
{
position
()
noexcept
=
default
;
position
(
int
x_
,
int
y_
)
:
x
(
x_
)
,
y
(
y_
)
{}
int
x
=
0
,
y
=
0
;
};
irt
::
vector
<
position
>
positions
;
!
expect
(
irt
::
status
::
success
==
positions
.
init
(
16u
));
expect
(
positions
.
size
()
==
0
_u
);
expect
(
positions
.
capacity
()
==
16u
);
{
expect
(
positions
.
can_alloc
(
1u
));
auto
it
=
positions
.
emplace_back
(
0
,
1
);
expect
(
positions
.
size
()
==
1
_u
);
expect
(
positions
.
begin
()
==
it
);
expect
(
it
->
x
==
0
);
expect
(
it
->
y
==
1
);
}
{
auto
ret
=
positions
.
try_emplace_back
(
2
,
3
);
expect
(
ret
.
first
==
true
);
expect
(
ret
.
second
==
positions
.
begin
()
+
1
);
expect
(
positions
.
size
()
==
2
_u
);
expect
(
positions
.
begin
()
->
x
==
0
);
expect
(
positions
.
begin
()
->
y
==
1
);
expect
((
positions
.
begin
()
+
1
)
->
x
==
2
);
expect
((
positions
.
begin
()
+
1
)
->
y
==
3
);
}
{
auto
it
=
positions
.
erase_and_swap
(
positions
.
begin
());
expect
(
positions
.
size
()
==
1
_u
);
expect
(
it
==
positions
.
begin
());
expect
(
it
->
x
==
2
);
expect
(
it
->
y
==
3
);
}
positions
.
clear
();
expect
(
positions
.
size
()
==
0
_ul
);
expect
(
positions
.
capacity
()
==
16
_u
);
expect
(
positions
.
can_alloc
(
16u
));
for
(
int
i
=
0
;
i
!=
16
;
++
i
)
positions
.
emplace_back
(
i
,
i
);
auto
ret
=
positions
.
try_emplace_back
(
16
,
16
);
expect
(
ret
.
first
==
false
);
expect
(
positions
.
size
()
==
16
_ul
);
expect
(
positions
.
capacity
()
==
16
_u
);
auto
it
=
positions
.
begin
();
while
(
it
!=
positions
.
end
())
it
=
positions
.
erase_and_swap
(
it
);
expect
(
positions
.
size
()
==
0
_ul
);
expect
(
positions
.
capacity
()
==
16
_u
);
};
"data_array_api"
_test
=
[]
{
struct
position
{
...
...
Write
Preview
Supports
Markdown
0%
Try again
or
attach a new file
.
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment