{"action":"created","comment":{"url":"https://api.github.com/repos/01org/parameter-framework/pulls/comments/35532428","id":35532428,"diff_hunk":"@@ -0,0 +1,526 @@\n+High level requirements\n+=======================\n+\n+(Note: some requirements are only motivated by the fact that the reference implementation\n+       implements them. Seach for \"reference implementation\".)\n+\n+# Introduction\n+The PF MUST be a library.\n+(Why: To be reused in different components.)\n+\n+PF instances MUST not share any muttable data.\n+(Why: to guarantee that different PF instances will not impact each others.)\n+\n+# Parameters\n+\n+A PF MUST be able to handle parameters.\n+(Why: because the PF aims to abstract hardware and model it by parameters.)\n+\n+## Definitions\n+\n+hardware: system controlled by the PF. Not necessary material system.\n+          This term was chosen because:\n+ - historically the PF reference implementation was used to abstract hardware\n+ - the subsystem term would arguably fit best is already used.\n+(FIXME: choose subsystem instead, it is not used in fact.)\n+\n+## Value\n+\n+A parameter MUST have a value.\n+(Why: because a parameter without value would not abstract any hardware.)\n+\n+A PF MUST support mutable parameters.\n+(Why: To control the underlined hardware.)\n+\n+A PF MAY support immutable parameters, ie parameters which value is determined on start then read only.\n+(Why: To permit hardware read only value reflection.)\n+(Note: This is not implemented in the PF reference implementation.)\n+\n+This value MUST be gettable and settable (except if immutable).\n+(Why: A parameter that can not be accessed is of no use.)\n+\n+A value MUST be convertible to a string.\n+(Why: To display a parameter value to the human user for debugging purpose.)\n+\n+A bijective conversion string <-> value SHOULD exist.\n+(Why: To support serialization and deserialization of the parameter values.\n+      It is not a MUST because a PF implementation could offer serialization to\n+      custom -not string based- format.)\n+\n+### Data type\n+\n+#### Definition\n+All parameters have a data type.\n+A data type designates parameter invariants.\n+A data type is the the meaning of the data and the way values of that type can be stored.\n+\n+\n+#### Philosophy\n+\n+A data type defines the value properties:\n+ - memory layout\n+ - value constrains\n+\n+A value type is mostly used to:\n+ - pretty display parameter values (not just a as an array of bits)\n+ - check for user error when setting it (out of bound, invalid...)\n+ - offer a type safe api\n+\n+#### Requirements\n+\n+A PF SHOULD support the following types.\n+If a type is chosen to be supported, it MUST respect all MUST clause,\n+SHOULD respect all SHOULD clause, MAY respect all MAY clause of the type.\n+(Why: All type are not necessary to use the PF. For example any parameter could\n+      be represented as an array of char (string). But this would not permit to\n+      check parameter validity (invariants) as well a pretty displaying the values.)\n+\n+Implementation MAY add another API to access a parameter value.\n+(Why: For example a C++ implementation may give access to a string as an std::string object.)\n+\n+##### Integers\n+PF SHOULD support signed and unsigned integer parameters\n+(Why: The reference implementation supports it.)\n+\n+PF MUST support integer with invariant size.\n+(Why: It is common in C API to expect numbers to have a fixed maximum size.)\n+\n+The API to access it MUST respect C integer abi.\n+(Why: For easy access from C code.)\n+\n+Supported integer size SHOULD be at least 8, 16 and 32 bits.\n+(Why: The reference implementation supports it.)\n+\n+PF MAY support constraining the parameter minimum and maximum value.\n+(Why: To catch user out of valid range errors when changing the parameter value.)\n+\n+##### String\n+PF SHOULD support array of characters.\n+(Why: Everything that a computer can store fits in an array of characters.\n+      It can be used as a fallback type if no other matches the parameter.)\n+\n+The array maximum size MAY be invariant (immutable).\n+(Note: This is what the reference implementation does.)\n+\n+The API to access the string value SHOULD support null terminated character array.\n+As it is commonly done in C.\n+(Why: For easy access from C code.)\n+\n+##### Fix point parameter\n+PF SHOULD support fix point parameters. Ie integers divided by a fixed power of two.\n+(Why: The reference implementation supports it.)\n+\n+The API to access the values SHOULD respect the Qm.n and UQm.n standards.\n+(Why: It is the main standard for fix point parameters.)\n+\n+PF SHOULD support at least m + n ∈ [0,32]\n+(Why: The reference implementation supports it.)\n+\n+PF MAY support constraining the parameter minimum and maximum value.\n+(Why: To catch user out of valid range errors when changing the parameter value.)\n+\n+##### Floating point\n+PF SHOULD support floating point parameters .\n+(Why: The reference implementation supports it.)\n+\n+The API to access the values SHOULD respect the IEEE 754 standard.\n+\n+PF SHOULD support at least 32 and 64 bit size floats.\n+(Why: The reference implementation supports it.)\n+\n+##### Bit field following the C abi.\n+PF SHOULD support 1 or more bit sized integers.\n+(Why: The reference implementation supports it.)\n+\n+Such parameters called are regrouped in a so called bit parameter block.\n+The API to access a bit parameter block SHOULD give access to a packed bit field.\n+(Why: The reference implementation supports it.)\n+\n+### Parameter adaptation\n+\n+#### Philosophy\n+Parameters expose by hardware sometimes need to transform a parameter\n+value. For example an hardware integer parameter could have a range 64-128 but\n+it might be necessary for upper layer to access in a range 0-100.\n+\n+This transformation (called parameter adaptation in the rest of the document)\n+could be done by the syncer. Nevertheless syncer are supposed to contain only\n+business logic and should not be impacted by upper layer needs.\n+\n+#### Definition\n+Parameter adaptation is a bijective pure function converting a parameter\n+value between the syncer and other parameter reader/writer (including the inference engine).\n+\n+#### Requirements\n+The following parameter adaptation SHOULD be supported\n+ - Affine adaptation:    `affAd(value) = slope * value + offset` where slope and offset and constant coefficient\n+(Why: The reference application supports it.)\n+ - Logarithm adaptation: `logAd(value) = log(value)` where log() is the binary logarithm\n+(Why: The reference application supports it.)\n+\n+A PF MAY offer Parameter adaptation composition. Ie combine multiple parameter adaptation\n+Eg: composing the affine and logarithm adaptation to `compAd(value) = slope * log(value) + offset`\n+(Note: The reference application supports in a tricky way: the logarithm adaptation is always combined with the affine adaptation)\n+(Why: To avoid combination explosion of parameter adaptations.\n+      The idea is to builtin basic function and let the user compose them to meet it's need.)\n+\n+## Identifiers\n+Every parameter MUST have a identifier that uniquely identifies it.\n+(Why: to identify a parameter outside the framework)\n+\n+This identifier SHOULD be a string.\n+(Why: so that the (human) user can identify a parameter with ease.)\n+\n+Two PF instances with the same parameters MUST have the same identifier for those parameters.\n+Ie. This identifier should be the same across all instances with the same configuration.\n+(Why: Persistence of parameter identifier across PF instances with the same configuration.\n+      To identify parameters independently of the host machine and PF instance)\n+\n+### Parameter tree\n+A parameter SHOULD be structured in a tree. Each parameter being a distinct tree leaf.\n+(Why: Tree is a simple data structure that can be easily represented and is enough to map\n+      underlined layers.\n+      It is not a MUST because an other structure could be chose like a list or a graph.\n+      It would not change the rest of the PF properties thank to the unique identifier requirement.)\n+\n+Each node of the tree SHOULD have its own identifier with the same\n+characteristics (type, independence...) than a parameter.\n+(Why: To represent the tree without treating the leaf nodes specifically.)\n+\n+The identifier of each node of the tree SHOULD be a combination of its parents.\n+More specifically, if the identifier is a string it should be formated the same\n+way as a file system path. Eg the parameter named \"/root/child1/4/parameter1\".\n+(Why: Usual syntax to address trees.)\n+\n+\n+# Syncer\n+\n+The PF philosophy is to map the hardware characteristics to parameters.\n+\n+A syncer MUST be mapped to one or more parameters.\n+(Why: The hardware minimal access may be bigger than one parameter.)\n+\n+One parameter MUST NOT be mapped to two or more syncer.\n+(Why: Which syncer should be responsible to retrieve the initial parameter value\n+      if they are multiple per parameter?)\n+\n+A syncer MUST support retrieving the mapped parameters value from the mapped hardware.\n+(Why: to retrieve a parameter value at the start of the PF.)\n+\n+A syncer MUST support setting the mapped parameters value to the mapped hardware.\n+(Why: to synchronise hardware on parameter change.)\n+\n+Syncers MUST retrieve and set the parameters value from the PF core.\n+(Why: to be able to synchronise with hardware.)\n+\n+This API MAY be a packed parameter structure, following the C abi without padding.\n+(Note: This is what the reference implementation does.)\n+(Why: ???)\n+\n+## Introspection\n+The syncer API SHOULD allow introspection of the mapped parameters.\n+(Why: the parameter structure may be useful for the syncer to communicate with the hardware.)\n+\n+## Plugins\n+The PF MUST be able to create syncers.\n+(Why: to bind on the corresponding parameters.)\n+\n+### Definition\n+The PF creates syncer using syncer builder.\n+\n+### Identifier\n+All syncer mapping the same hardware SHOULD have their builder regrouped in a syncer library.\n+(Why: to be able to link a group of parameters and a given hardware.)\n+\n+A syncer builder MUST have a unique identifier in its containing syncer library.\n+(Why: To uniquely identify the syncer that should bind on parameters.\n+      Given that the syncer library has already been specified.)\n+\n+A syncer library MUST have a unique identifier in the host system.\n+(Why: To identify the library associated to parameters.)\n+\n+Syncer build and syncer library identifiers SHOULD be strings.\n+(Why: The reference application does so.)\n+\n+### Loading\n+Syncer library or/and builder MAY be loaded from dynamically linked libraries (called syncer plugins).\n+(Why: The reference implementation supports it.)\n+\n+Such syncer plugins SHOULD have an unique entry point that -when called- should register\n+its payload (syncer library/builder) in the provided gatherer.\n+(Note: This permit to merge multiple syncer libraries in one dll.)\n+(Why: The reference implementation supports it.)\n+\n+Multiple syncer plugins, may depend on each other. The PF should appropriatly handle the case\n+and not fail.\n+(Why: The reference implementation supports it.)\n+\n+## Mapping\n+### Definition\n+A parameter not bound to a syncer is called a \"virtual parameter\".\n+(Todo: remove if not used in the requirements.)\n+\n+### Requirements\n+**TODO**:\n+ - Plugins\n+ - association builder <-> parameters\n+\n+## Sync\n+\n+Syncer SHOULD synchronise the mapped hardware on parameter change.\n+(Why: To always keep synchronise the underlined hardware and the PF parameters.)\n+\n+Syncer SHOULD retrieve parameter value from the hardware if no value has be set since the PF start.\n+(Note: This is usually implemented on PF start, initialize the parameter values with the mapped hardware current state.)\n+(Why: To allow introspection of the hardware.)\n+\n+A mode with synchronisation on client request MAY be supported.\n+(Why: The reference implementation supports it.)\n+\n+# Rule based dynamic abstraction\n+\n+## Philosophy\n+\n+The PF offers parameters mapped on hardware. This is a good but weak abstraction.\n+There is often a 1/1 relation between a parameter and the hardware it maps.\n+\n+A PF offers a mechanism to abstract the parameters to more high level concept.\n+\n+The goal is to hide numerous parameters and their dynamic value behind simple\n+and human friendly api.\n+\n+It works by regrouping parameters with similar management and defining configurations\n+for each \"scenario\". These \"scenario\" are then given a priority and a detection predicate.\n+Configuration are applied when their associated \"scenario\" is detected.\n+\n+\"Scenario\" are detected through arbitrary criterion provided by the PF host.\n+\n+## Definition\n+\n+Configurations: set of values for different parameters.\n+A configuration MUST not contain 2 values of the same parameters.\n+For example, given a PF with 3 integer parameters A,B,C,\n+a configuration can contain\n+ - 1 value for (A), (B) or (C)\n+ - 2 value for (A,B), (A,C) or (B,C)\n+ - 3 value for (A,B,C)\n+\n+## Configuration\n+\n+A PF MUST offer configurations as described in the Definition chapter.\n+(Note: rule based parameter engine does not manipulate directly values,\n+      it applies configuration on the parameters.)\n+(Why: This is what the reference implementation does.)\n+\n+Each configuration MUST be associated with a predicate that condition its eligibility.\n+A configuration with a predicate that evaluates to `true` is called an \"eligible configuration\"\n+(Why: This is what the reference implementation does.)\n+\n+The predicate SHOULD be a \"selection criterion rule\". See next chapter for a definition.\n+(Why: The reference implementation uses a boolean expression based engine.)\n+\n+## Selection criterion\n+\n+A selection criterion MUST have one, and only one, state at a given time.\n+\n+A selection criterion MUST know at construction all possible states.\n+(Why: To be able to validate:\n+       - rules on start\n+       - state changes)\n+\n+The selection criterion possible states MUST be specifiable by:\n+ - Directly a state set (Input -> states == identity)\n+   (Note: called exclusive criterion)\n+   (Note: An empty set is not allowed as the criterion could not have a state.)\n+   (Why: any criterion can be crated with this one.)\n+\n+The selection criterion possible states SHOULD be specifiable by:\n+ - A combination of values\n+   (Note: combination in the mathematical sense “ab” -> [“”, “a”, “b”, “ab”])\n+   (Note: called inclusive criterion)\n+   (Note: Un empty value set is allowed as it's combination -a set containing the empty set- would not be empty.\n+          The empty set would be the only possible criteria state.)\n+   (Why: The reference implementation supports it.)\n+\n+### Definitions\n+ - Selection criterion rule: function (in the mathematical sense) that MUST given selection criteria return a Boolean.\n+\n+ - Rule: an Boolean expression of Selection criterion rules\n+   (Note: implementation only allows AND and OR combination)\n+\n+### Criterion change\n+\n+The api to change criterion values MUST allow atomicity regarding configuration application.\n+Ie. It MUST be possible to change multiple criterion values without triggering a configuration\n+application.\n+(Why: Two criterion might have an excluding state.\n+      If configuration application was triggered after each)\n+\n+### Rules\n+\n+One MUST always be able to create a selection criterion rule from a given selection criterion\n+Ie: a criteria MUST always have a state that can be matched by a rule.\n+(Why: if no rules can be formulated from a criterion, it is useless)\n+\n+Parameter values change SHOULD be selected by Rules.\n+(Why: A rule based inference engine has been chosen based on implementation and configuration ease)\n+\n+## Domains\n+\n+### Definition\n+Domain: ordered set of configuration, all of which contain the values for the same parameters.\n+\n+### Requirement\n+\n+Each configuration SHOULD be in a \"domain\" (see Definition chapter).\n+(Why: Domains are mostly a way to define the priority of \"Scenarios\" for some parameters.\n+      It is not a MUST because this goal could also be achieve with (for example) global configurations and per parameter priority.\n+      It is not a MAY because the reference implementation uses domains.)\n+\n+If multiple configuration are eligible, the first one MUST be applied.\n+(Why: If multiple configuration are eligible)\n+\n+If no configuration is eligible, no configuration MUST be applied.\n+(Note: It means that if none of the configurations is eligible, none is applied.\n+       This also mean that no function can be defined between criteria and states.\n+       Ie: Parameter values MAY depend on previous selection criterion states.\n+(Why: This is what the reference implementation does.)\n+\n+TODO sequence aware domains\n+\n+# (de)serialization\n+\n+## Philosophy\n+Serialization and deserialization are meant to support destruction recovery\n+and configuration deployment.\n+\n+These are the same requirements than for a database, it needs to be able to save\n+its state and restore for backup, deployment, reboot...\n+\n+## Definition\n+PF data includes:\n+ - parameter tree\n+ - parameter values\n+ - configurations\n+ - criteria rule\n+ - domains","path":"doc/Requirements.md","position":406,"original_position":406,"commit_id":"556c345e77a36cdbd4b87a03893e0c911a7e938e","original_commit_id":"556c345e77a36cdbd4b87a03893e0c911a7e938e","user":{"login":"dawagner","id":6430928,"avatar_url":"https://avatars.githubusercontent.com/u/6430928?v=3","gravatar_id":"","url":"https://api.github.com/users/dawagner","html_url":"https://github.com/dawagner","followers_url":"https://api.github.com/users/dawagner/followers","following_url":"https://api.github.com/users/dawagner/following{/other_user}","gists_url":"https://api.github.com/users/dawagner/gists{/gist_id}","starred_url":"https://api.github.com/users/dawagner/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/dawagner/subscriptions","organizations_url":"https://api.github.com/users/dawagner/orgs","repos_url":"https://api.github.com/users/dawagner/repos","events_url":"https://api.github.com/users/dawagner/events{/privacy}","received_events_url":"https://api.github.com/users/dawagner/received_events","type":"User","site_admin":false},"body":"Parameter values in which context ? What is the content of a domain ?\r\n\r\nI'd rewrite this as:\r\n- parameters tree\r\n- configurations:\r\n  - selection rules\r\n  - parameter/value couples\r\n- domain:\r\n  - list of associated configurations\r\n  - order of priority","created_at":"2015-07-27T13:01:55Z","updated_at":"2015-07-27T13:01:55Z","html_url":"https://github.com/01org/parameter-framework/pull/144#discussion_r35532428","pull_request_url":"https://api.github.com/repos/01org/parameter-framework/pulls/144","_links":{"self":{"href":"https://api.github.com/repos/01org/parameter-framework/pulls/comments/35532428"},"html":{"href":"https://github.com/01org/parameter-framework/pull/144#discussion_r35532428"},"pull_request":{"href":"https://api.github.com/repos/01org/parameter-framework/pulls/144"}}},"pull_request":{"url":"https://api.github.com/repos/01org/parameter-framework/pulls/144","id":39301509,"html_url":"https://github.com/01org/parameter-framework/pull/144","diff_url":"https://github.com/01org/parameter-framework/pull/144.diff","patch_url":"https://github.com/01org/parameter-framework/pull/144.patch","issue_url":"https://api.github.com/repos/01org/parameter-framework/issues/144","number":144,"state":"open","locked":false,"title":"Parameter Framework requirements","user":{"login":"krocard","id":6862950,"avatar_url":"https://avatars.githubusercontent.com/u/6862950?v=3","gravatar_id":"","url":"https://api.github.com/users/krocard","html_url":"https://github.com/krocard","followers_url":"https://api.github.com/users/krocard/followers","following_url":"https://api.github.com/users/krocard/following{/other_user}","gists_url":"https://api.github.com/users/krocard/gists{/gist_id}","starred_url":"https://api.github.com/users/krocard/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/krocard/subscriptions","organizations_url":"https://api.github.com/users/krocard/orgs","repos_url":"https://api.github.com/users/krocard/repos","events_url":"https://api.github.com/users/krocard/events{/privacy}","received_events_url":"https://api.github.com/users/krocard/received_events","type":"User","site_admin":false},"body":"List the Parameter Framework requirements independently of it's reference implementation.","created_at":"2015-07-06T19:24:05Z","updated_at":"2015-07-27T13:01:55Z","closed_at":null,"merged_at":null,"merge_commit_sha":"c67cbc658b612d1b699f6c8fa63e6b13bdaf8f1c","assignee":null,"milestone":null,"commits_url":"https://api.github.com/repos/01org/parameter-framework/pulls/144/commits","review_comments_url":"https://api.github.com/repos/01org/parameter-framework/pulls/144/comments","review_comment_url":"https://api.github.com/repos/01org/parameter-framework/pulls/comments{/number}","comments_url":"https://api.github.com/repos/01org/parameter-framework/issues/144/comments","statuses_url":"https://api.github.com/repos/01org/parameter-framework/statuses/556c345e77a36cdbd4b87a03893e0c911a7e938e","head":{"label":"krocard:requirements","ref":"requirements","sha":"556c345e77a36cdbd4b87a03893e0c911a7e938e","user":{"login":"krocard","id":6862950,"avatar_url":"https://avatars.githubusercontent.com/u/6862950?v=3","gravatar_id":"","url":"https://api.github.com/users/krocard","html_url":"https://github.com/krocard","followers_url":"https://api.github.com/users/krocard/followers","following_url":"https://api.github.com/users/krocard/following{/other_user}","gists_url":"https://api.github.com/users/krocard/gists{/gist_id}","starred_url":"https://api.github.com/users/krocard/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/krocard/subscriptions","organizations_url":"https://api.github.com/users/krocard/orgs","repos_url":"https://api.github.com/users/krocard/repos","events_url":"https://api.github.com/users/krocard/events{/privacy}","received_events_url":"https://api.github.com/users/krocard/received_events","type":"User","site_admin":false},"repo":{"id":24673385,"name":"parameter-framework","full_name":"krocard/parameter-framework","owner":{"login":"krocard","id":6862950,"avatar_url":"https://avatars.githubusercontent.com/u/6862950?v=3","gravatar_id":"","url":"https://api.github.com/users/krocard","html_url":"https://github.com/krocard","followers_url":"https://api.github.com/users/krocard/followers","following_url":"https://api.github.com/users/krocard/following{/other_user}","gists_url":"https://api.github.com/users/krocard/gists{/gist_id}","starred_url":"https://api.github.com/users/krocard/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/krocard/subscriptions","organizations_url":"https://api.github.com/users/krocard/orgs","repos_url":"https://api.github.com/users/krocard/repos","events_url":"https://api.github.com/users/krocard/events{/privacy}","received_events_url":"https://api.github.com/users/krocard/received_events","type":"User","site_admin":false},"private":false,"html_url":"https://github.com/krocard/parameter-framework","description":"Plugin-based and rule-based framework for describing and controlling parameters","fork":true,"url":"https://api.github.com/repos/krocard/parameter-framework","forks_url":"https://api.github.com/repos/krocard/parameter-framework/forks","keys_url":"https://api.github.com/repos/krocard/parameter-framework/keys{/key_id}","collaborators_url":"https://api.github.com/repos/krocard/parameter-framework/collaborators{/collaborator}","teams_url":"https://api.github.com/repos/krocard/parameter-framework/teams","hooks_url":"https://api.github.com/repos/krocard/parameter-framework/hooks","issue_events_url":"https://api.github.com/repos/krocard/parameter-framework/issues/events{/number}","events_url":"https://api.github.com/repos/krocard/parameter-framework/events","assignees_url":"https://api.github.com/repos/krocard/parameter-framework/assignees{/user}","branches_url":"https://api.github.com/repos/krocard/parameter-framework/branches{/branch}","tags_url":"https://api.github.com/repos/krocard/parameter-framework/tags","blobs_url":"https://api.github.com/repos/krocard/parameter-framework/git/blobs{/sha}","git_tags_url":"https://api.github.com/repos/krocard/parameter-framework/git/tags{/sha}","git_refs_url":"https://api.github.com/repos/krocard/parameter-framework/git/refs{/sha}","trees_url":"https://api.github.com/repos/krocard/parameter-framework/git/trees{/sha}","statuses_url":"https://api.github.com/repos/krocard/parameter-framework/statuses/{sha}","languages_url":"https://api.github.com/repos/krocard/parameter-framework/languages","stargazers_url":"https://api.github.com/repos/krocard/parameter-framework/stargazers","contributors_url":"https://api.github.com/repos/krocard/parameter-framework/contributors","subscribers_url":"https://api.github.com/repos/krocard/parameter-framework/subscribers","subscription_url":"https://api.github.com/repos/krocard/parameter-framework/subscription","commits_url":"https://api.github.com/repos/krocard/parameter-framework/commits{/sha}","git_commits_url":"https://api.github.com/repos/krocard/parameter-framework/git/commits{/sha}","comments_url":"https://api.github.com/repos/krocard/parameter-framework/comments{/number}","issue_comment_url":"https://api.github.com/repos/krocard/parameter-framework/issues/comments{/number}","contents_url":"https://api.github.com/repos/krocard/parameter-framework/contents/{+path}","compare_url":"https://api.github.com/repos/krocard/parameter-framework/compare/{base}...{head}","merges_url":"https://api.github.com/repos/krocard/parameter-framework/merges","archive_url":"https://api.github.com/repos/krocard/parameter-framework/{archive_format}{/ref}","downloads_url":"https://api.github.com/repos/krocard/parameter-framework/downloads","issues_url":"https://api.github.com/repos/krocard/parameter-framework/issues{/number}","pulls_url":"https://api.github.com/repos/krocard/parameter-framework/pulls{/number}","milestones_url":"https://api.github.com/repos/krocard/parameter-framework/milestones{/number}","notifications_url":"https://api.github.com/repos/krocard/parameter-framework/notifications{?since,all,participating}","labels_url":"https://api.github.com/repos/krocard/parameter-framework/labels{/name}","releases_url":"https://api.github.com/repos/krocard/parameter-framework/releases{/id}","created_at":"2014-10-01T09:54:18Z","updated_at":"2015-04-13T15:36:05Z","pushed_at":"2015-07-24T19:20:29Z","git_url":"git://github.com/krocard/parameter-framework.git","ssh_url":"git@github.com:krocard/parameter-framework.git","clone_url":"https://github.com/krocard/parameter-framework.git","svn_url":"https://github.com/krocard/parameter-framework","homepage":"","size":4006,"stargazers_count":0,"watchers_count":0,"language":"C++","has_issues":false,"has_downloads":true,"has_wiki":true,"has_pages":false,"forks_count":0,"mirror_url":null,"open_issues_count":0,"forks":0,"open_issues":0,"watchers":0,"default_branch":"master"}},"base":{"label":"01org:master","ref":"master","sha":"b03e972701aeb7ffe1047c21a019e2d5c7c7bc5c","user":{"login":"01org","id":1635439,"avatar_url":"https://avatars.githubusercontent.com/u/1635439?v=3","gravatar_id":"","url":"https://api.github.com/users/01org","html_url":"https://github.com/01org","followers_url":"https://api.github.com/users/01org/followers","following_url":"https://api.github.com/users/01org/following{/other_user}","gists_url":"https://api.github.com/users/01org/gists{/gist_id}","starred_url":"https://api.github.com/users/01org/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/01org/subscriptions","organizations_url":"https://api.github.com/users/01org/orgs","repos_url":"https://api.github.com/users/01org/repos","events_url":"https://api.github.com/users/01org/events{/privacy}","received_events_url":"https://api.github.com/users/01org/received_events","type":"Organization","site_admin":false},"repo":{"id":16009363,"name":"parameter-framework","full_name":"01org/parameter-framework","owner":{"login":"01org","id":1635439,"avatar_url":"https://avatars.githubusercontent.com/u/1635439?v=3","gravatar_id":"","url":"https://api.github.com/users/01org","html_url":"https://github.com/01org","followers_url":"https://api.github.com/users/01org/followers","following_url":"https://api.github.com/users/01org/following{/other_user}","gists_url":"https://api.github.com/users/01org/gists{/gist_id}","starred_url":"https://api.github.com/users/01org/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/01org/subscriptions","organizations_url":"https://api.github.com/users/01org/orgs","repos_url":"https://api.github.com/users/01org/repos","events_url":"https://api.github.com/users/01org/events{/privacy}","received_events_url":"https://api.github.com/users/01org/received_events","type":"Organization","site_admin":false},"private":false,"html_url":"https://github.com/01org/parameter-framework","description":"Plugin-based and rule-based framework for describing and controlling parameters","fork":false,"url":"https://api.github.com/repos/01org/parameter-framework","forks_url":"https://api.github.com/repos/01org/parameter-framework/forks","keys_url":"https://api.github.com/repos/01org/parameter-framework/keys{/key_id}","collaborators_url":"https://api.github.com/repos/01org/parameter-framework/collaborators{/collaborator}","teams_url":"https://api.github.com/repos/01org/parameter-framework/teams","hooks_url":"https://api.github.com/repos/01org/parameter-framework/hooks","issue_events_url":"https://api.github.com/repos/01org/parameter-framework/issues/events{/number}","events_url":"https://api.github.com/repos/01org/parameter-framework/events","assignees_url":"https://api.github.com/repos/01org/parameter-framework/assignees{/user}","branches_url":"https://api.github.com/repos/01org/parameter-framework/branches{/branch}","tags_url":"https://api.github.com/repos/01org/parameter-framework/tags","blobs_url":"https://api.github.com/repos/01org/parameter-framework/git/blobs{/sha}","git_tags_url":"https://api.github.com/repos/01org/parameter-framework/git/tags{/sha}","git_refs_url":"https://api.github.com/repos/01org/parameter-framework/git/refs{/sha}","trees_url":"https://api.github.com/repos/01org/parameter-framework/git/trees{/sha}","statuses_url":"https://api.github.com/repos/01org/parameter-framework/statuses/{sha}","languages_url":"https://api.github.com/repos/01org/parameter-framework/languages","stargazers_url":"https://api.github.com/repos/01org/parameter-framework/stargazers","contributors_url":"https://api.github.com/repos/01org/parameter-framework/contributors","subscribers_url":"https://api.github.com/repos/01org/parameter-framework/subscribers","subscription_url":"https://api.github.com/repos/01org/parameter-framework/subscription","commits_url":"https://api.github.com/repos/01org/parameter-framework/commits{/sha}","git_commits_url":"https://api.github.com/repos/01org/parameter-framework/git/commits{/sha}","comments_url":"https://api.github.com/repos/01org/parameter-framework/comments{/number}","issue_comment_url":"https://api.github.com/repos/01org/parameter-framework/issues/comments{/number}","contents_url":"https://api.github.com/repos/01org/parameter-framework/contents/{+path}","compare_url":"https://api.github.com/repos/01org/parameter-framework/compare/{base}...{head}","merges_url":"https://api.github.com/repos/01org/parameter-framework/merges","archive_url":"https://api.github.com/repos/01org/parameter-framework/{archive_format}{/ref}","downloads_url":"https://api.github.com/repos/01org/parameter-framework/downloads","issues_url":"https://api.github.com/repos/01org/parameter-framework/issues{/number}","pulls_url":"https://api.github.com/repos/01org/parameter-framework/pulls{/number}","milestones_url":"https://api.github.com/repos/01org/parameter-framework/milestones{/number}","notifications_url":"https://api.github.com/repos/01org/parameter-framework/notifications{?since,all,participating}","labels_url":"https://api.github.com/repos/01org/parameter-framework/labels{/name}","releases_url":"https://api.github.com/repos/01org/parameter-framework/releases{/id}","created_at":"2014-01-17T19:24:01Z","updated_at":"2015-07-11T10:04:10Z","pushed_at":"2015-07-24T19:20:30Z","git_url":"git://github.com/01org/parameter-framework.git","ssh_url":"git@github.com:01org/parameter-framework.git","clone_url":"https://github.com/01org/parameter-framework.git","svn_url":"https://github.com/01org/parameter-framework","homepage":"","size":45500,"stargazers_count":10,"watchers_count":10,"language":"C++","has_issues":true,"has_downloads":true,"has_wiki":true,"has_pages":true,"forks_count":20,"mirror_url":null,"open_issues_count":19,"forks":20,"open_issues":19,"watchers":10,"default_branch":"master"}},"_links":{"self":{"href":"https://api.github.com/repos/01org/parameter-framework/pulls/144"},"html":{"href":"https://github.com/01org/parameter-framework/pull/144"},"issue":{"href":"https://api.github.com/repos/01org/parameter-framework/issues/144"},"comments":{"href":"https://api.github.com/repos/01org/parameter-framework/issues/144/comments"},"review_comments":{"href":"https://api.github.com/repos/01org/parameter-framework/pulls/144/comments"},"review_comment":{"href":"https://api.github.com/repos/01org/parameter-framework/pulls/comments{/number}"},"commits":{"href":"https://api.github.com/repos/01org/parameter-framework/pulls/144/commits"},"statuses":{"href":"https://api.github.com/repos/01org/parameter-framework/statuses/556c345e77a36cdbd4b87a03893e0c911a7e938e"}}}}