initial implementaiton with runtime validity checks

MMDevice/DeviceBase.h

@@ -584,6 +584,62 @@ class CDeviceBase : public T
       return properties_.CreateProperty(name, value, eType, readOnly, pAct, isPreInitProperty);
    }
 
+   /**
+    * Creates a standard property -- a property with a predefined name, type, and possibly values.
+    * Standard properties can apply to all devices, or only some types, as specified in the
+    * switch statement below.
+    * Type, read-only and pre-init are fixed for the standard property
+    * 
+    * @param property - the standard property enum
+    * @param value - initial value
+    * @param pAct - function object called on the property actions
+    */
+   int CreateStandardProperty(MM::StandardProperty property, const char* value, MM::ActionFunctor* pAct = 0)
+   {
+      if (!IsValidStandardProperty(property)) {
+         return DEVICE_INVALID_PROPERTY;
+      }
+
+      // TODO: check if value is valid?
+
+      // Prepend the prefix marking it as a standard property and the delimiter
+      std::string fullName = g_KeywordStandardPropertyPrefix + "//" + property.name;
+
+      return properties_.CreateStandardProperty(property, value, pAct);
+   }
+
+   /**
+    * Checks if a standard property is applicable to this device type
+    * @param property - the standard property to check
+    * @return - true if applicable, false otherwise
+    */
+   bool IsValidStandardProperty(MM::StandardProperty property) const
+   {
+      MM::DeviceType deviceType = T::Type;
+      return IsPropertyApplicableToDeviceType(property, deviceType);
+   }
+
+   /**
+    * Helper function to check if a standard property is applicable to a specific device type
+    * @param property - the standard property to check
+    * @param deviceType - the device type to check against
+    * @return - true if the property is applicable to the device type, false otherwise
+    */
+   bool IsPropertyApplicableToDeviceType(MM::StandardProperty property, MM::DeviceType deviceType) const
+   {
+      // Iterate through the standard property list to find if this property
+      // is applicable to this device type
+      for (const MM::StandardPropAssociation& association : MM::g_StandardPropertyList)
+      {
+         if (strcmp(association.property.name, property.name) == 0 && 
+             association.deviceType == deviceType)
+         {
+            return true;
+         }
+      }
+      return false;
+   }
+
    /**
    * Creates a new property for the device.
    * @param name - property name
@@ -596,6 +652,7 @@ class CDeviceBase : public T
    */
    int CreatePropertyWithHandler(const char* name, const char* value, MM::PropertyType eType, bool readOnly,
                                  int(U::*memberFunction)(MM::PropertyBase* pProp, MM::ActionType eAct), bool isPreInitProperty=false) {
+      // Check for reserved delimiter (handled in CreateProperty)
       CPropertyAction* pAct = new CPropertyAction((U*) this, memberFunction);
       return CreateProperty(name, value, eType, readOnly, pAct, isPreInitProperty);
    }

MMDevice/MMDevice.h

@@ -43,6 +43,7 @@
 #include "DeviceUtils.h"
 #include "ImageMetadata.h"
 #include "DeviceThreads.h"
+#include "Property.h"
 
 #include <climits>
 #include <cstdlib>
@@ -205,6 +206,39 @@ namespace MM {
    };
 
 
+   ////////////////////////////
+   ///// Standard properties
+   ////////////////////////////
+
+   // Specific standard properties
+   static const MM::StandardProperty g_BinningStandardProperty(
+      "Binning",                // name
+      String,               // type
+      false,                    // isReadOnly
+      false,                    // isPreInit
+      nullptr,          // allowedValues
+      PropertyLimitUndefined,   // lowerLimit
+      PropertyLimitUndefined    // upperLimit
+   );
+
+   // A struct to encode which which device types have/require which standard properties
+   struct StandardPropAssociation {
+      const MM::StandardProperty& property;
+      MM::DeviceType deviceType;  // which device types can use
+      bool required; 
+   };
+
+   // This data structure associates standard properties with device types.
+   // each entry defines one property-device association and whether the 
+   // standard property is required
+   static const StandardPropAssociation g_StandardPropertyList[] =
+   {
+      // propertyname             deviceTypes      required  
+      {g_BinningStandardProperty, MM::CameraDevice, false}
+   };
+
+
+
    /**
     * Generic device interface.
     */

MMDevice/MMDeviceConstants.h

@@ -88,6 +88,7 @@
 #define DEVICE_SEQUENCE_TOO_LARGE      39
 #define DEVICE_OUT_OF_MEMORY           40
 #define DEVICE_NOT_YET_IMPLEMENTED     41
+#define DEVICE_MISSING_REQUIRED_PROPERTY 42
 
 
 namespace MM {

MMDevice/Property.cpp

@@ -326,7 +326,23 @@ unsigned MM::PropertyCollection::GetSize() const
    return (unsigned) properties_.size();
 }
 
-int MM::PropertyCollection::CreateProperty(const char* pszName, const char* pszValue, MM::PropertyType eType, bool bReadOnly, MM::ActionFunctor* pAct, bool isPreInitProperty)
+int MM::PropertyCollection::CreateStandardProperty(StandardProperty property, const char* value, ActionFunctor* pAct)
+{
+   return DoCreateProperty(property.name, value, property.type, property.isReadOnly, pAct, property.isPreInit);
+}
+
+int MM::PropertyCollection::CreateProperty(const char* name, const char* value, PropertyType eType, bool bReadOnly, ActionFunctor* pAct=0, bool isPreInitProperty=false)
+{
+   // disallow properties that begin with the reserved prefix for standard properties
+   // std prefic + delimiter + property name
+   std::string prefixAndDelim = std::string(g_KeywordStandardPropertyPrefix) + std::string("//");
+   if (std::string(name).find(prefixAndDelim) == 0)
+      return DEVICE_INVALID_PROPERTY;
+
+   return DoCreateProperty(name, value, eType, bReadOnly, pAct, isPreInitProperty);
+}
+
+int MM::PropertyCollection::DoCreateProperty(const char* pszName, const char* pszValue, MM::PropertyType eType, bool bReadOnly, MM::ActionFunctor* pAct, bool isPreInitProperty)
 {
    // check if the name already exists
    if (Find(pszName))

MMDevice/Property.h

@@ -30,6 +30,48 @@
 
 namespace MM {
 
+// Standard Properties
+const char* const g_KeywordStandardPropertyPrefix = "api";
+
+// Define NaN for use in property definitions
+const double PropertyLimitUndefined = std::numeric_limits<double>::quiet_NaN();
+
+// Standard property metadata structure
+class StandardProperty {
+public:
+    StandardProperty(
+        const char* name,
+        PropertyType type,
+        bool isReadOnly,
+        bool isPreInit,
+        const char* const* allowedValues,
+        double lowerLimit,
+        double upperLimit
+    ) : 
+        name(name),
+        type(type),
+        isReadOnly(isReadOnly),
+        isPreInit(isPreInit),
+        allowedValues(allowedValues),
+        lowerLimit(lowerLimit),
+        upperLimit(upperLimit)
+    {}
+
+    // Helper to check if limits are defined
+    bool hasLimits() const {
+        return !std::isnan(lowerLimit) && !std::isnan(upperLimit);
+    }
+
+    const char* name;                  // Full property name (without prefix)
+    PropertyType type;                 // Float, String, or Integer
+    bool isReadOnly;                   // Whether property is read-only
+    bool isPreInit;                    // Whether property should be set before initialization
+    const char* const* allowedValues;  // Array of allowed string values (nullptr if not restricted)
+    double lowerLimit;                 // Lower limit for numeric properties (NaN if not limited)
+    double upperLimit;                 // Upper limit for numeric properties (NaN if not limited)
+};
+
+
 /**
  * Base API for all device properties.
  * This interface is used by action functors.
@@ -437,6 +479,7 @@ class PropertyCollection
    PropertyCollection();
    ~PropertyCollection();
 
+   int CreateStandardProperty(StandardProperty property, const char* value, ActionFunctor* pAct=0);
    int CreateProperty(const char* name, const char* value, PropertyType eType, bool bReadOnly, ActionFunctor* pAct=0, bool isPreInitProperty=false);
    int RegisterAction(const char* name, ActionFunctor* fpAct);
    int SetAllowedValues(const char* name, std::vector<std::string>& values);
@@ -457,9 +500,9 @@ class PropertyCollection
    int Apply(const char* Name);
 
 private:
+   int DoCreateProperty(const char* name, const char* value, PropertyType eType, bool bReadOnly, ActionFunctor* pAct=0, bool isPreInitProperty=false);
    typedef std::map<std::string, Property*> CPropArray;
    CPropArray properties_;
 };
 
-
 } // namespace MM