text:
var DocGenerator = require('../lib/doc_generator.js');
(new DocGenerator()).generate();

redpajama_set_name: RedPajamaGithub


text:
'use strict';

var assert = require('assert');
var should = require('should');
var assemble = require('..');

describe('assemble cache', function () {
  describe('set() - add:', function () {
    it('when an object is passed to set:', function () {
      assemble.set({one: 1, two: 2});
      assemble.get('one').should.eql(1);
      assemble.get('two').should.eql(2);
    });

    it('should set a new property with the given value', function () {
      assemble.set('one', 1);
      assemble.get('one').should.eql(1);
    });
  });

  describe('set() - update:', function () {
    it('should update an existing property with the given value', function () {
      assemble.set('one', 2);
      assemble.get('one').should.eql(2);
    });
  });

  describe('get():', function () {
    it('should get the given property', function () {
      assemble.get('one').should.eql(2);
    });

    var obj = {a: {b: {c: 1, d: '', e: null, f: undefined, 'g.h.i': 2}}};
    assemble.set(obj);

    it('should get immediate properties.', function() {
      assemble.get('a').should.eql(obj.a);
    });
    it('should get nested properties.', function() {
      assemble.get('a.b').should.eql(obj.a.b);
    });
    it('should return undefined for nonexistent properties.', function() {
      assert.equal(typeof assemble.get('a.x'), 'undefined');
    });
    it('should return values.', function() {
      assemble.get('a.b.c').should.eql(1);
    });
    it('should return values.', function() {
      assemble.get('a.b.d').should.eql('');
    });
    it('should return values.', function() {
      assert.equal(typeof assemble.get('a.b.e'), 'object');
    });
    it('should return values.', function() {
      assert.equal(typeof assemble.get('a.b.f'), 'undefined');
    });
    it('literal backslash should escape period in property name.', function() {
      assemble.get('a.b.g\\.h\\.i', true).should.equal(2);
    });
    it('should just return existing properties.', function() {
      assemble.get('a', true).should.eql(assemble.cache.a);
    });
    it('should create immediate properties.', function() {
      assemble.get('b', true).should.eql(assemble.cache.b);
    });
  });

  describe('all:', function () {
    it('should list the entire cache', function () {
      assemble.get().should.eql(assemble.cache);
    });
  });

  describe('set()/get():', function () {
    it('should return immediate property value.', function() {
      assemble.set('a', 1);
      assemble.get('a').should.equal(1);
    });
    it('should set property value.', function() {
      assemble.cache.a.should.equal(1);
    });
    it('should return nested property value.', function() {
      assemble.set('b.c.d', 1);
      assemble.get('b.c.d').should.equal(1);
    });
    it('should set property value.', function() {
      assemble.cache.b.c.d.should.equal(1);
    });
    it('literal backslash should escape period in property name.', function() {
      assemble.set('e\\.f\\.g', 1, true);
      assemble.get('e\\.f\\.g', true).should.equal(1);
      assemble.cache['e.f.g'].should.equal(1);
    });
  });

  describe('exists():', function () {
    var obj = {a: {b: {c: 1, d: '', e: null, f: undefined, 'g.h.i': 2}}};
    assemble.set(obj);

    it('immediate property should exist.', function() {
      assemble.exists('a').should.be.true;
    });
    it('nested property should exist.', function() {
      assemble.exists('a.b').should.be.true;
    });
    it('nested property should exist.', function() {
      assemble.exists('a.b.c').should.be.true;
    });
    it.skip('nested property should exist.', function() {
      assemble.exists('a.b.d').should.be.true;
    });
    it('nested property should exist.', function() {
      assemble.exists('a.b.e').should.be.false;
    });
    it('nested property should exist.', function() {
      assemble.exists('a.b.f').should.be.false;
    });
    it('nonexistent property should not exist.', function() {
      assemble.exists('x').should.be.false;
    });
    it('nonexistent property should not exist.', function() {
      assemble.exists('a.x').should.be.false;
    });
    it('nonexistent property should not exist.', function() {
      assemble.exists('a.b.x').should.be.false;
    });
  });

  describe('events:', function () {
    describe('when assembleuration settings are customized', function () {
      it('should have the custom settings', function () {
        assemble.wildcard.should.be.true;
        assemble.listenerTree.should.be.an.object;
      });
    });

    describe('when a listener is removed', function () {
      it('should remove listener', function () {
        var type = 'foo', listeners;
        var fn = function () {};

        // add
        assemble.on(type, fn);
        listeners = assemble.listeners(type);
        listeners.length.should.equal(1);

        // remove
        assemble.removeListener(type, fn);
        listeners = assemble.listeners(type);
        listeners.length.should.equal(0);
      });
    });

    describe('when listeners are added', function () {
      it('should add the listeners', function () {
        var called = false;
        assemble.on('foo', function () {
          called = 'a';
        });
        assemble.emit('foo');
        called.should.equal('a');
        assemble.on('foo', function () {
          called = 'b';
        });
        assemble.emit('foo');
        called.should.equal('b');
        assemble.on('foo', function () {
          called = true;
        });
        assemble.emit('foo');
        called.should.equal(true);
        assemble.listeners('foo').length.should.equal(3);
      });

      it('should emit `set` when a value is set', function () {
        var called = false;
        var value = '';
        assemble.on('set', function (key, val) {
          called = key;
          value = val;
        });
        assemble.set('foo', 'bar');
        called.should.equal('foo');
        value.should.equal('bar');
      });

      it('should emit `set` when items are set on the assemble.', function () {
        var called = false;

        assemble.on('set', function (key) {
          called = true;
          assemble.exists(key).should.be.true;
        });

        assemble.set('one', 'a');
        assemble.set('two', 'c');
        assemble.set('one', 'b');
        assemble.set('two', 'd');

        called.should.be.true;
      });
    });
  });
});


text:
package au.com.mountainpass.hyperstate.core;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletableFuture;

import org.springframework.http.HttpMethod;

import au.com.mountainpass.hyperstate.annotations.PresentationType;
import au.com.mountainpass.hyperstate.core.entities.CreatedEntity;
import au.com.mountainpass.hyperstate.core.entities.DeletedEntity;
import au.com.mountainpass.hyperstate.core.entities.Entity;
import au.com.mountainpass.hyperstate.core.entities.EntityWrapper;
import au.com.mountainpass.hyperstate.core.entities.UpdatedEntity;

public class JavaAction<T extends Entity> extends Action<T> {

    public static HttpMethod determineMethodNature(final Method method) {
        final Type type = method.getGenericReturnType();
        if (ParameterizedType.class.isAssignableFrom(type.getClass())) {
            final ParameterizedType parameterizedType = (ParameterizedType) type;
            final Type rawType = parameterizedType.getRawType();
            final Class<? extends Type> rawTypeClass = rawType.getClass();
            if (Class.class.isAssignableFrom(rawTypeClass)
                    && CompletableFuture.class
                            .isAssignableFrom((Class<?>) rawType)) {
                final Type[] typeParams = parameterizedType
                        .getActualTypeArguments();
                if (typeParams.length == 1) {
                    final Type typeParam = typeParams[0];
                    if (Class.class.isAssignableFrom(typeParam.getClass())
                            && DeletedEntity.class
                                    .isAssignableFrom((Class<?>) typeParam)) {
                        return HttpMethod.DELETE;
                    } else
                        if (Class.class.isAssignableFrom(typeParam.getClass())
                                && CreatedEntity.class.isAssignableFrom(
                                        (Class<?>) typeParam)) {
                        return HttpMethod.POST;
                    } else if (Class.class
                            .isAssignableFrom(typeParam.getClass())
                            && UpdatedEntity.class
                                    .isAssignableFrom((Class<?>) typeParam)) {
                        return HttpMethod.PUT;
                    } else if (ParameterizedType.class
                            .isAssignableFrom(typeParam.getClass())
                            && EntityWrapper.class.isAssignableFrom(
                                    (Class<?>) ((ParameterizedType) typeParam)
                                            .getRawType())) {
                        return HttpMethod.GET;
                    }
                }
            }
        }
        return null;
    }

    private static au.com.mountainpass.hyperstate.core.Parameter[] extractParameters(
            final Method method) {
        final List<Parameter> params = Arrays.asList(method.getParameters());

        final List<au.com.mountainpass.hyperstate.core.Parameter> rval = new ArrayList<>();
        for (int i = 0; i < params.size(); ++i) {
            // todo add type support here
            rval.add(new au.com.mountainpass.hyperstate.core.Parameter(
                    params.get(i).getName()));
        }
        rval.add(new au.com.mountainpass.hyperstate.core.Parameter("action",
                PresentationType.SUBMIT, method.getName()));
        return rval
                .toArray(new au.com.mountainpass.hyperstate.core.Parameter[0]);
    }

    private EntityWrapper<?> entity;

    private Method method;

    private HttpMethod nature;

    protected JavaAction() {
    }

    public JavaAction(final EntityRepository repository,
            final EntityWrapper<?> entity, final Method method) {
        super(method.getName(), new JavaAddress(repository, entity),
                extractParameters(method));
        this.method = method;
        this.entity = entity;
        this.nature = determineMethodNature(method);
    }

    @Override
    public CompletableFuture<T> doInvoke(
            final Map<String, Object> filteredParameters) {
        // TODO, this should use the resovler;
        final List<Object> args = new ArrayList<>(getParameters().size());
        for (final au.com.mountainpass.hyperstate.core.Parameter param : getParameters()) {
            if (!PresentationType.SUBMIT.equals(param.getType())) {
                args.add(filteredParameters.get(param.getIdentifier()));
            }
        }
        try {
            return (CompletableFuture<T>) method.invoke(entity, args.toArray());
        } catch (IllegalAccessException | IllegalArgumentException
                | InvocationTargetException e) {
            throw new RuntimeException(e);
        }

    }

    @Override
    public HttpMethod getNature() {
        return nature;
    }

}


text:
<!DOCTYPE html>

        <title> Welcome to my web site </title>
        <link rel = "stylesheet" type = "text/css" href="assets/css/style.css">

 Nataliia Ryzha

                     About  |
                     Portfolio |
                     Contact

  About me

 I decided to create this page because I would like to tell a bit about myself. Have you already guessed that I'm a coffee person?

 Not that long ago, I moved to the United States and settled down in Seattle (coffee also mattered) from my home country Ukraine. If you have not heard about Ukraine yet, please check this out - Ukraine. Perhaps it would be your next trip destination!

 Also want to mention that I'm very passionate about web development... being a creative person, web development looks like a kind of digital art to me!

 Oh, the section space runs out, so I'll be short...

 Saying that, feel free to reach out or check my portfolios!

             Copyright ©


text:
package com.jetbrains.python.inspections.quickfix;

import com.intellij.codeInspection.LocalQuickFix;
import com.intellij.codeInspection.ProblemDescriptor;
import com.intellij.openapi.editor.Document;
import com.intellij.openapi.editor.Editor;
import com.intellij.openapi.editor.EditorFactory;
import com.intellij.openapi.project.Project;
import com.intellij.psi.PsiDocumentManager;
import com.intellij.psi.PsiFile;
import com.jetbrains.python.PyBundle;
import com.jetbrains.python.codeInsight.override.PyOverrideImplementUtil;
import com.jetbrains.python.psi.PyClass;
import com.jetbrains.python.psi.PyFunction;
import org.jetbrains.annotations.NonNls;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import java.util.Set;

/**
 * User: ktisha
 */
public class PyImplementMethodsQuickFix implements LocalQuickFix {

  private final PyClass myClass;
  private final Set<PyFunction> myToImplement;

  public PyImplementMethodsQuickFix(PyClass aClass, Set<PyFunction> toBeImplemented) {
    myClass = aClass;
    myToImplement = toBeImplemented;
  }

  @NotNull
  public String getName() {
    return PyBundle.message("QFIX.NAME.implement.methods");
  }

  @NonNls
  @NotNull
  public String getFamilyName() {
    return getName();
  }

  public void applyFix(@NotNull final Project project, @NotNull final ProblemDescriptor descriptor) {
    final Editor editor = getEditor(project, descriptor.getPsiElement().getContainingFile());
    if (editor != null)
      PyOverrideImplementUtil.chooseAndOverrideOrImplementMethods(project, editor, myClass, myToImplement, "Select Methods to Implement", true);
  }

  @Nullable
  private static Editor getEditor(Project project, PsiFile file) {
    Document document = PsiDocumentManager.getInstance(project).getDocument(file);
    if (document != null) {
      final EditorFactory instance = EditorFactory.getInstance();
      if (instance == null) return null;
      Editor[] editors = instance.getEditors(document);
      if (editors.length > 0) {
        return editors[0];
      }
    }
    return null;
  }

}


text:
'use strict';

var mongoose = require('mongoose');
var Schema = mongoose.Schema;

var ThreadSchema = new Schema({
  topic: { type: String, lowercase: true, default: 'general', index: true },
  created: {
      type: Date,
      default: Date.now,
      index: true
  },
  modified: {
      type: Date,
      default: Date.now,
      index: true
  },
  lastUpdate: {
      type: Date,
      default: Date.now,
      index: true
  },
  title: String,
  author: {
    id: String
  },
  markdown: String,
  seenBy: [{
    user: String,
    when: {
      type: Date,
      default: Date.now
    }
  }],
  reply: [{
    created: {
        type: Date,
        default: Date.now
    },
    modified: {
        type: Date,
        default: Date.now
    },
    author: {
      id: String
    },
    markdown: String
  }]
});

ThreadSchema
  .virtual('preview')
  .get(function() {
    return 'preview'; // TODO
  });

/*
ThreadSchema
  .virtual('lastSeen')
  .get(function() {
    return this._lastSeen;
});

ThreadSchema
  .virtual('lastSeen')
  .set(function(lastSeen) {
    return this._lastSeen = lastSeen;
});

ThreadSchema
  .set('lastSeen', {
    getters: true
});

*/

/**
 * Pre-save hook
 */
ThreadSchema
  .pre('save', function(next) {
    if (!this.isNew) {
      this.modified = new Date();
    }
    next();
  });

module.exports = mongoose.model('Thread', ThreadSchema);


text:
// This code is auto-generated, do not modify
using Ds3.Models;
using System;
using System.Net;

namespace Ds3.Calls
{
    public class RegenerateUserSecretKeySpectraS3Request : Ds3Request
    {

        public string UserId { get; private set; }

        public RegenerateUserSecretKeySpectraS3Request(Guid userId)
        {
            this.UserId = userId.ToString();
            this.QueryParams.Add("operation", "regenerate_secret_key");

        }

        public RegenerateUserSecretKeySpectraS3Request(string userId)
        {
            this.UserId = userId;
            this.QueryParams.Add("operation", "regenerate_secret_key");

        }

        internal override HttpVerb Verb
        {
            get
            {
                return HttpVerb.PUT;
            }
        }

        internal override string Path
        {
            get
            {
                return "/_rest_/user/" + UserId.ToString();
            }
        }
    }
}


text:
require File.dirname(__FILE__) + '/../test_helper'
require 'tags_controller'

# Re-raise errors caught by the controller.
class TagsController; def rescue_action(e) raise e end; end

class TagsControllerTest < ActionController::TestCase
  def setup
    @controller = TagsController.new
    @request    = ActionController::TestRequest.new
    @response   = ActionController::TestResponse.new
    @tag        = Tag.find 1
  end

  context "with photo as parent" do
    context "get to :index" do
      setup do
        get :index, :photo_id => 1
      end

      should_assign_to :products
      should_render_template "index"
      should_respond_with :success

      should "respond with html" do
        assert_equal 'text/html', @response.content_type
      end
    end

    context "xhr to :index" do
      setup do
        xhr :get, :index, :photo_id => 1
      end

      should_assign_to :products
      should_respond_with :success

      should "respond with rjs" do
        assert_equal 'text/javascript', @response.content_type
      end
    end

    context "post to create" do
      setup do
        post :create, :photo_id => 1, :tag => {:name => "Hello!"}
      end

      should "add tag to photo" do
        assert assigns(:photo).tags.include?(assigns(:tag)), "photo does not include new tag"
      end
    end
  end

  context "without photo as parent" do
    should_be_restful do |resource|
      resource.formats = [:html]
    end

    should "render text for a missing object" do
      get :show, :id => 50000
      assert @response.body.match(/not found/i), @response.body
    end
  end
end


text:
using CSharpVerbalExpressions;
using NUnit.Framework;

namespace VerbalExpressionsUnitTests
{
    [TestFixture]
    public class ThenTests
    {
        [Test]
        public void Then_VerbalExpressionsEmail_DoesMatchEmail()
        {
            var verbEx = VerbalExpressions.DefaultExpression;
            verbEx.StartOfLine().Then(CommonRegex.Email);

            var isMatch = verbEx.IsMatch("test@github.com");
            Assert.IsTrue(isMatch, "Should match email address");
        }

        [Test]
        public void Then_VerbalExpressionsEmail_DoesNotMatchUrl()
        {
            var verbEx = VerbalExpressions.DefaultExpression;
            verbEx.StartOfLine().Then(CommonRegex.Email);

            var isMatch = verbEx.IsMatch("http://www.google.com");
            Assert.IsFalse(isMatch, "Should not match url address");
        }

        [Test]
        public void Then_VerbalExpressionsUrl_DoesMatchUrl()
        {
            var verbEx = VerbalExpressions.DefaultExpression;
            verbEx.StartOfLine()
                  .Then(CommonRegex.Url);

            Assert.IsTrue(verbEx.IsMatch("http://www.google.com"), "Should match url address");
            Assert.IsTrue(verbEx.IsMatch("https://www.google.com"), "Should match url address");
            Assert.IsTrue(verbEx.IsMatch("http://google.com"), "Should match url address");
        }

        [Test]
        public void Then_VerbalExpressionsUrl_DoesNotMatchEmail()
        {
            var verbEx = VerbalExpressions.DefaultExpression;
            verbEx.StartOfLine().Then(CommonRegex.Url);

            Assert.IsFalse(verbEx.IsMatch("test@github.com"), "Should not match email address");
        }
    }
}


text:
<?xml version='1.0' encoding='utf-8' ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

    <title>Rouge Core Array Class Spec</title>

    <link href='../../screw-unit/lib/screw.css' rel='stylesheet' />


text:
layout: page
title: Youth Air Party
date: 2016-05-24
author: Donna Cantrell
tags: weekly links, java
status: published
summary: Sed est nunc, lobortis eu tristique.
banner: images/banner/meeting-01.jpg
booking:
  startDate: 12/20/2018
  endDate: 12/21/2018
  ctyhocn: MEMCVHX
  groupCode: YAP
published: true
---
Suspendisse vulputate lacinia sapien sit amet facilisis. Integer lacinia orci facilisis pellentesque euismod. Proin vel sapien tempor, sagittis sem a, sagittis felis. Mauris commodo enim a tincidunt facilisis. Morbi odio enim, facilisis quis eros volutpat, mattis sagittis sem. Morbi non arcu tellus. Donec a mattis metus. Donec auctor posuere laoreet. Cras vitae diam purus. Morbi ut mauris dictum diam finibus hendrerit in a turpis. Vivamus placerat eu mauris sit amet suscipit. Sed efficitur imperdiet nisl in rutrum. Praesent non sodales tellus.

* In consectetur lorem eget velit placerat aliquam
* Nullam volutpat nulla non dolor varius, id hendrerit leo aliquam.

Proin vitae velit ut mauris auctor fringilla. Suspendisse accumsan in lacus a lobortis. Vivamus in vestibulum mauris. In non lorem odio. Sed purus lacus, accumsan at odio non, scelerisque pharetra nunc. Vivamus et sapien a augue tincidunt ornare ut in quam. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Praesent finibus porta commodo.
Integer condimentum tempus massa, in euismod est egestas vel. Quisque augue eros, ullamcorper non nulla in, feugiat tempor felis. Proin ultricies pharetra semper. Fusce nec ligula nec ligula posuere sollicitudin non sed ipsum. Nulla posuere tortor id est lobortis, eu maximus mauris venenatis. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Sed eleifend blandit nisl, vitae ullamcorper elit vehicula ac. Nam arcu sapien, aliquam at libero in, euismod dignissim enim. Praesent fringilla faucibus ipsum. In condimentum libero ligula, a pharetra ex laoreet vulputate.


text:
<list model="mkt.target" colors='{"#cfc":[["email_status","=","verified"]],"#fcc":[["email_status","in",["error_syntax","error_dns","error_smtp"]]]}'>
    <field name="list_id"/>
    <field name="date"/>
    <field name="target_life"/>
    <field name="first_name"/>
    <field name="last_name"/>
    <field name="company"/>
    <field name="country_id"/>
    <field name="phone"/>
    <field name="email"/>
    <field name="email_status"/>
</list>


text:
Sequel.migration do
  change do
    create_table(:tracks) do
      uuid         :uuid, default: Sequel.function(:uuid_generate_v4), primary_key: true
      timestamptz  :created_at, default: Sequel.function(:now), null: false
      timestamptz  :updated_at

      text         :rdio_key, index: true

      text         :rdio_name
      text         :rdio_artist
      text         :rdio_album
      integer      :rdio_duration
      column       :rdio_isrcs, "text[]"

      text         :spotify_id, index: true

      text         :spotify_name
      text         :spotify_album
      text         :spotify_artist
      float        :spotify_duration_ms
      column       :spotify_isrcs, "text[]"

      text         :isrc, index: true
    end
  end
end


text:
# Monkey-patch within the Gem module.
module Gem

  # Enhanced automated gem specification.
  class Specification

    # The title of the gem for documentation (by default, the capitalized
    # name).
    attr_accessor :title

    # The name of the file containing the gem's version (by default,
    # <tt>lib/_name_/version.rb</tt>).
    attr_accessor :version_file

    alias_method :original_initialize, :initialize

    # Create the gem specification. Requires a block to set up the basic gem
    # information (name, version, author, email, description). In addition, the
    # block may override default properties (e.g. title).
    def initialize(&block)
      original_initialize(&block)
      setup_default_members
      add_development_dependencies
      setup_file_members
      setup_rdoc
    end

    # Set the new data members to their default values, unless they were
    # already set by the gem specification block.
    def setup_default_members
      name = self.name
      @title ||= name.capitalize
      @version_file ||= "lib/#{name}/version.rb"
    end

    # Add dependencies required for developing the gem.
    def add_development_dependencies
      add_dependency("olag") unless self.name == "olag"
      %w(Saikuro codnar fakefs flay rake rcov rdoc reek roodi test-spec).each do |gem|
        add_development_dependency(gem)
      end
    end

    # Initialize the standard gem specification file list members.
    def setup_file_members
      # These should cover all the gem's files, except for the extra rdoc
      # files.
      setup_file_member(:files, "{lib,doc}/**/*")
      self.files << "Rakefile" << "codnar.html"
      setup_file_member(:executables, "bin/*") { |path| path.sub("bin/", "") }
      setup_file_member(:test_files, "test/**/*")
    end

    # Initialize a standard gem specification file list member to the files
    # matching a pattern. If a block is given, it is used to map the file
    # paths. This will append to the file list member if it has already been
    # set by the gem specification block.
    def setup_file_member(member, pattern, &block)
      old_value = instance_variable_get("@#{member}")
      new_value = FileList[pattern].find_all { |path| File.file?(path) }
      new_value.map!(&block) if block
      instance_variable_set("@#{member}", old_value + new_value)
    end

    # Setup RDOC options in the gem specification.
    def setup_rdoc
      self.extra_rdoc_files = [ "README.rdoc", "LICENSE", "ChangeLog" ]
      self.rdoc_options << "--title" << "#{title} #{version}" \
                        << "--main" << "README.rdoc" \
                        << "--line-numbers" \
                        << "--all" \
                        << "--quiet"
    end

  end

end


text:
const joi = require('joi')

module.exports = joi.object().keys({
  prefix: joi.string(),
  defaultRole: joi.string(),
  defaultRegisteredRole: joi.string(),
  userRoleFieldName: joi.string().required(),
  modelsAsResources: joi.boolean().required(),
  fixtures: joi.object().keys({
    roles: joi.array(),
    resources: joi.array(),
    permissions: joi.array()
  }).required(),
  defaultAdminUsername: joi.string().required(),
  defaultAdminPassword: joi.string().required()
})


text:
#include "condor_common.h"
#include "condor_classad.h"
#include "classad_merge.h"

void MergeClassAds(ClassAd *merge_into, ClassAd *merge_from,
				   bool merge_conflicts, bool mark_dirty)
{

	if (!merge_into || !merge_from) {
		return;
	}

	merge_from->ResetName();
	merge_from->ResetExpr();

	const char     *name;
	ExprTree       *expression;

	while ( merge_from->NextExpr(name, expression) ) {

		if (merge_conflicts || !merge_into->LookupExpr(name)) {
			ExprTree  *copy_expression;

			copy_expression = expression->Copy();
			merge_into->Insert(name, copy_expression);
			if ( !mark_dirty ) {
				merge_into->SetDirtyFlag(name, false);
			}
		}
	}

	return;
}


text:
@interface GPXKitTests : XCTestCase

@end

@implementation GPXKitTests

- (void)setUp {
    [super setUp];
    // Put setup code here. This method is called before the invocation of each test method in the class.
}

- (void)tearDown {
    // Put teardown code here. This method is called after the invocation of each test method in the class.
    [super tearDown];
}

- (void)testGPX {
    NSString *path = [[NSBundle bundleForClass:[self class]] pathForResource:@"mystic_basin_trail" ofType:@"gpx"];

    GPXRoot *root = [GPXParser parseGPXAtPath:path];

    // gpx
    XCTAssertNotNil(root);
    XCTAssertEqualObjects(root.creator, @"ExpertGPS 1.1b1 - http://www.topografix.com");

    // gpx > metadata
    GPXMetadata *metadata = root.metadata;
    XCTAssertNotNil(metadata);
    XCTAssertEqualObjects(metadata.name, @"Mystic River Basin Trails");
    XCTAssertEqualObjects(metadata.desc, @"Both banks of the lower Mystic River have paved trails, allowing for a short and a long loop along the water.  The short loop is a two mile trail with no road crossings.  The long loop adds side-trips out to Draw Seven Park and the MBTA yard at Wellington Station, but crosses the six lanes of Route 28 twice.");

    GPXAuthor *author = metadata.author;
    XCTAssertNotNil(author);
    XCTAssertEqualObjects(author.name, @"Dan Foster");
    GPXEmail *authorEmail = author.email;
    XCTAssertNotNil(authorEmail);
    XCTAssertEqualObjects(authorEmail.emailID, @"trails");
    XCTAssertEqualObjects(authorEmail.domain, @"topografix.com");
    GPXLink *authorLink = author.link;
    XCTAssertNotNil(authorLink);
    XCTAssertEqualObjects(authorLink.href, @"http://www.tufts.edu/mystic/amra/pamphlet.html");
    XCTAssertEqualObjects(authorLink.text, @"Lower Mystic Basin Trails");

    GPXCopyright *copyright = metadata.copyright;
    XCTAssertNotNil(copyright);
    XCTAssertEqualObjects(copyright.author, @"Dan Foster");
    XCTAssertEqualObjects(copyright.license, @"http://creativecommons.org/licenses/by/2.0/");

    GPXLink *link = metadata.link;
    XCTAssertNotNil(link);
    XCTAssertEqualObjects(link.href, @"http://www.topografix.com/gpx.asp");
    XCTAssertEqualObjects(link.text, @"GPX site");
    XCTAssertEqualObjects(link.mimetype, @"text/html");

    // gpx > wpt
    XCTAssertEqual(root.waypoints.count, 23);

    GPXWaypoint *waypoint;

    waypoint = [root.waypoints objectAtIndex:0];
    XCTAssertEqual(waypoint.latitude, 42.398167f);
    XCTAssertEqual(waypoint.longitude, -71.083339f);
    XCTAssertEqualObjects(waypoint.name, @"205A");
    XCTAssertEqualObjects(waypoint.desc, @"Concrete platform looking out onto the Mystic.\nWhile you take in the view, try not to think about the fact that you're standing on top of MWRA Wet Water Discharge Outflow #205A");

    waypoint = [root.waypoints objectAtIndex:2];
    XCTAssertEqual(waypoint.latitude, 42.398467f);
    XCTAssertEqual(waypoint.longitude, -71.090467f);
    XCTAssertEqualObjects(waypoint.name, @"BLESSING");
    XCTAssertEqualObjects(waypoint.desc, @"The Blessing of the Bay Boathouse, now run by the Somerville Boys and Girls Club.\nA dock with small boats for the children of Somerville.  Check out the Mystic River mural at the intersection of Shore Drive and Rt 16!");
    XCTAssertEqual(waypoint.links.count, 1U);
    GPXLink *waypointLink = [waypoint.links objectAtIndex:0];
    XCTAssertEqualObjects(waypointLink.href, @"http://www.everydaydesign.com/ourtown/bay.html");
    XCTAssertEqualObjects(waypointLink.text, @"Boat-building on the Mystic River");

    waypoint = [root.waypoints objectAtIndex:22];
    XCTAssertEqual(waypoint.latitude, 42.395889f);
    XCTAssertEqual(waypoint.longitude, -71.077949f);
    XCTAssertEqualObjects(waypoint.name, @"YACHT CLUB");
    XCTAssertEqualObjects(waypoint.desc, @"Winter Hill Yacht Club");

    // gpx > rte
    XCTAssertEqual(root.routes.count, 2);

    GPXRoute *route;
    GPXRoutePoint *routepoint;

    route = [root.routes objectAtIndex:0];
    XCTAssertEqualObjects(route.name, @"LONG LOOP");
    XCTAssertEqualObjects(route.desc, @"The long loop around the Mystic River, with stops at Draw Seven Park and the MBTA yard at Wellington Station (Orange Line).  Crosses Route 28 twice");
    XCTAssertEqual(route.number, 1);
    XCTAssertEqual(route.routepoints.count, 18);

    routepoint = [route.routepoints objectAtIndex:0];
    XCTAssertEqual(routepoint.latitude, 42.405495f);
    XCTAssertEqual(routepoint.longitude, -71.098364f);
    XCTAssertEqualObjects(routepoint.name, @"LOOP");
    XCTAssertEqualObjects(routepoint.desc, @"Starting point for the Mystic River loop trails.");

    routepoint = [route.routepoints objectAtIndex:9];
    XCTAssertEqual(routepoint.latitude, 42.400554f);
    XCTAssertEqual(routepoint.longitude, -71.079901f);
    XCTAssertEqualObjects(routepoint.name, @"WELL YACHT");
    XCTAssertEqualObjects(routepoint.desc, @"Mystic Wellington Yacht Club");

    routepoint = [route.routepoints objectAtIndex:17];
    XCTAssertEqual(routepoint.latitude, 42.405495f);
    XCTAssertEqual(routepoint.longitude, -71.098364f);
    XCTAssertEqualObjects(routepoint.name, @"LOOP");
    XCTAssertEqualObjects(routepoint.desc, @"Starting point for the Mystic River loop trails.");

    route = [root.routes objectAtIndex:1];
    XCTAssertEqualObjects(route.name, @"SHORT LOOP");
    XCTAssertEqualObjects(route.desc, @"Short Mystic River loop.\nThis loop circles the portion of the Mystic River enclosed by Routes 93, 16, and 28.  It's short, but you can do the entire loop without crossing any roads.");
    XCTAssertEqual(route.number, 3);
    XCTAssertEqual(route.routepoints.count, 8);

    routepoint = [route.routepoints objectAtIndex:0];
    XCTAssertEqual(routepoint.latitude, 42.405495f);
    XCTAssertEqual(routepoint.longitude, -71.098364f);
    XCTAssertEqualObjects(routepoint.name, @"LOOP");
    XCTAssertEqualObjects(routepoint.desc, @"Starting point for the Mystic River loop trails.");

    routepoint = [route.routepoints objectAtIndex:3];
    XCTAssertEqual(routepoint.latitude, 42.399733f);
    XCTAssertEqual(routepoint.longitude, -71.083567f);
    XCTAssertEqualObjects(routepoint.name, @"RT 28");
    XCTAssertEqualObjects(routepoint.desc, @"Wellington Bridge\nRoute 28 crosses the Mystic River on this 6 lane bridge.  Pedestrian walkways on both sides.  Access to the Assembly Square mall is at the south end of the bridge.");

    routepoint = [route.routepoints objectAtIndex:7];
    XCTAssertEqual(routepoint.latitude, 42.405495f);
    XCTAssertEqual(routepoint.longitude, -71.098364f);
    XCTAssertEqualObjects(routepoint.name, @"LOOP");
    XCTAssertEqualObjects(routepoint.desc, @"Starting point for the Mystic River loop trails.");

    // gpx > trk
    XCTAssertEqual(root.tracks.count, 3U);

    GPXTrack *track;
    GPXTrackSegment *tracksegment;
    GPXTrackPoint *trackpoint;

    track = [root.tracks objectAtIndex:0];
    XCTAssertEqualObjects(track.name, @"LONG TRACK");
    XCTAssertEqualObjects(track.desc, @"Tracklog from Long Loop");
    XCTAssertEqual(track.number, 2);
    XCTAssertEqual(track.tracksegments.count, 1);
    tracksegment = [track.tracksegments objectAtIndex:0];
    XCTAssertEqual(tracksegment.trackpoints.count, 166);
    trackpoint = [tracksegment.trackpoints objectAtIndex:0];
    XCTAssertEqual(trackpoint.latitude, 42.405488f);
    XCTAssertEqual(trackpoint.longitude, -71.098173f);
    trackpoint = [tracksegment.trackpoints objectAtIndex:82];
    XCTAssertEqual(trackpoint.latitude, 42.399266f);
    XCTAssertEqual(trackpoint.longitude, -71.083581f);
    trackpoint = [tracksegment.trackpoints objectAtIndex:165];
    XCTAssertEqual(trackpoint.latitude, 42.405703f);
    XCTAssertEqual(trackpoint.longitude, -71.098065f);

    track = [root.tracks objectAtIndex:1];
    XCTAssertEqualObjects(track.name, @"SHORT TRACK");
    XCTAssertEqualObjects(track.desc, @"Bike path along the Mystic River in Medford.\nThe trail runs along Interstate 93 to Shore Road.  It then crosses the Mystic on the Route 38 bridge near the Assembly Square mall.  After the bridge, the trail cuts through the high meadow grass behind the State Police barracks, and enters Torbert McDonald Park.  Leaving the park, the trail passes the Meadow Glen mall before crossing back over the Mystic on the Rt 16 bridge.");
    XCTAssertEqual(track.number, 4);
    XCTAssertEqual(track.tracksegments.count, 1);
    tracksegment = [track.tracksegments objectAtIndex:0];
    XCTAssertEqual(tracksegment.trackpoints.count, 95);
    trackpoint = [tracksegment.trackpoints objectAtIndex:0];
    XCTAssertEqual(trackpoint.latitude, 42.405381f);
    XCTAssertEqual(trackpoint.longitude, -71.098108f);
    trackpoint = [tracksegment.trackpoints objectAtIndex:48];
    XCTAssertEqual(trackpoint.latitude, 42.403944f);
    XCTAssertEqual(trackpoint.longitude, -71.085405f);
    trackpoint = [tracksegment.trackpoints objectAtIndex:94];
    XCTAssertEqual(trackpoint.latitude, 42.405660f);
    XCTAssertEqual(trackpoint.longitude, -71.098280f);

    track = [root.tracks objectAtIndex:2];
    XCTAssertEqualObjects(track.name, @"TUFTS CONNECT");
    XCTAssertEqualObjects(track.desc, @"Connecting route from Tufts Park to beginning of Mystic Basin loop trail.");
    XCTAssertEqual(track.number, 5);
    XCTAssertEqual(track.tracksegments.count, 1);
    tracksegment = [track.tracksegments objectAtIndex:0];
    XCTAssertEqual(tracksegment.trackpoints.count, 24);
    trackpoint = [tracksegment.trackpoints objectAtIndex:0];
    XCTAssertEqual(trackpoint.latitude, 42.402356f);
    XCTAssertEqual(trackpoint.longitude, -71.107807f);
    trackpoint = [tracksegment.trackpoints objectAtIndex:11];
    XCTAssertEqual(trackpoint.latitude, 42.405317f);
    XCTAssertEqual(trackpoint.longitude, -71.103923f);
    trackpoint = [tracksegment.trackpoints objectAtIndex:23];
    XCTAssertEqual(trackpoint.latitude, 42.405424f);
    XCTAssertEqual(trackpoint.longitude, -71.098173f);
}

@end


text:
package org.apache.hadoop.hive.ql.optimizer.calcite;

import java.util.List;

import org.apache.calcite.rel.RelNode;
import org.apache.calcite.rel.metadata.ChainedRelMetadataProvider;
import org.apache.calcite.rel.metadata.JaninoRelMetadataProvider;
import org.apache.calcite.rel.metadata.RelMetadataProvider;
import org.apache.hadoop.hive.conf.HiveConf;
import org.apache.hadoop.hive.ql.optimizer.calcite.cost.HiveDefaultCostModel;
import org.apache.hadoop.hive.ql.optimizer.calcite.cost.HiveOnTezCostModel;
import org.apache.hadoop.hive.ql.optimizer.calcite.cost.HiveRelMdCost;
import org.apache.hadoop.hive.ql.optimizer.calcite.stats.HiveRelMdColumnUniqueness;
import org.apache.hadoop.hive.ql.optimizer.calcite.stats.HiveRelMdCollation;
import org.apache.hadoop.hive.ql.optimizer.calcite.stats.HiveRelMdCumulativeCost;
import org.apache.hadoop.hive.ql.optimizer.calcite.stats.HiveRelMdDistinctRowCount;
import org.apache.hadoop.hive.ql.optimizer.calcite.stats.HiveRelMdDistribution;
import org.apache.hadoop.hive.ql.optimizer.calcite.stats.HiveRelMdExpressionLineage;
import org.apache.hadoop.hive.ql.optimizer.calcite.stats.HiveRelMdMemory;
import org.apache.hadoop.hive.ql.optimizer.calcite.stats.HiveRelMdParallelism;
import org.apache.hadoop.hive.ql.optimizer.calcite.stats.HiveRelMdPredicates;
import org.apache.hadoop.hive.ql.optimizer.calcite.stats.HiveRelMdRowCount;
import org.apache.hadoop.hive.ql.optimizer.calcite.stats.HiveRelMdRuntimeRowCount;
import org.apache.hadoop.hive.ql.optimizer.calcite.stats.HiveRelMdSelectivity;
import org.apache.hadoop.hive.ql.optimizer.calcite.stats.HiveRelMdSize;
import org.apache.hadoop.hive.ql.optimizer.calcite.stats.HiveRelMdUniqueKeys;

import com.google.common.collect.ImmutableList;

public class HiveDefaultRelMetadataProvider {

  /**
   * The default metadata provider can be instantiated statically since
   * it does not need any parameter specified by user (hive conf).
   */
  private static final JaninoRelMetadataProvider DEFAULT =
      JaninoRelMetadataProvider.of(
          ChainedRelMetadataProvider.of(
              ImmutableList.of(
                  HiveRelMdDistinctRowCount.SOURCE,
                  HiveRelMdCumulativeCost.SOURCE,
                  new HiveRelMdCost(HiveDefaultCostModel.getCostModel()).getMetadataProvider(),
                  HiveRelMdSelectivity.SOURCE,
                  HiveRelMdRuntimeRowCount.SOURCE,
                  HiveRelMdUniqueKeys.SOURCE,
                  HiveRelMdColumnUniqueness.SOURCE,
                  HiveRelMdExpressionLineage.SOURCE,
                  HiveRelMdSize.SOURCE,
                  HiveRelMdMemory.SOURCE,
                  HiveRelMdDistribution.SOURCE,
                  HiveRelMdCollation.SOURCE,
                  HiveRelMdPredicates.SOURCE,
                  JaninoRelMetadataProvider.DEFAULT)));

  private final RelMetadataProvider metadataProvider;

  public HiveDefaultRelMetadataProvider(HiveConf hiveConf, List<Class<? extends RelNode>> nodeClasses) {
    this.metadataProvider = init(hiveConf, nodeClasses);
  }

  private RelMetadataProvider init(HiveConf hiveConf, List<Class<? extends RelNode>> nodeClasses) {
    // Create cost metadata provider
    if (HiveConf.getVar(hiveConf, HiveConf.ConfVars.HIVE_EXECUTION_ENGINE).equals("tez")
        && HiveConf.getBoolVar(hiveConf, HiveConf.ConfVars.HIVE_CBO_EXTENDED_COST_MODEL)) {
      // Get max split size for HiveRelMdParallelism
      final Double maxSplitSize = (double) HiveConf.getLongVar(
          hiveConf, HiveConf.ConfVars.MAPREDMAXSPLITSIZE);

      // Create and return metadata provider
      JaninoRelMetadataProvider metadataProvider = JaninoRelMetadataProvider.of(
          ChainedRelMetadataProvider.of(
              ImmutableList.of(
                  HiveRelMdDistinctRowCount.SOURCE,
                  HiveRelMdCumulativeCost.SOURCE,
                  new HiveRelMdCost(HiveOnTezCostModel.getCostModel(hiveConf)).getMetadataProvider(),
                  HiveRelMdSelectivity.SOURCE,
                  HiveRelMdRowCount.SOURCE,
                  HiveRelMdUniqueKeys.SOURCE,
                  HiveRelMdColumnUniqueness.SOURCE,
                  HiveRelMdExpressionLineage.SOURCE,
                  HiveRelMdSize.SOURCE,
                  HiveRelMdMemory.SOURCE,
                  new HiveRelMdParallelism(maxSplitSize).getMetadataProvider(),
                  HiveRelMdDistribution.SOURCE,
                  HiveRelMdCollation.SOURCE,
                  HiveRelMdPredicates.SOURCE,
                  JaninoRelMetadataProvider.DEFAULT)));

      if (nodeClasses != null) {
        // If classes were passed, pre-register them
        metadataProvider.register(nodeClasses);
      }

      return metadataProvider;
    }

    return DEFAULT;
  }

  public RelMetadataProvider getMetadataProvider() {
    return metadataProvider;
  }

  /**
   * This method can be called at startup time to pre-register all the
   * additional Hive classes (compared to Calcite core classes) that may
   * be visited during the planning phase.
   */
  public static void initializeMetadataProviderClass(List<Class<? extends RelNode>> nodeClasses) {
    // This will register the classes in the default Hive implementation
    DEFAULT.register(nodeClasses);
  }
}


text:
id: separation-logic-and-bi-abduction
title: Separation logic and bi-abduction
---

export const Math = ({ code }) => ( <img
src={`https://math.now.sh?from=${encodeURIComponent(code)}&color=mediumslateblue`}
style={{ height: '100%', verticalAlign: "middle" }} /> );

- [Separation logic](separation-logic-and-bi-abduction#separation-logic)
- [Bi-abduction](separation-logic-and-bi-abduction#bi-abduction)
- [Technical papers](separation-logic-and-bi-abduction#technical-papers)

## Separation logic

Separation logic is a novel kind of mathematical logic which facilitates
reasoning about mutations to computer memory. It enables scalability by breaking
reasoning into chunks corresponding to local operations on memory, and then
composing the reasoning chunks together.

Separation logic is based on a logical connective <Math code="\\( * \\)" />
called the _separating conjunction_ and pronounced "and separately". Separation
logic formulae are interpreted over program allocated heaps. The logical formula
<Math code="\\( A*B \\)" /> holds of a piece of program heap (a heaplet) when it
can be divided into two sub-heaplets described by <Math code="\\(A\\)" /> and
<Math code="\\(B\\)" />. For example, the formula

---

<Math code="\\(x \mapsto y * y \mapsto x \\)" />

---

can be read "<Math code="\\(x\\)" /> points to <Math code="\\(y\\)" /> and
separately <Math code="\\(y\\)" /> points to <Math code="\\(x\\)" />". This
formula describes precisely two allocated memory cells. The first cell is
allocated at the address denoted by the pointer <Math code="\\(x\\)" /> and the
content of this cell is the value of <Math code="\\(y\\)" />. The second cell is
allocated at the address denoted by the pointer <Math code="\\(y\\)" /> and the
content of this second cell is the value of <Math code="\\(x\\)" />. Crucially,
we know that there are precisely two cells because <Math code="\\( * \\)" />
stipulates that they are separated and therefore the cells are allocated in two
different parts of memory. In other words, <Math code="\\( * \\)" /> says that
<Math code="\\(x\\)" /> and <Math code="\\(y\\)" /> do not hold the same value
(i.e., these pointers are not aliased). The heaplet partitioning defined by the
formula above can be visualized like so:

![](/img/SepSplit.jpg)

The important thing about separating conjunction is the way that it fits
together with mutation to computer memory; reasoning about program commands
tends to work by updating <Math code="\\(*\\)" />-conjuncts in-place, mimicking
the operational in-place update of RAM.

Separation logic uses Hoare triples of the form
<Math code="\\( \lbrace pre \rbrace prog \lbrace post \rbrace \\)" /> where
<Math code="\\(pre\\)" /> is the precondition, <Math code="\\(prog\\)" /> a
program part, and <Math code="\\(post\\)" /> the postcondition. Triples are
abstract specifications of the behavior of the program. For example, we could
take

---

<Math code="\\( \lbrace r \mapsto open\rbrace \, closeResource(r)\, \lbrace r \mapsto closed\rbrace  \;\;\; (spec)\\)" />

---

as a specification for a method which closes a resource given to it as a
parameter.

Now, suppose we have two resources <Math code="\\( r\_1 \\)" /> and
<Math code="\\( r\_2 \\)" />, described by
<Math code="\\(r\_1 \mapsto open * r\_2 \mapsto open\\)" /> and we close the
first of them. We think operationally in terms of updating the memory in place,
leaving <Math code="\\(r\_2 \mapsto open\\)" /> alone, as described by this triple:

---

<Math code="\\( \lbrace r\_1 \mapsto open * r\_2 \mapsto open\rbrace  closeResource(r\_1) \lbrace r\_1 \mapsto closed * r\_2 \mapsto open \rbrace \;\;\; (use)\\)" />

---

What we have here is the that specification (spec) described how
<Math code="\\(closeResource()\\)" /> works by mentioning only one piece of
state, what is sometimes called a small specification, and in (use) we use that
specification to update a larger precondition in place.

This is an instance of a general pattern. There is a rule that lets you go from
smaller to bigger specifications

---

<Math code="\\( \frac{\lbrace pre \rbrace prog \lbrace post \rbrace}{\lbrace pre * frame \rbrace prog \lbrace post * frame \rbrace}\\)" />

---

Our passage from (spec) to (use) is obtained by taking

- <Math code="\\(pre\\)" /> to be <Math code="\\(r\_1 \mapsto open\\)" />
- <Math code="\\(post\\)" /> to be <Math code="\\(r\_1 \mapsto closed \\)" />,
  and
- <Math code="\\(frame\\)" /> to be <Math code="\\(r\_2 \mapsto open \\)" />

This rule is called the _frame rule_ of separation logic. It is named after the
frame problem, a classic problem in artificial intelligence. Generally, the
<Math code="\\(frame\\)" /> describes state that remains unchanged; the
terminology comes from the analogy of a background scene in an animation as
unchanging while the objects and characters within the scene change.

The frame rule is the key to the principle of local reasoning in separation
logic: reasoning and specifications should concentrate on the resources that a
program accesses (the footprint), without mentioning what doesn't change.

## Bi-abduction

Bi-abduction is a form of logical inference for separation logic which automates
the key ideas about local reasoning.

Usually, logic works with validity or entailment statements like

---

<Math code="\\(A \vdash B\\)" />

---

which says that <Math code="\\(A\\)" /> implies <Math code="\\(B\\)" />. Infer
uses an extension of this inference question in an internal theorem prover while
it runs over program statements. Infer's question

---

<Math code="\\(A * ?antiframe \vdash B * ?frame\\)" />

---

is called _bi-abduction_. The problem here is for the theorem prover to
discover  a pair of frame and antiframe formulae that make the entailment
statement valid.

Global analyses of large programs are normally computational untractable.
However, bi-abduction allows to break the large analysis of a large program in
small independent analyses of its procedures. This gives Infer the ability to
scale independently of the size of the analyzed code. Moreover, by breaking the
analysis in small independent parts, when the full program is analyzed again
because of a code change the analysis results of the unchanged part of the code
can be reused and only the code change needs to be re-analyzed. This process is
called incremental analysis and it is very powerful when integrating a static
analysis tool like infer in a development environment.

In order to be able to decompose a global analysis in small independent
analyses, let's first consider how a function call is analyzed in separation
logic. Assume we have the following spec for a function
<Math code="\\( f() \\)" />:

---

<Math code="\\( \lbrace pre\_f \rbrace \;\; f() \;\; \lbrace post\_f \rbrace \\)" />

---

and by analyzing the caller function, we compute that before the call of
<Math code="\\( f \\)" />, the formula <Math code="\\( CallingState \\)" />
hold. Then to utilize the specification of <Math code="\\( f \\)" /> the
following implication must holds:

---

<Math code="\\( CallingState \vdash pre\_f  \;\;\;\;\;\;\;\;\;\;\;\; (Function Call)\\)" />

---

Given that, bi-abduction is used at procedure call sites for two reasons: to
discover missing state that is needed for the above implication to hold and
allow the analysis to proceed (the antiframe) as well as state that the
procedure leaves unchanged (the frame).

To see how this works suppose we have some bare code

---

<Math code="\\(closeResource(r1); \, closeResource(r2)\\)" />

---

but no overall specification; we are going to describe how to discover a
pre/post spec for it. Considering the first statement and the (spec) above, the
human might say: if only we had <Math code="\\(r1 \mapsto open\\)" /> in the
precondition then we could proceed. Technically, we ask a bi-abduction question

---

<Math code="\\(emp * ?antiframe \vdash r1 \mapsto open * ?frame\\)" />

---

and we can fill this in easily by picking
<Math code="\\(antiframe = r1 \mapsto open\\)" /> and
<Math code="\\(frame = emp\\)" />, where emp means the empty state. The emp is
recording that at the start we presume nothing. So we obtain the trivially true
implication:

---

<Math code="\\(emp * r1 \mapsto open \vdash r1 \mapsto open * emp\\)" />

---

which, by applying logical rules, can be re-written equivalently to:

---

<Math code="\\(r1 \mapsto open \vdash r1 \mapsto open\\)" />

---

Notice that this satisfy the (Function Call) requirement to correctly make the
call. So let's add that information in the pre, and while we are at it record
the information in the post of the first statement that comes from (spec).

---

<Math code="\\( \lbrace r1 \mapsto open  \rbrace \\)" />
<Math code="\\( closeResource(r1) \\)" />
<Math code="\\( \lbrace r1 \mapsto closed \rbrace \\)" />
<Math code="\\( closeResource(r2) \\)" />

---

Now, let's move to the second statement. Its precondition
<Math code="\\(r1 \mapsto closed\\)" /> in the partial symbolic execution trace
just given does not have the information needed by
<Math code="\\(closeResource(r2)\\)" />, so we can fill that in and continue by
putting <Math code="\\(r2 \mapsto open\\)" /> in the pre. While we are at it we
can thread this assertion back to the beginning.

---

<Math code="\\( \lbrace r1 \mapsto open * r2 \mapsto open  \rbrace \\)" />
<Math code="\\( closeResource(r1) \\)" />
<Math code="\\( \lbrace r1 \mapsto closed * r2 \mapsto open\rbrace \\)" />
<Math code="\\( closeResource(r2) \\)" />

---

This information on what to thread backwards can be obtained as the antiframe
part of the bi-abduction question

---

<Math code="\\(r1 \mapsto closed * ?antiframe \vdash r2 \mapsto open * ?frame\\)" />

---

where the solution picks
<Math code="\\(antiframe = r2 \mapsto open\\) and \\(frame = r1 \mapsto closed\\)" />.
Note that the antiframe is precisely the information missing from the
precondition in order for <Math code="\\(closeResource(r2)\\)" /> to proceed. On
the other hand, the frame <Math code="\\(r1 \mapsto closed\\)" /> is the portion
of state not changed by <Math code="\\(closeResource(r2)\\)" />; we can thread
that through to the overall postconditon (as justified by the frame rule),
giving us

---

<Math code="\\( \lbrace r1 \mapsto open * r2 \mapsto open  \rbrace \\)" />
<Math code="\\( closeResource(r1) \\)" />
<Math code="\\( \lbrace r1 \mapsto closed * r2 \mapsto open\rbrace \\)" />
<Math code="\\( closeResource(r2) \\)" />
<Math code="\\( \lbrace r1 \mapsto closed * r2 \mapsto closed \rbrace\\)" />

---

Thus, we have obtained a pre and post for this code by symbolically executing
it, using bi-abduction to discover preconditions (abduction of antiframes) as
well as untouched portions of memory (frames) as we go along.

In general, bi-abduction provides a way to infer a pre/post specs from bare
code, as long as we know specs for the primitives at the base level of the code.
The human does not need to write preconditions and postconditions for all the
procedures, which is the key to having a high level of automation. This is the
basis for how Infer works, why it can scale, and how it can analyze code changes
incrementally.

Context: The logical terminology we have been using here comes from AI and
philosophy of science. Abductive inference was introduced by the philosopher
Charles Peirce, and described as the mechanism underpinning hypothesis formation
(or, guessing what might be true about the world), the most creative part of the
scientific process. Abduction and the frame problem have both attracted
significant attention in AI. Infer uses an automated form of abduction to
generate preconditions describing the memory that a program touches (the
antiframe part above), and frame inference to discover what isn't touched. Infer
then uses deductive reasoning to calculate a formula describing the effect of a
program, starting from the preconditions. In a sense, Infer approaches automated
reasoning about programs by mimicking what a human might do when trying to
understand a program: it abduces what the program needs, and deduces conclusions
of that. It is when the reasoning goes wrong that Infer reports a potential bug.

This description is by necessity simplified compared to what Infer actually
does. More technical information can be found in the following papers. The
descriptions in the papers are precise, but still simplified; there are many
engineering decisions not recorded there. Finally, beyond the papers, you can
read the source code if you wish!

## Technical papers

The following papers contain some of the technical background on Infer and
information on how it is used inside Facebook.

- Local
  Reasoning about Programs that Alter Data Structures. An early separation
  logic paper which advanced ideas about local reasoning and the frame rule.
- Smallfoot:
  Modular Automatic Assertion Checking with Separation Logic. First
  separation logic verification tool, introduced frame inference
- A Local Shape
  Analysis Based on Separation Logic. Separation logic meets abstract
  interpretation; calculating loop invariants via a fixed-point computation.
- Compositional Shape
  Analysis by Means of Bi-Abduction. The bi-abduction paper.
- Moving
  Fast with Software Verification. A paper about the way we use Infer at
  Facebook.


text:
({
    /*
     * Make sure that forEach defs with items of null or empty lists render nothing and don't cause js errors
     */
    testEmptyLists:{
        test:function(cmp){
        	var children = cmp.getSuper().get("v.body");
            $A.test.assertEquals(8, children.length);
            $A.test.assertEquals("start", children[0].getLocalId());
            $A.test.assertEquals("0", $A.test.getTextByComponent(children[0]));
            $A.test.assertEquals("end", children[7].getLocalId());
            $A.test.assertEquals("1", $A.test.getTextByComponent(children[7]));
            for(var i =1; i<7;i++){
            	$A.test.assertEquals("", $A.test.getTextByComponent(children[i]));
            }
        }
    }
})


text:
package software.amazon.awssdk.enhanced.dynamodb.internal.converter.string;

import software.amazon.awssdk.annotations.Immutable;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.annotations.ThreadSafe;
import software.amazon.awssdk.enhanced.dynamodb.EnhancedType;
import software.amazon.awssdk.enhanced.dynamodb.internal.converter.PrimitiveConverter;
import software.amazon.awssdk.enhanced.dynamodb.internal.converter.StringConverter;
import software.amazon.awssdk.utils.Validate;

/**
 * A converter between {@link Character} and {@link String}.
 *
 * <p>
 * This converts values using {@link Character#toString()} and {@link String#charAt(int)}. If the string value is longer
 * than 1 character, an exception will be raised.
 */
@SdkInternalApi
@ThreadSafe
@Immutable
public class CharacterStringConverter implements StringConverter<Character>, PrimitiveConverter<Character> {
    private CharacterStringConverter() {
    }

    public static CharacterStringConverter create() {
        return new CharacterStringConverter();
    }

    @Override
    public EnhancedType<Character> type() {
        return EnhancedType.of(Character.class);
    }

    @Override
    public EnhancedType<Character> primitiveType() {
        return EnhancedType.of(char.class);
    }

    @Override
    public Character fromString(String string) {
        Validate.isTrue(string.length() == 1, "Character string was not of length 1: %s", string);
        return string.charAt(0);
    }
}


text:
<?xml version='1.0' encoding='utf-8'?>
<project name="org.oasis.spec.xhtml">
  <import file="build_dita2spec-xhtml.xml"/>
</project>


text:
"use strict";

! function(root, factory) {
    if ("function" === typeof define && define.amd) {
        define((function(require) {
            factory(require("devextreme/localization"))
        }))
    } else if ("object" === typeof module && module.exports) {
        factory(require("devextreme/localization"))
    } else {
        factory(DevExpress.localization)
    }
}(0, (function(localization) {
    localization.loadMessages({
        sv: {
            Yes: "Ja",
            No: "Nej",
            Cancel: "Avbryt",
            Close: "St\xe4ng",
            Clear: "Rensa",
            Done: "Klar",
            Loading: "Laddar...",
            Select: "V\xe4lj...",
            Search: "S\xf6k",
            Back: "Tillbaka",
            OK: "OK",
            "dxCollectionWidget-noDataText": "Inget data att visa",
            "dxDropDownEditor-selectLabel": "V\xe4lj",
            "validation-required": "Kr\xe4vs",
            "validation-required-formatted": "{0} kr\xe4vs",
            "validation-numeric": "V\xe4rdet m\xe5ste vara ett nummer",
            "validation-numeric-formatted": "{0} m\xe5ste vara ett nummer",
            "validation-range": "V\xe4rdet utanf\xf6r till\xe5tet intervall",
            "validation-range-formatted": "{0} utanf\xf6r till\xe5tet intervall",
            "validation-stringLength": "L\xe4ngden p\xe5 v\xe4rdet \xe4r inte korrekt",
            "validation-stringLength-formatted": "L\xe4ngden p\xe5  {0} \xe4r inte korrekt",
            "validation-custom": "Ogiltigt v\xe4rde",
            "validation-custom-formatted": "{0} \xe4r ogiltigt",
            "validation-async": "Ogiltigt v\xe4rde",
            "validation-async-formatted": "{0} \xe4r ogiltigt",
            "validation-compare": "V\xe4rdena matchar inte",
            "validation-compare-formatted": "{0} matchar inte",
            "validation-pattern": "V\xe4rdet matchar inte m\xf6nster",
            "validation-pattern-formatted": "{0} matchar inte m\xf6nster",
            "validation-email": "E-post \xe4r ogiltigt",
            "validation-email-formatted": "{0} \xe4r ogiltigt",
            "validation-mask": "V\xe4rdet \xe4r ogiltigt",
            "dxLookup-searchPlaceholder": "Minsta antal tecken: {0}",
            "dxList-pullingDownText": "Dra ner\xe5t f\xf6r att uppdatera...",
            "dxList-pulledDownText": "Sl\xe4pp f\xf6r att uppdatera...",
            "dxList-refreshingText": "Uppdaterar...",
            "dxList-pageLoadingText": "Laddar...",
            "dxList-nextButtonText": "Mer",
            "dxList-selectAll": "V\xe4lj alla",
            "dxListEditDecorator-delete": "Radera",
            "dxListEditDecorator-more": "Mer",
            "dxScrollView-pullingDownText": "Dra ner\xe5t f\xf6r att uppdatera...",
            "dxScrollView-pulledDownText": "Sl\xe4pp f\xf6r att uppdatera...",
            "dxScrollView-refreshingText": "uppdaterar...",
            "dxScrollView-reachBottomText": "Laddar...",
            "dxDateBox-simulatedDataPickerTitleTime": "V\xe4lj tid",
            "dxDateBox-simulatedDataPickerTitleDate": "V\xe4lj datum",
            "dxDateBox-simulatedDataPickerTitleDateTime": "V\xe4lj datum och tid",
            "dxDateBox-validation-datetime": "V\xe4rdet m\xe5ste vara ett datum eller en tid",
            "dxFileUploader-selectFile": "V\xe4lj fil",
            "dxFileUploader-dropFile": "eller sl\xe4pp filen h\xe4r",
            "dxFileUploader-bytes": "byte",
            "dxFileUploader-kb": "kb",
            "dxFileUploader-Mb": "Mb",
            "dxFileUploader-Gb": "Gb",
            "dxFileUploader-upload": "Ladda upp",
            "dxFileUploader-uploaded": "Uppladdad",
            "dxFileUploader-readyToUpload": "Klar att ladda upp",
            "dxFileUploader-uploadAbortedMessage": "Upload cancelled",
            "dxFileUploader-uploadFailedMessage": "Uppladdning misslyckades",
            "dxFileUploader-invalidFileExtension": "File type is not allowed",
            "dxFileUploader-invalidMaxFileSize": "File is too large",
            "dxFileUploader-invalidMinFileSize": "File is too small",
            "dxRangeSlider-ariaFrom": "Fr\xe5n",
            "dxRangeSlider-ariaTill": "Till",
            "dxSwitch-switchedOnText": "P\xc5",
            "dxSwitch-switchedOffText": "AV",
            "dxForm-optionalMark": "valfri",
            "dxForm-requiredMessage": "{0} \xe4r n\xf6dv\xe4ndigt",
            "dxNumberBox-invalidValueMessage": "V\xe4rdet m\xe5ste vara ett nummer",
            "dxNumberBox-noDataText": "Inget data",
            "dxDataGrid-columnChooserTitle": "Kolumnv\xe4ljare",
            "dxDataGrid-columnChooserEmptyText": "Dra en kolumn hit f\xf6r att d\xf6lja den",
            "dxDataGrid-groupContinuesMessage": "Forts\xe4tter p\xe5 n\xe4sta sida",
            "dxDataGrid-groupContinuedMessage": "Forts\xe4ttning fr\xe5n f\xf6reg\xe5ende sida",
            "dxDataGrid-groupHeaderText": "Gruppera enligt denna kolumn",
            "dxDataGrid-ungroupHeaderText": "Avgruppera",
            "dxDataGrid-ungroupAllText": "Avgruppera allt",
            "dxDataGrid-editingEditRow": "Redigera",
            "dxDataGrid-editingSaveRowChanges": "Spara",
            "dxDataGrid-editingCancelRowChanges": "Avbryt",
            "dxDataGrid-editingDeleteRow": "Radera",
            "dxDataGrid-editingUndeleteRow": "\xc5ngra radering",
            "dxDataGrid-editingConfirmDeleteMessage": "\xc4r du s\xe4ker p\xe5 att du vill radera denna post?",
            "dxDataGrid-validationCancelChanges": "Avbryt \xe4ndringarna",
            "dxDataGrid-groupPanelEmptyText": "Dra en kolumnrubrik hit f\xf6r att gruppera enligt den kolumnen",
            "dxDataGrid-noDataText": "Inget data",
            "dxDataGrid-searchPanelPlaceholder": "S\xf6k...",
            "dxDataGrid-filterRowShowAllText": "(Allt)",
            "dxDataGrid-filterRowResetOperationText": "\xc5terst\xe4ll",
            "dxDataGrid-filterRowOperationEquals": "\xc4r lika med",
            "dxDataGrid-filterRowOperationNotEquals": "\xc4r olika",
            "dxDataGrid-filterRowOperationLess": "Mindre \xe4n",
            "dxDataGrid-filterRowOperationLessOrEquals": "Mindre \xe4n eller lika med",
            "dxDataGrid-filterRowOperationGreater": "St\xf6rre \xe4n",
            "dxDataGrid-filterRowOperationGreaterOrEquals": "St\xf6rre \xe4n eller lika med",
            "dxDataGrid-filterRowOperationStartsWith": "B\xf6rjar med",
            "dxDataGrid-filterRowOperationContains": "Inneh\xe5ller",
            "dxDataGrid-filterRowOperationNotContains": "Inneh\xe5ller inte",
            "dxDataGrid-filterRowOperationEndsWith": "Slutar med",
            "dxDataGrid-filterRowOperationBetween": "Mellan",
            "dxDataGrid-filterRowOperationBetweenStartText": "Start",
            "dxDataGrid-filterRowOperationBetweenEndText": "Slut",
            "dxDataGrid-applyFilterText": "Anv\xe4nd filter",
            "dxDataGrid-trueText": "sant",
            "dxDataGrid-falseText": "falskt",
            "dxDataGrid-sortingAscendingText": "Sortera stigande",
            "dxDataGrid-sortingDescendingText": "Sortera fallande",
            "dxDataGrid-sortingClearText": "Rensa sortering",
            "dxDataGrid-editingSaveAllChanges": "Spara \xe4ndringar",
            "dxDataGrid-editingCancelAllChanges": "\xc5ngra \xe4ndringar",
            "dxDataGrid-editingAddRow": "L\xe4gg till rad",
            "dxDataGrid-summaryMin": "Min: {0}",
            "dxDataGrid-summaryMinOtherColumn": "Minimi av {1} \xe4r {0}",
            "dxDataGrid-summaryMax": "Max: {0}",
            "dxDataGrid-summaryMaxOtherColumn": "Maximi av {1} \xe4r {0}",
            "dxDataGrid-summaryAvg": "Medel: {0}",
            "dxDataGrid-summaryAvgOtherColumn": "Medeltal av {1} \xe4r {0}",
            "dxDataGrid-summarySum": "Sum: {0}",
            "dxDataGrid-summarySumOtherColumn": "Summan av {1} \xe4r {0}",
            "dxDataGrid-summaryCount": "Antal: {0}",
            "dxDataGrid-columnFixingFix": "Fixera",
            "dxDataGrid-columnFixingUnfix": "Avfixera",
            "dxDataGrid-columnFixingLeftPosition": "Till v\xe4nster",
            "dxDataGrid-columnFixingRightPosition": "Till h\xf6ger",
            "dxDataGrid-exportTo": "Exportera",
            "dxDataGrid-exportToExcel": "Exportera till Excel fil",
            "dxDataGrid-exporting": "Exportera...",
            "dxDataGrid-excelFormat": "Excel fil",
            "dxDataGrid-selectedRows": "Valda rader",
            "dxDataGrid-exportSelectedRows": "Exportera valda rader",
            "dxDataGrid-exportAll": "Exportera allt",
            "dxDataGrid-headerFilterLabel": "Filter options",
            "dxDataGrid-headerFilterIndicatorLabel": "Show filter options for column '{0}'",
            "dxDataGrid-headerFilterEmptyValue": "(Tomma)",
            "dxDataGrid-headerFilterOK": "OK",
            "dxDataGrid-headerFilterCancel": "Avbryt",
            "dxDataGrid-ariaAdaptiveCollapse": "Hide additional data",
            "dxDataGrid-ariaAdaptiveExpand": "Display additional data",
            "dxDataGrid-ariaColumn": "Kolumn",
            "dxDataGrid-ariaValue": "V\xe4rde",
            "dxDataGrid-ariaFilterCell": "Filtrera cell",
            "dxDataGrid-ariaCollapse": "Kollapsa",
            "dxDataGrid-ariaExpand": "Expandera",
            "dxDataGrid-ariaDataGrid": "Datarutn\xe4t",
            "dxDataGrid-ariaSearchInGrid": "S\xf6k i datarutn\xe4tet",
            "dxDataGrid-ariaSelectAll": "V\xe4lj allt",
            "dxDataGrid-ariaSelectRow": "V\xe4lj rad",
            "dxDataGrid-ariaToolbar": "Data grid toolbar",
            "dxDataGrid-filterBuilderPopupTitle": "Filterverktyg",
            "dxDataGrid-filterPanelCreateFilter": "Skapa filter",
            "dxDataGrid-filterPanelClearFilter": "Rensa",
            "dxDataGrid-filterPanelFilterEnabledHint": "Aktivera filter",
            "dxTreeList-ariaTreeList": "Tr\xe4dlista",
            "dxTreeList-ariaSearchInGrid": "Search in the tree list",
            "dxTreeList-ariaToolbar": "Tree list toolbar",
            "dxTreeList-editingAddRowToNode": "L\xe4gg till",
            "dxPager-infoText": "Sida {0} av {1} ({2} uppgifter)",
            "dxPager-pagesCountText": "av",
            "dxPager-pageSizesAllText": "Allt",
            "dxPager-page": "Page {0}",
            "dxPager-prevPage": "Previous Page",
            "dxPager-nextPage": "Next Page",
            "dxPager-ariaLabel": "Page Navigation",
            "dxPivotGrid-grandTotal": "Totalsumma",
            "dxPivotGrid-total": "{0} Summa",
            "dxPivotGrid-fieldChooserTitle": "F\xe4ltv\xe4ljare",
            "dxPivotGrid-showFieldChooser": "Visa f\xe4ltv\xe4ljare",
            "dxPivotGrid-expandAll": "Expandera alla",
            "dxPivotGrid-collapseAll": "Kollapsa alla",
            "dxPivotGrid-sortColumnBySummary": 'Sortera "{0}" enligt denna kolumn',
            "dxPivotGrid-sortRowBySummary": 'Sortera "{0}" enligt denna rad',
            "dxPivotGrid-removeAllSorting": "Avl\xe4gsna all sortering",
            "dxPivotGrid-dataNotAvailable": "Saknas",
            "dxPivotGrid-rowFields": "Radf\xe4lt",
            "dxPivotGrid-columnFields": "Kolumnf\xe4lt",
            "dxPivotGrid-dataFields": "Dataf\xe4lt",
            "dxPivotGrid-filterFields": "Filterf\xe4lt",
            "dxPivotGrid-allFields": "Alla f\xe4lt",
            "dxPivotGrid-columnFieldArea": "Sl\xe4pp kolumnf\xe4lt h\xe4r",
            "dxPivotGrid-dataFieldArea": "Sl\xe4pp dataf\xe4lt h\xe4r",
            "dxPivotGrid-rowFieldArea": "Sl\xe4pp radf\xe4lt h\xe4r",
            "dxPivotGrid-filterFieldArea": "Sl\xe4pp filterf\xe4lt h\xe4r",
            "dxScheduler-editorLabelTitle": "\xc4mne",
            "dxScheduler-editorLabelStartDate": "Startdatum",
            "dxScheduler-editorLabelEndDate": "Slutdatum",
            "dxScheduler-editorLabelDescription": "Beskrivning",
            "dxScheduler-editorLabelRecurrence": "Upprepa",
            "dxScheduler-openAppointment": "\xd6ppna avtalad tid",
            "dxScheduler-recurrenceNever": "Aldrig",
            "dxScheduler-recurrenceMinutely": "Minutely",
            "dxScheduler-recurrenceHourly": "Hourly",
            "dxScheduler-recurrenceDaily": "Varje dag",
            "dxScheduler-recurrenceWeekly": "Varje vecka",
            "dxScheduler-recurrenceMonthly": "Varje m\xe5nad",
            "dxScheduler-recurrenceYearly": "Varje \xe5r",
            "dxScheduler-recurrenceRepeatEvery": "Varje",
            "dxScheduler-recurrenceRepeatOn": "Repeat On",
            "dxScheduler-recurrenceEnd": "Upprepning slutar",
            "dxScheduler-recurrenceAfter": "Efter",
            "dxScheduler-recurrenceOn": "P\xe5",
            "dxScheduler-recurrenceRepeatMinutely": "minute(s)",
            "dxScheduler-recurrenceRepeatHourly": "hour(s)",
            "dxScheduler-recurrenceRepeatDaily": "dagar",
            "dxScheduler-recurrenceRepeatWeekly": "veckor",
            "dxScheduler-recurrenceRepeatMonthly": "m\xe5nader",
            "dxScheduler-recurrenceRepeatYearly": "\xe5r",
            "dxScheduler-switcherDay": "Dag",
            "dxScheduler-switcherWeek": "Vecka",
            "dxScheduler-switcherWorkWeek": "Arbetsvecka",
            "dxScheduler-switcherMonth": "M\xe5nad",
            "dxScheduler-switcherAgenda": "Agenda",
            "dxScheduler-switcherTimelineDay": "Tidslinje dag",
            "dxScheduler-switcherTimelineWeek": "Tidslinje vecka",
            "dxScheduler-switcherTimelineWorkWeek": "Tidslinje arbetsvecka",
            "dxScheduler-switcherTimelineMonth": "Tidslinje m\xe5nad",
            "dxScheduler-recurrenceRepeatOnDate": "p\xe5 datumet",
            "dxScheduler-recurrenceRepeatCount": "upprepning(ar)",
            "dxScheduler-allDay": "Hela dagen",
            "dxScheduler-confirmRecurrenceEditMessage": "Vill du redigera bara denna avtalade tid eller hela serien?",
            "dxScheduler-confirmRecurrenceDeleteMessage": "Vill du radera bara denna avtalade tid eller hela serien?",
            "dxScheduler-confirmRecurrenceEditSeries": "Redigera serien",
            "dxScheduler-confirmRecurrenceDeleteSeries": "Radera serien",
            "dxScheduler-confirmRecurrenceEditOccurrence": "Redigera avtalad tid",
            "dxScheduler-confirmRecurrenceDeleteOccurrence": "Radera avtalad tid",
            "dxScheduler-noTimezoneTitle": "Ingen tidszon",
            "dxScheduler-moreAppointments": "{0} mer",
            "dxCalendar-todayButtonText": "I dag",
            "dxCalendar-ariaWidgetName": "Kalender",
            "dxColorView-ariaRed": "R\xf6d",
            "dxColorView-ariaGreen": "Gr\xf6n",
            "dxColorView-ariaBlue": "Bl\xe5",
            "dxColorView-ariaAlpha": "Transparens",
            "dxColorView-ariaHex": "F\xe4rgkod",
            "dxTagBox-selected": "{0} valda",
            "dxTagBox-allSelected": "Alla valda ({0})",
            "dxTagBox-moreSelected": "{0} mer",
            "vizExport-printingButtonText": "Skriv ut",
            "vizExport-titleMenuText": "Export/Utskrift",
            "vizExport-exportButtonText": "{0} fil",
            "dxFilterBuilder-and": "Och",
            "dxFilterBuilder-or": "Eller",
            "dxFilterBuilder-notAnd": "Inte och",
            "dxFilterBuilder-notOr": "Inte eller",
            "dxFilterBuilder-addCondition": "L\xe4gg till villkor",
            "dxFilterBuilder-addGroup": "L\xe4gg till grupp",
            "dxFilterBuilder-enterValueText": "<ange v\xe4rde>",
            "dxFilterBuilder-filterOperationEquals": "\xc4r lika med",
            "dxFilterBuilder-filterOperationNotEquals": "\xc4r olika",
            "dxFilterBuilder-filterOperationLess": "Mindre \xe4n",
            "dxFilterBuilder-filterOperationLessOrEquals": "Mindre \xe4n eller lika med",
            "dxFilterBuilder-filterOperationGreater": "St\xf6rre \xe4n",
            "dxFilterBuilder-filterOperationGreaterOrEquals": "St\xf6rre \xe4n eller lika med",
            "dxFilterBuilder-filterOperationStartsWith": "B\xf6rjar med",
            "dxFilterBuilder-filterOperationContains": "Inneh\xe5ller",
            "dxFilterBuilder-filterOperationNotContains": "Inneh\xe5ller inte",
            "dxFilterBuilder-filterOperationEndsWith": "Slutar med",
            "dxFilterBuilder-filterOperationIsBlank": "\xc4r tom",
            "dxFilterBuilder-filterOperationIsNotBlank": "\xc4r inte tom",
            "dxFilterBuilder-filterOperationBetween": "Mellan",
            "dxFilterBuilder-filterOperationAnyOf": "N\xe5gon av",
            "dxFilterBuilder-filterOperationNoneOf": "Ingen av",
            "dxHtmlEditor-dialogColorCaption": "Change Font Color",
            "dxHtmlEditor-dialogBackgroundCaption": "Change Background Color",
            "dxHtmlEditor-dialogLinkCaption": "Add Link",
            "dxHtmlEditor-dialogLinkUrlField": "URL",
            "dxHtmlEditor-dialogLinkTextField": "Text",
            "dxHtmlEditor-dialogLinkTargetField": "Open link in new window",
            "dxHtmlEditor-dialogImageCaption": "Add Image",
            "dxHtmlEditor-dialogImageUrlField": "URL",
            "dxHtmlEditor-dialogImageAltField": "Alternate text",
            "dxHtmlEditor-dialogImageWidthField": "Width (px)",
            "dxHtmlEditor-dialogImageHeightField": "Height (px)",
            "dxHtmlEditor-dialogInsertTableRowsField": "Rows",
            "dxHtmlEditor-dialogInsertTableColumnsField": "Columns",
            "dxHtmlEditor-dialogInsertTableCaption": "Insert Table",
            "dxHtmlEditor-dialogUpdateImageCaption": "Update Image",
            "dxHtmlEditor-dialogImageUpdateButton": "Update",
            "dxHtmlEditor-dialogImageAddButton": "Add",
            "dxHtmlEditor-dialogImageSpecifyUrl": "From the Web",
            "dxHtmlEditor-dialogImageSelectFile": "From This Device",
            "dxHtmlEditor-dialogImageKeepAspectRatio": "Keep Aspect Ratio",
            "dxHtmlEditor-dialogImageEncodeToBase64": "Encode to Base64",
            "dxHtmlEditor-heading": "Heading",
            "dxHtmlEditor-normalText": "Normal text",
            "dxHtmlEditor-background": "Background Color",
            "dxHtmlEditor-bold": "Bold",
            "dxHtmlEditor-color": "Font Color",
            "dxHtmlEditor-font": "Font",
            "dxHtmlEditor-italic": "Italic",
            "dxHtmlEditor-link": "Add Link",
            "dxHtmlEditor-image": "Add Image",
            "dxHtmlEditor-size": "Size",
            "dxHtmlEditor-strike": "Strikethrough",
            "dxHtmlEditor-subscript": "Subscript",
            "dxHtmlEditor-superscript": "Superscript",
            "dxHtmlEditor-underline": "Underline",
            "dxHtmlEditor-blockquote": "Blockquote",
            "dxHtmlEditor-header": "Header",
            "dxHtmlEditor-increaseIndent": "Increase Indent",
            "dxHtmlEditor-decreaseIndent": "Decrease Indent",
            "dxHtmlEditor-orderedList": "Ordered List",
            "dxHtmlEditor-bulletList": "Bullet List",
            "dxHtmlEditor-alignLeft": "Align Left",
            "dxHtmlEditor-alignCenter": "Align Center",
            "dxHtmlEditor-alignRight": "Align Right",
            "dxHtmlEditor-alignJustify": "Align Justify",
            "dxHtmlEditor-codeBlock": "Code Block",
            "dxHtmlEditor-variable": "Add Variable",
            "dxHtmlEditor-undo": "Undo",
            "dxHtmlEditor-redo": "Redo",
            "dxHtmlEditor-clear": "Clear Formatting",
            "dxHtmlEditor-insertTable": "Insert Table",
            "dxHtmlEditor-insertHeaderRow": "Insert Header Row",
            "dxHtmlEditor-insertRowAbove": "Insert Row Above",
            "dxHtmlEditor-insertRowBelow": "Insert Row Below",
            "dxHtmlEditor-insertColumnLeft": "Insert Column Left",
            "dxHtmlEditor-insertColumnRight": "Insert Column Right",
            "dxHtmlEditor-deleteColumn": "Delete Column",
            "dxHtmlEditor-deleteRow": "Delete Row",
            "dxHtmlEditor-deleteTable": "Delete Table",
            "dxHtmlEditor-cellProperties": "Cell Properties",
            "dxHtmlEditor-tableProperties": "Table Properties",
            "dxHtmlEditor-insert": "Insert",
            "dxHtmlEditor-delete": "Delete",
            "dxHtmlEditor-border": "Border",
            "dxHtmlEditor-style": "Style",
            "dxHtmlEditor-width": "Width",
            "dxHtmlEditor-height": "Height",
            "dxHtmlEditor-borderColor": "Color",
            "dxHtmlEditor-tableBackground": "Background",
            "dxHtmlEditor-dimensions": "Dimensions",
            "dxHtmlEditor-alignment": "Alignment",
            "dxHtmlEditor-horizontal": "Horizontal",
            "dxHtmlEditor-vertical": "Vertical",
            "dxHtmlEditor-paddingVertical": "Vertical Padding",
            "dxHtmlEditor-paddingHorizontal": "Horizontal Padding",
            "dxHtmlEditor-pixels": "Pixels",
            "dxHtmlEditor-list": "List",
            "dxHtmlEditor-ordered": "Ordered",
            "dxHtmlEditor-bullet": "Bullet",
            "dxHtmlEditor-align": "Align",
            "dxHtmlEditor-center": "Center",
            "dxHtmlEditor-left": "Left",
            "dxHtmlEditor-right": "Right",
            "dxHtmlEditor-indent": "Indent",
            "dxHtmlEditor-justify": "Justify",
            "dxFileManager-newDirectoryName": "Untitled directory",
            "dxFileManager-rootDirectoryName": "Files",
            "dxFileManager-errorNoAccess": "Access Denied. Operation could not be completed.",
            "dxFileManager-errorDirectoryExistsFormat": "Directory '{0}' already exists.",
            "dxFileManager-errorFileExistsFormat": "File '{0}' already exists.",
            "dxFileManager-errorFileNotFoundFormat": "File '{0}' not found.",
            "dxFileManager-errorDirectoryNotFoundFormat": "Directory '{0}' not found.",
            "dxFileManager-errorWrongFileExtension": "File extension is not allowed.",
            "dxFileManager-errorMaxFileSizeExceeded": "File size exceeds the maximum allowed size.",
            "dxFileManager-errorInvalidSymbols": "This name contains invalid characters.",
            "dxFileManager-errorDefault": "Unspecified error.",
            "dxFileManager-errorDirectoryOpenFailed": "The directory cannot be opened",
            "dxFileManager-commandCreate": "New directory",
            "dxFileManager-commandRename": "Rename",
            "dxFileManager-commandMove": "Move to",
            "dxFileManager-commandCopy": "Copy to",
            "dxFileManager-commandDelete": "Delete",
            "dxFileManager-commandDownload": "Download",
            "dxFileManager-commandUpload": "Upload files",
            "dxFileManager-commandRefresh": "Refresh",
            "dxFileManager-commandThumbnails": "Thumbnails View",
            "dxFileManager-commandDetails": "Details View",
            "dxFileManager-commandClearSelection": "Clear selection",
            "dxFileManager-commandShowNavPane": "Toggle navigation pane",
            "dxFileManager-dialogDirectoryChooserMoveTitle": "Move to",
            "dxFileManager-dialogDirectoryChooserMoveButtonText": "Move",
            "dxFileManager-dialogDirectoryChooserCopyTitle": "Copy to",
            "dxFileManager-dialogDirectoryChooserCopyButtonText": "Copy",
            "dxFileManager-dialogRenameItemTitle": "Rename",
            "dxFileManager-dialogRenameItemButtonText": "Save",
            "dxFileManager-dialogCreateDirectoryTitle": "New directory",
            "dxFileManager-dialogCreateDirectoryButtonText": "Create",
            "dxFileManager-dialogDeleteItemTitle": "Delete",
            "dxFileManager-dialogDeleteItemButtonText": "Delete",
            "dxFileManager-dialogDeleteItemSingleItemConfirmation": "Are you sure you want to delete {0}?",
            "dxFileManager-dialogDeleteItemMultipleItemsConfirmation": "Are you sure you want to delete {0} items?",
            "dxFileManager-dialogButtonCancel": "Cancel",
            "dxFileManager-editingCreateSingleItemProcessingMessage": "Creating a directory inside {0}",
            "dxFileManager-editingCreateSingleItemSuccessMessage": "Created a directory inside {0}",
            "dxFileManager-editingCreateSingleItemErrorMessage": "Directory was not created",
            "dxFileManager-editingCreateCommonErrorMessage": "Directory was not created",
            "dxFileManager-editingRenameSingleItemProcessingMessage": "Renaming an item inside {0}",
            "dxFileManager-editingRenameSingleItemSuccessMessage": "Renamed an item inside {0}",
            "dxFileManager-editingRenameSingleItemErrorMessage": "Item was not renamed",
            "dxFileManager-editingRenameCommonErrorMessage": "Item was not renamed",
            "dxFileManager-editingDeleteSingleItemProcessingMessage": "Deleting an item from {0}",
            "dxFileManager-editingDeleteMultipleItemsProcessingMessage": "Deleting {0} items from {1}",
            "dxFileManager-editingDeleteSingleItemSuccessMessage": "Deleted an item from {0}",
            "dxFileManager-editingDeleteMultipleItemsSuccessMessage": "Deleted {0} items from {1}",
            "dxFileManager-editingDeleteSingleItemErrorMessage": "Item was not deleted",
            "dxFileManager-editingDeleteMultipleItemsErrorMessage": "{0} items were not deleted",
            "dxFileManager-editingDeleteCommonErrorMessage": "Some items were not deleted",
            "dxFileManager-editingMoveSingleItemProcessingMessage": "Moving an item to {0}",
            "dxFileManager-editingMoveMultipleItemsProcessingMessage": "Moving {0} items to {1}",
            "dxFileManager-editingMoveSingleItemSuccessMessage": "Moved an item to {0}",
            "dxFileManager-editingMoveMultipleItemsSuccessMessage": "Moved {0} items to {1}",
            "dxFileManager-editingMoveSingleItemErrorMessage": "Item was not moved",
            "dxFileManager-editingMoveMultipleItemsErrorMessage": "{0} items were not moved",
            "dxFileManager-editingMoveCommonErrorMessage": "Some items were not moved",
            "dxFileManager-editingCopySingleItemProcessingMessage": "Copying an item to {0}",
            "dxFileManager-editingCopyMultipleItemsProcessingMessage": "Copying {0} items to {1}",
            "dxFileManager-editingCopySingleItemSuccessMessage": "Copied an item to {0}",
            "dxFileManager-editingCopyMultipleItemsSuccessMessage": "Copied {0} items to {1}",
            "dxFileManager-editingCopySingleItemErrorMessage": "Item was not copied",
            "dxFileManager-editingCopyMultipleItemsErrorMessage": "{0} items were not copied",
            "dxFileManager-editingCopyCommonErrorMessage": "Some items were not copied",
            "dxFileManager-editingUploadSingleItemProcessingMessage": "Uploading an item to {0}",
            "dxFileManager-editingUploadMultipleItemsProcessingMessage": "Uploading {0} items to {1}",
            "dxFileManager-editingUploadSingleItemSuccessMessage": "Uploaded an item to {0}",
            "dxFileManager-editingUploadMultipleItemsSuccessMessage": "Uploaded {0} items to {1}",
            "dxFileManager-editingUploadSingleItemErrorMessage": "Item was not uploaded",
            "dxFileManager-editingUploadMultipleItemsErrorMessage": "{0} items were not uploaded",
            "dxFileManager-editingUploadCanceledMessage": "Canceled",
            "dxFileManager-editingDownloadSingleItemErrorMessage": "Item was not downloaded",
            "dxFileManager-editingDownloadMultipleItemsErrorMessage": "{0} items were not downloaded",
            "dxFileManager-listDetailsColumnCaptionName": "Name",
            "dxFileManager-listDetailsColumnCaptionDateModified": "Date Modified",
            "dxFileManager-listDetailsColumnCaptionFileSize": "File Size",
            "dxFileManager-listThumbnailsTooltipTextSize": "Size",
            "dxFileManager-listThumbnailsTooltipTextDateModified": "Date Modified",
            "dxFileManager-notificationProgressPanelTitle": "Progress",
            "dxFileManager-notificationProgressPanelEmptyListText": "No operations",
            "dxFileManager-notificationProgressPanelOperationCanceled": "Canceled",
            "dxDiagram-categoryGeneral": "General",
            "dxDiagram-categoryFlowchart": "Flowchart",
            "dxDiagram-categoryOrgChart": "Org Chart",
            "dxDiagram-categoryContainers": "Containers",
            "dxDiagram-categoryCustom": "Custom",
            "dxDiagram-commandExportToSvg": "Export to SVG",
            "dxDiagram-commandExportToPng": "Export to PNG",
            "dxDiagram-commandExportToJpg": "Export to JPEG",
            "dxDiagram-commandUndo": "Undo",
            "dxDiagram-commandRedo": "Redo",
            "dxDiagram-commandFontName": "Font Name",
            "dxDiagram-commandFontSize": "Font Size",
            "dxDiagram-commandBold": "Bold",
            "dxDiagram-commandItalic": "Italic",
            "dxDiagram-commandUnderline": "Underline",
            "dxDiagram-commandTextColor": "Font Color",
            "dxDiagram-commandLineColor": "Line Color",
            "dxDiagram-commandLineWidth": "Line Width",
            "dxDiagram-commandLineStyle": "Line Style",
            "dxDiagram-commandLineStyleSolid": "Solid",
            "dxDiagram-commandLineStyleDotted": "Dotted",
            "dxDiagram-commandLineStyleDashed": "Dashed",
            "dxDiagram-commandFillColor": "Fill Color",
            "dxDiagram-commandAlignLeft": "Align Left",
            "dxDiagram-commandAlignCenter": "Align Center",
            "dxDiagram-commandAlignRight": "Align Right",
            "dxDiagram-commandConnectorLineType": "Connector Line Type",
            "dxDiagram-commandConnectorLineStraight": "Straight",
            "dxDiagram-commandConnectorLineOrthogonal": "Orthogonal",
            "dxDiagram-commandConnectorLineStart": "Connector Line Start",
            "dxDiagram-commandConnectorLineEnd": "Connector Line End",
            "dxDiagram-commandConnectorLineNone": "None",
            "dxDiagram-commandConnectorLineArrow": "Arrow",
            "dxDiagram-commandFullscreen": "Full Screen",
            "dxDiagram-commandUnits": "Units",
            "dxDiagram-commandPageSize": "Page Size",
            "dxDiagram-commandPageOrientation": "Page Orientation",
            "dxDiagram-commandPageOrientationLandscape": "Landscape",
            "dxDiagram-commandPageOrientationPortrait": "Portrait",
            "dxDiagram-commandPageColor": "Page Color",
            "dxDiagram-commandShowGrid": "Show Grid",
            "dxDiagram-commandSnapToGrid": "Snap to Grid",
            "dxDiagram-commandGridSize": "Grid Size",
            "dxDiagram-commandZoomLevel": "Zoom Level",
            "dxDiagram-commandAutoZoom": "Auto Zoom",
            "dxDiagram-commandFitToContent": "Fit to Content",
            "dxDiagram-commandFitToWidth": "Fit to Width",
            "dxDiagram-commandAutoZoomByContent": "Auto Zoom by Content",
            "dxDiagram-commandAutoZoomByWidth": "Auto Zoom by Width",
            "dxDiagram-commandSimpleView": "Simple View",
            "dxDiagram-commandCut": "Cut",
            "dxDiagram-commandCopy": "Copy",
            "dxDiagram-commandPaste": "Paste",
            "dxDiagram-commandSelectAll": "Select All",
            "dxDiagram-commandDelete": "Delete",
            "dxDiagram-commandBringToFront": "Bring to Front",
            "dxDiagram-commandSendToBack": "Send to Back",
            "dxDiagram-commandLock": "Lock",
            "dxDiagram-commandUnlock": "Unlock",
            "dxDiagram-commandInsertShapeImage": "Insert Image...",
            "dxDiagram-commandEditShapeImage": "Change Image...",
            "dxDiagram-commandDeleteShapeImage": "Delete Image",
            "dxDiagram-commandLayoutLeftToRight": "Left-to-right",
            "dxDiagram-commandLayoutRightToLeft": "Right-to-left",
            "dxDiagram-commandLayoutTopToBottom": "Top-to-bottom",
            "dxDiagram-commandLayoutBottomToTop": "Bottom-to-top",
            "dxDiagram-unitIn": "in",
            "dxDiagram-unitCm": "cm",
            "dxDiagram-unitPx": "px",
            "dxDiagram-dialogButtonOK": "OK",
            "dxDiagram-dialogButtonCancel": "Cancel",
            "dxDiagram-dialogInsertShapeImageTitle": "Insert Image",
            "dxDiagram-dialogEditShapeImageTitle": "Change Image",
            "dxDiagram-dialogEditShapeImageSelectButton": "Select image",
            "dxDiagram-dialogEditShapeImageLabelText": "or drop a file here",
            "dxDiagram-uiExport": "Export",
            "dxDiagram-uiProperties": "Properties",
            "dxDiagram-uiSettings": "Settings",
            "dxDiagram-uiShowToolbox": "Show Toolbox",
            "dxDiagram-uiSearch": "Search",
            "dxDiagram-uiStyle": "Style",
            "dxDiagram-uiLayout": "Layout",
            "dxDiagram-uiLayoutTree": "Tree",
            "dxDiagram-uiLayoutLayered": "Layered",
            "dxDiagram-uiDiagram": "Diagram",
            "dxDiagram-uiText": "Text",
            "dxDiagram-uiObject": "Object",
            "dxDiagram-uiConnector": "Connector",
            "dxDiagram-uiPage": "Page",
            "dxDiagram-shapeText": "Text",
            "dxDiagram-shapeRectangle": "Rectangle",
            "dxDiagram-shapeEllipse": "Ellipse",
            "dxDiagram-shapeCross": "Cross",
            "dxDiagram-shapeTriangle": "Triangle",
            "dxDiagram-shapeDiamond": "Diamond",
            "dxDiagram-shapeHeart": "Heart",
            "dxDiagram-shapePentagon": "Pentagon",
            "dxDiagram-shapeHexagon": "Hexagon",
            "dxDiagram-shapeOctagon": "Octagon",
            "dxDiagram-shapeStar": "Star",
            "dxDiagram-shapeArrowLeft": "Left Arrow",
            "dxDiagram-shapeArrowUp": "Up Arrow",
            "dxDiagram-shapeArrowRight": "Right Arrow",
            "dxDiagram-shapeArrowDown": "Down Arrow",
            "dxDiagram-shapeArrowUpDown": "Up Down Arrow",
            "dxDiagram-shapeArrowLeftRight": "Left Right Arrow",
            "dxDiagram-shapeProcess": "Process",
            "dxDiagram-shapeDecision": "Decision",
            "dxDiagram-shapeTerminator": "Terminator",
            "dxDiagram-shapePredefinedProcess": "Predefined Process",
            "dxDiagram-shapeDocument": "Document",
            "dxDiagram-shapeMultipleDocuments": "Multiple Documents",
            "dxDiagram-shapeManualInput": "Manual Input",
            "dxDiagram-shapePreparation": "Preparation",
            "dxDiagram-shapeData": "Data",
            "dxDiagram-shapeDatabase": "Database",
            "dxDiagram-shapeHardDisk": "Hard Disk",
            "dxDiagram-shapeInternalStorage": "Internal Storage",
            "dxDiagram-shapePaperTape": "Paper Tape",
            "dxDiagram-shapeManualOperation": "Manual Operation",
            "dxDiagram-shapeDelay": "Delay",
            "dxDiagram-shapeStoredData": "Stored Data",
            "dxDiagram-shapeDisplay": "Display",
            "dxDiagram-shapeMerge": "Merge",
            "dxDiagram-shapeConnector": "Connector",
            "dxDiagram-shapeOr": "Or",
            "dxDiagram-shapeSummingJunction": "Summing Junction",
            "dxDiagram-shapeContainerDefaultText": "Container",
            "dxDiagram-shapeVerticalContainer": "Vertical Container",
            "dxDiagram-shapeHorizontalContainer": "Horizontal Container",
            "dxDiagram-shapeCardDefaultText": "Person's Name",
            "dxDiagram-shapeCardWithImageOnLeft": "Card with Image on the Left",
            "dxDiagram-shapeCardWithImageOnTop": "Card with Image on the Top",
            "dxDiagram-shapeCardWithImageOnRight": "Card with Image on the Right",
            "dxGantt-dialogTitle": "Title",
            "dxGantt-dialogStartTitle": "Start",
            "dxGantt-dialogEndTitle": "End",
            "dxGantt-dialogProgressTitle": "Progress",
            "dxGantt-dialogResourcesTitle": "Resources",
            "dxGantt-dialogResourceManagerTitle": "Resource Manager",
            "dxGantt-dialogTaskDetailsTitle": "Task Details",
            "dxGantt-dialogEditResourceListHint": "Edit Resource List",
            "dxGantt-dialogEditNoResources": "No resources",
            "dxGantt-dialogButtonAdd": "Add",
            "dxGantt-contextMenuNewTask": "New Task",
            "dxGantt-contextMenuNewSubtask": "New Subtask",
            "dxGantt-contextMenuDeleteTask": "Delete Task",
            "dxGantt-contextMenuDeleteDependency": "Delete Dependency",
            "dxGantt-dialogTaskDeleteConfirmation": "Deleting a task also deletes all its dependencies and subtasks. Are you sure you want to delete this task?",
            "dxGantt-dialogDependencyDeleteConfirmation": "Are you sure you want to delete the dependency from the task?",
            "dxGantt-dialogResourcesDeleteConfirmation": "Deleting a resource also deletes it from tasks to which this resource is assigned. Are you sure you want to delete these resources? Resources: {0}",
            "dxGantt-dialogConstraintCriticalViolationMessage": "The task you are attempting to move is linked to a second task by a dependency relation. This change would conflict with dependency rules. How would you like to proceed?",
            "dxGantt-dialogConstraintViolationMessage": "The task you are attempting to move is linked to a second task by a dependency relation. How would you like to proceed?",
            "dxGantt-dialogCancelOperationMessage": "Cancel the operation",
            "dxGantt-dialogDeleteDependencyMessage": "Delete the dependency",
            "dxGantt-dialogMoveTaskAndKeepDependencyMessage": "Move the task and keep the dependency",
            "dxGantt-dialogConstraintCriticalViolationSeveralTasksMessage": "The task you are attempting to move is linked to another tasks by dependency relations. This change would conflict with dependency rules. How would you like to proceed?",
            "dxGantt-dialogConstraintViolationSeveralTasksMessage": "The task you are attempting to move is linked to another tasks by dependency relations. How would you like to proceed?",
            "dxGantt-dialogDeleteDependenciesMessage": "Delete the dependency relations",
            "dxGantt-dialogMoveTaskAndKeepDependenciesMessage": "Move the task and keep the dependencies",
            "dxGantt-undo": "Undo",
            "dxGantt-redo": "Redo",
            "dxGantt-expandAll": "Expand All",
            "dxGantt-collapseAll": "Collapse All",
            "dxGantt-addNewTask": "Add New Task",
            "dxGantt-deleteSelectedTask": "Delete Selected Task",
            "dxGantt-zoomIn": "Zoom In",
            "dxGantt-zoomOut": "Zoom Out",
            "dxGantt-fullScreen": "Full Screen",
            "dxGantt-quarter": "Q{0}",
            "dxGantt-sortingAscendingText": "Sort Ascending",
            "dxGantt-sortingDescendingText": "Sort Descending",
            "dxGantt-sortingClearText": "Clear Sorting",
            "dxGantt-showResources": "Show Resources",
            "dxGantt-showDependencies": "Show Dependencies",
            "dxGantt-dialogStartDateValidation": "Start date must be after {0}",
            "dxGantt-dialogEndDateValidation": "End date must be after {0}"
        }
    })
}));


text:
@interface User : NSObject

@property (nonatomic, strong) NSString* session_id;
@property (nonatomic, strong) NSString* user_id;

-(id) initWithSession: (NSString*) session andID: (NSString*) user_id;

@end