diff --git a/.dockerignore b/.dockerignore index 49b5caab..16024d5d 100644 --- a/.dockerignore +++ b/.dockerignore @@ -14,3 +14,21 @@ Dockerfile # Exclude large demo assets not needed at runtime assets/live-peview.gif assets/*.gif + +# Never include connector secrets/configuration in build contexts +self-hosted/private/ + +**/node_modules/ +self-hosted/connector/test/ + +self-hosted/dist/ + +# Local deployment secrets +.env +**/.env + +# Never commit or bake connector profile/credential state into images +**/profiles.sqlite* +**/credential.key +**/credentials.enc +**/cloud-state/ diff --git a/.github/workflows/desktop-build.yml b/.github/workflows/desktop-build.yml index 9700ad63..52d4998e 100644 --- a/.github/workflows/desktop-build.yml +++ b/.github/workflows/desktop-build.yml @@ -33,6 +33,8 @@ jobs: cache: npm - run: npm ci - run: npm ci --prefix desktop-app + - name: Prepare Neutralino SDK for unit tests + run: node desktop-app/setup-binaries.js - run: npm run build && npm run test:unit - run: python3 tests/native/test_macos_load_commands.py - uses: actions/cache@v4 diff --git a/.github/workflows/desktop-native-demo.yml b/.github/workflows/desktop-native-demo.yml index 840a3880..6dcaf60d 100644 --- a/.github/workflows/desktop-native-demo.yml +++ b/.github/workflows/desktop-native-demo.yml @@ -41,6 +41,8 @@ jobs: - run: npm ci - run: npm ci --prefix desktop-app - run: npm run build + - name: Prepare desktop dependencies + run: npm --prefix desktop-app run setup - run: npm run test:unit - run: node assets/i18n/audit-ui-locales.mjs - name: Checkout pinned single-instance runtime @@ -59,8 +61,6 @@ jobs: cmake -S desktop-app/.native-runtime -B desktop-app/.native-runtime/build -G Ninja -DCMAKE_BUILD_TYPE=Release if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE } cmake --build desktop-app/.native-runtime/build --parallel 4 - - name: Prepare desktop dependencies - run: npm --prefix desktop-app run setup - name: Package isolated native demo run: node desktop-app/build-native-demo.js - name: Validate native rename with real Windows files diff --git a/.gitignore b/.gitignore index fc21f7c8..d1dc7cc2 100644 --- a/.gitignore +++ b/.gitignore @@ -17,3 +17,22 @@ __pycache__/ # OS files .DS_Store Thumbs.db + +# Self-hosted connector credentials and local configuration +self-hosted/private/ + +# Local Docker transfer bundles +self-hosted/dist/ + +# Local deployment secrets +.env +**/.env + +# Isolated browser verification output +test-results-copy-*/ + +# Never commit or bake connector profile/credential state into images +**/profiles.sqlite* +**/credential.key +**/credentials.enc +**/cloud-state/ diff --git a/README.md b/README.md index 5e4a3b16..340f6014 100644 --- a/README.md +++ b/README.md @@ -200,3 +200,7 @@ See the [contributing guide](CONTRIBUTING.md), [Code of Conduct](CODE_OF_CONDUCT ## License Markdown Viewer is licensed under the [Apache License 2.0](LICENSE). + +## Experimental cloud connections + +This branch adds Nextcloud and generic WebDAV folder access for Windows desktop and optional personal or multi-user self-hosted web deployments. See the [cloud guide](docs/cloud-connections.md) for behavior, build/deployment instructions and security limits. The connector provides profile isolation, not operator-blind/E2EE hosting; review the deployment limits before Internet exposure. diff --git a/cloud-copy.js b/cloud-copy.js new file mode 100644 index 00000000..1cac3f40 --- /dev/null +++ b/cloud-copy.js @@ -0,0 +1,127 @@ +// Shared copy workflow: snapshot locally, create exclusively, never replay uncertain writes. +(function(target){ + 'use strict'; + const model=target.MarkdownCloudModel; + const LIMITS=Object.freeze({files:500,folders:200,depth:20,totalBytes:50*1024*1024}); + function segment(value){ + if(typeof value!=='string' || !value || value!==value.trim() || /[\\/\u0000-\u001f\u007f:*?"<>|%]/.test(value) || /[. ]$/.test(value) || /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(value) || new TextEncoder().encode(value).length>200)throw new Error('Choose a portable name without path separators or reserved characters.'); + return value; + } + // Propose a portable destination from a local display name, never from a remote URL. + // Manual destination input still passes the strict validator without substitution. + function suggestName(value,{file=false}={}){ + let stem=String(value || '').trim();if(file)stem=stem.replace(/\.(md|markdown)$/i,''); + stem=stem.replace(/[\\/\u0000-\u001f\u007f:*?"<>|%]/g,'_').replace(/[. ]+$/,''); + if(!stem || stem==='.' || stem==='..')stem=file?'Untitled':'Folder'; + if(/^(con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(stem))stem='_'+stem; + const characters=Array.from(stem),extension=file?'.md':''; + while(new TextEncoder().encode(characters.join('')+extension).length>160)characters.pop(); + stem=characters.join('').replace(/[. ]+$/,'') || (file?'Untitled':'Folder'); + return file?model.markdownName(stem+extension):segment(stem); + } + const key=parts=>parts.map(p=>p.normalize('NFC').toLowerCase()).join('/'); + function validatePlan(input){ + if(!input || !Array.isArray(input.files) || !Array.isArray(input.folders) || input.files.length>LIMITS.files || input.folders.length>LIMITS.folders)throw new Error('Copy a smaller folder (up to 500 files and 200 folders).'); + const occupied=new Set(),directories=new Set(['']);let total=0; + const path=parts=>{if(!Array.isArray(parts) || !parts.length || parts.length>LIMITS.depth)throw new Error('Invalid or overly deep copy hierarchy.');return parts.map(segment);}; + const folders=input.folders.map(path).sort((a,b)=>a.length-b.length); + for(const parts of folders){const name=key(parts);if(occupied.has(name) || !directories.has(key(parts.slice(0,-1))))throw new Error('Duplicate or missing parent folder.');occupied.add(name);directories.add(name);} + const files=input.files.map(file=>{ + const parts=path(file.path),name=key(parts); + if(!/\.md$/.test(parts.at(-1)) || occupied.has(name) || !directories.has(key(parts.slice(0,-1))))throw new Error('Duplicate, non-Markdown or invalid copy destination.');occupied.add(name); + if(typeof file.content!=='string')throw new Error('A source draft could not be loaded. Nothing was copied.'); + const bytes=new TextEncoder().encode(file.content).length;total+=bytes; + if(bytes>model.MAX_BYTES || total>LIMITS.totalBytes)throw new Error('Copy exceeds the 20 MiB file or 50 MiB total limit.'); + return {path:parts,content:file.content}; + }); + if(!input.folder && (files.length!==1 || folders.length))throw new Error('Invalid file copy.'); + return {folder:!!input.folder,files,folders,totalBytes:total}; + } + async function execute({plan,client,parent,name,api,isConnected,cancelled=()=>false,progress=()=>{},saves}){ + plan=validatePlan(plan);name=plan.folder?segment(name):model.markdownName(name); + const requireLive=()=>{api.assertCopyAllowed?.();if(cancelled())throw new Error('Copy stopped. Completed files remain on the server; remaining drafts were kept.');if(!isConnected(client))throw new Error('The account disconnected. Check the server before retrying; all local drafts were kept.');}; + const root=plan.folder?client.folderRef(client.childRef(parent,name)):parent; + const ref=(parts,folder=false)=>{let result=root;for(const part of parts)result=client.childRef(client.folderRef(result),part);return folder?client.folderRef(result):result;}; + const items=plan.files.map(file=>({file,href:plan.folder?ref(file.path):client.childRef(parent,name)})); + // Validate every destination and check local ownership before any draft or network mutation. + for(const item of items){client.validateFile(item.href);if(api.findRemote(client.source(item.href)))throw new Error('A local cloud draft already exists at the destination. Choose another name.');} + const directories=plan.folder?[root,...plan.folders.map(parts=>ref(parts,true))]:[]; + directories.forEach(href=>client.validateRef(href)); + let completed=0,createdFolders=0,attempted=false;const drafts=[]; + try{ + requireLive(); + for(const item of items){ + requireLive(); + const digest=await model.digest(item.file.content); + const source=client.source(item.href,'',{savedDigest:'',attemptDigest:digest,status:'uncertain',creationPending:true}); + item.source=source;item.id=await api.createRemoteDraft(item.file.content,client.fileName(item.href),source,{activate:false});drafts.push(item);saves.add(item.id); + } + // All recovery bodies are durable before the first MKCOL/PUT. + requireLive(); + for(const folder of directories){requireLive();attempted=true;await client.createFolder(folder);createdFolders++;progress({completed,total:items.length,createdFolders});} + for(const item of items){ + requireLive();attempted=true; + try{const remote=await client.create(item.href,item.file.content);await api.updateRemote(item.id,{...item.source,version:remote.version,savedDigest:item.source.attemptDigest,attemptDigest:undefined,creationPending:undefined,status:'saved',availability:'available'});} + catch(error){if(error.code==='CONFLICT')await api.detachRemote(item.id,item.source);throw error;} + completed++;progress({completed,total:items.length,createdFolders}); + } + return {completed,createdFolders,root,firstId:items[0]?.id}; + }catch(error){ + // A refused new root grants no authority over an existing directory's contents. + if(!attempted || (plan.folder && createdFolders===0 && error.code==='CONFLICT'))for(const item of drafts)await api.detachRemote(item.id,item.source).catch(()=>{}); + throw Object.assign(new Error(completed+' of '+items.length+' files copied; '+createdFolders+' folders created. '+error.message+' No automatic retry or cleanup was performed.'),{code:error.code,completed,createdFolders}); + }finally{for(const item of drafts)saves.delete(item.id);api.statusChanged();} + } + function create(context){ + const {api,saves}=context;let dialog,busy=false; + async function open(descriptor){ + if(dialog || busy)throw new Error('Finish the current cloud copy first.'); + const description=api.describeCopySource(descriptor),clients=context.clients().filter(client=>client.capabilities.create); + if(!clients.length){api.notify('Connect a cloud account, then choose Copy to cloud again.');context.connect();return;} + const modal=document.createElement('div');dialog=modal;modal.className='reset-modal-overlay modal-overlay';modal.id='cloud-copy-modal';modal.style.display='none'; + modal.setAttribute('role','dialog');modal.setAttribute('aria-modal','true');modal.setAttribute('aria-hidden','true');modal.setAttribute('aria-labelledby','cloud-copy-title'); + modal.innerHTML='

Copy to cloud

Copies the current workspace drafts, including unsaved edits. Originals stay unchanged. Linked folders are not rescanned; only their currently linked files are included. A folder copy creates a new folder and never merges into an existing one. Copies use .md; unsupported name characters become underscores and duplicate names receive a numbered suffix.

'; + document.body.append(modal); + const select=modal.querySelector('select'),input=modal.querySelector('input'),list=modal.querySelector('.cloud-copy-folders'),status=modal.querySelector('.cloud-copy-status'),up=modal.querySelector('.cloud-copy-up'),confirm=modal.querySelector('.reset-modal-confirm'),cancel=modal.querySelector('.reset-modal-cancel'); + modal.querySelector('.cloud-copy-source').textContent=description.label+' \u00b7 '+description.count+' Markdown file(s)';input.value=description.name; + clients.forEach((client,index)=>{const option=document.createElement('option');option.value=String(index);option.textContent=client.account.label+' \u00b7 '+client.account.detail+' \u00b7 '+decodeURIComponent(new URL(client.root).pathname);select.append(option);}); + let client=clients[0],folder=client.root,epoch=0,stop=false,finished=false,result; + modal._confirmationCancel=()=>{stop=true;if(!busy){epoch++;modal.remove();dialog=undefined;}}; + const close=()=>{if(busy){stop=true;status.textContent='Stopping after the current operation settles\u2026';return;}epoch++;api.closeDialog(modal);modal.remove();dialog=undefined;}; + const live=()=>context.clients().includes(client); + async function browse(href){ + const ticket=++epoch;const chosen=client;folder=chosen.folderRef(href);list.replaceChildren();confirm.disabled=true;up.disabled=true;status.textContent='Loading folders\u2026'; + modal.querySelector('.cloud-copy-path').textContent=chosen.locationLabel(folder); + try{const entries=await chosen.list(folder);if(ticket!==epoch || dialog!==modal)return;if(!live())throw new Error('Reconnect the selected account.'); + for(const entry of entries.filter(item=>item.directory)){const button=document.createElement('button');button.type='button';button.className='nextcloud-entry is-folder';const icon=document.createElement('i');icon.className='lucide lucide-folder';icon.setAttribute('aria-hidden','true');const label=document.createElement('span');label.textContent=entry.name;button.append(icon,label);button.addEventListener('click',()=>void browse(entry.ref));list.append(button);} + status.textContent='New files are created only if their names are free.';confirm.disabled=false;up.disabled=folder===chosen.root; + }catch(error){if(ticket===epoch)status.textContent=error.message;} + } + select.addEventListener('change',()=>{client=clients[Number(select.value)];void browse(client.root);});up.addEventListener('click',()=>void browse(client.upRef(folder))); + cancel.addEventListener('click',close);modal.querySelector('.modal-close-btn').addEventListener('click',close); + confirm.addEventListener('click',async()=>{ + if(finished){try{if(result?.firstId && !description.folder)await api.activateRemote(client.source(planFileRef()));close();}catch(error){status.textContent=error.message;}return;} + if(busy || confirm.disabled)return; + let locked=false; + try{ + const name=description.folder?segment(input.value):model.markdownName(input.value); + if(!live())throw new Error('Reconnect the selected account.'); + busy=true;confirm.disabled=true;select.disabled=input.disabled=up.disabled=true;list.querySelectorAll('button').forEach(b=>b.disabled=true);cancel.textContent='Stop after current operation';cancel.focus(); + api.beginSave();locked=true; + const plan=await api.captureCopySource(descriptor,description.signature); + result=await execute({plan,client,parent:folder,name,api,saves,isConnected:c=>context.clients().includes(c),cancelled:()=>stop,progress:p=>{status.textContent=p.completed+' of '+p.total+' files copied \u00b7 '+p.createdFolders+' folders created';}}); + status.textContent='Copy complete. '+result.completed+' files copied. Originals remain unchanged.';api.notify(status.textContent); + finished=true;confirm.textContent=description.folder?'Done':'Open copy';confirm.disabled=false; + + }catch(error){status.textContent=error.message;api.notify(error.message,true);finished=true;confirm.textContent='Done';confirm.disabled=false;result=undefined;} + finally{if(locked)api.endSave();busy=false;cancel.textContent='Close';api.statusChanged();context.refresh();if(modal.getAttribute('aria-hidden')==='true'){epoch++;modal.remove();dialog=undefined;}} + }); + function planFileRef(){return client.childRef(folder,model.markdownName(input.value));} + // Closing via Escape/backdrop also stops future writes, but never abandons a live request. + api.openDialog(modal,select,close); + await browse(folder); + } + return {open}; + } + target.MarkdownCloudCopy=Object.freeze({LIMITS,segment,suggestName,validatePlan,execute,create}); +})(globalThis); diff --git a/cloud-model.js b/cloud-model.js new file mode 100644 index 00000000..a887bac3 --- /dev/null +++ b/cloud-model.js @@ -0,0 +1,21 @@ +(function(target) { + 'use strict'; + async function digest(content) { + const hash=await crypto.subtle.digest('SHA-256',new TextEncoder().encode(content)); + return Array.from(new Uint8Array(hash),byte=>byte.toString(16).padStart(2,'0')).join(''); + } + function equal(a,b) { + if(a===b)return true; + if(!a || !b || typeof a!=='object' || typeof b!=='object' || Array.isArray(a)!==Array.isArray(b))return false; + const keys=Object.keys(a);return keys.length===Object.keys(b).length && keys.every(key=>Object.prototype.hasOwnProperty.call(b,key) && equal(a[key],b[key])); + } + function markdownName(value) { + let name=String(value).trim(); + if(!name || /[\\/\u0000-\u001f\u007f:*?"<>|]/.test(name) || name==='.' || name==='..')throw new Error('Enter a valid Markdown filename without path separators.'); + if(/\.[^.]+$/.test(name) && !/\.md$/i.test(name))throw new Error('Only .md files can be created.'); + name=/\.md$/i.test(name)?name.slice(0,-3)+'.md':name+'.md'; + if(!name.slice(0,-3).trim() || /[. ]$/.test(name.slice(0,-3)) || /^(con|prn|aux|nul|com[1-9]|lpt[1-9])\.md$/i.test(name) || new TextEncoder().encode(name).byteLength>200)throw new Error('Choose a shorter, portable Markdown filename.'); + return name; + } + target.MarkdownCloudModel=Object.freeze({MAX_BYTES:20*1024*1024,digest,equal,markdownName,isAccountId:id=>typeof id==='string' && /^[a-zA-Z0-9._-]{1,128}$/.test(id)}); +})(globalThis); diff --git a/cloud-operations.js b/cloud-operations.js new file mode 100644 index 00000000..54739fb7 --- /dev/null +++ b/cloud-operations.js @@ -0,0 +1,237 @@ +// Shared durable cloud workflows. File references and version tokens belong to the provider. +(function(target) { + 'use strict'; + target.MarkdownCloudOperations=Object.freeze({create(context) { + const {api,sessions,saves,uploading,reviewedVersions,sessionKey,clientFor,accountState,saveWorkspace,browse,message,refresh}=context; + const model=target.MarkdownCloudModel; + const providerLabel=client=>target.MarkdownCloudProviders.get(client.providerId).label; + function requireCapability(client,name){if(!client.capabilities[name])throw new Error('This cloud connection does not support this action. Your draft was kept.');} + async function newFile(client, folder) { + if (!client || sessions.get(sessionKey(client)) !== client || !context.workspace.enabled) throw new Error('Connect to this cloud account first.'); + requireCapability(client,'create'); + folder=client.folderRef(folder); + const name=await api.requestName({title:'New Markdown file',description:'Create in '+client.account.label+' · '+client.account.userLabel+' · '+client.locationLabel(folder),label:'Filename',value:'Untitled.md',confirmText:'Create',validate:value=>{try { model.markdownName(value);return ''; }catch(error){return error.message;}}}); + if (name===null) return; + const filename=model.markdownName(name); + const href=client.childRef(folder,filename); + if (sessions.get(sessionKey(client)) !== client || !context.workspace.enabled) throw new Error('The account disconnected. Nothing was created.'); + if (api.findRemote(client.source(href))) throw new Error('A local document already exists for this path. Open it or choose another name; nothing was overwritten.'); + let locked=false, tabId, source; + try { + api.beginSave();locked=true; + source=client.source(href,'',{savedDigest:'',attemptDigest:await model.digest(''),status:'uncertain',creationPending:true}); + tabId=await api.createRemoteDraft('',filename,source); + saves.add(tabId); + const remote=await client.create(href,''); + await api.updateRemote(tabId,{...source,version:remote.version,savedDigest:source.attemptDigest,attemptDigest:undefined,creationPending:undefined,status:'saved',availability:'available'}); + if (context.activeClient===client) await browse(folder,client); + message('Created '+filename+' on '+providerLabel(client)+'.'); + } catch(error) { + if (tabId && error.code==='CONFLICT') await api.detachRemote(tabId,source); + throw error; + } finally { if(tabId)saves.delete(tabId);if(locked)api.endSave();refresh();api.statusChanged(); } + } + async function newForDocument(tabId) { + const tab=await api.snapshot(tabId); + if (!tab?.remoteSource) return; + const source=tab.remoteSource; + await newFile(clientFor(source),clientFor(source).parentRef(source.fileRef)); + } + async function deleteRemote(client,href,name,tabId) { + if (!client || sessions.get(sessionKey(client)) !== client) throw new Error('Connect to this cloud account first.'); + requireCapability(client,'delete'); + client.validateFile(href); + let locked=false, ownsSave=false, approved, intent; + try { + api.beginSave();locked=true; + tabId=tabId || api.findRemote(client.source(href)); + const before=tabId ? await api.snapshot(tabId) : null; + if(before?.remoteSource && ['uncertain','conflict'].includes(before.remoteSource.status)) throw new Error('Check and resolve the server version before deleting. Your draft was kept.'); + const remote=await client.read(href); + const version=await client.readVersion(href); + if (!client.isVersion(version) || !model.equal(version,remote.version) || (before?.remoteSource && !model.equal(before.remoteSource.version,version))) throw new Error('The server version changed or cannot be verified. Refresh and review it before deleting.'); + const accepted=await api.confirm('Delete “'+name+'” from '+client.account.label+' ('+client.account.userLabel+')? The server file will be removed. A local recovery copy will be kept.',{title:'Delete from cloud?',confirmLabel:'Delete from cloud',cancelLabel:'Keep file',destructive:true,focusCancel:true,dedupeKey:'cloud-delete:'+href}); + if (!accepted) {message('Deletion cancelled. Nothing was deleted.');return;} + if(sessions.get(sessionKey(client))!==client || !context.workspace.enabled) throw new Error('The account disconnected. Nothing was deleted.'); + if(before) { + const latest=await api.snapshot(tabId); + if(!latest || latest.content!==before.content || JSON.stringify(latest.remoteSource)!==JSON.stringify(before.remoteSource)) throw new Error('The draft changed while confirmation was open. Nothing was deleted.'); + approved=latest; + } else { + const source=client.source(href,version,{savedDigest:await model.digest(remote.content),status:'saved'}); + tabId=await api.createRemoteDraft(remote.content,name,source);approved=await api.snapshot(tabId); + } + saves.add(tabId); ownsSave=true; + intent={...approved.remoteSource,status:'uncertain',deletePending:true}; + await api.updateRemote(tabId,intent); // Exact durable draft/intent precedes DELETE. + try { await client.remove(href,version); } + catch(error) { + if(error.code==='CONFLICT') await api.updateRemote(tabId,{...approved.remoteSource,status:'conflict',deletePending:undefined}); + throw error; + } + await api.detachRemote(tabId,intent); + reviewedVersions.delete(tabId); + if(context.activeClient===client && context.currentFolder) await browse(context.currentFolder,client); + message('Deleted from '+providerLabel(client)+'. Your local recovery copy was kept.'); + } finally { if(ownsSave)saves.delete(tabId);if(locked)api.endSave();refresh();api.statusChanged(); } + } + async function remove(tabId) { + const tab=await api.snapshot(tabId); + if(!tab?.remoteSource)return; + const source=tab.remoteSource; + await deleteRemote(clientFor(source),source.fileRef,tab.title,tab.id); + } + async function save(tabId) { + if (saves.has(tabId)) return; + saves.add(tabId); + let tab; + let locked = false; + try { + api.beginSave(); + locked = true; + tab = await api.snapshot(tabId); + if (!tab?.remoteSource) return; + let source = tab.remoteSource; + const client = clientFor(source); + requireCapability(client,'conditionalSave'); + if (source.status === 'uncertain' || source.status === 'conflict') throw new Error('Check the server version before saving again. Your draft was kept.'); + if(client.readOnlyReason?.(source))throw new Error(client.readOnlyReason(source)); + const preference=accountState(await client.accountId()); + let skipFuture=false; + const accepted = preference.skipSaveConfirmation === true || await api.confirm('Upload “' + tab.title + '” to ' + client.account.label + ' (' + client.account.userLabel + ')? This updates the cloud file only if its server version has not changed. Your local recovery draft is kept.', { + title:'Save to cloud?', confirmLabel:'Upload changes', cancelLabel:'Keep local draft', focusCancel:true, dedupeKey:'cloud-save:' + tab.id, + checkbox:{label: "Don't show again for this account",onChange:checked => { skipFuture=checked; }} + }); + if (!accepted) { message('Upload cancelled. Your local draft was kept.'); return; } + if (skipFuture) { preference.skipSaveConfirmation=true; await saveWorkspace(); } + const approved = await api.snapshot(tabId); + if (!approved || approved.content !== tab.content || JSON.stringify(approved.remoteSource) !== JSON.stringify(tab.remoteSource)) throw new Error('The draft changed while confirmation was open. Nothing was uploaded. Save again to review the latest draft.'); + if (!client.isVersion(source.version)) { + message('Checking the original file version…'); + const original = await client.read(source.fileRef); + if (!client.isVersion(original.version)) throw new Error('The cloud server did not provide a usable file version. Your draft is safe locally; saving to the server is unavailable.'); + if (await model.digest(original.content) !== source.savedDigest) { + await api.updateRemote(tabId, { ...source, status: 'conflict' }); + throw new Error('The server file changed. Your draft was kept. Check the server version to compare them.'); + } + source = { ...source, version: original.version }; + await api.updateRemote(tabId, source); + } + if (new TextEncoder().encode(tab.content).byteLength > model.MAX_BYTES) throw new Error('The document exceeds the 20 MiB limit. Your draft was kept.'); + const attemptDigest = await model.digest(tab.content); + // Persist the attempt before issuing PUT: a crash during upload must not enable blind retries. + await api.updateRemote(tabId, { ...source, status: 'uncertain', attemptDigest }); + uploading.add(tabId); message('Saving to cloud…'); api.statusChanged(); + let saved; + try { saved = await client.save(source.fileRef, source.version, tab.content); } + catch (error) { + await api.updateRemote(tabId, { ...source, attemptDigest, status: error.code === 'CONFLICT' ? 'conflict' : 'uncertain' }); + throw error; + } + const finalState = await api.updateRemote(tabId, { ...source, version: saved.version, savedDigest: attemptDigest, creationPending:undefined, deletePending:undefined, status: 'saved', availability:'available' }); + message(finalState === 'draft' ? 'Saved to '+providerLabel(client)+'; newer edits remain in your draft.' : 'Saved to '+providerLabel(client)+'.'); + } catch (error) { + message(error.message, 'error'); + if (context.isHidden()) api.notify(error.message, true); + } finally { uploading.delete(tabId); saves.delete(tabId); if (locked) api.endSave(); refresh(); api.statusChanged(); } + } + async function checkActive(tabId) { + const tab = await api.snapshot(tabId); + if (!tab?.remoteSource) { message('Select a cloud document first.'); return; } + if (saves.has(tab.id)) { message('Wait for the current Save to finish.'); return; } + saves.add(tab.id); + let locked = false; + try { + api.beginSave(); locked = true; + const source = tab.remoteSource; + let remote; + try { remote = await clientFor(source).read(source.fileRef); } + catch(error) { + if(source.deletePending && error.httpStatus===404) { + await api.detachRemote(tab.id,source);reviewedVersions.delete(tab.id); + message('Server deletion confirmed. Your local recovery copy was kept.');return; + } + throw error; + } + if(source.deletePending) { + reviewedVersions.set(tab.id,{href:source.fileRef,version:remote.version,digest:await model.digest(remote.content)}); + await api.openComparison(remote.content,tab.title+' (cloud version)'); + message('The file is still on the server. Deletion was not retried; review it before resolving this draft.');return; + } + const remoteDigest = await model.digest(remote.content); + if (source.status === 'uncertain' && remoteDigest === source.savedDigest && remoteDigest !== source.attemptDigest) { + reviewedVersions.set(tab.id, { href:source.fileRef, version:remote.version, digest:remoteDigest }); + await api.openComparison(remote.content, tab.title + ' (cloud version)'); + message('The previous upload is still unconfirmed. Review the server copy before choosing Resolve using my draft; nothing was retried.'); + } else if (remoteDigest === source.savedDigest || remoteDigest === source.attemptDigest) { + await api.updateRemote(tab.id, { ...source, version: remote.version, savedDigest: remoteDigest, status: 'saved', attemptDigest: undefined, creationPending:undefined, availability:'available' }); + message('Server version checked. Your current draft was kept.'); + } else { + await api.updateRemote(tab.id, { ...source, status: 'conflict', availability:'available' }); + await api.openComparison(remote.content, tab.title + ' (cloud version)'); + reviewedVersions.set(tab.id, { href: source.fileRef, version: remote.version, digest: remoteDigest }); + message('Server file changed. Its version opened as a separate local document; your draft was kept.'); + } + } catch (error) { await markReadFailure(tab.id,error); throw error; } + finally { saves.delete(tab.id); if (locked) api.endSave(); refresh(); } + } + async function markReadFailure(tabId, error) { + if (!['HTTP','NETWORK','AUTH','NEXTCLOUD_CREDENTIALS','WEBDAV_CREDENTIALS'].includes(error.code)) return; + const latest = await api.snapshot(tabId); + if (latest?.remoteSource) await api.updateRemote(tabId, { ...latest.remoteSource, availability:error.httpStatus === 404 ? 'missing' : 'unavailable' }); + } + async function reloadRemote(tabId) { + const tab = await api.snapshot(tabId); + if (!tab?.remoteSource || saves.has(tab.id)) return; + const source = tab.remoteSource; + const client = clientFor(source); + saves.add(tab.id); + let locked = false; + try { + api.beginSave(); locked = true; + const remote = await client.read(source.fileRef); + const dirty = await model.digest(tab.content) !== source.savedDigest; + if (dirty) { + const accepted = await api.confirm('Replace your local draft with the current cloud version? A recovery copy of this draft will be kept in Cloud Workspace.', { + title:'Reload cloud file?', confirmLabel:'Keep recovery & reload', cancelLabel:'Keep draft', destructive:true, focusCancel:true, dedupeKey:'cloud-reload:' + tab.id + }); + if (!accepted) return; + } + const latest = await api.snapshot(tab.id); + if (!latest || latest.content !== tab.content || JSON.stringify(latest.remoteSource) !== JSON.stringify(source)) throw new Error('The draft changed while reload was pending. Nothing was replaced.'); + const verified = await client.read(source.fileRef); + if (!model.equal(verified.version,remote.version) || verified.content !== remote.content) throw new Error('The server file changed while reload was pending. Nothing was replaced.'); + if (dirty) await api.preserveDraft(tab.id, tab); + await api.replaceRemote(tab.id, tab, { ...verified, digest:await model.digest(verified.content) }); + reviewedVersions.delete(tab.id); + message('Reloaded from '+providerLabel(client)+'.'); + } catch (error) { await markReadFailure(tab.id,error); throw error; } + finally { saves.delete(tab.id); if (locked) api.endSave(); refresh(); } + } + async function resolveActive(tabId) { + const tab = await api.snapshot(tabId); + const reviewed = tab && reviewedVersions.get(tab.id); + if (!tab?.remoteSource || !reviewed || reviewed.href !== tab.remoteSource.fileRef) { + message('Check the server version first, review its copy, then select your original draft.'); + return; + } + if (saves.has(tab.id)) return; + if (!clientFor(tab.remoteSource).isVersion(reviewed.version)) throw new Error('This server version cannot be safely overwritten: no usable version token.'); + if (!(await api.confirm('Keep this draft for the next Save? It will replace the server version you just reviewed, provided that version has not changed again. Nothing is uploaded until you press Save.', { + title:'Resolve cloud conflict?', confirmLabel:'Keep my draft', cancelLabel:'Cancel', focusCancel:true, dedupeKey:'cloud-resolve:' + tab.id + }))) return; + const latest = await api.snapshot(tab.id); + if (!latest || latest.content !== tab.content || JSON.stringify(latest.remoteSource) !== JSON.stringify(tab.remoteSource)) throw new Error('The draft changed while confirmation was open. Review it again.'); + if (saves.has(tab.id)) throw new Error('A Save started while confirmation was open. Check the server version again.'); + saves.add(tab.id); + let locked = false; + try { + api.beginSave(); locked = true; + await api.updateRemote(tab.id, { ...tab.remoteSource, version: reviewed.version, savedDigest: reviewed.digest, attemptDigest: undefined, creationPending:undefined, deletePending:undefined, status: 'draft' }); + reviewedVersions.delete(tab.id); + message('Your draft was kept. Next Save will update the reviewed server version if it is still unchanged.'); + } finally { saves.delete(tab.id); if (locked) api.endSave(); refresh(); } + } + return Object.freeze({newFile,newForDocument,deleteRemote,remove,save,checkActive,reloadRemote,resolveActive}); + }}); +})(globalThis); diff --git a/cloud-platform.js b/cloud-platform.js new file mode 100644 index 00000000..f4d9287e --- /dev/null +++ b/cloud-platform.js @@ -0,0 +1,152 @@ +// Shared cloud protocol/UI depend only on this platform boundary. +(function(target) { + 'use strict'; + const EXTENSION = 'com.markdownviewer.cloud'; + const COMMAND = '"extensions/cloud/markdown-cloud.exe"'; + function extension(native) { + const pending = new Map(); + const disconnectListeners = new Set(); + let starting, stopping, healthChecked = false, leased = false, idleTimer; + let failed = false, enabled = true, generation = 0; + const fail = (message, code = 'NETWORK') => Object.assign(new Error(message), { code }); + const sleep = ms => new Promise(resolve => setTimeout(resolve, ms)); + function scheduleIdle() { + clearTimeout(idleTimer); + if (!leased && !pending.size && healthChecked) idleTimer = setTimeout(() => void stop().catch(() => {}), 10000); + } + const ready = Promise.all([ + native.events.on('cloudResponse', event => { + const reply = event.detail; + const item = pending.get(reply?.id); + if (!item) return; + pending.delete(reply.id); clearTimeout(item.timeout); + if (!item.timedOut) { + if (reply.error) item.reject(fail(reply.error.message || 'Cloud operation failed.', reply.error.code)); + else item.resolve(reply.returnValue); + } + scheduleIdle(); + }), + native.events.on('extClientDisconnect', event => { + if (event.detail !== EXTENSION && event.detail?.extensionId !== EXTENSION) return; + generation++; healthChecked = false; failed = false; + for (const item of pending.values()) { clearTimeout(item.timeout); item.reject(fail('The cloud connection service stopped. Your draft was kept.')); } + pending.clear(); clearTimeout(idleTimer); + if (!stopping) for (const listener of disconnectListeners) listener(); + }) + ]); + function send(operation, input = {}) { + if (failed || [...pending.values()].some(item => item.timedOut)) throw fail('A previous cloud operation is still settling. Wait before checking or saving again.'); + if (pending.size >= 8) throw fail('Cloud service is busy. Try again shortly.', 'BUSY'); + clearTimeout(idleTimer); + const id = crypto.randomUUID(); + return new Promise((resolve, reject) => { + const item = { resolve, reject, timedOut:false }; + item.timeout = setTimeout(() => { + // Keep the identity until native completion/disconnection: never let a + // caller reconcile or retry while a native operation might still run. + item.timedOut = true; + reject(fail('Cloud request timed out. Its outcome is unconfirmed; your local draft was kept.')); + }, 45000); + pending.set(id, item); + Promise.resolve().then(() => native.extensions.dispatch(EXTENSION, 'cloudRequest', { id, operation, input })).catch(() => { + clearTimeout(item.timeout); pending.delete(id); + reject(fail('Cloud extension is unavailable. Your local draft was kept.')); + }); + }); + } + async function ensureStarted() { + await ready; + if (!enabled) throw fail('Cloud connections are disabled.'); + if (stopping) await stopping; + if (!enabled) throw fail('Cloud connections are disabled.'); + if (failed || [...pending.values()].some(item => item.timedOut)) throw fail('A previous cloud operation is still settling. Wait before checking or saving again.'); + if (starting) return starting; + starting = (async () => { + const epoch=generation; + // Explicit preflight avoids the SDK dispatch async-executor rejection gap. + let stats; + try { stats = await native.extensions.getStats(); } + catch (_) { throw fail('Cloud extension is unavailable. Your local draft was kept.'); } + if (!enabled) throw fail('Cloud connections are disabled.'); + if (!stats?.loaded?.includes(EXTENSION)) throw fail('Cloud extension is not configured.'); + if (!stats.connected.includes(EXTENSION)) { + healthChecked = false; + const token = target.NL_TOKEN || target.sessionStorage?.getItem('NL_TOKEN'); + const port = Number(target.NL_PORT); + if (!token || !token.includes('.') || !Number.isInteger(port) || port < 1 || port > 65535 || !target.NL_PATH) throw fail('Cloud startup information is unavailable.'); + // Only a fixed relative executable is passed to the shell. cwd is a + // separate native option; no URL, account, filename or token is an arg. + const child = await native.os.spawnProcess(COMMAND, { cwd: target.NL_PATH }); + try { + await native.os.updateSpawnedProcess(child.id, 'stdIn', JSON.stringify({ nlPort:String(port), nlToken:token, nlConnectToken:token.split('.')[1], nlExtensionId:EXTENSION })); + await native.os.updateSpawnedProcess(child.id, 'stdInEnd'); + } catch (_) { + await native.os.updateSpawnedProcess(child.id, 'stdInEnd').catch(() => {}); + throw fail('Could not start the cloud helper. Check the extensions folder.'); + } + const deadline = Date.now() + 5000; + do { + stats = await native.extensions.getStats(); + if (stats.connected.includes(EXTENSION)) break; + await sleep(100); + } while (Date.now() < deadline); + if (!stats.connected.includes(EXTENSION)) throw fail('Cloud helper did not become ready. Check the extensions folder.'); + } + if (!healthChecked) { + const capabilities = await send('capabilities'); + if (capabilities?.version !== 5 || capabilities?.conditionalWrites !== true || capabilities?.requestDeadlineMs !== 35000 || !['nextcloud','webdav'].every(id=>capabilities?.providerIds?.includes(id))) { + failed = true; throw fail('Cloud helper is outdated. Replace the whole application package.'); + } + if (epoch !== generation) throw fail('Cloud helper stopped while connecting. Try Reconnect.'); + healthChecked = true; + } + })(); + try { await starting; } finally { starting = undefined; } + } + async function call(operation, input = {}) { + await ensureStarted(); + while (!healthChecked) await ensureStarted(); + if (!enabled) throw fail('Cloud connections are disabled.'); + return send(operation, input); + } + async function stop() { + await ready; + clearTimeout(idleTimer); + if (starting) await starting; + if (stopping) return stopping; + if (pending.size) throw fail('Wait for the current cloud operation to finish.'); + stopping = (async () => { + const stats = await native.extensions.getStats(); + if (!stats.connected.includes(EXTENSION)) { healthChecked=false; failed=false; clearTimeout(idleTimer); return; } + await send('shutdown'); + const deadline=Date.now()+3000; + while (Date.now() { enabled=Boolean(value); if (!enabled) { leased=false; clearTimeout(idleTimer); } }, + onDisconnect: listener => { disconnectListeners.add(listener); return () => disconnectListeners.delete(listener); }, + keepAlive: active => { leased=Boolean(active); scheduleIdle(); }, + stop, + request: async input => { + const response = await call('request', input); + if (response?.transportVersion !== 1 || typeof response.body !== 'string' || new TextEncoder().encode(response.body).byteLength > input.maxBytes) throw fail('Invalid or oversized cloud response.', 'SIZE'); + return response; + }, + storeAccount: account => call('accountStore', account), + listAccounts: () => call('accountList'), + forgetAccount: account => call('accountForget', account) + }); + } + target.MarkdownCloudPlatform = Object.freeze({ + extension, + available: () => Boolean(target.NL_OS === 'Windows' && target.Neutralino?.extensions?.dispatch && target.Neutralino?.events?.on), + create: () => extension(target.Neutralino) + }); +})(typeof globalThis !== 'undefined' ? globalThis : window); diff --git a/cloud-providers.js b/cloud-providers.js new file mode 100644 index 00000000..c22fa7ce --- /dev/null +++ b/cloud-providers.js @@ -0,0 +1,38 @@ +(function(target) { + 'use strict'; + // Only application-registered providers confer remote authority. Workspace or + // backup metadata cannot register code or enable an unknown provider. + const providers=new Map(); + function get(id) { + const provider=providers.get(id); + if(!provider)throw new Error('This cloud provider is unavailable. The local draft remains available.'); + return provider; + } + function forSource(source) { + if(!source || (source.providerId && source.provider && source.providerId!==source.provider))throw new Error('Invalid cloud provider identity.'); + return get(source.providerId || source.provider); + } + function normalizeSource(source) { return forSource(source).normalizeSource(source); } + function sameFile(a,b) { + try {const x=normalizeSource(a),y=normalizeSource(b);return x.providerId===y.providerId && x.accountKey===y.accountKey && x.fileRef===y.fileRef;}catch(_){return false;} + } + function accountProvider(account) { + if(!account || (account.providerId && account.provider && account.providerId!==account.provider))throw new Error('Invalid cloud account provider.'); + if(account.providerId || account.provider)return get(account.providerId || account.provider); + const legacy=[...providers.values()].filter(provider=>provider.legacyAccounts); + if(legacy.length!==1)throw new Error('Unknown legacy cloud account.'); + return legacy[0]; + } + target.MarkdownCloudProviders=Object.freeze({ + register(provider) { + if(!provider || !/^[a-z][a-z0-9-]{0,63}$/.test(provider.id) || providers.has(provider.id))throw new Error('Invalid or duplicate cloud provider.'); + for(const method of ['normalizeSource','serializeSource','recoveryIdentity','restore','connect'])if(typeof provider[method]!=='function')throw new Error('Incomplete cloud provider contract.'); + providers.set(provider.id,Object.freeze(provider)); + }, + list:()=>[...providers.values()],get,forSource,accountProvider,normalizeSource,sameFile, + serializeSource:source=>forSource(source).serializeSource(source), + sessionKey:source=>normalizeSource(source).accountKey, + recoveryIdentity:source=>forSource(source).recoveryIdentity(source), + describe(source){try{return forSource(source).describeSource(source);}catch(_){return 'Unavailable cloud provider';}} + }); +})(globalThis); diff --git a/cloud-workspace.js b/cloud-workspace.js new file mode 100644 index 00000000..848cafea --- /dev/null +++ b/cloud-workspace.js @@ -0,0 +1,615 @@ +// Shared cloud UI. Only non-secret source identity is passed to the editor. +(function (target) { + 'use strict'; + const providers=target.MarkdownCloudProviders, model=target.MarkdownCloudModel; + let operations,copyOperations; + const newFile=(...args)=>operations.newFile(...args); + const newForDocument=(...args)=>operations.newForDocument(...args); + const deleteRemote=(...args)=>operations.deleteRemote(...args); + const remove=(...args)=>operations.remove(...args); + const save=(...args)=>operations.save(...args); + const checkActive=(...args)=>operations.checkActive(...args); + const reloadRemote=(...args)=>operations.reloadRemote(...args); + const resolveActive=(...args)=>operations.resolveActive(...args); + let platform; + let api; + let panel; + let status; + let content; + let activeClient; + let currentFolder; + let pendingLogin; + let body; + let accountTools; + let entriesView; + let entriesData = []; + let entryClient; + let draftsView; + let documentRevision = ''; + let accountList; + let settingsModal; + let setupContent; + let setupStatus; + let settingsSummary; + let visibilityToggle; + let enabledToggle; + let automaticToggle; + let connectionEpoch = 0; + let disclosure; + const uploading = new Set(); + let workspace = { version: 1, accounts: [], activeId: '', enabled:false, autoConnect:true }; + let workspaceWrites = Promise.resolve(); + const accounts = new Map(); + const WORKSPACE_KEY = 'markdownViewerCloudWorkspace'; + let operation = 0; + const sessions = new Map(); + const saves = new Set(); + const reviewedVersions = new Map(); + function secureAccountsAvailable() { + return Boolean(platform?.secureAccounts); + } + function accountState(id) { + let state = workspace.accounts.find(item => item.id === id); + if (!state) { state = { id, folders: [] }; workspace.accounts.push(state); } + return state; + } + async function saveWorkspace() { + const storage = platform.storage || target.Neutralino?.storage; + if (!storage?.setData) return; + const snapshot = JSON.stringify(workspace); + workspaceWrites = workspaceWrites.catch(() => {}).then(() => storage.setData(WORKSPACE_KEY, snapshot)); + await workspaceWrites; + } + function tools() { + accountTools.replaceChildren(button('Add cloud account', () => connectForm(), 'plus', true)); + const sort = button('Sort cloud files', () => api.showMenu(sort,'Sort cloud files',[ + {id:'sort-asc',icon:'lucide-case-sensitive',label:'Name A–Z' + (workspace.sort !== 'desc' ? ' ✓' : ''),run:async () => { workspace.sort = 'asc'; await saveWorkspace(); renderDocuments(true); }}, + {id:'sort-desc',icon:'lucide-case-sensitive',label:'Name Z–A' + (workspace.sort === 'desc' ? ' ✓' : ''),run:async () => { workspace.sort = 'desc'; await saveWorkspace(); renderDocuments(true); }} + ]),'list',true,true); + accountTools.append(sort); + if (!activeClient) return; + accountTools.append(button('Refresh', () => browse(currentFolder || activeClient.root), 'refresh-cw', true)); + } + function updateVisibility() { + if (!panel) return; + const hasDrafts = draftsView && !draftsView.hidden; + panel.hidden = workspace.hidden === true || (!accounts.size && !hasDrafts); + if (visibilityToggle) visibilityToggle.checked = workspace.hidden !== true; + if (enabledToggle) enabledToggle.checked = workspace.enabled; + if (automaticToggle) automaticToggle.checked = workspace.autoConnect; + } + function applyExpansion() { + if (!body || !disclosure) return; + body.hidden = workspace.collapsed === true; + disclosure.setAttribute('aria-expanded',String(!body.hidden)); + disclosure.querySelector('.lucide-chevron-down').classList.toggle('is-collapsed',body.hidden); + } + function renderAccounts() { + accountList.replaceChildren(); + for (const profile of accounts.values()) { + const group = document.createElement('div'); + group.className = 'cloud-account'; + const state = accountState(profile.id); + const row = button(profile.client.account.label + ' (' + profile.client.account.userLabel + ')', () => activateAccount(profile), 'cloud-upload'); + row.className = 'nextcloud-entry cloud-account-row' + (profile.client === activeClient ? ' is-active' : ''); + row.title = profile.client.account.label + '\n' + profile.client.account.detail + (profile.remembered ? '\n' + (platform.rememberLabel || 'Remembered securely on this device') : '\nSession only'); + row.replaceChildren(icon('cloud-upload')); + const copy = document.createElement('span'); copy.className = 'cloud-account-copy'; + const name = document.createElement('span'); name.textContent = profile.client.account.label; + const detail = document.createElement('small'); detail.textContent = profile.client.account.detail; + copy.append(name,detail); row.append(copy); + const connected = sessions.has(sessionKey(profile)); + const connection = document.createElement('span'); connection.className = 'cloud-connection-dot'; connection.dataset.connected = String(connected); + connection.title = connected ? 'Connected' : 'Offline · local drafts remain available'; connection.setAttribute('aria-label',connection.title); row.append(connection); + const actions = () => [ + { id:'cloud-connect', icon:'lucide-refresh-cw', label:'Reconnect', run:() => activateAccount(profile) }, + { id:'cloud-new', icon:'lucide-file-plus', label:'New Markdown file', disabled:!profile.client.capabilities.create || !sessions.has(sessionKey(profile)), run:() => newFile(profile.client,profile.client.root) }, + { id:'cloud-forget', icon:'lucide-x', label:profile.remembered ? 'Forget account' : 'Disconnect', run:async () => { activeClient = profile.client; await disconnect(); } } + ]; + contextMenu(row, profile.client.account.userLabel, actions); + const toggle = button((state.collapsed ? 'Expand ' : 'Collapse ') + profile.client.account.label, async () => { + state.collapsed = !state.collapsed; await saveWorkspace(); renderAccounts(); + },state.collapsed ? 'chevron-right' : 'chevron-down',true); + toggle.setAttribute('aria-expanded', String(!state.collapsed)); + const line = document.createElement('div'); line.className = 'cloud-account-heading'; + const menu = button('Account options for ' + profile.client.account.userLabel, () => api.showMenu(menu,profile.client.account.userLabel,actions()),'ellipsis',true,true); + line.append(toggle,row,menu); group.append(line); + const locations = document.createElement('div'); + locations.className = 'cloud-folders'; + for (const folder of accountState(profile.id).folders) { + try { profile.client.validateRef(folder.href); } catch (_) { continue; } + const item = document.createElement('div'); + item.className = 'cloud-folder-row'; + const open = button(folder.name, () => activateAccount(profile, folder.href), 'folder'); + open.className = 'nextcloud-entry is-folder'; + open.title = profile.client.locationLabel(folder.href); + contextMenu(open, folder.name, () => [ + { id:'open', icon:'lucide-folder-open', label:'Open', run:() => activateAccount(profile, folder.href) }, + { id:'refresh', icon:'lucide-refresh-cw', label:'Refresh', run:() => activateAccount(profile, folder.href) }, + { id:'cloud-new', icon:'lucide-file-plus', label:'New Markdown file', disabled:!profile.client.capabilities.create || !sessions.has(sessionKey(profile)), run:() => newFile(profile.client,folder.href) } + ]); + const remove = button('Remove folder ' + folder.name + ' from workspace', async () => { + const state = accountState(profile.id); + state.folders = state.folders.filter(value => value.href !== folder.href); + await saveWorkspace(); renderAccounts(); + message('Folder removed from this workspace. Server files were not changed.'); + }, 'x', true); + item.append(open, remove); locations.append(item); + } + const children = document.createElement('div'); children.className = 'cloud-account-children'; children.hidden = state.collapsed === true; + children.append(locations); + if (profile.client === activeClient) children.append(content); + group.append(children); + accountList.append(group); + } + updateVisibility(); + } + function resetBrowser(){++operation;currentFolder=undefined;content.replaceChildren();entriesView=undefined;entriesData=[];entryClient=undefined;} + async function activateAccount(profile, href, keepCollapsed = false) { + if (pendingLogin || saves.size) throw new Error('Wait for the current connection or Save to finish.'); + const epoch = ++connectionEpoch; + const client = profile.client; + if(activeClient!==client)resetBrowser(); + activeClient = client; + if (!keepCollapsed) accountState(profile.id).collapsed = false; + workspace.activeId = profile.id; + tools(); renderAccounts(); + try { + await client.identify(); + if (epoch !== connectionEpoch || !workspace.enabled) return; + sessions.set(sessionKey(profile), client); platform.keepAlive(true); + let location = href || accountState(profile.id).lastFolder || client.root; + try { location = client.validateRef(location); } catch (_) { location = client.root; } + await browse(location, client); + } catch (error) { + if (epoch !== connectionEpoch) return; + sessions.delete(sessionKey(profile)); platform.keepAlive(sessions.size > 0); + renderAccounts(); + message('Could not reconnect to ' + profile.client.account.userLabel + '. ' + error.message + ' Use Add cloud account to sign in again if access was revoked.', 'error'); + } + } + async function pinFolder() { + const profile = [...accounts.values()].find(item => item.client === activeClient); + if (!profile || !currentFolder) return; + const state = accountState(profile.id); + if (!state.folders.some(folder => folder.href === currentFolder)) { + if (state.folders.length >= 50) throw new Error('This account already has 50 selected folders.'); + const suffix = activeClient.locationLabel(currentFolder).replace(/\/$/, ''); + state.folders.push({ href: currentFolder, name: suffix.split('/').pop() || 'Files' }); + await saveWorkspace(); renderAccounts(); + } + message('Folder added to Cloud Workspace.'); + } + async function restoreWorkspace() { + try { + let hadSavedWorkspace=false; + const storage = platform.storage || target.Neutralino?.storage; + if (storage?.getData) { + try { + const saved = JSON.parse(await storage.getData(WORKSPACE_KEY)); + if (saved.version === 1 && Array.isArray(saved.accounts)) {hadSavedWorkspace=true;workspace = { + version: 1, enabled: saved.enabled === true || (saved.enabled === undefined && saved.accounts.length > 0), autoConnect: saved.autoConnect !== false, activeId: String(saved.activeId || ''), hidden:saved.hidden === true, collapsed:saved.collapsed === true, sort:saved.sort === 'desc' ? 'desc' : 'asc', accounts: saved.accounts.slice(0, 20).filter(item => model.isAccountId(item.id)).map(item => ({ + id: item.id, ...(item.providerId ? {providerId:item.providerId} : {}), lastFolder: typeof item.lastFolder === 'string' ? item.lastFolder : '', + collapsed:item.collapsed === true, skipSaveConfirmation:item.skipSaveConfirmation === true, + folders: (Array.isArray(item.folders) ? item.folders : []).slice(0,50).filter(folder => typeof folder.href === 'string' && typeof folder.name === 'string').map(folder => ({ href: folder.href, name: folder.name.slice(0,160) })) + })) + }; + } + } catch (_) { /* No saved workspace yet. Credentials are never stored here. */ } + } + if(!hadSavedWorkspace && platform.canRestoreSession)workspace.enabled=true; + applyExpansion(); updateVisibility(); + platform.setEnabled(workspace.enabled); + if (!workspace.enabled || !workspace.autoConnect || (!workspace.accounts.length && !platform.canRestoreSession)) return; + await loadRemembered(); + } catch (error) { message(error.message, 'error'); } + } + async function loadRemembered(interactive=false) { + if (!workspace.enabled || (!secureAccountsAvailable() && !platform.canRestoreSession)) return; + const stored = await platform.listAccounts({interactive}); + if (!workspace.enabled) return; + for (const account of stored.slice(0,20)) { + try { + const provider=providers.accountProvider(account); + const client=await provider.restore(account,platform); + accounts.set(account.id,{id:account.id,providerId:provider.id,client,remembered:account.remembered!==false}); + } catch(error) { message(error.message,'error'); } + } + renderAccounts(); + const selected = accounts.get(workspace.activeId) || accounts.values().next().value; + if (selected) { message('Reconnecting to cloud…'); await activateAccount(selected, undefined, true); } + else { platform.keepAlive(false); message(platform.canRestoreSession?'No cloud connections in this session.':'No remembered cloud accounts.'); } + } + async function setCloudEnabled(enabled) { + if (pendingLogin || saves.size) throw new Error('Wait for the current cloud operation to finish.'); + if (!enabled) { + await api.flushDrafts(); + platform.setEnabled(false); + try { await platform.stop(); } catch (error) { platform.setEnabled(workspace.enabled); throw error; } + ++connectionEpoch; ++operation; + for (const profile of accounts.values()) profile.client.disconnect(); + sessions.clear(); accounts.clear(); activeClient = undefined; + platform.keepAlive(false); + content.replaceChildren(); entriesView=undefined; entriesData=[]; entryClient=undefined; + } + workspace.enabled = enabled; platform.setEnabled(enabled); + await saveWorkspace(); renderAccounts(); updateVisibility(); api.statusChanged(); + message(enabled ? 'Cloud connections enabled. Connect or load a remembered account.' : 'Cloud connections disabled. Local drafts and remembered accounts were kept.'); + } + function message(text, tone = 'info') { + if (status) { status.textContent = text; status.dataset.tone = tone; } + if (setupStatus) { setupStatus.textContent = text; setupStatus.dataset.tone = tone; } + refresh(); + } + function icon(name) { + const element = document.createElement('i'); + element.className = 'lucide lucide-' + name; + element.setAttribute('aria-hidden', 'true'); + return element; + } + function button(label, action, iconName, iconOnly = false, opensMenu = false) { + const element = document.createElement('button'); + element.type = 'button'; + element.className = iconOnly ? 'nextcloud-icon-button' : 'nextcloud-button'; + element.setAttribute('aria-label', label); + element.title = label; + if (iconName) element.append(icon(iconName)); + if (!iconOnly) { const span = document.createElement('span'); span.textContent = label; element.append(span); } + if (opensMenu) element.setAttribute('aria-haspopup','menu'); + element.addEventListener('click', event => { + if (opensMenu) event.stopPropagation(); + void Promise.resolve().then(action).catch(error => message(error.message, 'error')); + }); + return element; + } + function contextMenu(element, label, actions) { + element.addEventListener('contextmenu', event => api.showMenu(element, label, actions(), event)); + element.addEventListener('keydown', event => { + if (event.key === 'ContextMenu' || (event.shiftKey && event.key === 'F10')) api.showMenu(element, label, actions(), event); + }); + } + function renderDocuments(force = false) { + if (!panel) return; + const revision = api.revision() + JSON.stringify([[...reviewedVersions.keys()], [...sessions.keys()], [...uploading],workspace.sort]); + if (!force && revision === documentRevision) return; + if (!force && document.querySelector('.document-menu-dropdown.open')) return; + documentRevision = revision; + document.querySelectorAll('[data-cloud-panel-menu]').forEach(menu => menu.remove()); + const visible = []; + if (entriesView && entriesView.isConnected) { + entriesView.replaceChildren(); + const sortedEntries = entriesData.slice().sort((a,b) => Number(b.directory) - Number(a.directory) || (workspace.sort === 'desc' ? -1 : 1) * a.name.localeCompare(b.name,undefined,{numeric:true,sensitivity:'base'})); + for (const entry of sortedEntries) { + if (!entry.directory) { + visible.push(entryClient.source(entry.ref)); + if (api.renderFile(entriesView, entryClient.source(entry.ref))) continue; + } + const open = async () => { + if (activeClient !== entryClient) return; + if (entry.directory) return browse(entryClient.folderRef(entry.ref)); + if (await api.activateRemote(entryClient.source(entry.ref))) return; + const client = entryClient; + const ticket = operation; + message('Opening ' + entry.name + '…'); + const snapshot = await client.read(entry.ref); + if (activeClient !== client || ticket !== operation) return; + await api.openRemote(snapshot.content, entry.name, client.source(entry.ref,snapshot.version,{savedDigest:await model.digest(snapshot.content),status:'saved'})); + message(''); + }; + const row = button(entry.name, open, entry.directory ? 'folder' : 'file-text'); + row.className = 'nextcloud-entry' + (entry.directory ? ' is-folder' : ''); + row.dataset.nextcloudHref = entry.ref; row.title = entry.name; + const client=entryClient; + contextMenu(row, entry.name, () => [ + { id:'open', icon:entry.directory ? 'lucide-folder-open' : 'lucide-file-text', label:'Open', run:open }, + ...(entry.directory ? [{id:'cloud-new',icon:'lucide-file-plus',label:'New Markdown file',disabled:!client.capabilities.create,run:() => newFile(client,entry.ref)}] : + /\.md$/i.test(entry.name) ? [{id:'cloud-delete',icon:'lucide-trash-2',label:'Delete from cloud',danger:true,disabled:!client.capabilities.delete || Boolean(client.readOnlyReason?.(client.source(entry.ref,entry.version))),run:() => deleteRemote(client,entry.ref,entry.name)}] : []) + ]); + entriesView.append(row); + } + } + draftsView.replaceChildren(); + const count = api.renderRecovery(draftsView, visible); + draftsView.hidden = count === 0; + if (count) { + const label = document.createElement('p'); label.className = 'document-tree-section-label'; label.textContent = 'Local cloud drafts'; + draftsView.prepend(label); + } + updateVisibility(); + } + function refresh() { + if (!panel) return; + renderDocuments(); + const tab = api.currentRemote(); + const source = tab?.remoteSource; + panel.querySelectorAll('[data-nextcloud-href]').forEach(row => { + const selected = Boolean(source && entryClient && activeClient===entryClient && providers.sameFile(source,entryClient.source(row.dataset.nextcloudHref))); + row.classList.toggle('is-active', selected); + if (selected) row.setAttribute('aria-current', 'page'); else row.removeAttribute('aria-current'); + }); + } + function mount() { + if (panel) { document.querySelector('#document-tree > .cloud-offline-section')?.remove(); document.getElementById('document-tree')?.append(panel); renderDocuments(true); refresh(); updateVisibility(); return true; } + return false; + } + function sessionKey(source) { + for(const profile of accounts.values()){if(source===profile || source===profile.client)return profile.client.account.key;} + return providers.sessionKey(source); + } + function clientFor(source) { + const client = sessions.get(sessionKey(source)); + if (!client) throw new Error('Connect to this cloud account again. Your local draft is available.'); + return client; + } + async function browse(href, client = activeClient) { + if (!client || client !== activeClient) return; + const ticket = ++operation; + message('Loading folder…'); + const entries = await client.list(href); + if (ticket !== operation || activeClient !== client) return; + currentFolder = href; + const profile = [...accounts.values()].find(item => item.client === client); + if (profile) { accountState(profile.id).lastFolder = href; workspace.activeId = profile.id; await saveWorkspace(); } + if (ticket !== operation || activeClient !== client) return; + content.replaceChildren(); + const account = document.createElement('div'); + account.className = 'nextcloud-account'; + const server = document.createElement('span'); + server.textContent = client.account.label; + const user = document.createElement('span'); + user.textContent = client.account.userLabel; + account.title = client.account.label + '\n' + client.account.detail; + account.append(icon('cloud-upload'), server, user); + content.append(account); + tools(); renderAccounts(); + const navigation = document.createElement('div'); + navigation.className = 'nextcloud-navigation'; + const path = document.createElement('div'); + path.className = 'nextcloud-path'; + path.textContent = client.locationLabel(href); + path.title = path.textContent; + contextMenu(path,'Cloud folder',()=>[{id:'cloud-new',icon:'lucide-file-plus',label:'New Markdown file',disabled:!client.capabilities.create,run:()=>newFile(client,href)}]); + if (href !== client.root) { + navigation.append(button('Up', () => browse(client.upRef(href)), 'chevron-up', true)); + } + navigation.append(path); + navigation.append(button('Add current folder to Cloud Workspace', pinFolder, 'folder-plus', true)); + content.append(navigation); + entriesView = document.createElement('div'); entriesView.className = 'nextcloud-entries'; + entriesData = entries; entryClient = client; + content.append(entriesView); + renderDocuments(true); + message(entries.length ? '' : 'No Markdown files or folders here.'); + api.statusChanged(); + } + async function disconnect() { + if (saves.size) throw new Error('Wait for the current Save to finish.'); + await api.flushDrafts(); + const profile = [...accounts.values()].find(item => item.client === activeClient); + if (profile?.remembered) { + if (!(await api.confirm('Forget this cloud account on this device? Saved access and folder shortcuts will be removed. Your local drafts and server files will be kept.', { + title:'Forget cloud account?', confirmLabel:'Forget account', cancelLabel:'Keep account', focusCancel:true, dedupeKey:'cloud-forget:' + profile.id + }))) return; + if (saves.size) throw new Error('A cloud operation started while confirmation was open. Try again.'); + await platform.forgetAccount({ id: profile.id, providerId:profile.providerId }); + } + if (profile && !profile.remembered && platform.releaseAccount) await platform.releaseAccount({id:profile.id,providerId:profile.providerId}); + ++operation; + pendingLogin?.abort(); + pendingLogin = undefined; + if (activeClient) { + sessions.delete(sessionKey(activeClient)); + activeClient.disconnect(); + } + activeClient = undefined; + if (profile) { + accounts.delete(profile.id); + workspace.accounts = workspace.accounts.filter(item => item.id !== profile.id); + if (workspace.activeId === profile.id) workspace.activeId = ''; + await saveWorkspace(); + } + renderAccounts(); + content.replaceChildren(); entriesView = undefined; entriesData = []; entryClient = undefined; + refresh(); updateVisibility(); + api.statusChanged(); + platform.keepAlive(sessions.size > 0); + if (!accounts.size) { workspace.enabled=false; platform.setEnabled(false); await saveWorkspace(); await platform.stop(); updateVisibility(); } + message('Disconnected. Local drafts were kept. App access can be revoked in your cloud account settings.'); + } + function connectForm(providerId) { + setupContent.replaceChildren(); settingsSummary.replaceChildren(); + if (platform.logout) { + const notice=document.createElement('p');notice.className='nextcloud-note';notice.textContent=platform.accountNote; + settingsSummary.append(notice,button(platform.logoutLabel || 'Sign out of self-hosted connector',async()=>{await api.flushDrafts();await platform.logout();},'log-out')); + } + platform.renderProfileControls?.(settingsSummary); + for (const profile of accounts.values()) { + const summary = document.createElement('div'); summary.className = 'cloud-settings-account'; + const title = document.createElement('strong'); title.textContent = profile.client.account.label; + const detail = document.createElement('p'); detail.className = 'nextcloud-note'; detail.textContent = profile.client.account.detail + (profile.remembered ? ' · ' + (platform.rememberLabel || 'Remembered on this device') : ' · Session only'); + const open = button('Open files', async () => { workspace.hidden = false; workspace.collapsed = false; await saveWorkspace(); applyExpansion(); api.closeDialog(settingsModal); await activateAccount(profile); },'folder-open'); + const forget = button(profile.remembered ? 'Forget account' : 'Disconnect', async () => { api.closeDialog(settingsModal); activeClient = profile.client; await disconnect(); },'power'); + summary.append(title,detail,open,forget); settingsSummary.append(summary); + } + if (!accounts.size) settingsSummary.append(button('Load remembered accounts', async () => { + workspace.enabled=true; platform.setEnabled(true); await saveWorkspace(); updateVisibility(); await loadRemembered(true); connectForm(); + },'refresh-cw')); + const form = document.createElement('form'); + const available=providers.list(); + const selector=document.createElement('select'); selector.id='cloud-provider'; + const providerLabel=document.createElement('label');providerLabel.htmlFor=selector.id;providerLabel.textContent='Cloud provider'; selector.setAttribute('aria-label','Cloud provider'); + for(const candidate of available){const option=document.createElement('option');option.value=candidate.id;option.textContent=candidate.label;selector.append(option);} + if(typeof providerId==='string' && available.some(item=>item.id===providerId))selector.value=providerId; + const provider=providers.get(selector.value); + selector.disabled=available.length===1; + const fields=document.createElement('div'); fields.className='cloud-connection-fields'; + const inputs=new Map(); + for(const field of provider.connectionFields){ + const label=document.createElement('label');label.htmlFor=field.legacyId || 'cloud-'+field.id;label.textContent=field.label; + const input=document.createElement('input');input.id=label.htmlFor;input.type=field.type || 'text';input.required=field.required!==false;if(field.maxLength)input.maxLength=field.maxLength;input.placeholder=field.placeholder || '';input.autocomplete=field.autocomplete || 'off'; + inputs.set(field.id,input);fields.append(label,input); + } + const input=[...inputs.values()].find(input=>input.required) || inputs.values().next().value; + const connect=document.createElement('button');connect.type='submit';connect.className='nextcloud-button nextcloud-primary'; + connect.append(icon('cloud-upload'),document.createTextNode('Connect to '+provider.label)); + selector.addEventListener('change',()=>{pendingLogin?.abort();pendingLogin=undefined;connectForm(selector.value);}); + if (!target.MarkdownCloudPlatform?.available()) { + connect.disabled = true; + message('The cloud connection extension is unavailable.'); + } + const cancel = button('Cancel connection', () => { if(pendingLogin?.finishing)return; ++operation; pendingLogin?.abort(); pendingLogin = undefined; connect.disabled = false; selector.disabled=available.length===1;for(const input of inputs.values())if(input.type==='password')input.value=''; message('Connection cancelled.'); }); + const note = document.createElement('p'); + note.className = 'nextcloud-note'; + note.textContent = provider.connectionNote + ' Drafts are kept locally in Cloud Workspace; uploads require your confirmation.' + + (secureAccountsAvailable() ? ' ' + (platform.credentialNote || 'Remembered access is protected by Windows Credential Manager.') : ''); + const rememberLabel = document.createElement('label'); + rememberLabel.className = 'cloud-remember'; + const remember = document.createElement('input'); + remember.type = 'checkbox'; + remember.id = 'nextcloud-remember'; + remember.checked = secureAccountsAvailable() && platform.rememberDefault !== false; + remember.disabled = !secureAccountsAvailable(); + rememberLabel.append(remember, document.createTextNode(platform.rememberLabel || 'Remember account on this device')); + if (!secureAccountsAvailable()) rememberLabel.title = platform.rememberUnavailable || 'Requires a platform adapter with secure credential storage.'; + form.append(providerLabel, selector, fields, rememberLabel, connect, cancel, note); + cancel.hidden = true; + form.addEventListener('submit', async event => { + event.preventDefault(); + if (pendingLogin) return; + const controller = new AbortController(); + pendingLogin = controller; + connect.disabled = true; selector.disabled=true; + cancel.hidden = false; + message(provider.connectingMessage || 'Complete login in your browser…'); + try { + workspace.enabled=true; platform.setEnabled(true); await saveWorkspace(); updateVisibility(); + const client = await provider.connect(Object.fromEntries([...inputs].map(([id,input])=>[id,input.value])),platform,url=>platform.openBrowser ? platform.openBrowser(url) : target.Neutralino.os.open(url),controller.signal); + if (controller.signal.aborted) { client.disconnect(); return; } + // Authentication is complete. Finalizing secure storage cannot be undone + // by closing the dialog; Cancel is available only before this boundary. + controller.finishing=true;cancel.hidden=true; + for(const input of inputs.values())if(input.type==='password')input.value=''; + message('Finishing connection…'); + let id = await client.accountId(); + let remembered = false; + let rememberError = ''; + if (remember.checked) { + try { + await client.remember(account => platform.storeAccount(account)); + remembered = true; + } catch (error) { + rememberError = 'Connected for this session, but the account could not be remembered. ' + error.message; + } + } + const previous = accounts.get(id); + if (previous?.remembered && !remember.checked) await (platform.forgetRememberedAccount || platform.forgetAccount)({ id, providerId:provider.id }); + if (previous && previous.client !== client) previous.client.disconnect(); + accounts.set(id, { id, providerId:provider.id, client, remembered }); + accountState(id).providerId=provider.id; + workspace.activeId = id; + sessions.set(sessionKey(client), client); platform.keepAlive(true); + if(activeClient!==client)resetBrowser(); + activeClient = client; + workspace.hidden = false; workspace.collapsed = false; applyExpansion(); + await browse(accountState(id).lastFolder || client.root); + api.closeDialog(settingsModal); + if (rememberError) message(rememberError, 'error'); + } catch (error) { if (!controller.signal.aborted) message(error.message, 'error'); } + finally { + if (pendingLogin === controller) pendingLogin = undefined; + connect.disabled = false; selector.disabled=available.length===1; + for(const input of inputs.values())if(input.type==='password')input.value=''; + cancel.hidden = true; + } + }); + setupContent.append(form); + api.openDialog(settingsModal,input,closeSettings); + } + function closeSettings() { + if(!pendingLogin?.finishing){++operation;pendingLogin?.abort();pendingLogin=undefined;} + setupContent?.querySelectorAll('input[type="password"]').forEach(input=>input.value=''); + api.closeDialog(settingsModal); + } + function init(editorApi) { + if (panel || !target.MarkdownCloudPlatform?.available()) return; + api = editorApi; + platform = target.MarkdownCloudPlatform.create(); + platform.bindIdentity?.({flush:api.flushIdentityDrafts || api.flushDrafts,preserve:api.preserveIdentityDrafts,isBusy:()=>Boolean(pendingLogin) || saves.size>0 || uploading.size>0}); + platform.setEnabled(false); + operations=target.MarkdownCloudOperations.create({api,sessions,saves,uploading,reviewedVersions,sessionKey,clientFor,accountState,saveWorkspace,browse,message,refresh, + get activeClient(){return activeClient;},get currentFolder(){return currentFolder;},get workspace(){return workspace;},isHidden:()=>body.hidden || panel.offsetParent===null}); + copyOperations=target.MarkdownCloudCopy.create({api,saves,clients:()=>workspace.enabled?[...sessions.values()]:[],connect:connectForm,refresh}); + panel = document.createElement('section'); + panel.id = 'nextcloud-panel'; + panel.className = 'nextcloud-panel'; + panel.setAttribute('aria-label', 'Cloud Workspace'); + const heading = document.createElement('div'); + heading.className = 'nextcloud-heading'; + body = document.createElement('div'); + body.id = 'nextcloud-body'; + body.className = 'nextcloud-body'; + disclosure = button('Cloud Workspace', async () => { + workspace.collapsed = !body.hidden; applyExpansion(); await saveWorkspace(); + }, 'chevron-down'); + disclosure.className = 'nextcloud-disclosure'; + disclosure.setAttribute('aria-expanded', 'true'); + disclosure.setAttribute('aria-controls', body.id); + disclosure.insertBefore(icon('cloud-upload'), disclosure.lastChild); + accountTools = document.createElement('div'); + accountTools.className = 'nextcloud-tools'; + heading.append(disclosure, accountTools); + contextMenu(heading, 'Cloud Workspace', () => [ + { id:'add-account', icon:'lucide-plus', label:'Manage cloud connections', run:() => connectForm() }, + ...(activeClient && sessions.has(sessionKey(activeClient)) ? [{id:'cloud-new',icon:'lucide-file-plus',label:'New Markdown file',disabled:!activeClient.capabilities.create,run:()=>newFile(activeClient,currentFolder || activeClient.root)}] : []), + { id:'hide-cloud', icon:'lucide-eye-off', label:'Hide from Explorer', run:async () => { workspace.hidden = true; await saveWorkspace(); updateVisibility(); api.notify('Cloud Workspace hidden. Show it again from Settings → Cloud connections.'); } } + ]); + status = document.createElement('div'); + status.id = 'nextcloud-status'; + status.setAttribute('role', 'status'); + status.setAttribute('aria-live', 'polite'); + content = document.createElement('div'); + content.className = 'nextcloud-browser'; + accountList = document.createElement('div'); + accountList.className = 'cloud-accounts'; + draftsView = document.createElement('div'); draftsView.className = 'cloud-local-drafts'; + body.append(accountList, draftsView, status); + panel.append(heading, body); + panel.addEventListener('keydown', event => { + if (event.target.tagName === 'INPUT' && !event.ctrlKey && !event.metaKey) event.stopPropagation(); + }); + settingsModal = document.createElement('div'); settingsModal.id = 'cloud-settings-modal'; + settingsModal.className = 'reset-modal-overlay modal-overlay'; settingsModal.style.display = 'none'; + settingsModal.setAttribute('role','dialog'); settingsModal.setAttribute('aria-modal','true'); settingsModal.setAttribute('aria-hidden','true'); settingsModal.setAttribute('aria-labelledby','cloud-settings-title'); + settingsModal.innerHTML = '

Cloud connections

Connect a cloud account to browse Markdown files and keep local recovery drafts.

'; + document.body.append(settingsModal); + setupContent = settingsModal.querySelector('.cloud-setup-content'); setupStatus = settingsModal.querySelector('.cloud-setup-status'); settingsSummary = settingsModal.querySelector('.cloud-settings-accounts'); + enabledToggle = settingsModal.querySelector('#cloud-enabled'); + automaticToggle = settingsModal.querySelector('#cloud-auto-connect'); + enabledToggle.addEventListener('change', () => { + enabledToggle.disabled=true; + void setCloudEnabled(enabledToggle.checked).catch(error => message(error.message,'error')).finally(() => { enabledToggle.disabled=false; updateVisibility(); }); + }); + automaticToggle.addEventListener('change', () => { workspace.autoConnect=automaticToggle.checked; void saveWorkspace().catch(error => message(error.message,'error')); }); + visibilityToggle = settingsModal.querySelector('#cloud-sidebar-visible'); visibilityToggle.checked = true; + visibilityToggle.addEventListener('change', () => { workspace.hidden = !visibilityToggle.checked; void saveWorkspace().catch(error => message(error.message,'error')); updateVisibility(); }); + settingsModal.querySelectorAll('.modal-close-btn,.reset-modal-cancel').forEach(control => control.addEventListener('click', closeSettings)); + const settingsButton = document.getElementById('cloud-connections-button'); + if (settingsButton) { settingsButton.hidden = false; settingsButton.addEventListener('click',connectForm); } + mount(); tools(); + platform.onDisconnect(() => { + ++connectionEpoch; ++operation; sessions.clear(); platform.keepAlive(false); + renderAccounts(); api.statusChanged(); + message('Cloud connection service stopped. Local drafts were kept; use Reconnect to continue.', 'error'); + }); + void restoreWorkspace(); + } + function can(source,capability){try {const client=clientFor(source);if(capability==='delete')client.validateFile(providers.normalizeSource(source).fileRef);if(['delete','conditionalSave'].includes(capability) && client.readOnlyReason?.(providers.normalizeSource(source)))return false;return Boolean(client.capabilities[capability]);}catch(_){return false;}} + function report(operation) { return (...args) => void Promise.resolve().then(() => operation(...args)).catch(error => message(error.message, 'error')); } + target.MarkdownCloudUI = Object.freeze({ init, save, mount, refresh, newForDocument:report(newForDocument), remove:report(remove), + copyLocal:descriptor=>Promise.resolve().then(()=>copyOperations.open(descriptor)).catch(error=>{message(error.message,'error');api.notify(error.message,true);}), + check:report(checkActive), resolve:report(resolveActive), reload:report(reloadRemote), + readOnlyReason:source=>{try{return clientFor(source).readOnlyReason?.(providers.normalizeSource(source)) || '';}catch(_){return '';}}, + canDelete:source=>can(source,'delete'), canCreate:source=>can(source,'create'), canSave:source=>can(source,'conditionalSave'), + canResolve: id => reviewedVersions.has(id), isBusy:id => saves.has(id), isUploading:id => uploading.has(id), + canAccess: source => can(source,'read'), available:() => Boolean(panel) }); +})(globalThis); diff --git a/desktop-app/.gitignore b/desktop-app/.gitignore index 5ffd532d..ce796fa2 100644 --- a/desktop-app/.gitignore +++ b/desktop-app/.gitignore @@ -34,3 +34,6 @@ resources/js/desktop-runtime-features.js # Custom runtime source is separate from neu-managed .tmp downloads /.native-runtime/ /.macos-runtime/ +# Native cloud extension build outputs +/cloud-extension/build/ +/extensions/cloud/*.exe diff --git a/desktop-app/build-cloud-extension.js b/desktop-app/build-cloud-extension.js new file mode 100644 index 00000000..ba109221 --- /dev/null +++ b/desktop-app/build-cloud-extension.js @@ -0,0 +1,12 @@ +// Build the standalone Windows adapter; no Neutralino source checkout is required. +const fs = require('node:fs'); +const path = require('node:path'); +const {spawnSync} = require('node:child_process'); +if(process.platform !== 'win32') throw new Error('The current credential adapter targets Windows.'); +const root=__dirname; +const result=spawnSync('cmd.exe',['/d','/c',path.join(root,'cloud-extension/build-windows.cmd')],{stdio:'inherit',windowsHide:true}); +if(result.status!==0)throw new Error('Cloud extension build failed.'); +const binary=path.join(root,'cloud-extension/build/markdown-cloud.exe'); +fs.mkdirSync(path.join(root,'extensions/cloud'),{recursive:true}); +fs.copyFileSync(binary,path.join(root,'extensions/cloud/markdown-cloud.exe')); +console.log('Cloud extension built and copied to extensions/cloud.'); diff --git a/desktop-app/build-cloud-windows.js b/desktop-app/build-cloud-windows.js new file mode 100644 index 00000000..1f22c4a6 --- /dev/null +++ b/desktop-app/build-cloud-windows.js @@ -0,0 +1,16 @@ +#!/usr/bin/env node +// Uses the official pinned Neutralino release. No custom runtime is required. +const fs = require('node:fs'); +const path = require('node:path'); +const {spawnSync} = require('node:child_process'); +if (process.platform !== 'win32') throw new Error('The cloud credential adapter currently supports Windows only.'); +for (const [script, ...args] of [['setup-binaries.js'], ['prepare.js'], ['build-cloud-extension.js'], ['build-standalone.js', 'win_x64']]) { + const result = spawnSync(process.execPath, [path.join(__dirname, script), ...args], {cwd:__dirname, stdio:'inherit', windowsHide:true}); + if (result.error) throw result.error; + if (result.status !== 0) process.exit(result.status || 1); +} +const destination = path.join(__dirname, 'dist/markdown-viewer/extensions/cloud'); +fs.mkdirSync(destination, {recursive:true}); +fs.copyFileSync(path.join(__dirname,'extensions/cloud/markdown-cloud.exe'), path.join(destination,'markdown-cloud.exe')); +fs.copyFileSync(path.join(__dirname,'cloud-extension/vendor/LICENSE.json'), path.join(destination,'LICENSE.json')); +console.log('Keep the extensions directory alongside markdown-viewer-win_x64.exe when distributing this build.'); diff --git a/desktop-app/cloud-extension/CMakeLists.txt b/desktop-app/cloud-extension/CMakeLists.txt new file mode 100644 index 00000000..c0233e23 --- /dev/null +++ b/desktop-app/cloud-extension/CMakeLists.txt @@ -0,0 +1,14 @@ +cmake_minimum_required(VERSION 3.16) +project(MarkdownViewerCloudExtension LANGUAGES CXX) +if(NOT WIN32) + message(FATAL_ERROR "This first adapter preserves the existing Windows credential backend. Other platforms need a keychain adapter.") +endif() +set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$:Debug>") +add_executable(markdown-cloud WIN32 main.cpp providers.cpp credentials.cpp webdav-credentials.cpp) +target_compile_features(markdown-cloud PRIVATE cxx_std_17) +target_compile_definitions(markdown-cloud PRIVATE UNICODE _UNICODE WIN32_LEAN_AND_MEAN NOMINMAX) +target_link_libraries(markdown-cloud PRIVATE winhttp advapi32) +if(MSVC) + target_compile_options(markdown-cloud PRIVATE /W4 /EHsc /utf-8) + target_link_options(markdown-cloud PRIVATE /ENTRY:mainCRTStartup) +endif() diff --git a/desktop-app/cloud-extension/README.md b/desktop-app/cloud-extension/README.md new file mode 100644 index 00000000..f1727df8 --- /dev/null +++ b/desktop-app/cloud-extension/README.md @@ -0,0 +1,11 @@ +# Cloud extension (Windows) + +This application-owned helper uses official Neutralino extension APIs. The cloud branch requires no modified Neutralino source or binary. The runtime is pinned to 6.10.0 because its command allowlist enforcement is required for on-demand launch. + +Run `npm run build:cloud` from `desktop-app` on Windows with Node 22–26, Visual Studio C++ tools, CMake and Ninja installed. Visual Studio is discovered with vswhere, or an existing developer shell is used. The build downloads the official pinned runtime, prepares offline resources, compiles the helper and packages the Windows app. Distribute the complete `desktop-app/dist/markdown-viewer` directory: the helper must remain at `extensions/cloud/markdown-cloud.exe` beside the main executable. The end user needs no Node or C++ installation. Standalone helper build: `node desktop-app/build-cloud-extension.js`. + +The extension ID has no startup command. The app launches the fixed helper path only when cloud is used, passes authenticated IPC bootstrap over stdin, and stops the helper on shutdown, disable or idle. The helper monitors IPC and the real parent process handle. It exposes bounded cloud operations, never a shell or listening proxy. TLS verification remains enabled; redirects, implicit Windows auth and automatic cookies are disabled. + +Nextcloud and generic WebDAV have separate validated credential namespaces in Windows Credential Manager. Remembering is optional; stored passwords never return to browser JavaScript. Conditional existing-file writes/deletes require a strong ETag; creation is create-only. The helper also validates mutation headers and destinations. Timeouts cannot silently retry an uncertain write. Local recovery remains separate from Vault. + +Trusted application JavaScript and the operating-system account remain security boundaries. An extension is not a sandbox against compromised application code. macOS/Linux cloud credential adapters are not implemented; their ordinary editor builds remain available. See [cloud connections](../../docs/cloud-connections.md) and the [self-hosted guide](../../self-hosted/README.md). diff --git a/desktop-app/cloud-extension/build-windows.cmd b/desktop-app/cloud-extension/build-windows.cmd new file mode 100644 index 00000000..c77c0ca6 --- /dev/null +++ b/desktop-app/cloud-extension/build-windows.cmd @@ -0,0 +1,16 @@ +@echo off +setlocal +if defined VSCMD_VER goto build +set "VSWHERE=%ProgramFiles(x86)%\Microsoft Visual Studio\Installer\vswhere.exe" +if not exist "%VSWHERE%" ( + echo Install Visual Studio C++ build tools, CMake and Ninja, or use a C++ developer shell. + exit /b 1 +) +for /f "usebackq tokens=*" %%i in (`"%VSWHERE%" -latest -products * -requires Microsoft.VisualStudio.Component.VC.Tools.x86.x64 -property installationPath`) do set "CLOUD_VS=%%i" +if not defined CLOUD_VS exit /b 1 +call "%CLOUD_VS%\VC\Auxiliary\Build\vcvars64.bat" >nul +if errorlevel 1 exit /b 1 +:build +cmake -S "%~dp0." -B "%~dp0build" -G Ninja -DCMAKE_BUILD_TYPE=Release +if errorlevel 1 exit /b 1 +cmake --build "%~dp0build" --parallel 2 diff --git a/desktop-app/cloud-extension/credentials.cpp b/desktop-app/cloud-extension/credentials.cpp new file mode 100644 index 00000000..f3a3ea8b --- /dev/null +++ b/desktop-app/cloud-extension/credentials.cpp @@ -0,0 +1,130 @@ +#include "credentials.h" +#include +#include +#include +#include +#ifdef _WIN32 +#include +#include +#endif +using json = nlohmann::json; +namespace nextcloud_credentials { +static const std::wstring prefix = L"MarkdownViewer.Nextcloud.v1/"; +static bool validId(const std::string& id) { return std::regex_match(id, std::regex("[a-f0-9]{64}")); } +static bool text(const json& a, const char* field, size_t maximum) { + return a.contains(field) && a[field].is_string() && !a[field].get_ref().empty() && + a[field].get_ref().size() <= maximum && a[field].get_ref().find('\0') == std::string::npos; +} +static bool valid(const json& a) { + if(!a.is_object() || !text(a,"id",64) || !validId(a["id"]) || !text(a,"server",2048) || + !text(a,"userId",512) || !text(a,"loginName",512) || !text(a,"appPassword",4096)) return false; + const std::string server = a["server"]; + if(!std::regex_match(server, std::regex(R"((https://[^/@?#\\\s]+|http://(127\.0\.0\.1|localhost)(:[0-9]+)?)(/[^?#\\\s]*)?)")) || server.back() == '/') return false; + const std::string user = a["userId"]; + return user != "." && user != ".." && user.find_first_of("/\\\r\n") == std::string::npos && a["loginName"].get().find(':') == std::string::npos; +} +static json metadata(const json& a) { return {{"id",a["id"]},{"server",a["server"]},{"userId",a["userId"]}}; } +static json error(const char* message) { return {{"error", {{"code","NEXTCLOUD_CREDENTIALS"},{"message",message}}}}; } +static std::wstring target(const std::string& id) { return prefix + std::wstring(id.begin(), id.end()); } +bool read(const std::string& id, json& account) { +#ifdef _WIN32 + if(!validId(id)) return false; + PCREDENTIALW credential = nullptr; + if(!CredReadW(target(id).c_str(), CRED_TYPE_GENERIC, 0, &credential)) return false; + try { + account = json::parse(credential->CredentialBlob, credential->CredentialBlob + credential->CredentialBlobSize); + } catch(...) { CredFree(credential); return false; } + CredFree(credential); + return valid(account) && account["id"] == id; +#else + return false; +#endif +} +static std::string encode(const std::string& value) { + std::ostringstream out; + for(unsigned char c: value) { + if((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '-' || c == '_' || c == '.' || c == '~' || c == '!' || c == '\'' || c == '(' || c == ')' || c == '*') out << c; + else out << '%' << std::uppercase << std::hex << std::setw(2) << std::setfill('0') << static_cast(c); + } + return out.str(); +} +bool permits(const json& a, const std::string& url, const std::string& method) { + const std::string server = a["server"]; + if(method == "GET" && url == server + "/ocs/v2.php/cloud/user?format=json") return true; + const std::string root = server + "/remote.php/dav/files/" + encode(a["userId"]) + "/"; + // Native URL scope supplements JS validation. Never forward stored credentials + // to another origin, user-info URL, account root, redirect, or traversal path. + if(url.rfind(root,0) != 0 || (method != "GET" && method != "PUT" && method != "PROPFIND" && method != "DELETE" && method != "MKCOL")) return false; + auto suffix = url.substr(root.size()); + if(method=="MKCOL" && (suffix.empty() || suffix.back()!='/'))return false; + if(suffix.find_first_of("?#\\\r\n") != std::string::npos) return false; + std::string decoded; + for(size_t i=0; i= suffix.size() || !std::isxdigit(static_cast(suffix[i+1])) || !std::isxdigit(static_cast(suffix[i+2]))) return false; + const char c = static_cast(std::stoi(suffix.substr(i+1,2),nullptr,16)); + if(c == '/' || c == '\\' || static_cast(c) < 32) return false; + decoded += c; i += 2; + } else decoded += suffix[i]; + } + if(method=="MKCOL" && decoded.find('%')!=std::string::npos)return false; + if(method=="DELETE") { + std::string lower=decoded; + for(char& c:lower) if(c>='A' && c<='Z') c+='a'-'A'; + if(lower.size()<=3 || lower.substr(lower.size()-3)!=".md") return false; + } + std::istringstream parts(decoded); std::string part; + while(std::getline(parts,part,'/')) if(part == "." || part == "..") return false; + return true; +} +namespace controllers { +json store(const json& input) { +#ifdef _WIN32 + if(!valid(input)) return error("Invalid Nextcloud account."); + const json account = {{"id",input["id"]},{"server",input["server"]},{"userId",input["userId"]},{"loginName",input["loginName"]},{"appPassword",input["appPassword"]}}; + auto serialized = account.dump(); + if(serialized.size() > CRED_MAX_CREDENTIAL_BLOB_SIZE) return error("The account exceeds the Windows credential size limit."); + std::wstring name = target(account["id"]); + CREDENTIALW credential = {}; + credential.Type = CRED_TYPE_GENERIC; + credential.TargetName = name.data(); + credential.CredentialBlobSize = static_cast(serialized.size()); + credential.CredentialBlob = reinterpret_cast(serialized.data()); + credential.Persist = CRED_PERSIST_LOCAL_MACHINE; + const bool ok = CredWriteW(&credential,0); + SecureZeroMemory(serialized.data(),serialized.size()); + if(!ok) return error("Windows could not securely remember this Nextcloud account."); + return {{"success",true},{"returnValue",metadata(account)}}; +#else + return error("Secure Nextcloud accounts are available on Windows only."); +#endif +} +json list(const json&) { + json result = json::array(); +#ifdef _WIN32 + DWORD count = 0; PCREDENTIALW* credentials = nullptr; + if(!CredEnumerateW((prefix + L"*").c_str(),0,&count,&credentials)) { + if(GetLastError() == ERROR_NOT_FOUND) return {{"success",true},{"returnValue",result}}; + return error("Windows could not read remembered Nextcloud accounts."); + } + for(DWORD i=0; iCredentialBlob,credentials[i]->CredentialBlob + credentials[i]->CredentialBlobSize); + if(valid(account) && target(account["id"]) == credentials[i]->TargetName) result.push_back(metadata(account)); + } catch(...) { } + } + CredFree(credentials); +#endif + return {{"success",true},{"returnValue",result}}; +} +json forget(const json& input) { +#ifdef _WIN32 + if(!text(input,"id",64) || !validId(input["id"])) return error("Invalid Nextcloud account ID."); + if(!CredDeleteW(target(input["id"]).c_str(),CRED_TYPE_GENERIC,0) && GetLastError() != ERROR_NOT_FOUND) return error("Windows could not forget this account."); + return {{"success",true},{"returnValue",true}}; +#else + return error("Secure Nextcloud accounts are available on Windows only."); +#endif +} +} +} diff --git a/desktop-app/cloud-extension/credentials.h b/desktop-app/cloud-extension/credentials.h new file mode 100644 index 00000000..6accb453 --- /dev/null +++ b/desktop-app/cloud-extension/credentials.h @@ -0,0 +1,12 @@ +#pragma once +#include "vendor/json.hpp" +#include +namespace nextcloud_credentials { +bool read(const std::string&, nlohmann::json&); +bool permits(const nlohmann::json&, const std::string&, const std::string&); +namespace controllers { +nlohmann::json store(const nlohmann::json&); +nlohmann::json list(const nlohmann::json&); +nlohmann::json forget(const nlohmann::json&); +} +} diff --git a/desktop-app/cloud-extension/main.cpp b/desktop-app/cloud-extension/main.cpp new file mode 100644 index 00000000..c15ead2a --- /dev/null +++ b/desktop-app/cloud-extension/main.cpp @@ -0,0 +1,299 @@ +// Windows adapter for the documented Neutralino extension protocol. +// No Neutralino headers, custom controllers, or runtime source are required. +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "providers.h" +using json = nlohmann::json; +static constexpr size_t LIMIT = 20 * 1024 * 1024; +static constexpr size_t IPC_LIMIT = 128 * 1024 * 1024; +struct Handle { + HINTERNET value = nullptr; + explicit Handle(HINTERNET h = nullptr): value(h) {} + ~Handle() { if(value) WinHttpCloseHandle(value); } + Handle(const Handle&) = delete; + operator HINTERNET() const { return value; } +}; +static void require(bool condition) { if(!condition) throw std::runtime_error("Cloud operation refused or unavailable."); } +static std::wstring wide(const std::string& value) { + if(value.empty()) return {}; + int length = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, value.data(), (int)value.size(), nullptr, 0); + require(length > 0); + std::wstring result(length, L'\0'); + require(MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, value.data(), (int)value.size(), result.data(), length) == length); + return result; +} +static std::string utf8(const std::wstring& value) { + if(value.empty()) return {}; + int length = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, value.data(), (int)value.size(), nullptr, 0, nullptr, nullptr); + require(length > 0); + std::string result(length, '\0'); + require(WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, value.data(), (int)value.size(), result.data(), length, nullptr, nullptr) == length); + return result; +} +static bool clean(const std::string& value) { + for(unsigned char c:value) if(c < 32 || c == 127) return false; + return true; +} +static std::string lower(std::string value) { + for(char& c:value) if(c >= 'A' && c <= 'Z') c += 'a'-'A'; + return value; +} +static std::string basic(const std::string& value) { + static const char* table="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + std::string result; + for(size_t i=0;i>2]; result += table[((a&3)<<4)|(b>>4)]; + result += i+1>6)]:'='; + result += i+2 buffer; + std::chrono::steady_clock::time_point deadline; + static void CALLBACK callback(HINTERNET, DWORD_PTR context, DWORD status, LPVOID info, DWORD count) { + auto* self=reinterpret_cast(context); + if(!self)return; + std::lock_guard guard(self->mutex); + if(status==WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING)self->closed=true; + else if(status==WINHTTP_CALLBACK_STATUS_REQUEST_ERROR)self->error=static_cast(info)->dwError; + else if(status==WINHTTP_CALLBACK_STATUS_SENDREQUEST_COMPLETE || status==WINHTTP_CALLBACK_STATUS_HEADERS_AVAILABLE || status==WINHTTP_CALLBACK_STATUS_READ_COMPLETE) { + self->status=status;self->length=count; + } + self->changed.notify_all(); + } + AsyncRequest(HINTERNET connection,const std::wstring& method,const std::wstring& path,bool secure,std::chrono::steady_clock::time_point end):deadline(end) { + handle=WinHttpOpenRequest(connection,method.c_str(),path.c_str(),nullptr,WINHTTP_NO_REFERER,WINHTTP_DEFAULT_ACCEPT_TYPES,secure?WINHTTP_FLAG_SECURE:0); + require(handle); + DWORD_PTR context=reinterpret_cast(this); + if(!WinHttpSetOption(handle,WINHTTP_OPTION_CONTEXT_VALUE,&context,sizeof(context)) || + WinHttpSetStatusCallback(handle,callback,WINHTTP_CALLBACK_FLAG_ALL_COMPLETIONS|WINHTTP_CALLBACK_FLAG_HANDLES,0)==WINHTTP_INVALID_STATUS_CALLBACK) { + WinHttpCloseHandle(handle);handle=nullptr;require(false); + } + } + ~AsyncRequest() { + if(!handle)return; + WinHttpCloseHandle(handle);handle=nullptr; + std::unique_lock guard(mutex); + changed.wait(guard,[&]{return closed;}); + } + operator HINTERNET() const {return handle;} + void prepare() { + require(std::chrono::steady_clock::now() guard(mutex);status=error=length=0; + } + DWORD wait(BOOL result,DWORD expected) { + require(result || GetLastError()==ERROR_IO_PENDING); + std::unique_lock guard(mutex); + require(changed.wait_until(guard,deadline,[&]{return error || status==expected;})); + require(!error && std::chrono::steady_clock::now()=100 && timeout<=35000); + const auto deadline=std::chrono::steady_clock::now()+std::chrono::milliseconds(timeout); + const std::string url=input.at("url").get(), method=input.at("method").get(); + cloud_providers::validateRequest(input,url,method); + require(url.size() <= 8192 && clean(url) && url.find_first_of("\\#") == std::string::npos); + require(method=="GET" || method=="POST" || method=="PUT" || method=="PROPFIND" || method=="OPTIONS" || method=="DELETE" || method=="MKCOL"); + require(input.contains("maxBytes") && input["maxBytes"].is_number_integer()); + const auto maximum=input["maxBytes"].get(); require(maximum>0 && maximum<=LIMIT); + const auto wurl=wide(url); URL_COMPONENTS parts{};parts.dwStructSize=sizeof(parts); + parts.dwHostNameLength=parts.dwUrlPathLength=parts.dwExtraInfoLength=parts.dwUserNameLength=parts.dwPasswordLength=(DWORD)-1; + require(WinHttpCrackUrl(wurl.c_str(), (DWORD)wurl.size(), 0, &parts)); + std::wstring host(parts.lpszHostName,parts.dwHostNameLength); + require(parts.dwUserNameLength==0 && parts.dwPasswordLength==0); + require(parts.nScheme==INTERNET_SCHEME_HTTPS || (parts.nScheme==INTERNET_SCHEME_HTTP && (host==L"localhost" || host==L"127.0.0.1" || host==L"[::1]" || host==L"::1"))); + std::wstring path=parts.dwUrlPathLength?std::wstring(parts.lpszUrlPath,parts.dwUrlPathLength):L"/"; + if(parts.dwExtraInfoLength) path.append(parts.lpszExtraInfo,parts.dwExtraInfoLength); + json auth=input.value("auth", json::object()); + json account; + if(auth.contains("credentialId")) { + require(auth.size()==1 && auth["credentialId"].is_string()); + if(!cloud_providers::authorize(input,url,method,account)) + return {{"error",{{"code",input.value("providerId",std::string("nextcloud"))=="webdav"?"WEBDAV_CREDENTIALS":"NEXTCLOUD_CREDENTIALS"},{"message","Remembered access is unavailable for this account."}}}}; + auth=std::move(account); + } + const std::string body=input.value("body",std::string());require(body.size()<=LIMIT); + auto headers=input.value("headers",json::object()); require(headers.is_object() && headers.size()<=32); + const std::string contentType=input.value("contentType",std::string("application/json"));require(clean(contentType) && contentType.size()<=256); + std::string headerText=method=="MKCOL" ? "" : "Content-Type: "+contentType+"\r\n"; + std::set headerNames; + bool conditional=false, createOnly=false; + for(auto it=headers.begin();it!=headers.end();++it) { + const auto name=it.key(), value=it.value().get(), key=lower(name); + require(!name.empty() && name.find_first_not_of("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_")==std::string::npos && clean(value) && value.size()<=8192); + require(key!="authorization" && key!="proxy-authorization" && key!="host" && key!="content-length" && key!="transfer-encoding" && key!="connection" && key!="cookie" && key!="content-type"); + require(headerNames.insert(key).second); + if(key=="if-match") { + require(value.size()>2 && value.front()=='"' && value.back()=='"' && value.substr(1,value.size()-2).find('"')==std::string::npos); + conditional=true; + } + if(key=="if-none-match") { require(value=="*"); createOnly=true; } + headerText+=name+": "+value+"\r\n"; + } + if(method=="PUT") require(conditional != createOnly); + if(method=="DELETE") require(conditional && !createOnly && body.empty()); + if(method=="MKCOL") require(createOnly && !conditional && body.empty() && parts.dwExtraInfoLength==0 && !path.empty() && path.back()==L'/'); + if((createOnly && method!="MKCOL") || method=="DELETE") { + const auto targetPath=lower(utf8(path)); + require(parts.dwExtraInfoLength==0 && targetPath.size()>3 && targetPath.substr(targetPath.size()-3)==".md"); + } + if(!auth.empty()) { + const auto username=auth.at("username").get(), password=auth.at("password").get(); + require(!username.empty() && username.size()<=512 && username.find(':')==std::string::npos && clean(username) && !password.empty() && password.size()<=4096 && clean(password)); + headerText+="Authorization: Basic "+basic(username+":"+password)+"\r\n"; + } + Handle session(WinHttpOpen(L"MarkdownViewerCloud/1",WINHTTP_ACCESS_TYPE_DEFAULT_PROXY,WINHTTP_NO_PROXY_NAME,WINHTTP_NO_PROXY_BYPASS,WINHTTP_FLAG_ASYNC)); require(session.value); + require(WinHttpSetTimeouts(session,35000,35000,35000,35000)); + Handle connection(WinHttpConnect(session,host.c_str(),parts.nPort,0));require(connection.value); + const auto wheaders=wide(headerText); + AsyncRequest operation(connection,wide(method),path,parts.nScheme==INTERNET_SCHEME_HTTPS,deadline); + DWORD redirectPolicy=WINHTTP_OPTION_REDIRECT_POLICY_NEVER; + require(WinHttpSetOption(operation,WINHTTP_OPTION_REDIRECT_POLICY,&redirectPolicy,sizeof(redirectPolicy))); + DWORD disabled=WINHTTP_DISABLE_COOKIES|WINHTTP_DISABLE_AUTHENTICATION; + require(WinHttpSetOption(operation,WINHTTP_OPTION_DISABLE_FEATURE,&disabled,sizeof(disabled))); + operation.prepare(); + operation.wait(WinHttpSendRequest(operation,wheaders.c_str(),(DWORD)wheaders.size(),body.empty()?WINHTTP_NO_REQUEST_DATA:(LPVOID)body.data(),(DWORD)body.size(),(DWORD)body.size(),reinterpret_cast(&operation)),WINHTTP_CALLBACK_STATUS_SENDREQUEST_COMPLETE); + operation.prepare(); + operation.wait(WinHttpReceiveResponse(operation,nullptr),WINHTTP_CALLBACK_STATUS_HEADERS_AVAILABLE); + DWORD status=0,size=sizeof(status); + require(WinHttpQueryHeaders(operation,WINHTTP_QUERY_STATUS_CODE|WINHTTP_QUERY_FLAG_NUMBER,WINHTTP_HEADER_NAME_BY_INDEX,&status,&size,WINHTTP_NO_HEADER_INDEX)); + DWORD headerSize=0; + WinHttpQueryHeaders(operation,WINHTTP_QUERY_RAW_HEADERS_CRLF,WINHTTP_HEADER_NAME_BY_INDEX,nullptr,&headerSize,WINHTTP_NO_HEADER_INDEX); + require(headerSize>0 && headerSize<=256*1024); + std::vector raw(headerSize/sizeof(wchar_t)+1); + require(WinHttpQueryHeaders(operation,WINHTTP_QUERY_RAW_HEADERS_CRLF,WINHTTP_HEADER_NAME_BY_INDEX,raw.data(),&headerSize,WINHTTP_NO_HEADER_INDEX)); + const auto responseHeaders=utf8(raw.data());json pairs=json::array(); + size_t start=responseHeaders.find("\r\n"); + while(start!=std::string::npos) { + start+=2;const auto end=responseHeaders.find("\r\n",start);if(end==std::string::npos || end==start) break; + const auto colon=responseHeaders.find(':',start); + if(colon!=std::string::npos && colon(); + const auto input=call.value("input",json::object()); + if(operation=="request") return request(input); + if(operation=="accountStore" || operation=="accountList" || operation=="accountForget") return cloud_providers::accounts(operation,input); + if(operation=="capabilities") return {{"returnValue",{{"version",5},{"providerIds",json::array({"nextcloud","webdav"})},{"secureAccounts",true},{"conditionalWrites",true},{"requestDeadlineMs",35000}}}}; + throw std::runtime_error("Unsupported cloud operation."); +} +int main() { + try { + // Neutralino sends bootstrap JSON through stdin; never persist or log it. + std::string bootstrap;char character; + while(std::cin.get(character)) {if(character=='\n')break;require(bootstrap.size()<16384);bootstrap+=character;} + auto config=json::parse(bootstrap); + require(config.at("nlExtensionId")=="com.markdownviewer.cloud"); + const auto port=std::stoi(config.at("nlPort").get());require(port>0 && port<=65535); + const auto token=config.at("nlToken").get(), connectToken=config.at("nlConnectToken").get(); + require(clean(connectToken) && connectToken.find_first_not_of("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_")==std::string::npos); + Handle session(WinHttpOpen(L"MarkdownViewerExtension/1",WINHTTP_ACCESS_TYPE_NO_PROXY,WINHTTP_NO_PROXY_NAME,WINHTTP_NO_PROXY_BYPASS,0));require(session.value); + Handle connection(WinHttpConnect(session,L"127.0.0.1",(INTERNET_PORT)port,0));require(connection.value); + const auto path=wide("/?extensionId=com.markdownviewer.cloud&connectToken="+connectToken); + Handle upgrade(WinHttpOpenRequest(connection,L"GET",path.c_str(),nullptr,WINHTTP_NO_REFERER,WINHTTP_DEFAULT_ACCEPT_TYPES,0));require(upgrade.value); + require(WinHttpSetOption(upgrade,WINHTTP_OPTION_UPGRADE_TO_WEB_SOCKET,nullptr,0)); + require(WinHttpSendRequest(upgrade,WINHTTP_NO_ADDITIONAL_HEADERS,0,WINHTTP_NO_REQUEST_DATA,0,0,0) && WinHttpReceiveResponse(upgrade,nullptr)); + Handle socket(WinHttpWebSocketCompleteUpgrade(upgrade,0));require(socket.value); + // An inherited socket can survive its original server process on Windows. + // Obtain the actual runtime PID over authenticated IPC, not the cmd.exe + // launcher parent, and hold a process handle so PID reuse cannot fool us. + const std::string hostRequest=json({{"id","cloudHostProcess"},{"method","app.getProcessId"},{"accessToken",token},{"data",json::object()}}).dump(); + require(WinHttpWebSocketSend(socket,WINHTTP_WEB_SOCKET_UTF8_MESSAGE_BUFFER_TYPE,(PVOID)hostRequest.data(),(DWORD)hostRequest.size())==NO_ERROR); + bool monitoringHost=false; + std::mutex sendMutex;std::atomic active{0};std::atomic sequence{0}; + std::string message;char buffer[16384]; + for(;;) { + DWORD received=0;WINHTTP_WEB_SOCKET_BUFFER_TYPE type; + if(WinHttpWebSocketReceive(socket,buffer,sizeof(buffer),&received,&type)!=NO_ERROR || type==WINHTTP_WEB_SOCKET_CLOSE_BUFFER_TYPE) std::exit(0); + require(type==WINHTTP_WEB_SOCKET_UTF8_FRAGMENT_BUFFER_TYPE || type==WINHTTP_WEB_SOCKET_UTF8_MESSAGE_BUFFER_TYPE); + require(message.size()+received<=IPC_LIMIT);message.append(buffer,received); + if(type!=WINHTTP_WEB_SOCKET_UTF8_MESSAGE_BUFFER_TYPE) continue; + auto envelope=json::parse(message);message.clear(); + if(envelope.value("id",std::string())=="cloudHostProcess") { + require(!monitoringHost); + const auto& response=envelope.at("data"); + require(response.value("success",false) && response.contains("returnValue") && response["returnValue"].is_number_integer()); + const auto pid=response["returnValue"].get(); + require(pid>0 && pid<=MAXDWORD && pid!=GetCurrentProcessId()); + HANDLE hostProcess=OpenProcess(SYNCHRONIZE,FALSE,(DWORD)pid); + if(!hostProcess) std::exit(0); // Host already gone: never become an orphan. + monitoringHost=true; + std::thread([hostProcess] { + const auto result=WaitForSingleObject(hostProcess,INFINITE); + CloseHandle(hostProcess); + // No logging, credential deletion or remote request on termination. + std::exit(result==WAIT_OBJECT_0?0:1); + }).detach(); + continue; + } + if(envelope.value("event",std::string())!="cloudRequest") continue; + const auto call=envelope.at("data"); + const auto id=call.at("id").get();require(id.size()<=100 && clean(id)); + // Bound concurrent native work; errors never include request URLs, bodies or credentials. + if(active.load()>=8 || (call.value("operation",std::string())=="shutdown" && active.load()!=0)) { + json reply={{"id",id},{"error",{{"code","BUSY"},{"message","Cloud service is busy. Try again shortly."}}}}; + const auto wire=json({{"id",std::to_string(++sequence)},{"method","app.broadcast"},{"accessToken",token},{"data",{{"event","cloudResponse"},{"data",reply}}}}).dump(); + std::lock_guard guard(sendMutex); + require(WinHttpWebSocketSend(socket,WINHTTP_WEB_SOCKET_UTF8_MESSAGE_BUFFER_TYPE,(PVOID)wire.data(),(DWORD)wire.size())==NO_ERROR); + continue; + } + if(call.value("operation",std::string())=="shutdown") { + require(active.load()==0); + const auto wire=json({{"id",std::to_string(++sequence)},{"method","app.broadcast"},{"accessToken",token},{"data",{{"event","cloudResponse"},{"data",{{"id",id},{"returnValue",true}}}}}}).dump(); + {std::lock_guard guard(sendMutex);WinHttpWebSocketSend(socket,WINHTTP_WEB_SOCKET_UTF8_MESSAGE_BUFFER_TYPE,(PVOID)wire.data(),(DWORD)wire.size());} + std::exit(0); + } + ++active; + std::thread([&,call,id] { + json reply; + try { reply=dispatch(call); } + catch(...) {reply={{"error",{{"code","CLOUD_EXTENSION"},{"message","Cloud operation failed. Your local draft was kept."}}}};} + reply["id"]=id; + json outgoing={{"id",std::to_string(++sequence)},{"method","app.broadcast"},{"accessToken",token},{"data",{{"event","cloudResponse"},{"data",reply}}}}; + const auto wire=outgoing.dump(); + --active; + {std::lock_guard guard(sendMutex);if(WinHttpWebSocketSend(socket,WINHTTP_WEB_SOCKET_UTF8_MESSAGE_BUFFER_TYPE,(PVOID)wire.data(),(DWORD)wire.size())!=NO_ERROR) std::exit(0);} + }).detach(); + } + } catch(...) { return 1; } +} diff --git a/desktop-app/cloud-extension/providers.cpp b/desktop-app/cloud-extension/providers.cpp new file mode 100644 index 00000000..64a816ce --- /dev/null +++ b/desktop-app/cloud-extension/providers.cpp @@ -0,0 +1,57 @@ +// Registered credential policies. User metadata cannot register a provider. +#include "providers.h" +#include "credentials.h" +#include "webdav-credentials.h" +#include +namespace cloud_providers { +using json=nlohmann::json; +void validate(const json& input) { + if(!input.is_object() || (input.contains("providerId") && (!input["providerId"].is_string() || (input["providerId"]!="nextcloud" && input["providerId"]!="webdav")))) + throw std::runtime_error("Unsupported cloud provider. Local drafts were kept."); +} +void validateRequest(const json& input,const std::string& url,const std::string& method) { + validate(input); + if(input.value("providerId",std::string("nextcloud"))=="webdav" && (!input.contains("root") || !input["root"].is_string() || !webdav_credentials::permits(input["root"],url,method))) + throw std::runtime_error("The request is outside this WebDAV connection."); +} +bool authorize(const json& input, const std::string& url, const std::string& method, json& account) { + validate(input); + const auto& auth=input.at("auth"); + json record; + if(input.value("providerId",std::string("nextcloud"))=="webdav") { + if(!webdav_credentials::read(auth.at("credentialId"),record) || input.value("root",std::string())!=record["root"] || !webdav_credentials::permits(record["root"],url,method))return false; + } else if(!nextcloud_credentials::read(auth.at("credentialId"),record) || !nextcloud_credentials::permits(record,url,method))return false; + // Translate the provider-specific vault record at this boundary only. + account={{"username",record["loginName"]},{"password",record["appPassword"]}}; + return true; +} +static json tagged(json result) { + if(result.contains("returnValue")) { + auto& value=result["returnValue"]; + if(value.is_array())for(auto& item:value)item["providerId"]="nextcloud"; + else if(value.is_object())value["providerId"]="nextcloud"; + } + return result; +} +json accounts(const std::string& operation,const json& input) { + validate(input); + const auto provider=input.value("providerId",std::string("nextcloud")); + if(provider=="webdav") { + if(operation=="accountStore")return webdav_credentials::controllers::store(input); + if(operation=="accountList")return webdav_credentials::controllers::list(input); + if(operation=="accountForget")return webdav_credentials::controllers::forget(input); + } + if(operation=="accountList" && !input.contains("providerId")) { + auto nextcloud=tagged(nextcloud_credentials::controllers::list(input)); + auto webdav=webdav_credentials::controllers::list(input); + if(nextcloud.contains("error"))return nextcloud; + if(webdav.contains("error"))return webdav; + for(const auto& account:webdav["returnValue"])nextcloud["returnValue"].push_back(account); + return nextcloud; + } + if(operation=="accountStore")return tagged(nextcloud_credentials::controllers::store(input)); + if(operation=="accountList")return tagged(nextcloud_credentials::controllers::list(input)); + if(operation=="accountForget")return nextcloud_credentials::controllers::forget(input); + throw std::runtime_error("Unsupported cloud account operation."); +} +} diff --git a/desktop-app/cloud-extension/providers.h b/desktop-app/cloud-extension/providers.h new file mode 100644 index 00000000..edcc82e6 --- /dev/null +++ b/desktop-app/cloud-extension/providers.h @@ -0,0 +1,10 @@ +#pragma once +#include "vendor/json.hpp" +#include +namespace cloud_providers { +// Missing provider IDs are accepted only for the legacy Nextcloud IPC contract. +void validate(const nlohmann::json&); +void validateRequest(const nlohmann::json&,const std::string&,const std::string&); +bool authorize(const nlohmann::json&, const std::string&, const std::string&, nlohmann::json&); +nlohmann::json accounts(const std::string&, const nlohmann::json&); +} diff --git a/desktop-app/cloud-extension/vendor/LICENSE.json b/desktop-app/cloud-extension/vendor/LICENSE.json new file mode 100644 index 00000000..70c6af65 --- /dev/null +++ b/desktop-app/cloud-extension/vendor/LICENSE.json @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2013-2022 Niels Lohmann + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/desktop-app/cloud-extension/vendor/json.hpp b/desktop-app/cloud-extension/vendor/json.hpp new file mode 100644 index 00000000..4d1a37ad --- /dev/null +++ b/desktop-app/cloud-extension/vendor/json.hpp @@ -0,0 +1,24596 @@ +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.2 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann +// SPDX-License-Identifier: MIT + +/****************************************************************************\ + * Note on documentation: The source files contain links to the online * + * documentation of the public API at https://json.nlohmann.me. This URL * + * contains the most recent documentation and should also be applicable to * + * previous versions; documentation for deprecated functions is not * + * removed, but marked deprecated. See "Generate documentation" section in * + * file docs/README.md. * +\****************************************************************************/ + +#ifndef INCLUDE_NLOHMANN_JSON_HPP_ +#define INCLUDE_NLOHMANN_JSON_HPP_ + +#include // all_of, find, for_each +#include // nullptr_t, ptrdiff_t, size_t +#include // hash, less +#include // initializer_list +#ifndef JSON_NO_IO + #include // istream, ostream +#endif // JSON_NO_IO +#include // random_access_iterator_tag +#include // unique_ptr +#include // accumulate +#include // string, stoi, to_string +#include // declval, forward, move, pair, swap +#include // vector + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.2 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.2 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// This file contains all macro definitions affecting or depending on the ABI + +#ifndef JSON_SKIP_LIBRARY_VERSION_CHECK + #if defined(NLOHMANN_JSON_VERSION_MAJOR) && defined(NLOHMANN_JSON_VERSION_MINOR) && defined(NLOHMANN_JSON_VERSION_PATCH) + #if NLOHMANN_JSON_VERSION_MAJOR != 3 || NLOHMANN_JSON_VERSION_MINOR != 11 || NLOHMANN_JSON_VERSION_PATCH != 2 + #warning "Already included a different version of the library!" + #endif + #endif +#endif + +#define NLOHMANN_JSON_VERSION_MAJOR 3 // NOLINT(modernize-macro-to-enum) +#define NLOHMANN_JSON_VERSION_MINOR 11 // NOLINT(modernize-macro-to-enum) +#define NLOHMANN_JSON_VERSION_PATCH 2 // NOLINT(modernize-macro-to-enum) + +#ifndef JSON_DIAGNOSTICS + #define JSON_DIAGNOSTICS 0 +#endif + +#ifndef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON + #define JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON 0 +#endif + +#if JSON_DIAGNOSTICS + #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag +#else + #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS +#endif + +#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON + #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON _ldvcmp +#else + #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON +#endif + +#ifndef NLOHMANN_JSON_NAMESPACE_NO_VERSION + #define NLOHMANN_JSON_NAMESPACE_NO_VERSION 0 +#endif + +// Construct the namespace ABI tags component +#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b) json_abi ## a ## b +#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b) \ + NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b) + +#define NLOHMANN_JSON_ABI_TAGS \ + NLOHMANN_JSON_ABI_TAGS_CONCAT( \ + NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS, \ + NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON) + +// Construct the namespace version component +#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \ + _v ## major ## _ ## minor ## _ ## patch +#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(major, minor, patch) \ + NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) + +#if NLOHMANN_JSON_NAMESPACE_NO_VERSION +#define NLOHMANN_JSON_NAMESPACE_VERSION +#else +#define NLOHMANN_JSON_NAMESPACE_VERSION \ + NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(NLOHMANN_JSON_VERSION_MAJOR, \ + NLOHMANN_JSON_VERSION_MINOR, \ + NLOHMANN_JSON_VERSION_PATCH) +#endif + +// Combine namespace components +#define NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b) a ## b +#define NLOHMANN_JSON_NAMESPACE_CONCAT(a, b) \ + NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b) + +#ifndef NLOHMANN_JSON_NAMESPACE +#define NLOHMANN_JSON_NAMESPACE \ + nlohmann::NLOHMANN_JSON_NAMESPACE_CONCAT( \ + NLOHMANN_JSON_ABI_TAGS, \ + NLOHMANN_JSON_NAMESPACE_VERSION) +#endif + +#ifndef NLOHMANN_JSON_NAMESPACE_BEGIN +#define NLOHMANN_JSON_NAMESPACE_BEGIN \ + namespace nlohmann \ + { \ + inline namespace NLOHMANN_JSON_NAMESPACE_CONCAT( \ + NLOHMANN_JSON_ABI_TAGS, \ + NLOHMANN_JSON_NAMESPACE_VERSION) \ + { +#endif + +#ifndef NLOHMANN_JSON_NAMESPACE_END +#define NLOHMANN_JSON_NAMESPACE_END \ + } /* namespace (inline namespace) NOLINT(readability/namespace) */ \ + } // namespace nlohmann +#endif + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.2 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // transform +#include // array +#include // forward_list +#include // inserter, front_inserter, end +#include // map +#include // string +#include // tuple, make_tuple +#include // is_arithmetic, is_same, is_enum, underlying_type, is_convertible +#include // unordered_map +#include // pair, declval +#include // valarray + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.2 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // nullptr_t +#include // exception +#include // runtime_error +#include // to_string +#include // vector + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.2 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // array +#include // size_t +#include // uint8_t +#include // string + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.2 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // declval, pair +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.2 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.2 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +template struct make_void +{ + using type = void; +}; +template using void_t = typename make_void::type; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +// https://en.cppreference.com/w/cpp/experimental/is_detected +struct nonesuch +{ + nonesuch() = delete; + ~nonesuch() = delete; + nonesuch(nonesuch const&) = delete; + nonesuch(nonesuch const&&) = delete; + void operator=(nonesuch const&) = delete; + void operator=(nonesuch&&) = delete; +}; + +template class Op, + class... Args> +struct detector +{ + using value_t = std::false_type; + using type = Default; +}; + +template class Op, class... Args> +struct detector>, Op, Args...> +{ + using value_t = std::true_type; + using type = Op; +}; + +template class Op, class... Args> +using is_detected = typename detector::value_t; + +template class Op, class... Args> +struct is_detected_lazy : is_detected { }; + +template class Op, class... Args> +using detected_t = typename detector::type; + +template class Op, class... Args> +using detected_or = detector; + +template class Op, class... Args> +using detected_or_t = typename detected_or::type; + +template class Op, class... Args> +using is_detected_exact = std::is_same>; + +template class Op, class... Args> +using is_detected_convertible = + std::is_convertible, To>; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include + + +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.2 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann +// SPDX-FileCopyrightText: 2016-2021 Evan Nemerson +// SPDX-License-Identifier: MIT + +/* Hedley - https://nemequ.github.io/hedley + * Created by Evan Nemerson + */ + +#if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 15) +#if defined(JSON_HEDLEY_VERSION) + #undef JSON_HEDLEY_VERSION +#endif +#define JSON_HEDLEY_VERSION 15 + +#if defined(JSON_HEDLEY_STRINGIFY_EX) + #undef JSON_HEDLEY_STRINGIFY_EX +#endif +#define JSON_HEDLEY_STRINGIFY_EX(x) #x + +#if defined(JSON_HEDLEY_STRINGIFY) + #undef JSON_HEDLEY_STRINGIFY +#endif +#define JSON_HEDLEY_STRINGIFY(x) JSON_HEDLEY_STRINGIFY_EX(x) + +#if defined(JSON_HEDLEY_CONCAT_EX) + #undef JSON_HEDLEY_CONCAT_EX +#endif +#define JSON_HEDLEY_CONCAT_EX(a,b) a##b + +#if defined(JSON_HEDLEY_CONCAT) + #undef JSON_HEDLEY_CONCAT +#endif +#define JSON_HEDLEY_CONCAT(a,b) JSON_HEDLEY_CONCAT_EX(a,b) + +#if defined(JSON_HEDLEY_CONCAT3_EX) + #undef JSON_HEDLEY_CONCAT3_EX +#endif +#define JSON_HEDLEY_CONCAT3_EX(a,b,c) a##b##c + +#if defined(JSON_HEDLEY_CONCAT3) + #undef JSON_HEDLEY_CONCAT3 +#endif +#define JSON_HEDLEY_CONCAT3(a,b,c) JSON_HEDLEY_CONCAT3_EX(a,b,c) + +#if defined(JSON_HEDLEY_VERSION_ENCODE) + #undef JSON_HEDLEY_VERSION_ENCODE +#endif +#define JSON_HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision)) + +#if defined(JSON_HEDLEY_VERSION_DECODE_MAJOR) + #undef JSON_HEDLEY_VERSION_DECODE_MAJOR +#endif +#define JSON_HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000) + +#if defined(JSON_HEDLEY_VERSION_DECODE_MINOR) + #undef JSON_HEDLEY_VERSION_DECODE_MINOR +#endif +#define JSON_HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000) + +#if defined(JSON_HEDLEY_VERSION_DECODE_REVISION) + #undef JSON_HEDLEY_VERSION_DECODE_REVISION +#endif +#define JSON_HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000) + +#if defined(JSON_HEDLEY_GNUC_VERSION) + #undef JSON_HEDLEY_GNUC_VERSION +#endif +#if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__) + #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__) +#elif defined(__GNUC__) + #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0) +#endif + +#if defined(JSON_HEDLEY_GNUC_VERSION_CHECK) + #undef JSON_HEDLEY_GNUC_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_GNUC_VERSION) + #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GNUC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_MSVC_VERSION) + #undef JSON_HEDLEY_MSVC_VERSION +#endif +#if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000) && !defined(__ICL) + #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000, (_MSC_FULL_VER % 10000000) / 100000, (_MSC_FULL_VER % 100000) / 100) +#elif defined(_MSC_FULL_VER) && !defined(__ICL) + #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, (_MSC_FULL_VER % 1000000) / 10000, (_MSC_FULL_VER % 10000) / 10) +#elif defined(_MSC_VER) && !defined(__ICL) + #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0) +#endif + +#if defined(JSON_HEDLEY_MSVC_VERSION_CHECK) + #undef JSON_HEDLEY_MSVC_VERSION_CHECK +#endif +#if !defined(JSON_HEDLEY_MSVC_VERSION) + #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (0) +#elif defined(_MSC_VER) && (_MSC_VER >= 1400) + #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch))) +#elif defined(_MSC_VER) && (_MSC_VER >= 1200) + #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch))) +#else + #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor))) +#endif + +#if defined(JSON_HEDLEY_INTEL_VERSION) + #undef JSON_HEDLEY_INTEL_VERSION +#endif +#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && !defined(__ICL) + #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE) +#elif defined(__INTEL_COMPILER) && !defined(__ICL) + #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0) +#endif + +#if defined(JSON_HEDLEY_INTEL_VERSION_CHECK) + #undef JSON_HEDLEY_INTEL_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_INTEL_VERSION) + #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_INTEL_CL_VERSION) + #undef JSON_HEDLEY_INTEL_CL_VERSION +#endif +#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && defined(__ICL) + #define JSON_HEDLEY_INTEL_CL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER, __INTEL_COMPILER_UPDATE, 0) +#endif + +#if defined(JSON_HEDLEY_INTEL_CL_VERSION_CHECK) + #undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_INTEL_CL_VERSION) + #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_CL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_PGI_VERSION) + #undef JSON_HEDLEY_PGI_VERSION +#endif +#if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__) + #define JSON_HEDLEY_PGI_VERSION JSON_HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__) +#endif + +#if defined(JSON_HEDLEY_PGI_VERSION_CHECK) + #undef JSON_HEDLEY_PGI_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_PGI_VERSION) + #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PGI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_SUNPRO_VERSION) + #undef JSON_HEDLEY_SUNPRO_VERSION +#endif +#if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000) + #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_C >> 16) & 0xf) * 10) + ((__SUNPRO_C >> 12) & 0xf), (((__SUNPRO_C >> 8) & 0xf) * 10) + ((__SUNPRO_C >> 4) & 0xf), (__SUNPRO_C & 0xf) * 10) +#elif defined(__SUNPRO_C) + #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, (__SUNPRO_C) & 0xf) +#elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000) + #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_CC >> 16) & 0xf) * 10) + ((__SUNPRO_CC >> 12) & 0xf), (((__SUNPRO_CC >> 8) & 0xf) * 10) + ((__SUNPRO_CC >> 4) & 0xf), (__SUNPRO_CC & 0xf) * 10) +#elif defined(__SUNPRO_CC) + #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_CC >> 8) & 0xf, (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC) & 0xf) +#endif + +#if defined(JSON_HEDLEY_SUNPRO_VERSION_CHECK) + #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_SUNPRO_VERSION) + #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_SUNPRO_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION) + #undef JSON_HEDLEY_EMSCRIPTEN_VERSION +#endif +#if defined(__EMSCRIPTEN__) + #define JSON_HEDLEY_EMSCRIPTEN_VERSION JSON_HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__) +#endif + +#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK) + #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION) + #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_EMSCRIPTEN_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_ARM_VERSION) + #undef JSON_HEDLEY_ARM_VERSION +#endif +#if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION) + #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, (__ARMCOMPILER_VERSION % 1000000) / 10000, (__ARMCOMPILER_VERSION % 10000) / 100) +#elif defined(__CC_ARM) && defined(__ARMCC_VERSION) + #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, (__ARMCC_VERSION % 1000000) / 10000, (__ARMCC_VERSION % 10000) / 100) +#endif + +#if defined(JSON_HEDLEY_ARM_VERSION_CHECK) + #undef JSON_HEDLEY_ARM_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_ARM_VERSION) + #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_ARM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_IBM_VERSION) + #undef JSON_HEDLEY_IBM_VERSION +#endif +#if defined(__ibmxl__) + #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ibmxl_version__, __ibmxl_release__, __ibmxl_modification__) +#elif defined(__xlC__) && defined(__xlC_ver__) + #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff) +#elif defined(__xlC__) + #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0) +#endif + +#if defined(JSON_HEDLEY_IBM_VERSION_CHECK) + #undef JSON_HEDLEY_IBM_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_IBM_VERSION) + #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IBM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_VERSION) + #undef JSON_HEDLEY_TI_VERSION +#endif +#if \ + defined(__TI_COMPILER_VERSION__) && \ + ( \ + defined(__TMS470__) || defined(__TI_ARM__) || \ + defined(__MSP430__) || \ + defined(__TMS320C2000__) \ + ) +#if (__TI_COMPILER_VERSION__ >= 16000000) + #define JSON_HEDLEY_TI_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif +#endif + +#if defined(JSON_HEDLEY_TI_VERSION_CHECK) + #undef JSON_HEDLEY_TI_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_VERSION) + #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_CL2000_VERSION) + #undef JSON_HEDLEY_TI_CL2000_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C2000__) + #define JSON_HEDLEY_TI_CL2000_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_CL2000_VERSION_CHECK) + #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_CL2000_VERSION) + #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL2000_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_CL430_VERSION) + #undef JSON_HEDLEY_TI_CL430_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && defined(__MSP430__) + #define JSON_HEDLEY_TI_CL430_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_CL430_VERSION_CHECK) + #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_CL430_VERSION) + #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL430_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_ARMCL_VERSION) + #undef JSON_HEDLEY_TI_ARMCL_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && (defined(__TMS470__) || defined(__TI_ARM__)) + #define JSON_HEDLEY_TI_ARMCL_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK) + #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_ARMCL_VERSION) + #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_ARMCL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_CL6X_VERSION) + #undef JSON_HEDLEY_TI_CL6X_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C6X__) + #define JSON_HEDLEY_TI_CL6X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_CL6X_VERSION_CHECK) + #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_CL6X_VERSION) + #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL6X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_CL7X_VERSION) + #undef JSON_HEDLEY_TI_CL7X_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && defined(__C7000__) + #define JSON_HEDLEY_TI_CL7X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_CL7X_VERSION_CHECK) + #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_CL7X_VERSION) + #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL7X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_CLPRU_VERSION) + #undef JSON_HEDLEY_TI_CLPRU_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && defined(__PRU__) + #define JSON_HEDLEY_TI_CLPRU_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_CLPRU_VERSION_CHECK) + #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_CLPRU_VERSION) + #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CLPRU_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_CRAY_VERSION) + #undef JSON_HEDLEY_CRAY_VERSION +#endif +#if defined(_CRAYC) + #if defined(_RELEASE_PATCHLEVEL) + #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL) + #else + #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0) + #endif +#endif + +#if defined(JSON_HEDLEY_CRAY_VERSION_CHECK) + #undef JSON_HEDLEY_CRAY_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_CRAY_VERSION) + #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_CRAY_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_IAR_VERSION) + #undef JSON_HEDLEY_IAR_VERSION +#endif +#if defined(__IAR_SYSTEMS_ICC__) + #if __VER__ > 1000 + #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000)) + #else + #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE(__VER__ / 100, __VER__ % 100, 0) + #endif +#endif + +#if defined(JSON_HEDLEY_IAR_VERSION_CHECK) + #undef JSON_HEDLEY_IAR_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_IAR_VERSION) + #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IAR_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TINYC_VERSION) + #undef JSON_HEDLEY_TINYC_VERSION +#endif +#if defined(__TINYC__) + #define JSON_HEDLEY_TINYC_VERSION JSON_HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100) +#endif + +#if defined(JSON_HEDLEY_TINYC_VERSION_CHECK) + #undef JSON_HEDLEY_TINYC_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TINYC_VERSION) + #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TINYC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_DMC_VERSION) + #undef JSON_HEDLEY_DMC_VERSION +#endif +#if defined(__DMC__) + #define JSON_HEDLEY_DMC_VERSION JSON_HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf) +#endif + +#if defined(JSON_HEDLEY_DMC_VERSION_CHECK) + #undef JSON_HEDLEY_DMC_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_DMC_VERSION) + #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_DMC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_COMPCERT_VERSION) + #undef JSON_HEDLEY_COMPCERT_VERSION +#endif +#if defined(__COMPCERT_VERSION__) + #define JSON_HEDLEY_COMPCERT_VERSION JSON_HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, (__COMPCERT_VERSION__ / 100) % 100, __COMPCERT_VERSION__ % 100) +#endif + +#if defined(JSON_HEDLEY_COMPCERT_VERSION_CHECK) + #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_COMPCERT_VERSION) + #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_COMPCERT_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_PELLES_VERSION) + #undef JSON_HEDLEY_PELLES_VERSION +#endif +#if defined(__POCC__) + #define JSON_HEDLEY_PELLES_VERSION JSON_HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0) +#endif + +#if defined(JSON_HEDLEY_PELLES_VERSION_CHECK) + #undef JSON_HEDLEY_PELLES_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_PELLES_VERSION) + #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PELLES_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_MCST_LCC_VERSION) + #undef JSON_HEDLEY_MCST_LCC_VERSION +#endif +#if defined(__LCC__) && defined(__LCC_MINOR__) + #define JSON_HEDLEY_MCST_LCC_VERSION JSON_HEDLEY_VERSION_ENCODE(__LCC__ / 100, __LCC__ % 100, __LCC_MINOR__) +#endif + +#if defined(JSON_HEDLEY_MCST_LCC_VERSION_CHECK) + #undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_MCST_LCC_VERSION) + #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_MCST_LCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_GCC_VERSION) + #undef JSON_HEDLEY_GCC_VERSION +#endif +#if \ + defined(JSON_HEDLEY_GNUC_VERSION) && \ + !defined(__clang__) && \ + !defined(JSON_HEDLEY_INTEL_VERSION) && \ + !defined(JSON_HEDLEY_PGI_VERSION) && \ + !defined(JSON_HEDLEY_ARM_VERSION) && \ + !defined(JSON_HEDLEY_CRAY_VERSION) && \ + !defined(JSON_HEDLEY_TI_VERSION) && \ + !defined(JSON_HEDLEY_TI_ARMCL_VERSION) && \ + !defined(JSON_HEDLEY_TI_CL430_VERSION) && \ + !defined(JSON_HEDLEY_TI_CL2000_VERSION) && \ + !defined(JSON_HEDLEY_TI_CL6X_VERSION) && \ + !defined(JSON_HEDLEY_TI_CL7X_VERSION) && \ + !defined(JSON_HEDLEY_TI_CLPRU_VERSION) && \ + !defined(__COMPCERT__) && \ + !defined(JSON_HEDLEY_MCST_LCC_VERSION) + #define JSON_HEDLEY_GCC_VERSION JSON_HEDLEY_GNUC_VERSION +#endif + +#if defined(JSON_HEDLEY_GCC_VERSION_CHECK) + #undef JSON_HEDLEY_GCC_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_GCC_VERSION) + #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_HAS_ATTRIBUTE) + #undef JSON_HEDLEY_HAS_ATTRIBUTE +#endif +#if \ + defined(__has_attribute) && \ + ( \ + (!defined(JSON_HEDLEY_IAR_VERSION) || JSON_HEDLEY_IAR_VERSION_CHECK(8,5,9)) \ + ) +# define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute) +#else +# define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_ATTRIBUTE) + #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE +#endif +#if defined(__has_attribute) + #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute) +#else + #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_ATTRIBUTE) + #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE +#endif +#if defined(__has_attribute) + #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute) +#else + #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE) + #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE +#endif +#if \ + defined(__has_cpp_attribute) && \ + defined(__cplusplus) && \ + (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) + #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute) +#else + #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0) +#endif + +#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS) + #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS +#endif +#if !defined(__cplusplus) || !defined(__has_cpp_attribute) + #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0) +#elif \ + !defined(JSON_HEDLEY_PGI_VERSION) && \ + !defined(JSON_HEDLEY_IAR_VERSION) && \ + (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) && \ + (!defined(JSON_HEDLEY_MSVC_VERSION) || JSON_HEDLEY_MSVC_VERSION_CHECK(19,20,0)) + #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute) +#else + #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE) + #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE +#endif +#if defined(__has_cpp_attribute) && defined(__cplusplus) + #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute) +#else + #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE) + #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE +#endif +#if defined(__has_cpp_attribute) && defined(__cplusplus) + #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute) +#else + #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_BUILTIN) + #undef JSON_HEDLEY_HAS_BUILTIN +#endif +#if defined(__has_builtin) + #define JSON_HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin) +#else + #define JSON_HEDLEY_HAS_BUILTIN(builtin) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_BUILTIN) + #undef JSON_HEDLEY_GNUC_HAS_BUILTIN +#endif +#if defined(__has_builtin) + #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin) +#else + #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_BUILTIN) + #undef JSON_HEDLEY_GCC_HAS_BUILTIN +#endif +#if defined(__has_builtin) + #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin) +#else + #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_FEATURE) + #undef JSON_HEDLEY_HAS_FEATURE +#endif +#if defined(__has_feature) + #define JSON_HEDLEY_HAS_FEATURE(feature) __has_feature(feature) +#else + #define JSON_HEDLEY_HAS_FEATURE(feature) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_FEATURE) + #undef JSON_HEDLEY_GNUC_HAS_FEATURE +#endif +#if defined(__has_feature) + #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature) +#else + #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_FEATURE) + #undef JSON_HEDLEY_GCC_HAS_FEATURE +#endif +#if defined(__has_feature) + #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature) +#else + #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_EXTENSION) + #undef JSON_HEDLEY_HAS_EXTENSION +#endif +#if defined(__has_extension) + #define JSON_HEDLEY_HAS_EXTENSION(extension) __has_extension(extension) +#else + #define JSON_HEDLEY_HAS_EXTENSION(extension) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_EXTENSION) + #undef JSON_HEDLEY_GNUC_HAS_EXTENSION +#endif +#if defined(__has_extension) + #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension) +#else + #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_EXTENSION) + #undef JSON_HEDLEY_GCC_HAS_EXTENSION +#endif +#if defined(__has_extension) + #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension) +#else + #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE) + #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE +#endif +#if defined(__has_declspec_attribute) + #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute) +#else + #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE) + #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE +#endif +#if defined(__has_declspec_attribute) + #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute) +#else + #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE) + #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE +#endif +#if defined(__has_declspec_attribute) + #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute) +#else + #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_WARNING) + #undef JSON_HEDLEY_HAS_WARNING +#endif +#if defined(__has_warning) + #define JSON_HEDLEY_HAS_WARNING(warning) __has_warning(warning) +#else + #define JSON_HEDLEY_HAS_WARNING(warning) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_WARNING) + #undef JSON_HEDLEY_GNUC_HAS_WARNING +#endif +#if defined(__has_warning) + #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning) +#else + #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_WARNING) + #undef JSON_HEDLEY_GCC_HAS_WARNING +#endif +#if defined(__has_warning) + #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning) +#else + #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if \ + (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \ + defined(__clang__) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,0,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) || \ + JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,17) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(8,0,0) || \ + (JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) && defined(__C99_PRAGMA_OPERATOR)) + #define JSON_HEDLEY_PRAGMA(value) _Pragma(#value) +#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) + #define JSON_HEDLEY_PRAGMA(value) __pragma(value) +#else + #define JSON_HEDLEY_PRAGMA(value) +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_PUSH) + #undef JSON_HEDLEY_DIAGNOSTIC_PUSH +#endif +#if defined(JSON_HEDLEY_DIAGNOSTIC_POP) + #undef JSON_HEDLEY_DIAGNOSTIC_POP +#endif +#if defined(__clang__) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("clang diagnostic pop") +#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop") +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push)) + #define JSON_HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop)) +#elif JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("push") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("pop") +#elif \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,4,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("diag_push") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("diag_pop") +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)") +#else + #define JSON_HEDLEY_DIAGNOSTIC_PUSH + #define JSON_HEDLEY_DIAGNOSTIC_POP +#endif + +/* JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ is for + HEDLEY INTERNAL USE ONLY. API subject to change without notice. */ +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ +#endif +#if defined(__cplusplus) +# if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat") +# if JSON_HEDLEY_HAS_WARNING("-Wc++17-extensions") +# if JSON_HEDLEY_HAS_WARNING("-Wc++1z-extensions") +# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \ + _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \ + _Pragma("clang diagnostic ignored \"-Wc++1z-extensions\"") \ + xpr \ + JSON_HEDLEY_DIAGNOSTIC_POP +# else +# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \ + _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \ + xpr \ + JSON_HEDLEY_DIAGNOSTIC_POP +# endif +# else +# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \ + xpr \ + JSON_HEDLEY_DIAGNOSTIC_POP +# endif +# endif +#endif +#if !defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x +#endif + +#if defined(JSON_HEDLEY_CONST_CAST) + #undef JSON_HEDLEY_CONST_CAST +#endif +#if defined(__cplusplus) +# define JSON_HEDLEY_CONST_CAST(T, expr) (const_cast(expr)) +#elif \ + JSON_HEDLEY_HAS_WARNING("-Wcast-qual") || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) +# define JSON_HEDLEY_CONST_CAST(T, expr) (__extension__ ({ \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \ + ((T) (expr)); \ + JSON_HEDLEY_DIAGNOSTIC_POP \ + })) +#else +# define JSON_HEDLEY_CONST_CAST(T, expr) ((T) (expr)) +#endif + +#if defined(JSON_HEDLEY_REINTERPRET_CAST) + #undef JSON_HEDLEY_REINTERPRET_CAST +#endif +#if defined(__cplusplus) + #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast(expr)) +#else + #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) ((T) (expr)) +#endif + +#if defined(JSON_HEDLEY_STATIC_CAST) + #undef JSON_HEDLEY_STATIC_CAST +#endif +#if defined(__cplusplus) + #define JSON_HEDLEY_STATIC_CAST(T, expr) (static_cast(expr)) +#else + #define JSON_HEDLEY_STATIC_CAST(T, expr) ((T) (expr)) +#endif + +#if defined(JSON_HEDLEY_CPP_CAST) + #undef JSON_HEDLEY_CPP_CAST +#endif +#if defined(__cplusplus) +# if JSON_HEDLEY_HAS_WARNING("-Wold-style-cast") +# define JSON_HEDLEY_CPP_CAST(T, expr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wold-style-cast\"") \ + ((T) (expr)) \ + JSON_HEDLEY_DIAGNOSTIC_POP +# elif JSON_HEDLEY_IAR_VERSION_CHECK(8,3,0) +# define JSON_HEDLEY_CPP_CAST(T, expr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("diag_suppress=Pe137") \ + JSON_HEDLEY_DIAGNOSTIC_POP +# else +# define JSON_HEDLEY_CPP_CAST(T, expr) ((T) (expr)) +# endif +#else +# define JSON_HEDLEY_CPP_CAST(T, expr) (expr) +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wdeprecated-declarations") + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"") +#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warning(disable:1478 1786)") +#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:1478 1786)) +#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1216,1444,1445") +#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") +#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:4996)) +#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444") +#elif \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1291,1718") +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && !defined(__cplusplus) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)") +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && defined(__cplusplus) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,symdeprecated,symdeprecated2)") +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress=Pe1444,Pe1215") +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warn(disable:2241)") +#else + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas") + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"") +#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("warning(disable:161)") +#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:161)) +#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 1675") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("GCC diagnostic ignored \"-Wunknown-pragmas\"") +#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:4068)) +#elif \ + JSON_HEDLEY_TI_VERSION_CHECK(16,9,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163") +#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163") +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress=Pe161") +#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 161") +#else + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wunknown-attributes") + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("clang diagnostic ignored \"-Wunknown-attributes\"") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") +#elif JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("warning(disable:1292)") +#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:1292)) +#elif JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:5030)) +#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097,1098") +#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097") +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("error_messages(off,attrskipunsup)") +#elif \ + JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1173") +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress=Pe1097") +#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097") +#else + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wcast-qual") + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("clang diagnostic ignored \"-Wcast-qual\"") +#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("warning(disable:2203 2331)") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("GCC diagnostic ignored \"-Wcast-qual\"") +#else + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wunused-function") + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("clang diagnostic ignored \"-Wunused-function\"") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("GCC diagnostic ignored \"-Wunused-function\"") +#elif JSON_HEDLEY_MSVC_VERSION_CHECK(1,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION __pragma(warning(disable:4505)) +#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("diag_suppress 3142") +#else + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION +#endif + +#if defined(JSON_HEDLEY_DEPRECATED) + #undef JSON_HEDLEY_DEPRECATED +#endif +#if defined(JSON_HEDLEY_DEPRECATED_FOR) + #undef JSON_HEDLEY_DEPRECATED_FOR +#endif +#if \ + JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated("Since " # since)) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated("Since " #since "; use " #replacement)) +#elif \ + (JSON_HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) && !defined(JSON_HEDLEY_IAR_VERSION)) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(18,1,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__("Since " #since))) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__("Since " #since "; use " #replacement))) +#elif defined(__cplusplus) && (__cplusplus >= 201402L) + #define JSON_HEDLEY_DEPRECATED(since) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since)]]) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since "; use " #replacement)]]) +#elif \ + JSON_HEDLEY_HAS_ATTRIBUTE(deprecated) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) + #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__)) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__)) +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ + JSON_HEDLEY_PELLES_VERSION_CHECK(6,50,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated) +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_DEPRECATED(since) _Pragma("deprecated") + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma("deprecated") +#else + #define JSON_HEDLEY_DEPRECATED(since) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) +#endif + +#if defined(JSON_HEDLEY_UNAVAILABLE) + #undef JSON_HEDLEY_UNAVAILABLE +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(warning) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_UNAVAILABLE(available_since) __attribute__((__warning__("Not available until " #available_since))) +#else + #define JSON_HEDLEY_UNAVAILABLE(available_since) +#endif + +#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT) + #undef JSON_HEDLEY_WARN_UNUSED_RESULT +#endif +#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT_MSG) + #undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(warn_unused_result) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__)) + #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) __attribute__((__warn_unused_result__)) +#elif (JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L) + #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]]) + #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard(msg)]]) +#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) + #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]]) + #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]]) +#elif defined(_Check_return_) /* SAL */ + #define JSON_HEDLEY_WARN_UNUSED_RESULT _Check_return_ + #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) _Check_return_ +#else + #define JSON_HEDLEY_WARN_UNUSED_RESULT + #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) +#endif + +#if defined(JSON_HEDLEY_SENTINEL) + #undef JSON_HEDLEY_SENTINEL +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(sentinel) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position))) +#else + #define JSON_HEDLEY_SENTINEL(position) +#endif + +#if defined(JSON_HEDLEY_NO_RETURN) + #undef JSON_HEDLEY_NO_RETURN +#endif +#if JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_NO_RETURN __noreturn +#elif \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__)) +#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L + #define JSON_HEDLEY_NO_RETURN _Noreturn +#elif defined(__cplusplus) && (__cplusplus >= 201103L) + #define JSON_HEDLEY_NO_RETURN JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[noreturn]]) +#elif \ + JSON_HEDLEY_HAS_ATTRIBUTE(noreturn) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,2,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) + #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__)) +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) + #define JSON_HEDLEY_NO_RETURN _Pragma("does_not_return") +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_NO_RETURN __declspec(noreturn) +#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus) + #define JSON_HEDLEY_NO_RETURN _Pragma("FUNC_NEVER_RETURNS;") +#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0) + #define JSON_HEDLEY_NO_RETURN __attribute((noreturn)) +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0) + #define JSON_HEDLEY_NO_RETURN __declspec(noreturn) +#else + #define JSON_HEDLEY_NO_RETURN +#endif + +#if defined(JSON_HEDLEY_NO_ESCAPE) + #undef JSON_HEDLEY_NO_ESCAPE +#endif +#if JSON_HEDLEY_HAS_ATTRIBUTE(noescape) + #define JSON_HEDLEY_NO_ESCAPE __attribute__((__noescape__)) +#else + #define JSON_HEDLEY_NO_ESCAPE +#endif + +#if defined(JSON_HEDLEY_UNREACHABLE) + #undef JSON_HEDLEY_UNREACHABLE +#endif +#if defined(JSON_HEDLEY_UNREACHABLE_RETURN) + #undef JSON_HEDLEY_UNREACHABLE_RETURN +#endif +#if defined(JSON_HEDLEY_ASSUME) + #undef JSON_HEDLEY_ASSUME +#endif +#if \ + JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_ASSUME(expr) __assume(expr) +#elif JSON_HEDLEY_HAS_BUILTIN(__builtin_assume) + #define JSON_HEDLEY_ASSUME(expr) __builtin_assume(expr) +#elif \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) + #if defined(__cplusplus) + #define JSON_HEDLEY_ASSUME(expr) std::_nassert(expr) + #else + #define JSON_HEDLEY_ASSUME(expr) _nassert(expr) + #endif +#endif +#if \ + (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && (!defined(JSON_HEDLEY_ARM_VERSION))) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(18,10,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(13,1,5) || \ + JSON_HEDLEY_CRAY_VERSION_CHECK(10,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_UNREACHABLE() __builtin_unreachable() +#elif defined(JSON_HEDLEY_ASSUME) + #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0) +#endif +#if !defined(JSON_HEDLEY_ASSUME) + #if defined(JSON_HEDLEY_UNREACHABLE) + #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, ((expr) ? 1 : (JSON_HEDLEY_UNREACHABLE(), 1))) + #else + #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, expr) + #endif +#endif +#if defined(JSON_HEDLEY_UNREACHABLE) + #if \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) + #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (JSON_HEDLEY_STATIC_CAST(void, JSON_HEDLEY_ASSUME(0)), (value)) + #else + #define JSON_HEDLEY_UNREACHABLE_RETURN(value) JSON_HEDLEY_UNREACHABLE() + #endif +#else + #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (value) +#endif +#if !defined(JSON_HEDLEY_UNREACHABLE) + #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0) +#endif + +JSON_HEDLEY_DIAGNOSTIC_PUSH +#if JSON_HEDLEY_HAS_WARNING("-Wpedantic") + #pragma clang diagnostic ignored "-Wpedantic" +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") && defined(__cplusplus) + #pragma clang diagnostic ignored "-Wc++98-compat-pedantic" +#endif +#if JSON_HEDLEY_GCC_HAS_WARNING("-Wvariadic-macros",4,0,0) + #if defined(__clang__) + #pragma clang diagnostic ignored "-Wvariadic-macros" + #elif defined(JSON_HEDLEY_GCC_VERSION) + #pragma GCC diagnostic ignored "-Wvariadic-macros" + #endif +#endif +#if defined(JSON_HEDLEY_NON_NULL) + #undef JSON_HEDLEY_NON_NULL +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(nonnull) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) + #define JSON_HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__))) +#else + #define JSON_HEDLEY_NON_NULL(...) +#endif +JSON_HEDLEY_DIAGNOSTIC_POP + +#if defined(JSON_HEDLEY_PRINTF_FORMAT) + #undef JSON_HEDLEY_PRINTF_FORMAT +#endif +#if defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && !defined(__USE_MINGW_ANSI_STDIO) + #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(ms_printf, string_idx, first_to_check))) +#elif defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && defined(__USE_MINGW_ANSI_STDIO) + #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(gnu_printf, string_idx, first_to_check))) +#elif \ + JSON_HEDLEY_HAS_ATTRIBUTE(format) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(__printf__, string_idx, first_to_check))) +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(6,0,0) + #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __declspec(vaformat(printf,string_idx,first_to_check)) +#else + #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) +#endif + +#if defined(JSON_HEDLEY_CONSTEXPR) + #undef JSON_HEDLEY_CONSTEXPR +#endif +#if defined(__cplusplus) + #if __cplusplus >= 201103L + #define JSON_HEDLEY_CONSTEXPR JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr) + #endif +#endif +#if !defined(JSON_HEDLEY_CONSTEXPR) + #define JSON_HEDLEY_CONSTEXPR +#endif + +#if defined(JSON_HEDLEY_PREDICT) + #undef JSON_HEDLEY_PREDICT +#endif +#if defined(JSON_HEDLEY_LIKELY) + #undef JSON_HEDLEY_LIKELY +#endif +#if defined(JSON_HEDLEY_UNLIKELY) + #undef JSON_HEDLEY_UNLIKELY +#endif +#if defined(JSON_HEDLEY_UNPREDICTABLE) + #undef JSON_HEDLEY_UNPREDICTABLE +#endif +#if JSON_HEDLEY_HAS_BUILTIN(__builtin_unpredictable) + #define JSON_HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable((expr)) +#endif +#if \ + (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) && !defined(JSON_HEDLEY_PGI_VERSION)) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(9,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) +# define JSON_HEDLEY_PREDICT(expr, value, probability) __builtin_expect_with_probability( (expr), (value), (probability)) +# define JSON_HEDLEY_PREDICT_TRUE(expr, probability) __builtin_expect_with_probability(!!(expr), 1 , (probability)) +# define JSON_HEDLEY_PREDICT_FALSE(expr, probability) __builtin_expect_with_probability(!!(expr), 0 , (probability)) +# define JSON_HEDLEY_LIKELY(expr) __builtin_expect (!!(expr), 1 ) +# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) +#elif \ + (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,27) || \ + JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) +# define JSON_HEDLEY_PREDICT(expr, expected, probability) \ + (((probability) >= 0.9) ? __builtin_expect((expr), (expected)) : (JSON_HEDLEY_STATIC_CAST(void, expected), (expr))) +# define JSON_HEDLEY_PREDICT_TRUE(expr, probability) \ + (__extension__ ({ \ + double hedley_probability_ = (probability); \ + ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 1) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) : !!(expr))); \ + })) +# define JSON_HEDLEY_PREDICT_FALSE(expr, probability) \ + (__extension__ ({ \ + double hedley_probability_ = (probability); \ + ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 0) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) : !!(expr))); \ + })) +# define JSON_HEDLEY_LIKELY(expr) __builtin_expect(!!(expr), 1) +# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0) +#else +# define JSON_HEDLEY_PREDICT(expr, expected, probability) (JSON_HEDLEY_STATIC_CAST(void, expected), (expr)) +# define JSON_HEDLEY_PREDICT_TRUE(expr, probability) (!!(expr)) +# define JSON_HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr)) +# define JSON_HEDLEY_LIKELY(expr) (!!(expr)) +# define JSON_HEDLEY_UNLIKELY(expr) (!!(expr)) +#endif +#if !defined(JSON_HEDLEY_UNPREDICTABLE) + #define JSON_HEDLEY_UNPREDICTABLE(expr) JSON_HEDLEY_PREDICT(expr, 1, 0.5) +#endif + +#if defined(JSON_HEDLEY_MALLOC) + #undef JSON_HEDLEY_MALLOC +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(malloc) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_MALLOC __attribute__((__malloc__)) +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) + #define JSON_HEDLEY_MALLOC _Pragma("returns_new_memory") +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_MALLOC __declspec(restrict) +#else + #define JSON_HEDLEY_MALLOC +#endif + +#if defined(JSON_HEDLEY_PURE) + #undef JSON_HEDLEY_PURE +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(pure) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(2,96,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) +# define JSON_HEDLEY_PURE __attribute__((__pure__)) +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) +# define JSON_HEDLEY_PURE _Pragma("does_not_write_global_data") +#elif defined(__cplusplus) && \ + ( \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) \ + ) +# define JSON_HEDLEY_PURE _Pragma("FUNC_IS_PURE;") +#else +# define JSON_HEDLEY_PURE +#endif + +#if defined(JSON_HEDLEY_CONST) + #undef JSON_HEDLEY_CONST +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(const) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(2,5,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_CONST __attribute__((__const__)) +#elif \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) + #define JSON_HEDLEY_CONST _Pragma("no_side_effect") +#else + #define JSON_HEDLEY_CONST JSON_HEDLEY_PURE +#endif + +#if defined(JSON_HEDLEY_RESTRICT) + #undef JSON_HEDLEY_RESTRICT +#endif +#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus) + #define JSON_HEDLEY_RESTRICT restrict +#elif \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,4) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \ + defined(__clang__) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_RESTRICT __restrict +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,3,0) && !defined(__cplusplus) + #define JSON_HEDLEY_RESTRICT _Restrict +#else + #define JSON_HEDLEY_RESTRICT +#endif + +#if defined(JSON_HEDLEY_INLINE) + #undef JSON_HEDLEY_INLINE +#endif +#if \ + (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \ + (defined(__cplusplus) && (__cplusplus >= 199711L)) + #define JSON_HEDLEY_INLINE inline +#elif \ + defined(JSON_HEDLEY_GCC_VERSION) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(6,2,0) + #define JSON_HEDLEY_INLINE __inline__ +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,1,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_INLINE __inline +#else + #define JSON_HEDLEY_INLINE +#endif + +#if defined(JSON_HEDLEY_ALWAYS_INLINE) + #undef JSON_HEDLEY_ALWAYS_INLINE +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(always_inline) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) +# define JSON_HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__)) JSON_HEDLEY_INLINE +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) +# define JSON_HEDLEY_ALWAYS_INLINE __forceinline +#elif defined(__cplusplus) && \ + ( \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) \ + ) +# define JSON_HEDLEY_ALWAYS_INLINE _Pragma("FUNC_ALWAYS_INLINE;") +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) +# define JSON_HEDLEY_ALWAYS_INLINE _Pragma("inline=forced") +#else +# define JSON_HEDLEY_ALWAYS_INLINE JSON_HEDLEY_INLINE +#endif + +#if defined(JSON_HEDLEY_NEVER_INLINE) + #undef JSON_HEDLEY_NEVER_INLINE +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(noinline) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) + #define JSON_HEDLEY_NEVER_INLINE __attribute__((__noinline__)) +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline) +#elif JSON_HEDLEY_PGI_VERSION_CHECK(10,2,0) + #define JSON_HEDLEY_NEVER_INLINE _Pragma("noinline") +#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus) + #define JSON_HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;") +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_NEVER_INLINE _Pragma("inline=never") +#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0) + #define JSON_HEDLEY_NEVER_INLINE __attribute((noinline)) +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0) + #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline) +#else + #define JSON_HEDLEY_NEVER_INLINE +#endif + +#if defined(JSON_HEDLEY_PRIVATE) + #undef JSON_HEDLEY_PRIVATE +#endif +#if defined(JSON_HEDLEY_PUBLIC) + #undef JSON_HEDLEY_PUBLIC +#endif +#if defined(JSON_HEDLEY_IMPORT) + #undef JSON_HEDLEY_IMPORT +#endif +#if defined(_WIN32) || defined(__CYGWIN__) +# define JSON_HEDLEY_PRIVATE +# define JSON_HEDLEY_PUBLIC __declspec(dllexport) +# define JSON_HEDLEY_IMPORT __declspec(dllimport) +#else +# if \ + JSON_HEDLEY_HAS_ATTRIBUTE(visibility) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \ + ( \ + defined(__TI_EABI__) && \ + ( \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) \ + ) \ + ) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) +# define JSON_HEDLEY_PRIVATE __attribute__((__visibility__("hidden"))) +# define JSON_HEDLEY_PUBLIC __attribute__((__visibility__("default"))) +# else +# define JSON_HEDLEY_PRIVATE +# define JSON_HEDLEY_PUBLIC +# endif +# define JSON_HEDLEY_IMPORT extern +#endif + +#if defined(JSON_HEDLEY_NO_THROW) + #undef JSON_HEDLEY_NO_THROW +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(nothrow) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_NO_THROW __attribute__((__nothrow__)) +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(13,1,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) + #define JSON_HEDLEY_NO_THROW __declspec(nothrow) +#else + #define JSON_HEDLEY_NO_THROW +#endif + +#if defined(JSON_HEDLEY_FALL_THROUGH) + #undef JSON_HEDLEY_FALL_THROUGH +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(fallthrough) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(7,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_FALL_THROUGH __attribute__((__fallthrough__)) +#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(clang,fallthrough) + #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[clang::fallthrough]]) +#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough) + #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[fallthrough]]) +#elif defined(__fallthrough) /* SAL */ + #define JSON_HEDLEY_FALL_THROUGH __fallthrough +#else + #define JSON_HEDLEY_FALL_THROUGH +#endif + +#if defined(JSON_HEDLEY_RETURNS_NON_NULL) + #undef JSON_HEDLEY_RETURNS_NON_NULL +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(returns_nonnull) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__)) +#elif defined(_Ret_notnull_) /* SAL */ + #define JSON_HEDLEY_RETURNS_NON_NULL _Ret_notnull_ +#else + #define JSON_HEDLEY_RETURNS_NON_NULL +#endif + +#if defined(JSON_HEDLEY_ARRAY_PARAM) + #undef JSON_HEDLEY_ARRAY_PARAM +#endif +#if \ + defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \ + !defined(__STDC_NO_VLA__) && \ + !defined(__cplusplus) && \ + !defined(JSON_HEDLEY_PGI_VERSION) && \ + !defined(JSON_HEDLEY_TINYC_VERSION) + #define JSON_HEDLEY_ARRAY_PARAM(name) (name) +#else + #define JSON_HEDLEY_ARRAY_PARAM(name) +#endif + +#if defined(JSON_HEDLEY_IS_CONSTANT) + #undef JSON_HEDLEY_IS_CONSTANT +#endif +#if defined(JSON_HEDLEY_REQUIRE_CONSTEXPR) + #undef JSON_HEDLEY_REQUIRE_CONSTEXPR +#endif +/* JSON_HEDLEY_IS_CONSTEXPR_ is for + HEDLEY INTERNAL USE ONLY. API subject to change without notice. */ +#if defined(JSON_HEDLEY_IS_CONSTEXPR_) + #undef JSON_HEDLEY_IS_CONSTEXPR_ +#endif +#if \ + JSON_HEDLEY_HAS_BUILTIN(__builtin_constant_p) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,19) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \ + (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) && !defined(__cplusplus)) || \ + JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr) +#endif +#if !defined(__cplusplus) +# if \ + JSON_HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \ + JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \ + JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,24) +#if defined(__INTPTR_TYPE__) + #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0)), int*) +#else + #include + #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((intptr_t) ((expr) * 0)) : (int*) 0)), int*) +#endif +# elif \ + ( \ + defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && \ + !defined(JSON_HEDLEY_SUNPRO_VERSION) && \ + !defined(JSON_HEDLEY_PGI_VERSION) && \ + !defined(JSON_HEDLEY_IAR_VERSION)) || \ + (JSON_HEDLEY_HAS_EXTENSION(c_generic_selections) && !defined(JSON_HEDLEY_IAR_VERSION)) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(5,3,0) +#if defined(__INTPTR_TYPE__) + #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0), int*: 1, void*: 0) +#else + #include + #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((intptr_t) * 0) : (int*) 0), int*: 1, void*: 0) +#endif +# elif \ + defined(JSON_HEDLEY_GCC_VERSION) || \ + defined(JSON_HEDLEY_INTEL_VERSION) || \ + defined(JSON_HEDLEY_TINYC_VERSION) || \ + defined(JSON_HEDLEY_TI_ARMCL_VERSION) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(18,12,0) || \ + defined(JSON_HEDLEY_TI_CL2000_VERSION) || \ + defined(JSON_HEDLEY_TI_CL6X_VERSION) || \ + defined(JSON_HEDLEY_TI_CL7X_VERSION) || \ + defined(JSON_HEDLEY_TI_CLPRU_VERSION) || \ + defined(__clang__) +# define JSON_HEDLEY_IS_CONSTEXPR_(expr) ( \ + sizeof(void) != \ + sizeof(*( \ + 1 ? \ + ((void*) ((expr) * 0L) ) : \ +((struct { char v[sizeof(void) * 2]; } *) 1) \ + ) \ + ) \ + ) +# endif +#endif +#if defined(JSON_HEDLEY_IS_CONSTEXPR_) + #if !defined(JSON_HEDLEY_IS_CONSTANT) + #define JSON_HEDLEY_IS_CONSTANT(expr) JSON_HEDLEY_IS_CONSTEXPR_(expr) + #endif + #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (JSON_HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1)) +#else + #if !defined(JSON_HEDLEY_IS_CONSTANT) + #define JSON_HEDLEY_IS_CONSTANT(expr) (0) + #endif + #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (expr) +#endif + +#if defined(JSON_HEDLEY_BEGIN_C_DECLS) + #undef JSON_HEDLEY_BEGIN_C_DECLS +#endif +#if defined(JSON_HEDLEY_END_C_DECLS) + #undef JSON_HEDLEY_END_C_DECLS +#endif +#if defined(JSON_HEDLEY_C_DECL) + #undef JSON_HEDLEY_C_DECL +#endif +#if defined(__cplusplus) + #define JSON_HEDLEY_BEGIN_C_DECLS extern "C" { + #define JSON_HEDLEY_END_C_DECLS } + #define JSON_HEDLEY_C_DECL extern "C" +#else + #define JSON_HEDLEY_BEGIN_C_DECLS + #define JSON_HEDLEY_END_C_DECLS + #define JSON_HEDLEY_C_DECL +#endif + +#if defined(JSON_HEDLEY_STATIC_ASSERT) + #undef JSON_HEDLEY_STATIC_ASSERT +#endif +#if \ + !defined(__cplusplus) && ( \ + (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \ + (JSON_HEDLEY_HAS_FEATURE(c_static_assert) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(6,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + defined(_Static_assert) \ + ) +# define JSON_HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message) +#elif \ + (defined(__cplusplus) && (__cplusplus >= 201103L)) || \ + JSON_HEDLEY_MSVC_VERSION_CHECK(16,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) +# define JSON_HEDLEY_STATIC_ASSERT(expr, message) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(static_assert(expr, message)) +#else +# define JSON_HEDLEY_STATIC_ASSERT(expr, message) +#endif + +#if defined(JSON_HEDLEY_NULL) + #undef JSON_HEDLEY_NULL +#endif +#if defined(__cplusplus) + #if __cplusplus >= 201103L + #define JSON_HEDLEY_NULL JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr) + #elif defined(NULL) + #define JSON_HEDLEY_NULL NULL + #else + #define JSON_HEDLEY_NULL JSON_HEDLEY_STATIC_CAST(void*, 0) + #endif +#elif defined(NULL) + #define JSON_HEDLEY_NULL NULL +#else + #define JSON_HEDLEY_NULL ((void*) 0) +#endif + +#if defined(JSON_HEDLEY_MESSAGE) + #undef JSON_HEDLEY_MESSAGE +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas") +# define JSON_HEDLEY_MESSAGE(msg) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \ + JSON_HEDLEY_PRAGMA(message msg) \ + JSON_HEDLEY_DIAGNOSTIC_POP +#elif \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,4,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) +# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message msg) +#elif JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) +# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(_CRI message msg) +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) +# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg)) +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,0,0) +# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg)) +#else +# define JSON_HEDLEY_MESSAGE(msg) +#endif + +#if defined(JSON_HEDLEY_WARNING) + #undef JSON_HEDLEY_WARNING +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas") +# define JSON_HEDLEY_WARNING(msg) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \ + JSON_HEDLEY_PRAGMA(clang warning msg) \ + JSON_HEDLEY_DIAGNOSTIC_POP +#elif \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,8,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) +# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(GCC warning msg) +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) +# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(message(msg)) +#else +# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_MESSAGE(msg) +#endif + +#if defined(JSON_HEDLEY_REQUIRE) + #undef JSON_HEDLEY_REQUIRE +#endif +#if defined(JSON_HEDLEY_REQUIRE_MSG) + #undef JSON_HEDLEY_REQUIRE_MSG +#endif +#if JSON_HEDLEY_HAS_ATTRIBUTE(diagnose_if) +# if JSON_HEDLEY_HAS_WARNING("-Wgcc-compat") +# define JSON_HEDLEY_REQUIRE(expr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \ + __attribute__((diagnose_if(!(expr), #expr, "error"))) \ + JSON_HEDLEY_DIAGNOSTIC_POP +# define JSON_HEDLEY_REQUIRE_MSG(expr,msg) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \ + __attribute__((diagnose_if(!(expr), msg, "error"))) \ + JSON_HEDLEY_DIAGNOSTIC_POP +# else +# define JSON_HEDLEY_REQUIRE(expr) __attribute__((diagnose_if(!(expr), #expr, "error"))) +# define JSON_HEDLEY_REQUIRE_MSG(expr,msg) __attribute__((diagnose_if(!(expr), msg, "error"))) +# endif +#else +# define JSON_HEDLEY_REQUIRE(expr) +# define JSON_HEDLEY_REQUIRE_MSG(expr,msg) +#endif + +#if defined(JSON_HEDLEY_FLAGS) + #undef JSON_HEDLEY_FLAGS +#endif +#if JSON_HEDLEY_HAS_ATTRIBUTE(flag_enum) && (!defined(__cplusplus) || JSON_HEDLEY_HAS_WARNING("-Wbitfield-enum-conversion")) + #define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__)) +#else + #define JSON_HEDLEY_FLAGS +#endif + +#if defined(JSON_HEDLEY_FLAGS_CAST) + #undef JSON_HEDLEY_FLAGS_CAST +#endif +#if JSON_HEDLEY_INTEL_VERSION_CHECK(19,0,0) +# define JSON_HEDLEY_FLAGS_CAST(T, expr) (__extension__ ({ \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("warning(disable:188)") \ + ((T) (expr)); \ + JSON_HEDLEY_DIAGNOSTIC_POP \ + })) +#else +# define JSON_HEDLEY_FLAGS_CAST(T, expr) JSON_HEDLEY_STATIC_CAST(T, expr) +#endif + +#if defined(JSON_HEDLEY_EMPTY_BASES) + #undef JSON_HEDLEY_EMPTY_BASES +#endif +#if \ + (JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,23918) && !JSON_HEDLEY_MSVC_VERSION_CHECK(20,0,0)) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_EMPTY_BASES __declspec(empty_bases) +#else + #define JSON_HEDLEY_EMPTY_BASES +#endif + +/* Remaining macros are deprecated. */ + +#if defined(JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK) + #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK +#endif +#if defined(__clang__) + #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) (0) +#else + #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_CLANG_HAS_ATTRIBUTE) + #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE +#endif +#define JSON_HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_ATTRIBUTE(attribute) + +#if defined(JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE) + #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE +#endif +#define JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) + +#if defined(JSON_HEDLEY_CLANG_HAS_BUILTIN) + #undef JSON_HEDLEY_CLANG_HAS_BUILTIN +#endif +#define JSON_HEDLEY_CLANG_HAS_BUILTIN(builtin) JSON_HEDLEY_HAS_BUILTIN(builtin) + +#if defined(JSON_HEDLEY_CLANG_HAS_FEATURE) + #undef JSON_HEDLEY_CLANG_HAS_FEATURE +#endif +#define JSON_HEDLEY_CLANG_HAS_FEATURE(feature) JSON_HEDLEY_HAS_FEATURE(feature) + +#if defined(JSON_HEDLEY_CLANG_HAS_EXTENSION) + #undef JSON_HEDLEY_CLANG_HAS_EXTENSION +#endif +#define JSON_HEDLEY_CLANG_HAS_EXTENSION(extension) JSON_HEDLEY_HAS_EXTENSION(extension) + +#if defined(JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE) + #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE +#endif +#define JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) + +#if defined(JSON_HEDLEY_CLANG_HAS_WARNING) + #undef JSON_HEDLEY_CLANG_HAS_WARNING +#endif +#define JSON_HEDLEY_CLANG_HAS_WARNING(warning) JSON_HEDLEY_HAS_WARNING(warning) + +#endif /* !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < X) */ + + +// This file contains all internal macro definitions (except those affecting ABI) +// You MUST include macro_unscope.hpp at the end of json.hpp to undef all of them + +// #include + + +// exclude unsupported compilers +#if !defined(JSON_SKIP_UNSUPPORTED_COMPILER_CHECK) + #if defined(__clang__) + #if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400 + #error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers" + #endif + #elif defined(__GNUC__) && !(defined(__ICC) || defined(__INTEL_COMPILER)) + #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40800 + #error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers" + #endif + #endif +#endif + +// C++ language standard detection +// if the user manually specified the used c++ version this is skipped +#if !defined(JSON_HAS_CPP_20) && !defined(JSON_HAS_CPP_17) && !defined(JSON_HAS_CPP_14) && !defined(JSON_HAS_CPP_11) + #if (defined(__cplusplus) && __cplusplus >= 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L) + #define JSON_HAS_CPP_20 + #define JSON_HAS_CPP_17 + #define JSON_HAS_CPP_14 + #elif (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464 + #define JSON_HAS_CPP_17 + #define JSON_HAS_CPP_14 + #elif (defined(__cplusplus) && __cplusplus >= 201402L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1) + #define JSON_HAS_CPP_14 + #endif + // the cpp 11 flag is always specified because it is the minimal required version + #define JSON_HAS_CPP_11 +#endif + +#ifdef __has_include + #if __has_include() + #include + #endif +#endif + +#if !defined(JSON_HAS_FILESYSTEM) && !defined(JSON_HAS_EXPERIMENTAL_FILESYSTEM) + #ifdef JSON_HAS_CPP_17 + #if defined(__cpp_lib_filesystem) + #define JSON_HAS_FILESYSTEM 1 + #elif defined(__cpp_lib_experimental_filesystem) + #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1 + #elif !defined(__has_include) + #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1 + #elif __has_include() + #define JSON_HAS_FILESYSTEM 1 + #elif __has_include() + #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1 + #endif + + // std::filesystem does not work on MinGW GCC 8: https://sourceforge.net/p/mingw-w64/bugs/737/ + #if defined(__MINGW32__) && defined(__GNUC__) && __GNUC__ == 8 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before GCC 8: https://en.cppreference.com/w/cpp/compiler_support + #if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 8 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before Clang 7: https://en.cppreference.com/w/cpp/compiler_support + #if defined(__clang_major__) && __clang_major__ < 7 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before MSVC 19.14: https://en.cppreference.com/w/cpp/compiler_support + #if defined(_MSC_VER) && _MSC_VER < 1914 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before iOS 13 + #if defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED < 130000 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before macOS Catalina + #if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + #endif +#endif + +#ifndef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 0 +#endif + +#ifndef JSON_HAS_FILESYSTEM + #define JSON_HAS_FILESYSTEM 0 +#endif + +#ifndef JSON_HAS_THREE_WAY_COMPARISON + #if defined(__cpp_impl_three_way_comparison) && __cpp_impl_three_way_comparison >= 201907L \ + && defined(__cpp_lib_three_way_comparison) && __cpp_lib_three_way_comparison >= 201907L + #define JSON_HAS_THREE_WAY_COMPARISON 1 + #else + #define JSON_HAS_THREE_WAY_COMPARISON 0 + #endif +#endif + +#ifndef JSON_HAS_RANGES + // ranges header shipping in GCC 11.1.0 (released 2021-04-27) has syntax error + #if defined(__GLIBCXX__) && __GLIBCXX__ == 20210427 + #define JSON_HAS_RANGES 0 + #elif defined(__cpp_lib_ranges) + #define JSON_HAS_RANGES 1 + #else + #define JSON_HAS_RANGES 0 + #endif +#endif + +#ifdef JSON_HAS_CPP_17 + #define JSON_INLINE_VARIABLE inline +#else + #define JSON_INLINE_VARIABLE +#endif + +#if JSON_HEDLEY_HAS_ATTRIBUTE(no_unique_address) + #define JSON_NO_UNIQUE_ADDRESS [[no_unique_address]] +#else + #define JSON_NO_UNIQUE_ADDRESS +#endif + +// disable documentation warnings on clang +#if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wdocumentation" + #pragma clang diagnostic ignored "-Wdocumentation-unknown-command" +#endif + +// allow disabling exceptions +#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION) + #define JSON_THROW(exception) throw exception + #define JSON_TRY try + #define JSON_CATCH(exception) catch(exception) + #define JSON_INTERNAL_CATCH(exception) catch(exception) +#else + #include + #define JSON_THROW(exception) std::abort() + #define JSON_TRY if(true) + #define JSON_CATCH(exception) if(false) + #define JSON_INTERNAL_CATCH(exception) if(false) +#endif + +// override exception macros +#if defined(JSON_THROW_USER) + #undef JSON_THROW + #define JSON_THROW JSON_THROW_USER +#endif +#if defined(JSON_TRY_USER) + #undef JSON_TRY + #define JSON_TRY JSON_TRY_USER +#endif +#if defined(JSON_CATCH_USER) + #undef JSON_CATCH + #define JSON_CATCH JSON_CATCH_USER + #undef JSON_INTERNAL_CATCH + #define JSON_INTERNAL_CATCH JSON_CATCH_USER +#endif +#if defined(JSON_INTERNAL_CATCH_USER) + #undef JSON_INTERNAL_CATCH + #define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER +#endif + +// allow overriding assert +#if !defined(JSON_ASSERT) + #include // assert + #define JSON_ASSERT(x) assert(x) +#endif + +// allow to access some private functions (needed by the test suite) +#if defined(JSON_TESTS_PRIVATE) + #define JSON_PRIVATE_UNLESS_TESTED public +#else + #define JSON_PRIVATE_UNLESS_TESTED private +#endif + +/*! +@brief macro to briefly define a mapping between an enum and JSON +@def NLOHMANN_JSON_SERIALIZE_ENUM +@since version 3.4.0 +*/ +#define NLOHMANN_JSON_SERIALIZE_ENUM(ENUM_TYPE, ...) \ + template \ + inline void to_json(BasicJsonType& j, const ENUM_TYPE& e) \ + { \ + static_assert(std::is_enum::value, #ENUM_TYPE " must be an enum!"); \ + static const std::pair m[] = __VA_ARGS__; \ + auto it = std::find_if(std::begin(m), std::end(m), \ + [e](const std::pair& ej_pair) -> bool \ + { \ + return ej_pair.first == e; \ + }); \ + j = ((it != std::end(m)) ? it : std::begin(m))->second; \ + } \ + template \ + inline void from_json(const BasicJsonType& j, ENUM_TYPE& e) \ + { \ + static_assert(std::is_enum::value, #ENUM_TYPE " must be an enum!"); \ + static const std::pair m[] = __VA_ARGS__; \ + auto it = std::find_if(std::begin(m), std::end(m), \ + [&j](const std::pair& ej_pair) -> bool \ + { \ + return ej_pair.second == j; \ + }); \ + e = ((it != std::end(m)) ? it : std::begin(m))->first; \ + } + +// Ugly macros to avoid uglier copy-paste when specializing basic_json. They +// may be removed in the future once the class is split. + +#define NLOHMANN_BASIC_JSON_TPL_DECLARATION \ + template class ObjectType, \ + template class ArrayType, \ + class StringType, class BooleanType, class NumberIntegerType, \ + class NumberUnsignedType, class NumberFloatType, \ + template class AllocatorType, \ + template class JSONSerializer, \ + class BinaryType> + +#define NLOHMANN_BASIC_JSON_TPL \ + basic_json + +// Macros to simplify conversion from/to types + +#define NLOHMANN_JSON_EXPAND( x ) x +#define NLOHMANN_JSON_GET_MACRO(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, NAME,...) NAME +#define NLOHMANN_JSON_PASTE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, \ + NLOHMANN_JSON_PASTE64, \ + NLOHMANN_JSON_PASTE63, \ + NLOHMANN_JSON_PASTE62, \ + NLOHMANN_JSON_PASTE61, \ + NLOHMANN_JSON_PASTE60, \ + NLOHMANN_JSON_PASTE59, \ + NLOHMANN_JSON_PASTE58, \ + NLOHMANN_JSON_PASTE57, \ + NLOHMANN_JSON_PASTE56, \ + NLOHMANN_JSON_PASTE55, \ + NLOHMANN_JSON_PASTE54, \ + NLOHMANN_JSON_PASTE53, \ + NLOHMANN_JSON_PASTE52, \ + NLOHMANN_JSON_PASTE51, \ + NLOHMANN_JSON_PASTE50, \ + NLOHMANN_JSON_PASTE49, \ + NLOHMANN_JSON_PASTE48, \ + NLOHMANN_JSON_PASTE47, \ + NLOHMANN_JSON_PASTE46, \ + NLOHMANN_JSON_PASTE45, \ + NLOHMANN_JSON_PASTE44, \ + NLOHMANN_JSON_PASTE43, \ + NLOHMANN_JSON_PASTE42, \ + NLOHMANN_JSON_PASTE41, \ + NLOHMANN_JSON_PASTE40, \ + NLOHMANN_JSON_PASTE39, \ + NLOHMANN_JSON_PASTE38, \ + NLOHMANN_JSON_PASTE37, \ + NLOHMANN_JSON_PASTE36, \ + NLOHMANN_JSON_PASTE35, \ + NLOHMANN_JSON_PASTE34, \ + NLOHMANN_JSON_PASTE33, \ + NLOHMANN_JSON_PASTE32, \ + NLOHMANN_JSON_PASTE31, \ + NLOHMANN_JSON_PASTE30, \ + NLOHMANN_JSON_PASTE29, \ + NLOHMANN_JSON_PASTE28, \ + NLOHMANN_JSON_PASTE27, \ + NLOHMANN_JSON_PASTE26, \ + NLOHMANN_JSON_PASTE25, \ + NLOHMANN_JSON_PASTE24, \ + NLOHMANN_JSON_PASTE23, \ + NLOHMANN_JSON_PASTE22, \ + NLOHMANN_JSON_PASTE21, \ + NLOHMANN_JSON_PASTE20, \ + NLOHMANN_JSON_PASTE19, \ + NLOHMANN_JSON_PASTE18, \ + NLOHMANN_JSON_PASTE17, \ + NLOHMANN_JSON_PASTE16, \ + NLOHMANN_JSON_PASTE15, \ + NLOHMANN_JSON_PASTE14, \ + NLOHMANN_JSON_PASTE13, \ + NLOHMANN_JSON_PASTE12, \ + NLOHMANN_JSON_PASTE11, \ + NLOHMANN_JSON_PASTE10, \ + NLOHMANN_JSON_PASTE9, \ + NLOHMANN_JSON_PASTE8, \ + NLOHMANN_JSON_PASTE7, \ + NLOHMANN_JSON_PASTE6, \ + NLOHMANN_JSON_PASTE5, \ + NLOHMANN_JSON_PASTE4, \ + NLOHMANN_JSON_PASTE3, \ + NLOHMANN_JSON_PASTE2, \ + NLOHMANN_JSON_PASTE1)(__VA_ARGS__)) +#define NLOHMANN_JSON_PASTE2(func, v1) func(v1) +#define NLOHMANN_JSON_PASTE3(func, v1, v2) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE2(func, v2) +#define NLOHMANN_JSON_PASTE4(func, v1, v2, v3) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE3(func, v2, v3) +#define NLOHMANN_JSON_PASTE5(func, v1, v2, v3, v4) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE4(func, v2, v3, v4) +#define NLOHMANN_JSON_PASTE6(func, v1, v2, v3, v4, v5) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE5(func, v2, v3, v4, v5) +#define NLOHMANN_JSON_PASTE7(func, v1, v2, v3, v4, v5, v6) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE6(func, v2, v3, v4, v5, v6) +#define NLOHMANN_JSON_PASTE8(func, v1, v2, v3, v4, v5, v6, v7) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE7(func, v2, v3, v4, v5, v6, v7) +#define NLOHMANN_JSON_PASTE9(func, v1, v2, v3, v4, v5, v6, v7, v8) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE8(func, v2, v3, v4, v5, v6, v7, v8) +#define NLOHMANN_JSON_PASTE10(func, v1, v2, v3, v4, v5, v6, v7, v8, v9) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE9(func, v2, v3, v4, v5, v6, v7, v8, v9) +#define NLOHMANN_JSON_PASTE11(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE10(func, v2, v3, v4, v5, v6, v7, v8, v9, v10) +#define NLOHMANN_JSON_PASTE12(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE11(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) +#define NLOHMANN_JSON_PASTE13(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE12(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) +#define NLOHMANN_JSON_PASTE14(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE13(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) +#define NLOHMANN_JSON_PASTE15(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE14(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) +#define NLOHMANN_JSON_PASTE16(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE15(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) +#define NLOHMANN_JSON_PASTE17(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE16(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) +#define NLOHMANN_JSON_PASTE18(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE17(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17) +#define NLOHMANN_JSON_PASTE19(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE18(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18) +#define NLOHMANN_JSON_PASTE20(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE19(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19) +#define NLOHMANN_JSON_PASTE21(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE20(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20) +#define NLOHMANN_JSON_PASTE22(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE21(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21) +#define NLOHMANN_JSON_PASTE23(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE22(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22) +#define NLOHMANN_JSON_PASTE24(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE23(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23) +#define NLOHMANN_JSON_PASTE25(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE24(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24) +#define NLOHMANN_JSON_PASTE26(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE25(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25) +#define NLOHMANN_JSON_PASTE27(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE26(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26) +#define NLOHMANN_JSON_PASTE28(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE27(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27) +#define NLOHMANN_JSON_PASTE29(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE28(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28) +#define NLOHMANN_JSON_PASTE30(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE29(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29) +#define NLOHMANN_JSON_PASTE31(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE30(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30) +#define NLOHMANN_JSON_PASTE32(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE31(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31) +#define NLOHMANN_JSON_PASTE33(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE32(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32) +#define NLOHMANN_JSON_PASTE34(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE33(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33) +#define NLOHMANN_JSON_PASTE35(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE34(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34) +#define NLOHMANN_JSON_PASTE36(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE35(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35) +#define NLOHMANN_JSON_PASTE37(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE36(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36) +#define NLOHMANN_JSON_PASTE38(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE37(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37) +#define NLOHMANN_JSON_PASTE39(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE38(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38) +#define NLOHMANN_JSON_PASTE40(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE39(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39) +#define NLOHMANN_JSON_PASTE41(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE40(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40) +#define NLOHMANN_JSON_PASTE42(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE41(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41) +#define NLOHMANN_JSON_PASTE43(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE42(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42) +#define NLOHMANN_JSON_PASTE44(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE43(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43) +#define NLOHMANN_JSON_PASTE45(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE44(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44) +#define NLOHMANN_JSON_PASTE46(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE45(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45) +#define NLOHMANN_JSON_PASTE47(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE46(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46) +#define NLOHMANN_JSON_PASTE48(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE47(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47) +#define NLOHMANN_JSON_PASTE49(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE48(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48) +#define NLOHMANN_JSON_PASTE50(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE49(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49) +#define NLOHMANN_JSON_PASTE51(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE50(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50) +#define NLOHMANN_JSON_PASTE52(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE51(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51) +#define NLOHMANN_JSON_PASTE53(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE52(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52) +#define NLOHMANN_JSON_PASTE54(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE53(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53) +#define NLOHMANN_JSON_PASTE55(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE54(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54) +#define NLOHMANN_JSON_PASTE56(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE55(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55) +#define NLOHMANN_JSON_PASTE57(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE56(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56) +#define NLOHMANN_JSON_PASTE58(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE57(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57) +#define NLOHMANN_JSON_PASTE59(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE58(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58) +#define NLOHMANN_JSON_PASTE60(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE59(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59) +#define NLOHMANN_JSON_PASTE61(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE60(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60) +#define NLOHMANN_JSON_PASTE62(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE61(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61) +#define NLOHMANN_JSON_PASTE63(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE62(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62) +#define NLOHMANN_JSON_PASTE64(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE63(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63) + +#define NLOHMANN_JSON_TO(v1) nlohmann_json_j[#v1] = nlohmann_json_t.v1; +#define NLOHMANN_JSON_FROM(v1) nlohmann_json_j.at(#v1).get_to(nlohmann_json_t.v1); +#define NLOHMANN_JSON_FROM_WITH_DEFAULT(v1) nlohmann_json_t.v1 = nlohmann_json_j.value(#v1, nlohmann_json_default_obj.v1); + +/*! +@brief macro +@def NLOHMANN_DEFINE_TYPE_INTRUSIVE +@since version 3.9.0 +*/ +#define NLOHMANN_DEFINE_TYPE_INTRUSIVE(Type, ...) \ + friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + friend void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) } + +#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(Type, ...) \ + friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + friend void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { Type nlohmann_json_default_obj; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE +@since version 3.9.0 +*/ +#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Type, ...) \ + inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + inline void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) } + +#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Type, ...) \ + inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + inline void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { Type nlohmann_json_default_obj; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) } + + +// inspired from https://stackoverflow.com/a/26745591 +// allows to call any std function as if (e.g. with begin): +// using std::begin; begin(x); +// +// it allows using the detected idiom to retrieve the return type +// of such an expression +#define NLOHMANN_CAN_CALL_STD_FUNC_IMPL(std_name) \ + namespace detail { \ + using std::std_name; \ + \ + template \ + using result_of_##std_name = decltype(std_name(std::declval()...)); \ + } \ + \ + namespace detail2 { \ + struct std_name##_tag \ + { \ + }; \ + \ + template \ + std_name##_tag std_name(T&&...); \ + \ + template \ + using result_of_##std_name = decltype(std_name(std::declval()...)); \ + \ + template \ + struct would_call_std_##std_name \ + { \ + static constexpr auto const value = ::nlohmann::detail:: \ + is_detected_exact::value; \ + }; \ + } /* namespace detail2 */ \ + \ + template \ + struct would_call_std_##std_name : detail2::would_call_std_##std_name \ + { \ + } + +#ifndef JSON_USE_IMPLICIT_CONVERSIONS + #define JSON_USE_IMPLICIT_CONVERSIONS 1 +#endif + +#if JSON_USE_IMPLICIT_CONVERSIONS + #define JSON_EXPLICIT +#else + #define JSON_EXPLICIT explicit +#endif + +#ifndef JSON_DISABLE_ENUM_SERIALIZATION + #define JSON_DISABLE_ENUM_SERIALIZATION 0 +#endif + +#ifndef JSON_USE_GLOBAL_UDLS + #define JSON_USE_GLOBAL_UDLS 1 +#endif + +#if JSON_HAS_THREE_WAY_COMPARISON + #include // partial_ordering +#endif + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +/////////////////////////// +// JSON type enumeration // +/////////////////////////// + +/*! +@brief the JSON type enumeration + +This enumeration collects the different JSON types. It is internally used to +distinguish the stored values, and the functions @ref basic_json::is_null(), +@ref basic_json::is_object(), @ref basic_json::is_array(), +@ref basic_json::is_string(), @ref basic_json::is_boolean(), +@ref basic_json::is_number() (with @ref basic_json::is_number_integer(), +@ref basic_json::is_number_unsigned(), and @ref basic_json::is_number_float()), +@ref basic_json::is_discarded(), @ref basic_json::is_primitive(), and +@ref basic_json::is_structured() rely on it. + +@note There are three enumeration entries (number_integer, number_unsigned, and +number_float), because the library distinguishes these three types for numbers: +@ref basic_json::number_unsigned_t is used for unsigned integers, +@ref basic_json::number_integer_t is used for signed integers, and +@ref basic_json::number_float_t is used for floating-point numbers or to +approximate integers which do not fit in the limits of their respective type. + +@sa see @ref basic_json::basic_json(const value_t value_type) -- create a JSON +value with the default value for a given type + +@since version 1.0.0 +*/ +enum class value_t : std::uint8_t +{ + null, ///< null value + object, ///< object (unordered set of name/value pairs) + array, ///< array (ordered collection of values) + string, ///< string value + boolean, ///< boolean value + number_integer, ///< number value (signed integer) + number_unsigned, ///< number value (unsigned integer) + number_float, ///< number value (floating-point) + binary, ///< binary array (ordered collection of bytes) + discarded ///< discarded by the parser callback function +}; + +/*! +@brief comparison operator for JSON types + +Returns an ordering that is similar to Python: +- order: null < boolean < number < object < array < string < binary +- furthermore, each type is not smaller than itself +- discarded values are not comparable +- binary is represented as a b"" string in python and directly comparable to a + string; however, making a binary array directly comparable with a string would + be surprising behavior in a JSON file. + +@since version 1.0.0 +*/ +#if JSON_HAS_THREE_WAY_COMPARISON + inline std::partial_ordering operator<=>(const value_t lhs, const value_t rhs) noexcept // *NOPAD* +#else + inline bool operator<(const value_t lhs, const value_t rhs) noexcept +#endif +{ + static constexpr std::array order = {{ + 0 /* null */, 3 /* object */, 4 /* array */, 5 /* string */, + 1 /* boolean */, 2 /* integer */, 2 /* unsigned */, 2 /* float */, + 6 /* binary */ + } + }; + + const auto l_index = static_cast(lhs); + const auto r_index = static_cast(rhs); +#if JSON_HAS_THREE_WAY_COMPARISON + if (l_index < order.size() && r_index < order.size()) + { + return order[l_index] <=> order[r_index]; // *NOPAD* + } + return std::partial_ordering::unordered; +#else + return l_index < order.size() && r_index < order.size() && order[l_index] < order[r_index]; +#endif +} + +// GCC selects the built-in operator< over an operator rewritten from +// a user-defined spaceship operator +// Clang, MSVC, and ICC select the rewritten candidate +// (see GCC bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105200) +#if JSON_HAS_THREE_WAY_COMPARISON && defined(__GNUC__) +inline bool operator<(const value_t lhs, const value_t rhs) noexcept +{ + return std::is_lt(lhs <=> rhs); // *NOPAD* +} +#endif + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.2 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +/*! +@brief replace all occurrences of a substring by another string + +@param[in,out] s the string to manipulate; changed so that all + occurrences of @a f are replaced with @a t +@param[in] f the substring to replace with @a t +@param[in] t the string to replace @a f + +@pre The search string @a f must not be empty. **This precondition is +enforced with an assertion.** + +@since version 2.0.0 +*/ +template +inline void replace_substring(StringType& s, const StringType& f, + const StringType& t) +{ + JSON_ASSERT(!f.empty()); + for (auto pos = s.find(f); // find first occurrence of f + pos != StringType::npos; // make sure f was found + s.replace(pos, f.size(), t), // replace with t, and + pos = s.find(f, pos + t.size())) // find next occurrence of f + {} +} + +/*! + * @brief string escaping as described in RFC 6901 (Sect. 4) + * @param[in] s string to escape + * @return escaped string + * + * Note the order of escaping "~" to "~0" and "/" to "~1" is important. + */ +template +inline StringType escape(StringType s) +{ + replace_substring(s, StringType{"~"}, StringType{"~0"}); + replace_substring(s, StringType{"/"}, StringType{"~1"}); + return s; +} + +/*! + * @brief string unescaping as described in RFC 6901 (Sect. 4) + * @param[in] s string to unescape + * @return unescaped string + * + * Note the order of escaping "~1" to "/" and "~0" to "~" is important. + */ +template +static void unescape(StringType& s) +{ + replace_substring(s, StringType{"~1"}, StringType{"/"}); + replace_substring(s, StringType{"~0"}, StringType{"~"}); +} + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.2 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // size_t + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +/// struct to capture the start position of the current token +struct position_t +{ + /// the total number of characters read + std::size_t chars_read_total = 0; + /// the number of characters read in the current line + std::size_t chars_read_current_line = 0; + /// the number of lines read + std::size_t lines_read = 0; + + /// conversion to size_t to preserve SAX interface + constexpr operator size_t() const + { + return chars_read_total; + } +}; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.2 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann +// SPDX-FileCopyrightText: 2018 The Abseil Authors +// SPDX-License-Identifier: MIT + + + +#include // array +#include // size_t +#include // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type +#include // index_sequence, make_index_sequence, index_sequence_for + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +template +using uncvref_t = typename std::remove_cv::type>::type; + +#ifdef JSON_HAS_CPP_14 + +// the following utilities are natively available in C++14 +using std::enable_if_t; +using std::index_sequence; +using std::make_index_sequence; +using std::index_sequence_for; + +#else + +// alias templates to reduce boilerplate +template +using enable_if_t = typename std::enable_if::type; + +// The following code is taken from https://github.com/abseil/abseil-cpp/blob/10cb35e459f5ecca5b2ff107635da0bfa41011b4/absl/utility/utility.h +// which is part of Google Abseil (https://github.com/abseil/abseil-cpp), licensed under the Apache License 2.0. + +//// START OF CODE FROM GOOGLE ABSEIL + +// integer_sequence +// +// Class template representing a compile-time integer sequence. An instantiation +// of `integer_sequence` has a sequence of integers encoded in its +// type through its template arguments (which is a common need when +// working with C++11 variadic templates). `absl::integer_sequence` is designed +// to be a drop-in replacement for C++14's `std::integer_sequence`. +// +// Example: +// +// template< class T, T... Ints > +// void user_function(integer_sequence); +// +// int main() +// { +// // user_function's `T` will be deduced to `int` and `Ints...` +// // will be deduced to `0, 1, 2, 3, 4`. +// user_function(make_integer_sequence()); +// } +template +struct integer_sequence +{ + using value_type = T; + static constexpr std::size_t size() noexcept + { + return sizeof...(Ints); + } +}; + +// index_sequence +// +// A helper template for an `integer_sequence` of `size_t`, +// `absl::index_sequence` is designed to be a drop-in replacement for C++14's +// `std::index_sequence`. +template +using index_sequence = integer_sequence; + +namespace utility_internal +{ + +template +struct Extend; + +// Note that SeqSize == sizeof...(Ints). It's passed explicitly for efficiency. +template +struct Extend, SeqSize, 0> +{ + using type = integer_sequence < T, Ints..., (Ints + SeqSize)... >; +}; + +template +struct Extend, SeqSize, 1> +{ + using type = integer_sequence < T, Ints..., (Ints + SeqSize)..., 2 * SeqSize >; +}; + +// Recursion helper for 'make_integer_sequence'. +// 'Gen::type' is an alias for 'integer_sequence'. +template +struct Gen +{ + using type = + typename Extend < typename Gen < T, N / 2 >::type, N / 2, N % 2 >::type; +}; + +template +struct Gen +{ + using type = integer_sequence; +}; + +} // namespace utility_internal + +// Compile-time sequences of integers + +// make_integer_sequence +// +// This template alias is equivalent to +// `integer_sequence`, and is designed to be a drop-in +// replacement for C++14's `std::make_integer_sequence`. +template +using make_integer_sequence = typename utility_internal::Gen::type; + +// make_index_sequence +// +// This template alias is equivalent to `index_sequence<0, 1, ..., N-1>`, +// and is designed to be a drop-in replacement for C++14's +// `std::make_index_sequence`. +template +using make_index_sequence = make_integer_sequence; + +// index_sequence_for +// +// Converts a typename pack into an index sequence of the same length, and +// is designed to be a drop-in replacement for C++14's +// `std::index_sequence_for()` +template +using index_sequence_for = make_index_sequence; + +//// END OF CODE FROM GOOGLE ABSEIL + +#endif + +// dispatch utility (taken from ranges-v3) +template struct priority_tag : priority_tag < N - 1 > {}; +template<> struct priority_tag<0> {}; + +// taken from ranges-v3 +template +struct static_const +{ + static JSON_INLINE_VARIABLE constexpr T value{}; +}; + +#ifndef JSON_HAS_CPP_17 + template + constexpr T static_const::value; +#endif + +template +inline constexpr std::array make_array(Args&& ... args) +{ + return std::array {{static_cast(std::forward(args))...}}; +} + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.2 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // numeric_limits +#include // false_type, is_constructible, is_integral, is_same, true_type +#include // declval +#include // tuple + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.2 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // random_access_iterator_tag + +// #include + +// #include + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +template +struct iterator_types {}; + +template +struct iterator_types < + It, + void_t> +{ + using difference_type = typename It::difference_type; + using value_type = typename It::value_type; + using pointer = typename It::pointer; + using reference = typename It::reference; + using iterator_category = typename It::iterator_category; +}; + +// This is required as some compilers implement std::iterator_traits in a way that +// doesn't work with SFINAE. See https://github.com/nlohmann/json/issues/1341. +template +struct iterator_traits +{ +}; + +template +struct iterator_traits < T, enable_if_t < !std::is_pointer::value >> + : iterator_types +{ +}; + +template +struct iterator_traits::value>> +{ + using iterator_category = std::random_access_iterator_tag; + using value_type = T; + using difference_type = ptrdiff_t; + using pointer = T*; + using reference = T&; +}; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.2 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN + +NLOHMANN_CAN_CALL_STD_FUNC_IMPL(begin); + +NLOHMANN_JSON_NAMESPACE_END + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.2 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN + +NLOHMANN_CAN_CALL_STD_FUNC_IMPL(end); + +NLOHMANN_JSON_NAMESPACE_END + +// #include + +// #include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.2 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann +// SPDX-License-Identifier: MIT + +#ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_ + #define INCLUDE_NLOHMANN_JSON_FWD_HPP_ + + #include // int64_t, uint64_t + #include // map + #include // allocator + #include // string + #include // vector + + // #include + + + /*! + @brief namespace for Niels Lohmann + @see https://github.com/nlohmann + @since version 1.0.0 + */ + NLOHMANN_JSON_NAMESPACE_BEGIN + + /*! + @brief default JSONSerializer template argument + + This serializer ignores the template arguments and uses ADL + ([argument-dependent lookup](https://en.cppreference.com/w/cpp/language/adl)) + for serialization. + */ + template + struct adl_serializer; + + /// a class to store JSON values + /// @sa https://json.nlohmann.me/api/basic_json/ + template class ObjectType = + std::map, + template class ArrayType = std::vector, + class StringType = std::string, class BooleanType = bool, + class NumberIntegerType = std::int64_t, + class NumberUnsignedType = std::uint64_t, + class NumberFloatType = double, + template class AllocatorType = std::allocator, + template class JSONSerializer = + adl_serializer, + class BinaryType = std::vector> + class basic_json; + + /// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document + /// @sa https://json.nlohmann.me/api/json_pointer/ + template + class json_pointer; + + /*! + @brief default specialization + @sa https://json.nlohmann.me/api/json/ + */ + using json = basic_json<>; + + /// @brief a minimal map-like container that preserves insertion order + /// @sa https://json.nlohmann.me/api/ordered_map/ + template + struct ordered_map; + + /// @brief specialization that maintains the insertion order of object keys + /// @sa https://json.nlohmann.me/api/ordered_json/ + using ordered_json = basic_json; + + NLOHMANN_JSON_NAMESPACE_END + +#endif // INCLUDE_NLOHMANN_JSON_FWD_HPP_ + + +NLOHMANN_JSON_NAMESPACE_BEGIN +/*! +@brief detail namespace with internal helper functions + +This namespace collects functions that should not be exposed, +implementations of some @ref basic_json methods, and meta-programming helpers. + +@since version 2.1.0 +*/ +namespace detail +{ + +///////////// +// helpers // +///////////// + +// Note to maintainers: +// +// Every trait in this file expects a non CV-qualified type. +// The only exceptions are in the 'aliases for detected' section +// (i.e. those of the form: decltype(T::member_function(std::declval()))) +// +// In this case, T has to be properly CV-qualified to constraint the function arguments +// (e.g. to_json(BasicJsonType&, const T&)) + +template struct is_basic_json : std::false_type {}; + +NLOHMANN_BASIC_JSON_TPL_DECLARATION +struct is_basic_json : std::true_type {}; + +// used by exceptions create() member functions +// true_type for pointer to possibly cv-qualified basic_json or std::nullptr_t +// false_type otherwise +template +struct is_basic_json_context : + std::integral_constant < bool, + is_basic_json::type>::type>::value + || std::is_same::value > +{}; + +////////////////////// +// json_ref helpers // +////////////////////// + +template +class json_ref; + +template +struct is_json_ref : std::false_type {}; + +template +struct is_json_ref> : std::true_type {}; + +////////////////////////// +// aliases for detected // +////////////////////////// + +template +using mapped_type_t = typename T::mapped_type; + +template +using key_type_t = typename T::key_type; + +template +using value_type_t = typename T::value_type; + +template +using difference_type_t = typename T::difference_type; + +template +using pointer_t = typename T::pointer; + +template +using reference_t = typename T::reference; + +template +using iterator_category_t = typename T::iterator_category; + +template +using to_json_function = decltype(T::to_json(std::declval()...)); + +template +using from_json_function = decltype(T::from_json(std::declval()...)); + +template +using get_template_function = decltype(std::declval().template get()); + +// trait checking if JSONSerializer::from_json(json const&, udt&) exists +template +struct has_from_json : std::false_type {}; + +// trait checking if j.get is valid +// use this trait instead of std::is_constructible or std::is_convertible, +// both rely on, or make use of implicit conversions, and thus fail when T +// has several constructors/operator= (see https://github.com/nlohmann/json/issues/958) +template +struct is_getable +{ + static constexpr bool value = is_detected::value; +}; + +template +struct has_from_json < BasicJsonType, T, enable_if_t < !is_basic_json::value >> +{ + using serializer = typename BasicJsonType::template json_serializer; + + static constexpr bool value = + is_detected_exact::value; +}; + +// This trait checks if JSONSerializer::from_json(json const&) exists +// this overload is used for non-default-constructible user-defined-types +template +struct has_non_default_from_json : std::false_type {}; + +template +struct has_non_default_from_json < BasicJsonType, T, enable_if_t < !is_basic_json::value >> +{ + using serializer = typename BasicJsonType::template json_serializer; + + static constexpr bool value = + is_detected_exact::value; +}; + +// This trait checks if BasicJsonType::json_serializer::to_json exists +// Do not evaluate the trait when T is a basic_json type, to avoid template instantiation infinite recursion. +template +struct has_to_json : std::false_type {}; + +template +struct has_to_json < BasicJsonType, T, enable_if_t < !is_basic_json::value >> +{ + using serializer = typename BasicJsonType::template json_serializer; + + static constexpr bool value = + is_detected_exact::value; +}; + +template +using detect_key_compare = typename T::key_compare; + +template +struct has_key_compare : std::integral_constant::value> {}; + +// obtains the actual object key comparator +template +struct actual_object_comparator +{ + using object_t = typename BasicJsonType::object_t; + using object_comparator_t = typename BasicJsonType::default_object_comparator_t; + using type = typename std::conditional < has_key_compare::value, + typename object_t::key_compare, object_comparator_t>::type; +}; + +template +using actual_object_comparator_t = typename actual_object_comparator::type; + +/////////////////// +// is_ functions // +/////////////////// + +// https://en.cppreference.com/w/cpp/types/conjunction +template struct conjunction : std::true_type { }; +template struct conjunction : B { }; +template +struct conjunction +: std::conditional(B::value), conjunction, B>::type {}; + +// https://en.cppreference.com/w/cpp/types/negation +template struct negation : std::integral_constant < bool, !B::value > { }; + +// Reimplementation of is_constructible and is_default_constructible, due to them being broken for +// std::pair and std::tuple until LWG 2367 fix (see https://cplusplus.github.io/LWG/lwg-defects.html#2367). +// This causes compile errors in e.g. clang 3.5 or gcc 4.9. +template +struct is_default_constructible : std::is_default_constructible {}; + +template +struct is_default_constructible> + : conjunction, is_default_constructible> {}; + +template +struct is_default_constructible> + : conjunction, is_default_constructible> {}; + +template +struct is_default_constructible> + : conjunction...> {}; + +template +struct is_default_constructible> + : conjunction...> {}; + + +template +struct is_constructible : std::is_constructible {}; + +template +struct is_constructible> : is_default_constructible> {}; + +template +struct is_constructible> : is_default_constructible> {}; + +template +struct is_constructible> : is_default_constructible> {}; + +template +struct is_constructible> : is_default_constructible> {}; + + +template +struct is_iterator_traits : std::false_type {}; + +template +struct is_iterator_traits> +{ + private: + using traits = iterator_traits; + + public: + static constexpr auto value = + is_detected::value && + is_detected::value && + is_detected::value && + is_detected::value && + is_detected::value; +}; + +template +struct is_range +{ + private: + using t_ref = typename std::add_lvalue_reference::type; + + using iterator = detected_t; + using sentinel = detected_t; + + // to be 100% correct, it should use https://en.cppreference.com/w/cpp/iterator/input_or_output_iterator + // and https://en.cppreference.com/w/cpp/iterator/sentinel_for + // but reimplementing these would be too much work, as a lot of other concepts are used underneath + static constexpr auto is_iterator_begin = + is_iterator_traits>::value; + + public: + static constexpr bool value = !std::is_same::value && !std::is_same::value && is_iterator_begin; +}; + +template +using iterator_t = enable_if_t::value, result_of_begin())>>; + +template +using range_value_t = value_type_t>>; + +// The following implementation of is_complete_type is taken from +// https://blogs.msdn.microsoft.com/vcblog/2015/12/02/partial-support-for-expression-sfinae-in-vs-2015-update-1/ +// and is written by Xiang Fan who agreed to using it in this library. + +template +struct is_complete_type : std::false_type {}; + +template +struct is_complete_type : std::true_type {}; + +template +struct is_compatible_object_type_impl : std::false_type {}; + +template +struct is_compatible_object_type_impl < + BasicJsonType, CompatibleObjectType, + enable_if_t < is_detected::value&& + is_detected::value >> +{ + using object_t = typename BasicJsonType::object_t; + + // macOS's is_constructible does not play well with nonesuch... + static constexpr bool value = + is_constructible::value && + is_constructible::value; +}; + +template +struct is_compatible_object_type + : is_compatible_object_type_impl {}; + +template +struct is_constructible_object_type_impl : std::false_type {}; + +template +struct is_constructible_object_type_impl < + BasicJsonType, ConstructibleObjectType, + enable_if_t < is_detected::value&& + is_detected::value >> +{ + using object_t = typename BasicJsonType::object_t; + + static constexpr bool value = + (is_default_constructible::value && + (std::is_move_assignable::value || + std::is_copy_assignable::value) && + (is_constructible::value && + std::is_same < + typename object_t::mapped_type, + typename ConstructibleObjectType::mapped_type >::value)) || + (has_from_json::value || + has_non_default_from_json < + BasicJsonType, + typename ConstructibleObjectType::mapped_type >::value); +}; + +template +struct is_constructible_object_type + : is_constructible_object_type_impl {}; + +template +struct is_compatible_string_type +{ + static constexpr auto value = + is_constructible::value; +}; + +template +struct is_constructible_string_type +{ + // launder type through decltype() to fix compilation failure on ICPC +#ifdef __INTEL_COMPILER + using laundered_type = decltype(std::declval()); +#else + using laundered_type = ConstructibleStringType; +#endif + + static constexpr auto value = + conjunction < + is_constructible, + is_detected_exact>::value; +}; + +template +struct is_compatible_array_type_impl : std::false_type {}; + +template +struct is_compatible_array_type_impl < + BasicJsonType, CompatibleArrayType, + enable_if_t < + is_detected::value&& + is_iterator_traits>>::value&& +// special case for types like std::filesystem::path whose iterator's value_type are themselves +// c.f. https://github.com/nlohmann/json/pull/3073 + !std::is_same>::value >> +{ + static constexpr bool value = + is_constructible>::value; +}; + +template +struct is_compatible_array_type + : is_compatible_array_type_impl {}; + +template +struct is_constructible_array_type_impl : std::false_type {}; + +template +struct is_constructible_array_type_impl < + BasicJsonType, ConstructibleArrayType, + enable_if_t::value >> + : std::true_type {}; + +template +struct is_constructible_array_type_impl < + BasicJsonType, ConstructibleArrayType, + enable_if_t < !std::is_same::value&& + !is_compatible_string_type::value&& + is_default_constructible::value&& +(std::is_move_assignable::value || + std::is_copy_assignable::value)&& +is_detected::value&& +is_iterator_traits>>::value&& +is_detected::value&& +// special case for types like std::filesystem::path whose iterator's value_type are themselves +// c.f. https://github.com/nlohmann/json/pull/3073 +!std::is_same>::value&& + is_complete_type < + detected_t>::value >> +{ + using value_type = range_value_t; + + static constexpr bool value = + std::is_same::value || + has_from_json::value || + has_non_default_from_json < + BasicJsonType, + value_type >::value; +}; + +template +struct is_constructible_array_type + : is_constructible_array_type_impl {}; + +template +struct is_compatible_integer_type_impl : std::false_type {}; + +template +struct is_compatible_integer_type_impl < + RealIntegerType, CompatibleNumberIntegerType, + enable_if_t < std::is_integral::value&& + std::is_integral::value&& + !std::is_same::value >> +{ + // is there an assert somewhere on overflows? + using RealLimits = std::numeric_limits; + using CompatibleLimits = std::numeric_limits; + + static constexpr auto value = + is_constructible::value && + CompatibleLimits::is_integer && + RealLimits::is_signed == CompatibleLimits::is_signed; +}; + +template +struct is_compatible_integer_type + : is_compatible_integer_type_impl {}; + +template +struct is_compatible_type_impl: std::false_type {}; + +template +struct is_compatible_type_impl < + BasicJsonType, CompatibleType, + enable_if_t::value >> +{ + static constexpr bool value = + has_to_json::value; +}; + +template +struct is_compatible_type + : is_compatible_type_impl {}; + +template +struct is_constructible_tuple : std::false_type {}; + +template +struct is_constructible_tuple> : conjunction...> {}; + +template +struct is_json_iterator_of : std::false_type {}; + +template +struct is_json_iterator_of : std::true_type {}; + +template +struct is_json_iterator_of : std::true_type +{}; + +// checks if a given type T is a template specialization of Primary +template