Skip to content
GitLab
Projects
Groups
Snippets
Help
Loading...
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in
Toggle navigation
Open sidebar
OpenWalnut
OpenWalnut Core
Commits
43347abb
Commit
43347abb
authored
Feb 04, 2010
by
schurade
Browse files
Merge with a617e7d5d4024deb653de38834457614fd3d9b29
parents
8fc57f1a
08ccff2a
Changes
9
Hide whitespace changes
Inline
Side-by-side
Showing
9 changed files
with
595 additions
and
47 deletions
+595
-47
src/common/WProperties2.cpp
src/common/WProperties2.cpp
+101
-0
src/common/WProperties2.h
src/common/WProperties2.h
+218
-0
src/common/WPropertyTypes.h
src/common/WPropertyTypes.h
+140
-0
src/common/WPropertyVariable.h
src/common/WPropertyVariable.h
+14
-33
src/common/exceptions/WPropertyUnknown.cpp
src/common/exceptions/WPropertyUnknown.cpp
+38
-0
src/common/exceptions/WPropertyUnknown.h
src/common/exceptions/WPropertyUnknown.h
+53
-0
src/kernel/WModuleContainer.cpp
src/kernel/WModuleContainer.cpp
+2
-0
src/kernel/test/WModuleConnector_test.h
src/kernel/test/WModuleConnector_test.h
+2
-2
src/modules/fiberDisplay2/WMFiberDisplay2.cpp
src/modules/fiberDisplay2/WMFiberDisplay2.cpp
+27
-12
No files found.
src/common/WProperties2.cpp
0 → 100644
View file @
43347abb
//---------------------------------------------------------------------------
//
// Project: OpenWalnut ( http://www.openwalnut.org )
//
// Copyright 2009 OpenWalnut Community, BSV@Uni-Leipzig and CNCF@MPI-CBS
// For more information see http://www.openwalnut.org/copying
//
// This file is part of OpenWalnut.
//
// OpenWalnut is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// OpenWalnut is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with OpenWalnut. If not, see <http://www.gnu.org/licenses/>.
//
//---------------------------------------------------------------------------
#include <iostream>
#include <map>
#include <string>
#include <vector>
#include "WLogger.h"
#include "exceptions/WPropertyUnknown.h"
#include "WProperties2.h"
WProperties2
::
WProperties2
()
:
m_iterationLock
(
boost
::
shared_lock
<
boost
::
shared_mutex
>
(
m_updateLock
)
)
{
m_iterationLock
.
unlock
();
}
WProperties2
::~
WProperties2
()
{
}
void
WProperties2
::
addProperty
(
boost
::
shared_ptr
<
WPropertyBase
>
prop
)
{
boost
::
unique_lock
<
boost
::
shared_mutex
>
lock
=
boost
::
unique_lock
<
boost
::
shared_mutex
>
(
m_updateLock
);
m_properties
.
insert
(
prop
);
lock
.
unlock
();
}
bool
WProperties2
::
existsProperty
(
std
::
string
name
)
{
return
(
findProperty
(
name
)
!=
boost
::
shared_ptr
<
WPropertyBase
>
()
);
}
boost
::
shared_ptr
<
WPropertyBase
>
WProperties2
::
getProperty
(
std
::
string
name
)
{
boost
::
shared_ptr
<
WPropertyBase
>
p
=
findProperty
(
name
);
if
(
findProperty
(
name
)
==
boost
::
shared_ptr
<
WPropertyBase
>
()
)
{
throw
WPropertyUnknown
(
"Property
\"
"
+
name
+
"
\"
can't be found."
);
}
return
p
;
}
boost
::
shared_ptr
<
WPropertyBase
>
WProperties2
::
findProperty
(
std
::
string
name
)
{
boost
::
shared_ptr
<
WPropertyBase
>
result
=
boost
::
shared_ptr
<
WPropertyBase
>
();
// iterate over the items
for
(
PropertyIterator
it
=
beginIteration
();
it
!=
getPropertyIteratorEnd
();
++
it
)
{
if
(
(
*
it
)
->
getName
()
==
name
)
{
result
=
(
*
it
);
break
;
}
}
endIteration
();
return
result
;
}
const
WProperties2
::
PropertyIterator
WProperties2
::
beginIteration
()
{
m_iterationLock
.
lock
();
return
m_properties
.
begin
();
}
void
WProperties2
::
endIteration
()
{
m_iterationLock
.
unlock
();
}
const
WProperties2
::
PropertyIterator
WProperties2
::
getPropertyIteratorEnd
()
const
{
return
m_properties
.
end
();
}
src/common/WProperties2.h
0 → 100644
View file @
43347abb
//---------------------------------------------------------------------------
//
// Project: OpenWalnut ( http://www.openwalnut.org )
//
// Copyright 2009 OpenWalnut Community, BSV@Uni-Leipzig and CNCF@MPI-CBS
// For more information see http://www.openwalnut.org/copying
//
// This file is part of OpenWalnut.
//
// OpenWalnut is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// OpenWalnut is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with OpenWalnut. If not, see <http://www.gnu.org/licenses/>.
//
//---------------------------------------------------------------------------
#ifndef WPROPERTIES2_H
#define WPROPERTIES2_H
#include <map>
#include <string>
#include <set>
#include <boost/thread/thread.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/thread/locks.hpp>
#include <boost/thread.hpp>
#include "WPropertyBase.h"
#include "WPropertyVariable.h"
/**
* class to manage properties of an object and to provide convinience methods for easy access and manipulation. It also allows
* thread safe iteration on its elements.
*/
class
WProperties2
{
public:
/**
* The iterator used to iterate over the property set
*/
typedef
std
::
set
<
boost
::
shared_ptr
<
WPropertyBase
>
>::
iterator
PropertyIterator
;
/**
* standard constructor
*/
WProperties2
();
/**
* destructor
*/
virtual
~
WProperties2
();
/**
* Simply insert the specified property to the list.
*
* \param prop the property to add
*/
void
addProperty
(
boost
::
shared_ptr
<
WPropertyBase
>
prop
);
/**
* Helper function that finds a property by its name. Use this method to find out whether the property exists or not, since
* findProperty throws an exception.
*
* \param name name of searched property.
*/
bool
existsProperty
(
std
::
string
name
);
/**
* Function searches the property. If it does not exists, it throws an exception.
*
* \param name the name of the property
*
* \return a WProperty object
*/
boost
::
shared_ptr
<
WPropertyBase
>
getProperty
(
std
::
string
name
);
/**
* Iterator over all property elements. This locks the property set for writing. endIteration() frees the lock.
*
* \return the list of properties.
*/
const
PropertyIterator
beginIteration
();
/**
* To iterate over all set elements. Use this method to denote the end of iteration. This allows others to write to the set again.
*/
void
endIteration
();
/**
* Iterator denoting the end of the property set.
*
* \return the list of properties.
*/
const
PropertyIterator
getPropertyIteratorEnd
()
const
;
/**
* Create and add a new property of the template type. For more details see appropriate constructor ow WPropertyVariable.
*
* \see WPropertyVariable
*
* \param name the property name
* \param description the property description
* \param initial the initial value
*/
template
<
typename
T
>
boost
::
shared_ptr
<
WPropertyVariable
<
T
>
>
addProperty
(
std
::
string
name
,
std
::
string
description
,
const
T
&
initial
);
/**
* Create and add a new property of the template type. For more details see appropriate constructor ow WPropertyVariable.
*
* \see WPropertyVariable
*
* \param name the property name
* \param description the property description
* \param initial the initial value
* \param condition use this external condition for notification.
*/
template
<
typename
T
>
boost
::
shared_ptr
<
WPropertyVariable
<
T
>
>
addProperty
(
std
::
string
name
,
std
::
string
description
,
const
T
&
initial
,
boost
::
shared_ptr
<
WCondition
>
condition
);
/**
* Create and add a new property of the template type. For more details see appropriate constructor ow WPropertyVariable.
*
* \see WPropertyVariable
*
* \param name the property name
* \param description the property description
* \param initial the initial value
* \param notifier use this notifier for change callbacks.
*/
template
<
typename
T
>
boost
::
shared_ptr
<
WPropertyVariable
<
T
>
>
addProperty
(
std
::
string
name
,
std
::
string
description
,
const
T
&
initial
,
WCondition
::
t_ConditionNotifierType
notifier
);
/**
* Create and add a new property of the template type. For more details see appropriate constructor ow WPropertyVariable.
*
* \see WPropertyVariable
*
* \param name the property name
* \param description the property description
* \param initial the initial value
* \param notifier use this notifier for change callbacks.
* \param condition use this external condition for notification
*/
template
<
typename
T
>
boost
::
shared_ptr
<
WPropertyVariable
<
T
>
>
addProperty
(
std
::
string
name
,
std
::
string
description
,
const
T
&
initial
,
boost
::
shared_ptr
<
WCondition
>
condition
,
WCondition
::
t_ConditionNotifierType
notifier
);
private:
/**
* Searches the property with a given name. It does not throw any exception. It simply returns NULL if it can't be found.
*
* \param name the name of the property to search
*
* \return the property or NULL if not found.
*/
boost
::
shared_ptr
<
WPropertyBase
>
findProperty
(
std
::
string
name
);
/**
* The set of proerties. This uses the operators ==,<,> WProperty to determine equalnes.
*/
std
::
set
<
boost
::
shared_ptr
<
WPropertyBase
>
>
m_properties
;
/**
* boost mutex object for thread safety of updating of properties
*/
boost
::
shared_mutex
m_updateLock
;
/**
* The lock for a thread safe iteration.
*/
boost
::
shared_lock
<
boost
::
shared_mutex
>
m_iterationLock
;
};
template
<
typename
T
>
boost
::
shared_ptr
<
WPropertyVariable
<
T
>
>
WProperties2
::
addProperty
(
std
::
string
name
,
std
::
string
description
,
const
T
&
initial
)
{
return
boost
::
shared_ptr
<
WPropertyVariable
<
T
>
>
(
new
WPropertyVariable
<
T
>
(
name
,
description
,
initial
)
);
}
template
<
typename
T
>
boost
::
shared_ptr
<
WPropertyVariable
<
T
>
>
WProperties2
::
addProperty
(
std
::
string
name
,
std
::
string
description
,
const
T
&
initial
,
boost
::
shared_ptr
<
WCondition
>
condition
)
{
return
boost
::
shared_ptr
<
WPropertyVariable
<
T
>
>
(
new
WPropertyVariable
<
T
>
(
name
,
description
,
initial
,
condition
)
);
}
template
<
typename
T
>
boost
::
shared_ptr
<
WPropertyVariable
<
T
>
>
WProperties2
::
addProperty
(
std
::
string
name
,
std
::
string
description
,
const
T
&
initial
,
WCondition
::
t_ConditionNotifierType
notifier
)
{
return
boost
::
shared_ptr
<
WPropertyVariable
<
T
>
>
(
new
WPropertyVariable
<
T
>
(
name
,
description
,
initial
,
notifier
)
);
}
template
<
typename
T
>
boost
::
shared_ptr
<
WPropertyVariable
<
T
>
>
WProperties2
::
addProperty
(
std
::
string
name
,
std
::
string
description
,
const
T
&
initial
,
boost
::
shared_ptr
<
WCondition
>
condition
,
WCondition
::
t_ConditionNotifierType
notifier
)
{
return
boost
::
shared_ptr
<
WPropertyVariable
<
T
>
>
(
new
WPropertyVariable
<
T
>
(
name
,
description
,
initial
,
condition
,
notifier
)
);
}
#endif // WPROPERTIES2_H
src/common/WPropertyTypes.h
View file @
43347abb
...
...
@@ -25,6 +25,13 @@
#ifndef WPROPERTYTYPES_H
#define WPROPERTYTYPES_H
#include <stdint.h>
#include <string>
#include <list>
#include <boost/filesystem.hpp>
/**
* Enum of all possible types, that can be used with WProperty.
*/
...
...
@@ -40,4 +47,137 @@ typedef enum
}
PROPERTY_TYPE
;
/**
* This namespace contains several helper classes which translate their template type to an enum.
*/
namespace
PROPERTY_TYPE_HELPER
{
/**
* Class helping to adapt types specified as template parameter into an enum.
*/
template
<
typename
T
>
class
WTypeIdentifier
{
public:
/**
* Get type identifier of the template type T.
*
* \return type identifier-
*/
PROPERTY_TYPE
getType
()
{
return
UNKNOWN
;
}
};
/**
* Class helping to adapt types specified as template parameter into an enum.
*/
template
<
>
class
WTypeIdentifier
<
bool
>
{
public:
/**
* Get type identifier of the template type T.
*
* \return type identifier-
*/
PROPERTY_TYPE
getType
()
{
return
BOOL
;
}
};
/**
* Class helping to adapt types specified as template parameter into an enum.
*/
template
<
>
class
WTypeIdentifier
<
int32_t
>
{
public:
/**
* Get type identifier of the template type T.
*
* \return type identifier-
*/
PROPERTY_TYPE
getType
()
{
return
INT
;
}
};
/**
* Class helping to adapt types specified as template parameter into an enum.
*/
template
<
>
class
WTypeIdentifier
<
double
>
{
public:
/**
* Get type identifier of the template type T.
*
* \return type identifier-
*/
PROPERTY_TYPE
getType
()
{
return
DOUBLE
;
}
};
/**
* Class helping to adapt types specified as template parameter into an enum.
*/
template
<
>
class
WTypeIdentifier
<
std
::
string
>
{
public:
/**
* Get type identifier of the template type T.
*
* \return type identifier-
*/
PROPERTY_TYPE
getType
()
{
return
STRING
;
}
};
/**
* Class helping to adapt types specified as template parameter into an enum.
*/
template
<
>
class
WTypeIdentifier
<
boost
::
filesystem
::
path
>
{
public:
/**
* Get type identifier of the template type T.
*
* \return type identifier-
*/
PROPERTY_TYPE
getType
()
{
return
PATH
;
}
};
/**
* Class helping to adapt types specified as template parameter into an enum.
*/
template
<
>
class
WTypeIdentifier
<
std
::
list
<
std
::
string
>
>
{
public:
/**
* Get type identifier of the template type T.
*
* \return type identifier-
*/
PROPERTY_TYPE
getType
()
{
return
LIST
;
}
};
}
#endif // WPROPERTYTYPES_H
src/common/WPropertyVariable.h
View file @
43347abb
...
...
@@ -170,41 +170,22 @@ WPropertyVariable< T >::~WPropertyVariable()
}
template
<
typename
T
>
bool
WPropertyVariable
<
T
>::
accept
(
T
newValue
)
bool
WPropertyVariable
<
T
>::
accept
(
T
/*
newValue
*/
)
{
// this currently is a dummy. Later this can be implemented to determine whether a value is valid.
return
true
;
}
///////////////////////////////////////////////////////////////////////////////////////////////////
// Implement the type function for each known type
// This is useful since the user does not need to specify some kind of type identifier
///////////////////////////////////////////////////////////////////////////////////////////////////
template
<
typename
T
>
void
WPropertyVariable
<
T
>::
updateType
()
{
m_type
=
UNKNOWN
;
if
(
typeid
(
int32_t
)
==
typeid
(
T
)
)
{
m_type
=
INT
;
}
else
if
(
typeid
(
double
)
==
typeid
(
T
)
)
{
m_type
=
DOUBLE
;
}
else
if
(
typeid
(
bool
)
==
typeid
(
T
)
)
{
m_type
=
BOOL
;
}
else
if
(
typeid
(
std
::
string
)
==
typeid
(
T
)
)
{
m_type
=
STRING
;
}
else
if
(
typeid
(
boost
::
filesystem
::
path
)
==
typeid
(
T
)
)
{
m_type
=
PATH
;
}
else
if
(
typeid
(
boost
::
filesystem
::
path
)
==
typeid
(
T
)
)
{
m_type
=
LIST
;
}
PROPERTY_TYPE_HELPER
::
WTypeIdentifier
<
T
>
tid
;
m_type
=
tid
.
getType
();
}
/**
...
...
@@ -213,32 +194,32 @@ void WPropertyVariable< T >::updateType()
/**
* Alias for int32_t property variables.
*/
typedef
WPropertyVariable
<
int32_t
>
WPropInt
;
typedef
boost
::
shared_ptr
<
WPropertyVariable
<
int32_t
>
>
WPropInt
;
/**
* Alias for int32_t property variables.
*/
typedef
WPropertyVariable
<
double
>
WPropDouble
;
typedef
boost
::
shared_ptr
<
WPropertyVariable
<
double
>
>
WPropDouble
;
/**
* Alias for bool property variables.
*/
typedef
WPropertyVariable
<
bool
>
WPropBool
;
typedef
boost
::
shared_ptr
<
WPropertyVariable
<
bool
>
>
WPropBool
;
/**
* Alias for string property variables.
*/
typedef
WPropertyVariable
<
std
::
string
>
WPropString
;
typedef
boost
::
shared_ptr
<
WPropertyVariable
<
std
::
string
>
>
WPropString
;
/**
* Alias for filename property variables.
*/
typedef
WPropertyVariable
<
boost
::
filesystem
::
path
>
WPropFilename
;
typedef
boost
::
shared_ptr
<
WPropertyVariable
<
boost
::
filesystem
::
path
>
>
WPropFilename
;
/**
* Alias for string list property variables.
*/
typedef
WPropertyVariable
<
std
::
list
<
std
::
string
>
>
WPropList
;
typedef
boost
::
shared_ptr
<
WPropertyVariable
<
std
::
list
<
std
::
string
>
>
>
WPropList
;
#endif // WPROPERTYVARIABLE_H
src/common/exceptions/WPropertyUnknown.cpp
0 → 100644
View file @
43347abb
//---------------------------------------------------------------------------
//
// Project: OpenWalnut ( http://www.openwalnut.org )
//
// Copyright 2009 OpenWalnut Community, BSV@Uni-Leipzig and CNCF@MPI-CBS
// For more information see http://www.openwalnut.org/copying
//
// This file is part of OpenWalnut.
//
// OpenWalnut is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// OpenWalnut is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with OpenWalnut. If not, see <http://www.gnu.org/licenses/>.
//
//---------------------------------------------------------------------------
#include <string>
#include "WPropertyUnknown.h"
WPropertyUnknown
::
WPropertyUnknown
(
const
std
::
string
&
msg
)
:
WException
(
msg
)
{
// init members
}
WPropertyUnknown
::~
WPropertyUnknown
()
throw
()
{
// clean up
}
src/common/exceptions/WPropertyUnknown.h
0 → 100644
View file @
43347abb
//---------------------------------------------------------------------------
//
// Project: OpenWalnut ( http://www.openwalnut.org )
//
// Copyright 2009 OpenWalnut Community, BSV@Uni-Leipzig and CNCF@MPI-CBS
// For more information see http://www.openwalnut.org/copying
//
// This file is part of OpenWalnut.
//
// OpenWalnut is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// OpenWalnut is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with OpenWalnut. If not, see <http://www.gnu.org/licenses/>.
//
//---------------------------------------------------------------------------
#ifndef WPROPERTYUNKNOWN_H
#define WPROPERTYUNKNOWN_H