mtstates.state(): optionally create named state if it does not exist

Author: osch

README.md

@@ -163,7 +163,7 @@ assert(thread:join())
 
 ### Module Functions
 
-* **`mtstates.newstate([name,][libs,]setup[,...)`**
+* <a id="newstate">**`mtstates.newstate([name,][libs,]setup[,...)`**</a>
 
  Creates a new state. The given setup function is executed in the new state. The
  setup function must return a state callback function which can be called
@@ -188,24 +188,45 @@ assert(thread:join())
  *mtstates.error.state_result*
 
 * **`mtstates.state(id|name)`**
+* **`mtstates.state(name,[libs,]setup[,...)`**
 
- Creates a lua object for referencing an existing state. The state must
- be referenced by its *id* or *name*. Referencing the state by *id* is
- much faster than referencing by *name* if the number of states 
- increases.
-
- * *id* - integer, the unique state id that can be obtained by
- *state:id()*.
-
- * *name* - string, the optional name that was given when the
- state was created with *mtstates.newstate()*. To
- find a state by name the name must be unique for
- the whole process.
-
- Possible errors: *mtstates.error.ambiguous_name*,
- *mtstates.error.unknown_object*
-
+ * **First form:**
+ 
+ Creates a lua object for referencing an existing state. The state must
+ be referenced by its *id* or *name*. Referencing the state by *id* is
+ much faster than referencing by *name* if the number of states 
+ increases.
+ 
+ * *id* - integer, the unique state id that can be obtained by
+ *state:id()*.
+ 
+ * *name* - string, the optional name that was given when the
+ state was created with *mtstates.newstate()*. To
+ find a state by name the name must be unique for
+ the whole process.
+ 
+ Possible errors: *mtstates.error.ambiguous_name*,
+ *mtstates.error.unknown_object*
+ 
 
+ * **Second form:**
+ 
+ Creates a lua object for referencing an existing state by name. If the
+ state referenced by the name does not exist, a new state is created using
+ the supplied parameters. This invocation can be used to atomically construct a
+ globally named state securely from different threads.
+ 
+ * *name* - mandatory string, name for finding an existing state. If the state is
+ not found the following parameters are used to create a new state
+ with the given name.
+ 
+ * *libs*, *setup*, *...* - same parameters as in [*mtstates.newstate()*](#newstate).
+
+ Possible errors: *mtstates.error.ambiguous_name*,
+ *mtstates.error.invoking_state*,
+ *mtstates.error.state_result* 
+ 
+ 
 * **`mtstates.type(arg)`**
 
  Returns the type of *arg* as string. Same as *type(arg)* for builtin types.

src/state.c

@@ -254,12 +254,19 @@ static const luaL_Reg mtstates_stdlibs[] =
  { NULL, NULL}
 };
 
-static int Mtstates_newState2(lua_State* L);
 
+static int Mtstates_newState1(lua_State* L, bool isNewState);
 static int Mtstates_newState(lua_State* L)
+{
+ return Mtstates_newState1(L, true);
+}
+
+static int Mtstates_newState2(lua_State* L);
+static int Mtstates_newState1(lua_State* L, bool isNewState)
 {
  NewStateVars vars; memset(&vars, 0, sizeof(NewStateVars));
  NewStateVars* this = &vars;
+ this->isNewState = isNewState;
 
  int nargs = lua_gettop(L);
 
@@ -301,14 +308,71 @@ static int Mtstates_newState3(lua_State* L);
 
 static int Mtstates_newState2(lua_State* L)
 {
- int arg = 1;
+ NewStateVars* this = (NewStateVars*)lua_touserdata(L, 1);
 
- NewStateVars* this = (NewStateVars*)lua_touserdata(L, arg++);
-
- int firstArg = arg;
- int lastArg = lua_gettop(L);
- int nargs = lastArg - firstArg + 1;
+ const int firstArg = 2;
+ const int lastArg = lua_gettop(L);
+ const int nargs = lastArg - firstArg + 1;
+ 
+ if (!this->isNewState)
+ {
+ int arg = firstArg;
+ 
+ bool hasArg = false;
+ const char* stateName = NULL;
+ size_t stateNameLength = 0;
+ lua_Integer stateId = 0;
+ 
+ if (arg <= lastArg) {
+ if (lua_type(L, arg) == LUA_TSTRING) {
+ stateName = lua_tolstring(L, arg++, &stateNameLength);
+ hasArg = true;
+ }
+ else if (lua_type(L, arg) == LUA_TNUMBER && lua_isinteger(L, arg)) {
+ stateId = lua_tointeger(L, arg++);
+ hasArg = true;
+ }
+ }
+ if (!hasArg) {
+ this->errorArg = arg;
+ return luaL_error(L, "state name or id expected");
+ }
+ 
+ /* Lock */
+ 
+ async_mutex_lock(mtstates_global_lock); this->globalLocked = true;
+ 
+ MtState* state = NULL;
+ if (stateName != NULL) {
+ bool unique;
+ state = findStateWithName(stateName, stateNameLength, &unique);
+ if (!state && arg > lastArg) {
+ return mtstates_ERROR_UNKNOWN_OBJECT_state_name(L, stateName, stateNameLength);
+ } else if (state && !unique) {
+ return mtstates_ERROR_AMBIGUOUS_NAME_state_name(L, stateName, stateNameLength);
+ }
+ } else {
+ state = findStateWithId(stateId);
+ if (!state) {
+ return mtstates_ERROR_UNKNOWN_OBJECT_state_id(L, stateId);
+ }
+ }
+ if (state) {
+ StateUserData* userData = lua_newuserdata(L, sizeof(StateUserData));
+ memset(userData, 0, sizeof(StateUserData));
+ pushStateMeta(L); /* -> udata, meta */
+ lua_setmetatable(L, -2); /* -> udata */
+ 
+ userData->state = state;
+ atomic_inc(&state->used);
 
+ this->nrslts = 1;
+ return this->nrslts; 
+ }
+ // else we have a stateName and more args -> create new state
+ }
+ 
+ int arg = firstArg;
  const char* stateName = NULL;
  size_t stateNameLength = 0;
  if (arg <= lastArg && nargs >= 2) {
@@ -373,7 +437,10 @@ static int Mtstates_newState2(lua_State* L)
  pushStateMeta(L); /* -> udata, meta */
  lua_setmetatable(L, -2); /* -> udata */
 
- async_mutex_lock(mtstates_global_lock); this->globalLocked = true;
+ if (!this->globalLocked) {
+ async_mutex_lock(mtstates_global_lock); 
+ this->globalLocked = true;
+ }
 
  /* ------------------------------------------------------------------------------------ */
 
@@ -524,62 +591,10 @@ static int Mtstates_newState3(lua_State* L2)
 }
 
 
+static int Mtstates_newState1(lua_State* L, bool isNewState);
 static int Mtstates_state(lua_State* L)
 {
- int arg = 1;
-
- bool hasArg = false;
- const char* stateName = NULL;
- size_t stateNameLength = 0;
- lua_Integer stateId = 0;
-
- if (lua_gettop(L) >= arg) {
- if (lua_type(L, arg) == LUA_TSTRING) {
- stateName = lua_tolstring(L, arg++, &stateNameLength);
- hasArg = true;
- }
- else if (lua_type(L, arg) == LUA_TNUMBER && lua_isinteger(L, arg)) {
- stateId = lua_tointeger(L, arg++);
- hasArg = true;
- }
- }
- if (!hasArg) {
- return luaL_argerror(L, arg, "state name or id expected");
- }
-
- StateUserData* userData = lua_newuserdata(L, sizeof(StateUserData));
- memset(userData, 0, sizeof(StateUserData));
- pushStateMeta(L); /* -> udata, meta */
- lua_setmetatable(L, -2); /* -> udata */
-
- /* Lock */
- 
- async_mutex_lock(mtstates_global_lock);
-
- MtState* state;
- if (stateName != NULL) {
- bool unique;
- state = findStateWithName(stateName, stateNameLength, &unique);
- if (!state) {
- async_mutex_unlock(mtstates_global_lock);
- return mtstates_ERROR_UNKNOWN_OBJECT_state_name(L, stateName, stateNameLength);
- } else if (!unique) {
- async_mutex_unlock(mtstates_global_lock);
- return mtstates_ERROR_AMBIGUOUS_NAME_state_name(L, stateName, stateNameLength);
- }
- } else {
- state = findStateWithId(stateId);
- if (!state) {
- async_mutex_unlock(mtstates_global_lock);
- return mtstates_ERROR_UNKNOWN_OBJECT_state_id(L, stateId);
- }
- }
-
- userData->state = state;
- atomic_inc(&state->used);
- 
- async_mutex_unlock(mtstates_global_lock);
- return 1;
+ return Mtstates_newState1(L, false);
 }
 
 

src/state_intern.h

@@ -22,6 +22,8 @@ typedef struct {
 
 typedef struct 
 {
+ bool isNewState;
+ 
  bool globalLocked;
  bool stateLocked;
 

tests/test01.lua

@@ -500,4 +500,22 @@ do
  assert(ok and rslt1 == 103 and rslt2 == 100)
 end
 PRINT("==================================================================================")
+do
+ local stateSetup = function()
+ return function(x)
+ return 100 + x
+ end
+ end
+ local _, err = pcall(function()
+ mtstates.state("foo")
+ end)
+ assert(err:match(mtstates.error.unknown_object))
+ local s1 = mtstates.state("foo", stateSetup)
+ local s2 = mtstates.state("foo", stateSetup)
+ assert(s1:id() == s2:id())
+ assert(s2:call(3) == 103)
+ local s3 = mtstates.state("foo")
+ assert(s1:id() == s3:id())
+end
+PRINT("==================================================================================")
 print("Done.")