text:
<TITLE>Review for Party Girl (1995/I)</TITLE>
<LINK REL="STYLESHEET" TYPE="text/css" HREF="/ramr.css">

Party Girl (1995/I)

reviewed by
Christopher Null

                                  PARTY GIRL
                      A film review by Christopher Null
                       Copyright 1995 Christopher Null

     "I don't have a job.  I'm a loser.  Shoot me!"

     This pretty much sums up the early attitude of the title character
in PARTY GIRL, a new film by Daisy von Scherler Mayer, about the
misadventures of a New York City diva who finds her life suddenly
falling apart.  Parker Posey plays Mary, the Party Girl in question,
whose flair and style are matched only by her inability to do anything
productive with her life.

     Mary is an old-style slacker of the first degree.  The picture
opens with Mary hosting a party to cover this month's rent, only to get
busted by the cops and having to call her librarian godmother (Sasha
von Scherler) to bail her out.  Godmother takes pity and gives Mary a
job as a library clerk, which seems to suit the carefree socialite like
a designer muumuu.  Interspersed with Mary's quest to find her place in
the fascinating world of library science, she frequents party after
party, always in search of the hippest hangout and the ultimate cool
time.

     PARTY GIRL is something of an allegory to the existentialist
literature it refers to: Mary is in search of life's meaning in a
world which appears to have none.  This New York is completely surreal,
full of ultra-hip people and places that are usually too cute for their
own good.  In the end, Mary can't find a shred of meaning in this
world, so she turns to...the Dewey Decimal System.  And it gets weirder
than that, perhaps the most bizarre part of the film being an
inexplicable romance Mary has with a street falafel vendor (Omar
Townsend).

     PARTY GIRL ends up being a mostly-entertaining movie.  It isn't
the raucous comedy it's billed as, but the funny bits are worth the
price of admission.  Posey is electric, a consummate professional (and
the only one in the cast who nails her lines every time).  It's
incredible how she makes the most mundane thing look cool; the most
enjoyable part of PARTY GIRL just might be seeing what Posey is wearing
in the next scene, and managing to outdo what she had on previously.

     The film takes quite awhile to really get rolling, and that's
largely due to the relatively inexperienced supporting cast and the low
low budget which allowed for only two takes of any scene.  As a result,
much of the movie's dialogue is stilted and just doesn't flow smoothly
enough to convey the sarcastic wit all of these characters are supposed
to be imbued with.  The budget has also burdened PARTY GIRL with some
damaging sound problems.

     Also, while Mary's parties are to die for, her search for a career
is uninspired.  What begins as a comedic Mary vs. The World ends up
being an overdramatic Mary vs. The Dewey Decimal System--not what I was
expecting, and probably not what the audience wants to watch.  I wish
the filmmakers had taken Mary's own advice here:  "Lighten up!  It's a
party!"

     Isn't it?

RATING:  ***

+-------------------------------+
|*     Unquestionably awful     |
|**    Sub-par on many levels   |
|***   Average, hits and misses |
|****  Good, memorable film     |
|***** Perfection               |
+-------------------------------+

The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).

The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.

Please direct comments/criticisms of the review to relevant newsgroups.

Broken URLs inthe reviews are the responsibility of the author.

The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.

Related links: index of all rec.arts.movies.reviews reviews


text:
/**
 * Internationalization / Localization Settings
 * (sails.config.i18n)
 *
 * If your app will touch people from all over the world, i18n (or internationalization)
 * may be an important part of your international strategy.
 *
 *
 * For more information, check out:
 * http://links.sailsjs.org/docs/config/i18n
 */

module.exports.i18n = {

  // Which locales are supported?
  locales: ['en', 'es', 'fr', 'de']

};

redpajama_set_name: RedPajamaGithub


text:
[Click here to get in touch](https://bytescout.zendesk.com/hc/en-us/requests/new?subject=ByteScout%20Cloud%20API%20Server%20Question)

or just send email to [support@bytescout.com](mailto:support@bytescout.com?subject=ByteScout%20Cloud%20API%20Server%20Question)

## ON-PREMISE OFFLINE SDK

[Get Your 60 Day Free Trial](https://bytescout.com/download/web-installer?utm_source=github-readme)
[Explore Documentation](https://bytescout.com/documentation/index.html?utm_source=github-readme)
[Explore Source Code Samples](https://github.com/bytescout/ByteScout-SDK-SourceCode/)
[Sign Up For Online Training](https://academy.bytescout.com/)

## ON-DEMAND REST WEB API

[Get your API key](https://app.pdf.co/signup?utm_source=github-readme)
[Security](https://pdf.co/security)
[Explore Web API Documentation](https://apidocs.pdf.co?utm_source=github-readme)
[Explore Web API Samples](https://github.com/bytescout/ByteScout-SDK-SourceCode/tree/master/PDF.co%20Web%20API)

## VIDEO REVIEW

[https://www.youtube.com/watch?v=NEwNs2b9YN8](https://www.youtube.com/watch?v=NEwNs2b9YN8)

<!-- code block begin -->

##### **GetEmailInfo.java:**

```
import java.io.*;
import okhttp3.*;

// Please NOTE: In this sample we're assuming Cloud Api Server is hosted at "https://localhost".
// If it's not then please replace this with with your hosting url.
public class main {
		public static void main(String []args) throws IOException{
				OkHttpClient client = new OkHttpClient().newBuilder()
						.build();
				MediaType mediaType = MediaType.parse("application/json");
				RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
						.addFormDataPart("url", "https://bytescout-com.s3-us-west-2.amazonaws.com/files/demo-files/cloud-api/email-extractor/sample.eml")
						.build();
				Request request = new Request.Builder()
						.url("https://localhost/email/decode")
						.method("POST", body)
						.addHeader("Content-Type", "application/json")
						.addHeader("x-api-key", "{{x-api-key}}")
						.build();
				Response response = client.newCall(request).execute();
				System.out.println(response.body().string());
		}
}

```

<!-- code block end -->


text:
baseURL='http://localhost:8089'
repository='2'
user='admin'
password='admin'


text:
<!DOCTYPE html>

        <meta charset="UTF-8" />
        <meta name="robots" content="index, follow, all" />
        <title>Thelia\Core\Security\UserProvider\TokenUserProvider | </title>
                    <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css">

Classes

Namespaces

Interfaces

Traits

Index

Class

Thelia\Core\Security\UserProvider\TokenUserProvider

abstract     class
    TokenUserProvider        extends TokenProvider        implements
        UserProviderInterface

Methods

                    encodeKey(UserInterface $user)

                from TokenProvider

                    decodeKey($key)

                from TokenProvider

                    a

                    getUser($key $key)

Returns a UserInterface instance

Details

in TokenProvider at line 9

                    public
    encodeKey(UserInterface $user)

Parameters

                UserInterface
                $user

in TokenProvider at line 18

                    public
    decodeKey($key)

Parameters

                $key

at line 30

            abstract        public            a
    getUser($key $key)

Returns a UserInterface instance

Parameters

                $key
                $key
                the unique user key (username, email address, etc.)

Return Value

            a
            UserInterface instance, or null if none was found.

        Generated by Sami, the API Documentation Generator.


text:
package org.jetbrains.plugins.scala.util;

import com.intellij.openapi.extensions.ExtensionPointName;
import com.intellij.psi.tree.TokenSet;

/**
 * User: Dmitry Naydanov
 * Date: 3/25/13
 */
abstract public class MemberElementTypesExtension {
  public static ExtensionPointName<MemberElementTypesExtension> EP_NAME = ExtensionPointName.create("org.intellij.scala.memberElementTypesExtension");

  public TokenSet getMemberElementTypes() {
    return TokenSet.EMPTY;
  }

  public static TokenSet getAllElementTypes() {
    TokenSet types = TokenSet.EMPTY;

/*    for (MemberElementTypesExtension extension : EP_NAME.getExtensions()) {
      types = TokenSet.orSet(types, extension.getMemberElementTypes());
    }*/

    return types;
  }
}


text:
#ifndef _system_locale_h
#define _system_locale_h

#ifdef HAVE_CTYPE_H
#include <ctype.h>
#endif

#ifdef HAVE_LOCALE_H
#include <locale.h>
#endif

#endif


text:
using namespace arangodb::basics;

static bool Initialized = false;
static uint64_t counter = 0;

// -----------------------------------------------------------------------------
// --SECTION--                                                 setup / tear-down
// -----------------------------------------------------------------------------

class CFilesTest : public ::testing::Test {
protected:
  CFilesTest () : _directory(true) {
    long systemError;
    std::string errorMessage;

    if (!Initialized) {
      Initialized = true;
      arangodb::RandomGenerator::initialize(arangodb::RandomGenerator::RandomType::MERSENNE);
    }

    _directory.appendText(TRI_GetTempPath());
    _directory.appendChar(TRI_DIR_SEPARATOR_CHAR);
    _directory.appendText("arangotest-");
    _directory.appendInteger(static_cast<uint64_t>(TRI_microtime()));
    _directory.appendInteger(arangodb::RandomGenerator::interval(UINT32_MAX));

    TRI_CreateDirectory(_directory.c_str(), systemError, errorMessage);
  }

  ~CFilesTest () {
    // let's be sure we delete the right stuff
    TRI_ASSERT(_directory.length() > 10);

    TRI_RemoveDirectory(_directory.c_str());
  }

  StringBuffer* writeFile (const char* blob) {
    StringBuffer* filename = new StringBuffer(true);
    filename->appendText(_directory);
    filename->appendChar(TRI_DIR_SEPARATOR_CHAR);
    filename->appendText("tmp-");
    filename->appendInteger(++counter);
    filename->appendInteger(arangodb::RandomGenerator::interval(UINT32_MAX));

    FILE* fd = fopen(filename->c_str(), "wb");

    if (fd) {
      size_t numWritten = fwrite(blob, strlen(blob), 1, fd);
      (void) numWritten;
      fclose(fd);
    }
    else {
      EXPECT_TRUE(false == true);
    }

    return filename;
  }

  StringBuffer _directory;
};

struct ByteCountFunctor {

  size_t _byteCount;

  ByteCountFunctor() : _byteCount(0) {};

  bool operator() (const char * data, size_t size) {
    _byteCount+=size;
    return true;
  };
};// struct ByteCountFunctor

TEST_F(CFilesTest, tst_copyfile) {
  std::ostringstream out;
  out << _directory.c_str() << TRI_DIR_SEPARATOR_CHAR << "tmp-" << ++counter;

  std::string source = out.str();
  out << "-dest";
  std::string dest = out.str();

  // non-existing file
  std::string error;
  EXPECT_TRUE(false == TRI_CopyFile(source, dest, error));

  // empty file
  FileUtils::spit(source, std::string(""), false);
  EXPECT_TRUE(true == TRI_CopyFile(source, dest, error));
  EXPECT_TRUE("" == FileUtils::slurp(dest));

  // copy over an existing target file
  FileUtils::remove(source);
  FileUtils::spit(source, std::string("foobar"), false);
  EXPECT_TRUE(false == TRI_CopyFile(source, dest, error));

  FileUtils::remove(source);
  FileUtils::remove(dest);
  FileUtils::spit(source, std::string("foobar"), false);
  EXPECT_TRUE(true == TRI_CopyFile(source, dest, error));
  EXPECT_TRUE("foobar" == FileUtils::slurp(dest));

  // copy larger file
  std::string value("the quick brown fox");
  for (size_t i = 0; i < 10; ++i) {
    value += value;
  }

  FileUtils::remove(source);
  FileUtils::remove(dest);
  FileUtils::spit(source, value, false);
  EXPECT_TRUE(true == TRI_CopyFile(source, dest, error));
  EXPECT_TRUE(value == FileUtils::slurp(dest));
  EXPECT_TRUE(TRI_SizeFile(source.c_str()) == TRI_SizeFile(dest.c_str()));

  // copy file slightly larger than copy buffer
  std::string value2(128 * 1024 + 1, 'x');
  FileUtils::remove(source);
  FileUtils::remove(dest);
  FileUtils::spit(source, value2, false);
  EXPECT_TRUE(true == TRI_CopyFile(source, dest, error));
  EXPECT_TRUE(value2 == FileUtils::slurp(dest));
  EXPECT_TRUE(TRI_SizeFile(source.c_str()) == TRI_SizeFile(dest.c_str()));
}

TEST_F(CFilesTest, tst_createdirectory) {
  std::ostringstream out;
  out << _directory.c_str() << TRI_DIR_SEPARATOR_CHAR << "tmp-" << ++counter << "-dir";

  std::string filename = out.str();
  long unused1;
  std::string unused2;
  int res = TRI_CreateDirectory(filename.c_str(), unused1, unused2);
  EXPECT_TRUE(0 == res);
  EXPECT_TRUE(true == TRI_ExistsFile(filename.c_str()));
  EXPECT_TRUE(true == TRI_IsDirectory(filename.c_str()));

  res = TRI_RemoveDirectory(filename.c_str());
  EXPECT_TRUE(false == TRI_ExistsFile(filename.c_str()));
  EXPECT_TRUE(false == TRI_IsDirectory(filename.c_str()));
}

TEST_F(CFilesTest, tst_createdirectoryrecursive) {
  std::ostringstream out;
  out << _directory.c_str() << TRI_DIR_SEPARATOR_CHAR << "tmp-" << ++counter << "-dir";

  std::string filename1 = out.str();
  out << TRI_DIR_SEPARATOR_CHAR << "abc";
  std::string filename2 = out.str();

  long unused1;
  std::string unused2;
  int res = TRI_CreateRecursiveDirectory(filename2.c_str(), unused1, unused2);
  EXPECT_TRUE(0 == res);
  EXPECT_TRUE(true == TRI_ExistsFile(filename1.c_str()));
  EXPECT_TRUE(true == TRI_IsDirectory(filename1.c_str()));
  EXPECT_TRUE(true == TRI_ExistsFile(filename2.c_str()));
  EXPECT_TRUE(true == TRI_IsDirectory(filename2.c_str()));

  res = TRI_RemoveDirectory(filename1.c_str());
  EXPECT_TRUE(false == TRI_ExistsFile(filename1.c_str()));
  EXPECT_TRUE(false == TRI_IsDirectory(filename1.c_str()));
  EXPECT_TRUE(false == TRI_ExistsFile(filename2.c_str()));
  EXPECT_TRUE(false == TRI_IsDirectory(filename2.c_str()));
}

TEST_F(CFilesTest, tst_removedirectorydeterministic) {
  std::ostringstream out;
  out << _directory.c_str() << TRI_DIR_SEPARATOR_CHAR << "tmp-" << ++counter << "-dir";

  std::string filename1 = out.str();
  out << TRI_DIR_SEPARATOR_CHAR << "abc";
  std::string filename2 = out.str();

  long unused1;
  std::string unused2;
  int res = TRI_CreateRecursiveDirectory(filename2.c_str(), unused1, unused2);
  EXPECT_TRUE(0 == res);
  EXPECT_TRUE(true == TRI_ExistsFile(filename1.c_str()));
  EXPECT_TRUE(true == TRI_IsDirectory(filename1.c_str()));
  EXPECT_TRUE(true == TRI_ExistsFile(filename2.c_str()));
  EXPECT_TRUE(true == TRI_IsDirectory(filename2.c_str()));

  res = TRI_RemoveDirectoryDeterministic(filename1.c_str());
  EXPECT_TRUE(false == TRI_ExistsFile(filename1.c_str()));
  EXPECT_TRUE(false == TRI_IsDirectory(filename1.c_str()));
  EXPECT_TRUE(false == TRI_ExistsFile(filename2.c_str()));
  EXPECT_TRUE(false == TRI_IsDirectory(filename2.c_str()));
}

////////////////////////////////////////////////////////////////////////////////
/// @brief test file exists
////////////////////////////////////////////////////////////////////////////////

TEST_F(CFilesTest, tst_existsfile) {
  StringBuffer* filename = writeFile("");
  EXPECT_TRUE(true == TRI_ExistsFile(filename->c_str()));
  TRI_UnlinkFile(filename->c_str());
  EXPECT_TRUE(false == TRI_ExistsFile(filename->c_str()));

  delete filename;
}

////////////////////////////////////////////////////////////////////////////////
/// @brief test file size empty file
////////////////////////////////////////////////////////////////////////////////

TEST_F(CFilesTest, tst_filesize_empty) {
  StringBuffer* filename = writeFile("");
  EXPECT_TRUE(0U == TRI_SizeFile(filename->c_str()));

  TRI_UnlinkFile(filename->c_str());
  delete filename;
}

////////////////////////////////////////////////////////////////////////////////
/// @brief test file size
////////////////////////////////////////////////////////////////////////////////

TEST_F(CFilesTest, tst_filesize_exists) {
  const char* buffer = "the quick brown fox";

  StringBuffer* filename = writeFile(buffer);
  EXPECT_TRUE(static_cast<int>(strlen(buffer)) == TRI_SizeFile(filename->c_str()));

  TRI_UnlinkFile(filename->c_str());
  delete filename;
}

////////////////////////////////////////////////////////////////////////////////
/// @brief test file size, non existing file
////////////////////////////////////////////////////////////////////////////////

TEST_F(CFilesTest, tst_filesize_non) {
  EXPECT_TRUE(-1 == (int) TRI_SizeFile("h5uuuuui3unn645wejhdjhikjdsf"));
  EXPECT_TRUE(-1 == (int) TRI_SizeFile("dihnui8ngiu54"));
}

////////////////////////////////////////////////////////////////////////////////
/// @brief test absolute path
////////////////////////////////////////////////////////////////////////////////

TEST_F(CFilesTest, tst_absolute_paths) {
  std::string path;

#ifdef _WIN32
  path = TRI_GetAbsolutePath("the-fox", "\\tmp");

  EXPECT_TRUE(std::string("\\tmp\\the-fox") == path);

  path = TRI_GetAbsolutePath("the-fox.lol", "\\tmp");
  EXPECT_TRUE(std::string("\\tmp\\the-fox.lol") == path);

  path = TRI_GetAbsolutePath("the-fox.lol", "\\tmp\\the-fox");
  EXPECT_TRUE(std::string("\\tmp\\the-fox\\the-fox.lol") == path);

  path = TRI_GetAbsolutePath("file", "\\");
  EXPECT_TRUE(std::string("\\file") == path);

  path = TRI_GetAbsolutePath(".\\file", "\\");
  EXPECT_TRUE(std::string("\\.\\file") == path);

  path = TRI_GetAbsolutePath("\\file", "\\tmp");
  EXPECT_TRUE(std::string("\\tmp\\file") == path);

  path = TRI_GetAbsolutePath("\\file\\to\\file", "\\tmp");
  EXPECT_TRUE(std::string("\\tmp\\file\\to\\file") == path);

  path = TRI_GetAbsolutePath("file\\to\\file", "\\tmp");
  EXPECT_TRUE(std::string("\\tmp\\file\\to\\file") == path);

  path = TRI_GetAbsolutePath("c:\\file\\to\\file", "abc");
  EXPECT_TRUE(std::string("c:\\file\\to\\file") == path);

  path = TRI_GetAbsolutePath("c:\\file\\to\\file", "\\tmp");
  EXPECT_TRUE(std::string("c:\\file\\to\\file") == path);

#else

  path = TRI_GetAbsolutePath("the-fox", "/tmp");
  EXPECT_TRUE(std::string("/tmp/the-fox") == path);

  path = TRI_GetAbsolutePath("the-fox.lol", "/tmp");
  EXPECT_TRUE(std::string("/tmp/the-fox.lol") == path);

  path = TRI_GetAbsolutePath("the-fox.lol", "/tmp/the-fox");
  EXPECT_TRUE(std::string("/tmp/the-fox/the-fox.lol") == path);

  path = TRI_GetAbsolutePath("file", "/");
  EXPECT_TRUE(std::string("/file") == path);

  path = TRI_GetAbsolutePath("./file", "/");
  EXPECT_TRUE(std::string("/./file") == path);

  path = TRI_GetAbsolutePath("/file", "/tmp");
  EXPECT_TRUE(std::string("/file") == path);

  path = TRI_GetAbsolutePath("/file/to/file", "/tmp");
  EXPECT_TRUE(std::string("/file/to/file") == path);

  path = TRI_GetAbsolutePath("file/to/file", "/tmp");
  EXPECT_TRUE(std::string("/tmp/file/to/file") == path);

  path = TRI_GetAbsolutePath("c:file/to/file", "/tmp");
  EXPECT_TRUE(std::string("c:file/to/file") == path);
#endif
}

TEST_F(CFilesTest, tst_normalize) {
  std::string path;

  path = "/foo/bar/baz";
  FileUtils::normalizePath(path);
#ifdef _WIN32
  EXPECT_TRUE(std::string("\\foo\\bar\\baz") == path);
#else
  EXPECT_TRUE(std::string("/foo/bar/baz") == path);
#endif

  path = "\\foo\\bar\\baz";
  FileUtils::normalizePath(path);
#ifdef _WIN32
  EXPECT_TRUE(std::string("\\foo\\bar\\baz") == path);
#else
  EXPECT_TRUE(std::string("\\foo\\bar\\baz") == path);
#endif

  path = "/foo/bar\\baz";
  FileUtils::normalizePath(path);
#ifdef _WIN32
  EXPECT_TRUE(std::string("\\foo\\bar\\baz") == path);
#else
  EXPECT_TRUE(std::string("/foo/bar\\baz") == path);
#endif

  path = "/foo/bar/\\baz";
  FileUtils::normalizePath(path);
#ifdef _WIN32
  EXPECT_TRUE(std::string("\\foo\\bar\\baz") == path);
#else
  EXPECT_TRUE(std::string("/foo/bar/\\baz") == path);
#endif

  path = "//foo\\/bar/\\baz";
  FileUtils::normalizePath(path);
#ifdef _WIN32
  EXPECT_TRUE(std::string("\\\\foo\\bar\\baz") == path);
#else
  EXPECT_TRUE(std::string("//foo\\/bar/\\baz") == path);
#endif

  path = "\\\\foo\\/bar/\\baz";
  FileUtils::normalizePath(path);
#ifdef _WIN32
  EXPECT_TRUE(std::string("\\\\foo\\bar\\baz") == path);
#else
  EXPECT_TRUE(std::string("\\\\foo\\/bar/\\baz") == path);
#endif
}

TEST_F(CFilesTest, tst_getfilename) {
  EXPECT_TRUE("" == TRI_GetFilename(""));
  EXPECT_TRUE("." == TRI_GetFilename("."));
  EXPECT_TRUE("" == TRI_GetFilename("/"));
  EXPECT_TRUE("haxxmann" == TRI_GetFilename("haxxmann"));
  EXPECT_TRUE("haxxmann" == TRI_GetFilename("/haxxmann"));
  EXPECT_TRUE("haxxmann" == TRI_GetFilename("/tmp/haxxmann"));
  EXPECT_TRUE("haxxmann" == TRI_GetFilename("/a/b/c/haxxmann"));
  EXPECT_TRUE("haxxmann" == TRI_GetFilename("c:/haxxmann"));
  EXPECT_TRUE("haxxmann" == TRI_GetFilename("c:/tmp/haxxmann"));
  EXPECT_TRUE("foo" == TRI_GetFilename("c:/tmp/haxxmann/foo"));
  EXPECT_TRUE("haxxmann" == TRI_GetFilename("\\haxxmann"));
  EXPECT_TRUE("haxxmann" == TRI_GetFilename("\\a\\haxxmann"));
  EXPECT_TRUE("haxxmann" == TRI_GetFilename("\\a\\b\\haxxmann"));
}

////////////////////////////////////////////////////////////////////////////////
/// @brief test TRI_Dirname
////////////////////////////////////////////////////////////////////////////////

TEST_F(CFilesTest, tst_dirname) {
#ifdef _WIN32
  EXPECT_EQ("C:\\Users\\abc def\\foobar", TRI_Dirname("C:\\Users\\abc def\\foobar\\"));
  EXPECT_EQ("C:\\Users\\abc def\\foobar", TRI_Dirname("C:\\Users\\abc def\\foobar\\baz"));
  EXPECT_EQ("C:\\Users\\abc def\\foobar", TRI_Dirname("C:\\Users\\abc def\\foobar\\baz.text"));
  EXPECT_EQ("C:\\Users\\abc def\\foobar", TRI_Dirname("C:\\Users\\abc def\\foobar\\VERSION-1.tmp"));
  EXPECT_EQ("\\Users\\abc def\\foobar", TRI_Dirname("\\Users\\abc def\\foobar\\VERSION-1.tmp"));
#else
  EXPECT_EQ("/tmp/abc/def hihi", TRI_Dirname("/tmp/abc/def hihi/"));
  EXPECT_EQ("/tmp/abc/def hihi", TRI_Dirname("/tmp/abc/def hihi/abc"));
  EXPECT_EQ("/tmp/abc/def hihi", TRI_Dirname("/tmp/abc/def hihi/abc.txt"));
  EXPECT_EQ("/tmp", TRI_Dirname("/tmp/"));
  EXPECT_EQ("/tmp", TRI_Dirname("/tmp/1"));
  EXPECT_EQ("/", TRI_Dirname("/tmp"));
  EXPECT_EQ("/", TRI_Dirname("/"));
  EXPECT_EQ(".", TRI_Dirname("./"));
  EXPECT_EQ(".", TRI_Dirname(""));
  EXPECT_EQ(".", TRI_Dirname("."));
  EXPECT_EQ("..", TRI_Dirname(".."));
#endif
}

////////////////////////////////////////////////////////////////////////////////
/// @brief process data in a file via a functor
////////////////////////////////////////////////////////////////////////////////

TEST_F(CFilesTest, tst_processFile) {
  const char* buffer = "the quick brown fox";
  bool good;

  StringBuffer* filename = writeFile(buffer);

  ByteCountFunctor bcf;
  auto reader = std::ref(bcf);
  good = TRI_ProcessFile(filename->c_str(), reader);

  EXPECT_TRUE(good);
  EXPECT_EQ(strlen(buffer), bcf._byteCount);

  TRI_SHA256Functor sha;
  auto shaReader = std::ref(sha);

  good = TRI_ProcessFile(filename->c_str(), shaReader);

  EXPECT_TRUE(good);
  EXPECT_TRUE(sha.final().compare("9ecb36561341d18eb65484e833efea61edc74b84cf5e6ae1b81c63533e25fc8f")==0);

  TRI_UnlinkFile(filename->c_str());
  delete filename;
}


text:
'use strict';
const express = require('express');
const router = express.Router();
const User = require('../models/user');
const logger = require('../logger');
const jwt = require('jsonwebtoken');
const JWT_SECRET = process.env.JWT_SECRET;

function validation(req, res, next) {
    if (!req.body.email || !req.body.password) {
        return res.status(400).json({
            message: 'Missing params',
            code: 'missing_params'
        });
    }
    return next();
}

router.post('/auth/login', validation, (req, res) => {
    return User.findOne({email: req.body.email})
        .then((user) => {
            if (!user) {
                return res.status(400).json({
                    code: 'authentication_failed',
                    message: 'User not found'
                });
            }
            if (!user.validPassword(req.body.password)) {
                return res.status(400).json({
                    code: 'authentication_failed',
                    message: 'Authentication failed!'
                });
            }
            var token = jwt.sign(user.toJSON(), JWT_SECRET);
            return res.status(200).json({
                token
            });
        })
        .catch((error) => {
            logger.error('Login error: ', error.message);
            return res.status(500).json({
                message: 'Internal error',
                code: 'internal_error'
            });
        });
});

function checkIfExist(req, res, next) {
    return User.count({email: req.body.email}).then((count) => {
        if (count === 0) {
            return next();
        }
        return res.status(400).json({
            message: 'email already in use!',
            code: 'email_alredy_used'
        });
    }).catch((error) => {
        logger.error('countUserError: ', error.message);
        return res.status(500).json({
            message: 'Internal error',
            code: 'internal_error'
        });
    });
}

router.post('/auth/signup', validation, checkIfExist, (req, res) => {
    const newUser = new User({
        full_name: req.body.fullname,
        password: req.body.password,
        email: req.body.email
    });

    return newUser.save()
        .then(() => {
            return res.status(201).json({});
        })
        .catch((error) => {
            logger.error('signupError: ', error.message);
            return res.status(500).json({
                message: 'Internal error',
                code: 'internal_error'
            });
        });
});

module.exports = router;


text:
title: Shared Template for ToolTips
page_title: Shared Template for ToolTips | RadHtmlChart for ASP.NET AJAX Documentation
description: Shared Template for ToolTips
slug: htmlchart/functionality/clienttemplate/shared-template-for-tooltips
tags: shared,template,for,tooltips
published: True
position: 2
---

# Shared Template for ToolTips

## Shared Templates for ToolTips

You can hover over a single series item and display a common tooltip with information about all the series items from the particular category. As of Q3 2013, the templates for tooltips in **RadHtmlChart** can be shared among all the series items within their group. You can share these templatesby setting the following properties in the **CommonTooltipsAppearance** element, exposed by the **PlotArea** of the chart:

* **Shared** - You must explicitly set this property to **true** for standard charts. For Sparkline layout, the default value is **true**.

* **SharedTemplate** - You must set the composite **SharedTemplate** property to the appropriate string that represents the desired shared template that you want to apply to the tooltips when they render. The **SharedTemplate** composite property can use the following fields:

* **points** - The category points (`#= points[i].series.name#, #= points[i].value #`) where i is the index of the series.

* **category** - The category name (`#= category #`) The string delimited inside `#=.....#` is the expression to be evaluated. The tooltips are HTML, so HTML can be used outside of the expression tags.

>note You can use number formats inside **SharedTemplates** . You can find more information in [this Formatting Numbers]({%slug htmlchart/appearance-and-styling/format-numbers%}) article in the section called *Formatting Labels and Tooltips by Using their Client Templates.*

## Example of Using SharedTemplates for ToolTips

This example illustrates the code that configures **SharedTemplate** for tooltips in **Example 1** and shows the actual output in **Figure 1**.

>caption Figure 1: Hover over a single series item and display common information about all the series items from	the category in the tooltip.

![htmlchart-client Templates-shared Template](images/htmlchart-clientTemplates-sharedTemplate.png)

The chart in **Figure 1** was created with the markup in **Example 1**.

>caption Example 1: You can share the information about the series items from the category in a tooltip by configuring the **Shared** and **SharedTemplate** properties exposed by the **CommonTooltipsAppearance** element in the **PlotArea**.

````C#
<telerik:radhtmlchart runat="server" id="ColumnChart" width="800" height="500">
	<ChartTitle Text="GDP for Transport and Communication">
	</ChartTitle>
	<PlotArea>
		<CommonTooltipsAppearance Shared="true" Color="White" BackgroundColor="Gray">
			<SharedTemplate>
				<div>GDP in #= category #</div>
				 # for (var i = 0; i < points.length; i++) { #
				<div>#: points[i].series.name#: #: points[i].value #</div>
				# } #
			</SharedTemplate>
		</CommonTooltipsAppearance>
		<XAxis>
			<Items>
				<telerik:AxisItem LabelText="1999"></telerik:AxisItem>
				<telerik:AxisItem LabelText="2000"></telerik:AxisItem>
				<telerik:AxisItem LabelText="2001"></telerik:AxisItem>
				<telerik:AxisItem LabelText="2002"></telerik:AxisItem>
			</Items>
			<TitleAppearance Text="Years">
			</TitleAppearance>
		</XAxis>
		<YAxis>
			<TitleAppearance Text="GDP">
			</TitleAppearance>
		</YAxis>
		<Series>
			<telerik:ColumnSeries Name="Transport">
				<Appearance>
					<FillStyle BackgroundColor="#2A7A00"></FillStyle>
				</Appearance>
				<SeriesItems>
					<telerik:CategorySeriesItem Y="32735.7"></telerik:CategorySeriesItem>
					<telerik:CategorySeriesItem Y="37911.3"></telerik:CategorySeriesItem>
					<telerik:CategorySeriesItem Y="39462.8"></telerik:CategorySeriesItem>
					<telerik:CategorySeriesItem Y="32234.5"></telerik:CategorySeriesItem>
				</SeriesItems>
			</telerik:ColumnSeries>
			<telerik:ColumnSeries Name="Community">
				<Appearance>
					<FillStyle BackgroundColor="#B8D936"></FillStyle>
				</Appearance>
				<SeriesItems>
					<telerik:CategorySeriesItem Y="12453.9"></telerik:CategorySeriesItem>
					<telerik:CategorySeriesItem Y="14394.3"></telerik:CategorySeriesItem>
					<telerik:CategorySeriesItem Y="16333.1"></telerik:CategorySeriesItem>
					<telerik:CategorySeriesItem Y="25109"></telerik:CategorySeriesItem>
				</SeriesItems>
			</telerik:ColumnSeries>
		</Series>
	</PlotArea>
</telerik:radhtmlchart>
````

## See Also

 * [Overview]({%slug htmlchart/functionality/clienttemplate/overview%})

 * [Display HTML and Execute JavaScript]({%slug htmlchart/functionality/clienttemplate/display-html-and-execute-javascript%})

 * [Format Numbers]({%slug htmlchart/appearance-and-styling/format-numbers%})


text:
<?php
namespace Jasekz\RentalsUnitedCaching\Models;

use DB;

class DiscountsLongStay extends Base{

    protected $table = 'RentalsUnited_PropertyDiscountsLongStays';

    protected  $primaryKey = 'ID';

    public function prop()
    {
        return $this->belongsTo('Jasekz\RentalsUnitedCaching\Models\Prop', 'PropID', 'ID');
    }

}


text:
*******
Dialogs
*******

Asymptote Options Dialog
========================

The asymptotes are the points at which the probability function goes to zero.  This occurs between the positive and negative phases.  For raytracing, only the opacity has relevance.

- **Opacity**: If set to less than 100%, the surface of the asymptote will be translucent.  When using raytracing, this has a uniform opacity.  When in polugon or point mode, this is not a true translucence, but is done by drawing only some of the pixels to produce quick results.  If 0%, no asymptotes are drawn.

- **Wireframe**: If selected, then only the edges of the asymptote polygons are drawn.  The opacity settings are ignored.

- **Points**: If selected, then only the verticies of the asymptote polygons are drawn.  The opacity settings are ignored.

- **Polygon Density**:- When an asymptote is drawn in either the point mode or the polygon mode, it is approximated by a series of polygons (much the way the polygon mode works).  The density is the maximum number of polygon edges across the asymptote radius.  This number must be even and must be at least 6.

  Generally, the density is required to be at least the maximum of :math:`2 (n - l)`, :math:`2 (l - |m|)`, and :math:`2 |m|`, or features will be missing.  If the asymptote is not complete, try increasing the density.

- **Auto**: Automatically sets the polygon density to "good" values.  The density is a best guess, and will almost never be too high.  It may, however, be too low.

Camera Options Dialog
=====================

When the orbital is rotated using the mouse or menu commands, it's coordinate system actually remains the same.  Rather, the camera is moved.

The axes figure shows the orientation, position, and size of the current camera view.  It shows the three cardinal axes.  It can be rotated using the left mouse button, zoomed using the right mouse button, and panned using the middle mouse button (or both right and left mouse buttons together).

- **Fixed Image Size**: If this option is not selected, the image on the screen is stored internally at the same resolution as the screen.  This means that the screen resolution is used for saving, copying, and raytracing.  If the window is resized, the size of the image changes.  When using raytracing, the computer must restart the computations.

  When fixed size is turned on and a positive **width** and **height** are specified, the orbital is internally drawn at the specified resolution.  This is the resolution saved to a graphics file or copied to the clipboard.  Raytracing draws the orbital at the specified resolution, then scales the result to fit the visible window.  This allows images larger than the screen to be produced (limited only by available memory), and prevents resizing a window from affecting processing.

- **Current Radius**: This is current length of the axes drawn to the right.  It is also the size of the orbital that is considered when Reset Position or Reframe Orbital are selected.  If asymptotes or probability density plots are used, this radius is located at point where the probability is 1/1000 of the maximum probability present in the orbital.  If only probability surfaces are used, this radius is at the point which encloses this surface.  Note that the radius will be artificially large for molecules, as the computations to determine surface extents and maximum probability are too time-consuming to do otherwise.

- **theta**, **phi**, and **psi** angles: This is the orientation of the camera.  At the 0, 0, 0 orientation, the coordinate system has positive *z* out of the screen, positive *x* to the right, and positive *y* pointing upward.  A rotation in *theta* rotates about the *z* axis.  A rotation in *phi* rotates about the transformed *x* axis (transformed by *theta*).  A rotation in *psi* rotates about the transformed *y* axis (transformed by *theta* and *phi*).

- **x**, **y**, and **z** position: This is the camera's position with respect to the center of the orbital, in the camera's rotation system.  Zero *x* and *y* values and a positive *z* value always points directly at the center of the orbital, regardless of the camera orientation.

Colors Dialog
=============

The specified colors are used for all drawing modes (points, polygons, and raytracing).  On 8-bit displays, the actual specified colors may not be available, and an approximation is used.  In stereo display modes, the colors may be ignored.

- **Background**: This is the color used in areas where no orbital is visible.  It is not used on stereograms.

- **Positive Phase**: This is the color used for the positive phase of the orbital when the light intensity is of value 1.  The positive phase is the part of the orbital where the value of *Psi* (:math:`\Psi`) is greater than zero (:math:`\Psi^2` is plotted).  It is not used in red-blue, stereograms, or chromadepth stereo displays.

- **Negative Phase**: This is the color used for the negative phase of the orbital when the light intensity is of value 1.  The negative phase is the part of the orbital where the value of Psi is less than zero (:math:`\Psi^2` is plotted).  It is not used in red-blue, stereograms, or chromadepth stereo displays.

- **Asymptote Color**: This is the color used for the orbital asymptote when the light intensity is of value 1. It is not used in red-blue, stereograms, or chromadepth stereo displays.

- **Preview**: This is the color of the figures shown in the Lighting Dialog and in the Cutaway Dialog.

- **Apply to all windows**: If this is selected, changes in color will affect all open windows.  Otherwise, changes will only affect the active window.

- **Change preferences**: If this is selected, all new orbitals will have the new colors; otherwise this change is a one-time event.

- **Reset**: Sets the colors back to the default values.

Customize Toolbar Dialog
========================

This is a standard Windows dialog; see Windows documentation for details.

Cutaway Options Dialog
======================

A cutaway allows the interior of an orbital to be seen.  For polygons, this results in a very coarse approximation unless the cutaway is exactly aligned with the coordinate system axes.

The figure shows what part of the orbital will be removed.  It is drawn in the default camera orientation (not the current camera orientation).  The sphere has the same radius as the current orbital (this is displayed in the Camera Dialog).

The cutaway can be rotated using the left mouse button, moved front and back using the right mouse button, and panned using the middle mouse button (or both right and left mouse buttons together).

- **Cutaway Type**: The cutaway type determines how much of the orbital is removed.

  - **None** turns off cutaways.

  - **Plane** removes everything with a positive *z* value.

  - **Corner** removes everything that has a positive *z* and a positive *y* value.

  - **Wedge** removes everything which has positive *x*, *y*, and *z* values.

- **Surface**: (Applies only to raytracing)  This determines if a part of the orbital which is cut by the cutaway will have a surface.  Without the surface, the "interior" of a surface plot can be seen.  With a surface, the orbital will appear as a solid object with a piece removed.

- **Invert**: This reverses what is kept versus what is removed.  The coordinates for this are determined by the cutaway orientation and position.  This has no effect if the None option is selected.

- **alpha**, **beta**, and **gamma** angles: This is the orientation of the cutaway.  At the 0, 0, 0 orientation, the coordinate system has positive *z* out of the screen, positive *x* to the right, and positive *y* pointing upward.  A rotation in *alpha* rotates about the *z* axis.  A rotation in *beta* rotates about the transformed *x* axis (transformed by *alpha*).  A rotation in *gamma* rotates about the transformed *z* axis (transformed by *alpha* and *beta*).

- **x**, **y**, and **z** position: This is the cutaway's position with respect to the center of the orbital, in the orbital's rotation system.

Light Source Dialog
===================

Lighting determines how a polygon or raytraced orbital looks.  The figure shows a preview of the currently selected light's position, intensity, and ambience.  It is always shaded with a planar light source, not a point source.  The light's position can be rotated using the left mouse button, and can be moved closer or further from the origin with the right mouse button.

- **Light**: This is the currently displayed light source.  Any number of light sources may be specified, limited only to available memory.  Additional light sources will slow down orbital computation for all but point displays.

- **Add**: Adds an additional light source, exactly duplicating the currently displayed light source.  In no light sources are currently defined, the light source is the default upper-left light source.

- **Delete**: Discards the current light source.

- **x**, **y**, and **z** position: This is the location of the current light source in the orbital coordinate system  If the **Rotate with viewpoint** box is not checked, then the light source will be always appear to be from the same location, regardless of how the camera is rotated.  The light source is never moved aside from this rotation.

  For polygon displays, all light source are planar light sources.  Their position only determines the direction.  As such, a light source at 0, 0, 0 will not properly illuminate a polygon set.

  For raytraced displays, all light sources are point light sources.  If the light source is sufficiently far away, it is effectively a planar light source.

- **Rotate with viewpoint**: If unselected, the light source will remain in a visually fixed location while the orbital is rotated.  If selected, then the light source remains in the orbital coordinate system, which rotates the same way the orbital rotates.

- **Intensity**: This is the amount of light put out by the current light source.  An intensity of 1 which is normal to a surface will produce exactly the color specified in the Colors Dialog.  Intensities may exceed 1.  Typically, the sum of the intensities of all light sources should be from 1 to 1.1.  If an orbital is too dark, the intensity can be increased to brighten it.

- **Ambiance**: This determines how sharp the shadows are.  It only applies to raytracing.  An ambiance of 1 produces no shadows.  An ambiance of 0 produces completely black shadows.

Orbital Dialog
==============

This dialog determines exactly what atom or molecule is drawn.  Different elements can be specified by explicitly giving the number of protons and the mass of the atom.  Molecules are produced using a linear combination of atomic orbitals (LCAO).  To reverse the positive and negative phases of an atom, change the factor to -1.

- **Atom**: This is the currently displayed atom.  Any positive number of atoms may be specified, limited only to available memory.  Calculation time is directly affected by the number of atoms used.

- **Add**: Adds an additional atom, exactly duplicating the currently displayed atom.

- **Delete**: Discards the current atom.

- **n**: Principal quantum number.  This is the most significant quantum number.  It is a positive integer.  Due to precision limitations of 64-bit floating point numbers, *n* is restricted to values from 1 to 30.

- **l**: Orbital quantum number.  This is a non-negative integer that is less than *n*.  It is often referred to by a letter (for historical reasons), as follows:

  0 - s;  1 - p;  2 - d;  3 - f;  4 - g;  5 - h;  6 - i;  7 - k;  8 - l;  9 - m;  10 - n;  11 - o;  12 - q;  13 - r;  14 - t;  15 - u;  16 - v;  17 - w;  18 - x;  19 - y;  20 - z

- **m**: Angular momentum quantum number.  This is an integer from *-l* to *+l*.

- **Protons**: Number of protons in the atom.  This affects the scale of the orbital.

- **Atomic Mass**: The mass of the atom affects the radius of the orbital.  It is dependent on the number of protons and neutrons.  As an approximation, it is (number of protons) + (number of neutrons) amu.

- **Factor**: This is a multiplicative factor for the orbital probability, Psi (:math:`\Psi`).  It is primarily of use in constructing molecules.  For example, the orbital for H2O contains two hydrogen atoms, one which has a positive phase and one which has a negative.  For the first, the factor is 1, and for the second it is -1.

- **alpha**, **beta**, and **gamma** angles: This is the orientation of the atom.  At the :math:`0, 0, 0` orientation, the coordinate system has positive *z* out of the screen, positive *x* to the right, and positive *y* pointing upward.  A rotation in *alpha* rotates about the *z* axis.  A rotation in *beta* rotates about the transformed *x* axis (transformed by *alpha*).  A rotation in *gamma* rotates about the transformed *z* axis (transformed by *alpha* and *beta*).

- **x**, **y**, and **z** position: This is the location of the center of the atom.  It is primarily useful in specifying molecules, since each atom must be at a different location.

Play Sequence Dialog
====================

A sequence gradually transforms the orbital.  This can include rotation and position, lighting, probability values, opacity, color, atomic values, cutaway location, and more.

- **Frame**: This is the frame at which point the sequence is exactly like the orbital file specified to the right.  These points are used to interpolate all of the other frames.

  If Bezier interpolation is used, only the first and last frames will exactly match the selected orbital files.  The other frames are construction frames.

  The check box shows which of the four sequence specification orbitals are in use.  At least two orbitals must be used to define a sequence.  If two are used, all values are scaled linearly between the two sequences.  If three are used, values are interpolated using either a bezier or quadratic function, and if four are specified, values are interpolated using a bezier or cubic function.

  Clicking on an empty box will allow the orbital to be selected from a file.  To keep an existing orbital, cancel the file dialog.

  Files can be in either .ORB or .OV format.

  The frame number must be an integer.

- **Incremental positions**:  If this box is turned off, all values, including camera position and orientation are determined by either a linear, quadratic, cubic, or Bezier fit depending on the number of orbitals used to define the sequence.  Since angles are specified on a [0, 2pi) range, using interpolation does not always produce the desired results.

  When the box is checked, the first orbital is used as a starting position, and the difference between the first and second orbital is used as an increment for the camera angle and position on a per frame basis.  Even if the second orbital is at an earlier frame, the difference is the increment per positive frame.

- **Bezier interpolation**: This box only applies when three or four orbital specification files are used to define the sequence.

  When this box is not checked, each frame is determined by a quadratic or cubic interpolation.  The interpolated values are guaranteed to match the specified values at the specified times.  For example, the cubic function uses the formula

  :math:`v = A t^3 + B t^2 + C t + D`

  where :math:`v` is the computed value, :math:`A`, :math:`B`, :math:`C`, and :math:`D` are the coefficients of the cubic function, and :math:`t` is the current time.

  When the Bezier box is checked, a Bezier spline is used to determine the interpolated values.  The interpolated values are guaranteed to match the specified values at the specified times for the first and last specifications only.  The slope of the interpolation function at the first and last points is the same as the slope between the first and second points and the second to last and last points, respectively.  The Bezier interpolation satisfies the equations

  :math:`t = A_t p^3 + B_t p^2 + C_t p + D_t`

  :math:`v = A_v p^3 + B_v p^2 + C_v P + D_v`

  where :math:`v` is the computed value, :math:`p` is a parametric value, :math:`t` is the current time, :math:`A_t`, :math:`B_t`, :math:`C_t`, and :math:`D_t` are coefficients based on the times of the specification files, and :math:`A_v`, :math:`B_v`, :math:`C_v`, and :math:`D_v` are coefficients based on the values of the specification files.

- **Base save file name**: After a sequence frame has been computed, it can optionally be saved.  If the base is set, the frame is saved as a graphic file with the name ``base number.type``, where ``base`` is the specified base name, ``number`` is the frame number, and ``type`` is the file type.  The base name should be chosen such that it produces valid filenames in the current system using the specified frame numbers.

  For .AVI files, the entire sequence is saved to a file with the name ``base.AVI``.

- **Browse**: This shows a file dialog so that the base file name can be graphically selected.

- **File format**: Sequence files can be saved as any of these graphics formats:

  - .PPM - Portable Pixel Map Files - save a 24-bit per pixel uncompressed graphic.  This is a format popular on Unix machines.

  - .TIF - Tagged Image File Format - save a 24-bit per pixel run-length-encoded compressed graphic.  This is a very widespread format that can be read on almost any platform.

  - .BMP - Windows Bitmap Files - save a 24-bit per pixel uncompressed graphic.  This is compatible with most Windows programs.

  - .AVI - Audio Video Interleaved Files - save an AVI animation file.  This is an uncompressed file (use Compress AVI to compress it) contain every frame.  Frames are appended to the file, never destroying anything already in the file.

- **Frames per second**: This is the rate at which AVI files will be played back.  It only applies to AVI files.

- **Start frame** and **End frame**: The sequence will begin with the specified start frame, and advance or retreat one frame at a time until the end frame is reached.  The orbital for each frame is determined by interpolating between the specification files.  If the end frame is less than the start frame, then the sequence is run "backwards", counting down.

- **Done**: Closes the dialog, saving changes but not starting the sequence.

- **Play**: Closes the dialog, storing the changes made, and starts playing the sequence.  Each frame is generated and saved, then the window advances to the next frame.

Point Options Dialog
====================

The point display is a probability density plot.  This means that there are more points in areas with greater probabilities.

- **Number of Points**: This is the number of points which will be generated.  Depending on the exact orbital, this may be very quick or very slow.  All points are guaranteed to be within the radius where the orbital's probability is 1/1000th of the maximum probability.

- **Asymptote Options**: Show the Asymptote Options Dialog

Polygon Options Dialog
======================

Polygons are an approximation of a surface of constant probability.  They are fast to draw, but are not as good looking as raytracing.

- **Psi^2 probability**: This is the value for which the constant probability is drawn, expressed at the base-10 exponent.  A more negative number results in a probability surface which has a larger radius.  If the probability is too high, no surfaces of the orbital may be visible.

- **Auto**: Automatically sets the probability and polygon density to "good" values.  The density is a best guess, and will almost never be too high.  It may, however, be too low.

- **Asymptote Options**: Show the Asymptote Options Dialog

- **Positive phase opacity**:  If set to less than 100%, the surface of the polygon will be functionally translucent by not drawing all pixels.  This is not a true translucence like raytracing, but is done to still produce quick results.  If 0%, the positive phase surface will not be drawn.

- **Negative phase opacity**:  If set to less than 100%, the surface of the polygon will be functionally translucent by not drawing all pixels.  This is not a true translucence like raytracing, but is done to still produce quick results.

- **Density**: A probability surface is approximated by a series of polygons.  The density is the maximum number of initial polygon edges across the orbital radius.  This number must be even and must be at least 6.  After the initial polygons are computed, they are divided into smaller polygons based on the Refine setting.

  Generally, the density is required to be at least the maximum of :math:`2 (n - l)`, :math:`2 (l - |m|)`, and :math:`2 |m|`, or features will be missing.  If the orbital is not complete, try increasing the density.

- **Refine**: The probability surface is initially approximated by a series of polygons, the quantity of which is determined by the density.  After the initial polygons are computed, they are divided into smaller polygons based on the Refine setting.  A setting of 0 will prevent any refinement from being performed.  A refinement of :math:`x` will ensure that no edge is longer than :math:`1/x` of the original density specification.  The larger the refinement number, the more polygons will be generated.

- **Wireframe**: If selected, then only the edges of the orbital polygons are drawn.  The opacity settings are ignored.

- **Points**: If selected, then only the verticies of the orbital polygons are drawn.  The opacity settings are ignored.

Preferences Dialog
==================

- **Show Error Messages**: These are messages informing of problems such as insufficient memory or a problem reading or writing a file.

- **Show Warning Messages**: These are dialogs which confirm that a certain action should be taken, such as deleting an atom or a light source, overwriting an existing file, or reseting the preferences.

- **Show Toolbar**: This is the line of controls immediately below the menu.

- **Show Tool Tips**: These are the small rectangles of text which identify the controls on the toolbar.

- **Show Status Line**: This is the bottom line on the main window showing the percent completion of an orbital, the frame or atom, and informational text about menu items.

- **Show Start Screen**: This is the window which is displayed for five seconds when the program starts.  When it is shown, it can be removed sooner by clicking on it or using a menu.

- **VRML File Options**: Some VRML require a particular point or polygon color style or the points and polygons will not appear.  The default is to use ambient and diffuse color for both point and polygons, and to use emissive color for the points (emissive color is never used for polygons).  This works in many, but not all VRML viewers.

- **Point Size**: In the point drawing style, and for asymptotes and polygons drawn as points, this is the size of the point on the screen.  The point will be this many pixels square.  Larger sizes improve visibility, but produce a chunky look.

- **Menu / Toolbar Step Sizes**: When the menu items are used to rotate, pan, or zoom the orbital, these controls specify by how much.

- **Reset All**: This restores all colors and preferences to the default setting.  It also disregards the DEFAULT.ORB file, making new windows with the original default orbital.

Raytrace Options Dialog
=======================

Raytracing is the highest quality method of drawing an orbital, but it is also the slowest.  It is the only method which supports shadows, index of refraction, and true opacity.

- **Psi^2 probability**: This is the value for which the constant probability is drawn, expressed at the base-10 exponent.  A more negative number results in a probability surface which has a larger radius.  If the probability is too high, no surfaces of the orbital may be visible.  This does not affect drawings based on probability opacity.

- **Auto**: Automatically select surface probability.  This is the computer's best guess at what will make an interesting figure.

- **Probability opacity per step**: This determines the opacity of a particular pixel based on the probability of the orbital along the ray from the camera point through that pixel.  The higher the probability, the more opaque the image.  This is computed by taking a number of steps through the orbital (specified in the Number of Steps parameter), and evaluating the probability at each point.  A point with the maximum probability in the orbital will have the specified opacity within that step.  Typically small values work well, such as between 5 % and 20 %.

- **Surface opacity**: This is the opacity of a surface of constant probability.  For positive and negative phases, the probability is specified above, whereas for asymptotes the probability is zero.  For positive and negative phases, the opacity is constant regardless of view angle.  For asymptotes the opacity increases as the view becomes oblique.

- **Interior opacity per step**: If a point is within the surface of constant probability, than it has this opacity.  This is computed by taking a number of steps through the orbital (specified in the Number of Steps parameter), and evaluating the probability at each point.  Any point above the specified probability will have this opacity.  Numbers are specified in percent of percent (1%% equals 0.0001).

- **Index of refraction**: A non-unity index of refraction creates a "lensing" effect, as if the orbital were made of glass.  The index of refraction is relative to that of free space.  This means that to model a glass orbital in air, an index of refraction of 1.54 (crown glass) might be specified, whereas to model an air orbital in glass, the index of refraction would be :math:`1/1.54=0.65`.  Note that shadow computations are not technically perfect when a non-unity index of refraction is specified.

- **Link positive and negative phases**: When this box is checked, any change to the positive phase will result in an equal change to the negative phase, and vice versa.

- **Number of steps**: For any plots other than 100% opacity surface plots, each pixel is computed by taking a series of small steps through its interior and determining the cumulative effect.  This determines the number of steps through the radius of the orbital.  Twice this many will be taken at the center, whereas almost no steps are taken at the edge.

- **Auto Brightness**: When turned on, this will draw the orbital in a very coarse manner (16x16 pixel blocks), and, based on this picture will adjust the brightness to a "good" value.  This necessitates redrawing the coarse pixels.

  To adjust brightness manually, change the intensity of the light source.

- **Antialias**: An orbital is raytraced using a multipass technique.  First, 16x16 pixel blocks are drawn, then 4x4 pixel blocks, then individual pixels.  If antialias is turned on, one more pass is performed, where pixels at color transitions are analyzed by oversampling (measuring the pixels at non-integer locations).  The average of the oversampling is then drawn.  This has the effect of smoothing the edges of the orbital.

- **Coarse Render**: An orbital is raytraced using a multipass technique.  First, 16x16 pixel blocks are drawn, then 4x4 pixel blocks, then individual pixels.  If coarse rendering is turned on, then the individual pixels may be approximated from the 4x4 blocks.  This is only done in regions where there is relatively smooth color transition between the 4x4 blocks.  Coarse rendering can substantially speed up drawing, but may blur or miss small features.

Rendering Method Dialog
=======================

Point mode draws a point probability density plot.

Polygon mode draws a probablity surface approximated by polygons.

Raytracing produces the best drawings, but is generally the slowest.  It has more options than point or polygon modes, including index of refraction and interior opacity.

- **Use Quick Rendering**:- When the orbital is drawn, one of the three rendering techniques can be used.  When quick rendering is turned on, any time the orbital is moved or rotated, the quick method will be used to draw the orbital.  When the quick method has finished, the precise method will then be used to redraw it.

  This allows, for example, a polygon drawing method be used for spinning the orbital in real time, while drawing a higher precision raytracing when the orbital s not moving.

Stereo Options Dialog
=====================

A stereo display allows the orbital to be seen three-dimensionally.  This is always at the expense of either resolution or color.

The accompanying graphic shows an example of the stereo mode.  With the exception of stereograms, these are all pregenerated images in the actual stereo mode.  Stereograms only show random dots (no image within it) or the selected image file.

- **Monoscopic**: The standard one image, non-stereo method of drawing.

- **Stereoscope**: A stereoscope is a device with mirrors to allows two images from different vantage points to be seen easily.  Stereoscopes can be cheaply constructed from easily obtainable materials (see the elsewhere inthe documentation for instructions), or can be bought with high-quality optics.  The two views are present side by side.

- **Interlaced**: LCD shutter glasses often work by showing alternate scan lines of the monitor to each eye.  The **Swap** option switches which line is drawn on the left.

- **Red-blue** (Anaglyph): The old classic 3D glasses use one red lens and one blue lens.  This allows either the right or the left to contain either color.  Color information is lost in this mode.

- **Stereogram**: The Single Image Random Dot Stereogram (SIRDS) has the benefit that it does not require special optics to view.  This can either use random pixels or can use a source image.  The preview shown to the right is NOT an actual stereo image.  Color and intensity information is lost in this mode.

- **Overlay**: For those people blessed with excellent stereo vision, this method is a more attractive alternative to stereograms.

- **Chromadepth**: Chromadepth glasses are similar to anaglyph (red-blue) glasses, but they use diffraction to create depth.  The depth is therefore based on the color, with red being closest.  Original color information is lost in this mode.

- **Interocular distance**: This is the separation between the eyes in pixels.  For red-blue, overlay, stereogram, and interlaced modes, this is the actual physical distance between the eyes (which is dependent both on the viewer and on the monitor used).  For stereoscopes, this is the distance between the eyes, plus the mirror separation distance.

- **Actual separation**: For stereoscope, red-blue, overlay, and interlaced modes, this is the "physical" separation between the eyes in the orbital coordinate system.  Generally, this is a very small number since the orbitals are very small.    More separation will give a greater perception of depth.  If **Auto** is turned on, the separation is selected automatically to a "good" value.

- **Perspective factor**: This number determines the effective focal length of the camera used in viewing the orbital.  A larger number is a larger focal length, which results in less perspective distortion.  Typically, values between 5 and 25 work well.  Larger numbers have little noticeable effect, while smaller numbers have pronounced keystone effects.

- **Stereogram Image**: Stereograms can either be based on random dots or on a source image.  If this box is not checked, it is based on random dots.  Checking the box will present a file dialog along any graphic file in the following formats to be selected: .BMP (Windows bitmap), .CUR (Windows cursor), .GROB (HP calculator), .ICO (Windows icon), .JPG (jpeg), .PCX (Paintbrush), .PPM (portable pixel map), .TGA (targa), .TIF (tagged image file format).  The image is displayed in the preview area.

  Some additional formats may be usable if Python with the Pillow module are installed such that Python can be run from the system path.


text:
import {DataSource} from "../../../../../catalog/api/models/datasource";
import {Injectable} from "@angular/core";
import {PreviewDataSet} from "../../../../../catalog/datasource/preview-schema/model/preview-data-set";
import {FEED_DEFINITION_SECTION_STATE_NAME} from "../../../../../model/feed/feed-constants";
import {DefineFeedService} from "../../../services/define-feed.service";
import {TdDialogService} from "@covalent/core/dialogs";
import {FeedLoadingService} from "../../../services/feed-loading-service";
import {StateRegistry, StateService} from "@uirouter/angular";
import {Feed} from "../../../../../model/feed/feed.model";
import {Step} from "../../../../../model/feed/feed-step.model";
import {HttpClient} from "@angular/common/http";
import {SparkDataSet} from "../../../../../model/spark-data-set.model";
import {PreviewFileDataSet} from "../../../../../catalog/datasource/preview-schema/model/preview-file-data-set";
import {Observable} from "rxjs/Observable";
import {RestUrlConstants} from "../../../../../services/RestUrlConstants";

@Injectable()
export class DefineFeedSourceSampleService {
    constructor(private http:HttpClient){

    }

    public parseSchema(previewDataSet:PreviewFileDataSet) : Observable<any>{

        let ds:SparkDataSet = previewDataSet.toSparkDataSet();
        let schemaParser = previewDataSet.schemaParser;
        let request = {dataSet:ds,schemaParser:schemaParser};
        let url = RestUrlConstants.SCHEMA_DISCOVERY_PARSE_DATA_SET;
        return <Observable<any>> this.http.post(url,request,{ headers: {
                'Content-Type': 'application/json; charset=UTF-8'
            }});
    }

    public parseTableSettings(previewDataSet:PreviewFileDataSet) : Observable<any>{

        let ds:SparkDataSet = previewDataSet.toSparkDataSet();
        let schemaParser = previewDataSet.schemaParser;
        let request = {dataSet:ds,schemaParser:schemaParser};
        let url = RestUrlConstants.SCHEMA_DISCOVERY_TABLE_SETTINGS_DATA_SET;
        return <Observable<any>> this.http.post(url,request,{ headers: {
                'Content-Type': 'application/json; charset=UTF-8'
            }});
    }

}


text:
export function foo(): string {
  return 'foo';
}


text:
using System.Runtime.CompilerServices;
using Windows.ApplicationModel.Resources;

namespace Kinnara.Xaml.Controls
{
    internal class ControlResources
    {
        private static ResourceLoader _resourceLoader = ResourceLoader.GetForViewIndependentUse("Kinnara.Toolkit/Resources");

        public static string DatePickerTitleText
        {
            get { return GetString(); }
        }

        public static string TimePickerTitleText
        {
            get { return GetString(); }
        }

        private static string GetString([CallerMemberName]string resource = null)
        {
            return _resourceLoader.GetString(resource);
        }
    }
}


text:
using System;
using System.Linq;
using System.Threading;
using NewRelic.Microsoft.SqlServer.Plugin.Configuration;
using NewRelic.Microsoft.SqlServer.Plugin.Core;
using NewRelic.Platform.Sdk.Utils;

namespace NewRelic.Microsoft.SqlServer.Plugin
{
    internal class Program
    {
        private static readonly Logger _log = Logger.GetLogger(typeof(Program).Name);

        private static int Main(string[] args)
        {
            try
            {
                var options = Options.ParseArguments(args);

                var settings = ConfigurationParser.ParseSettings();
                settings.TestMode = options.TestMode;
                Settings.Default = settings;

                Thread.CurrentThread.Name = "Main";
                _log.Info("New Relic Sql Server Plugin");
                _log.Info("Loaded Settings:");
                settings.ToLog();

                if (!settings.Endpoints.Any())
                {
                    _log.Error("No sql endpoints found please, update the configuration file to monitor one or more sql server instances.");
                }
                else
                {
                    var poller = new SqlPoller(settings);
                    poller.Start();

                    // Suspend the main thread indefinitely as the SqlPoller will spawn its own thread
                    Thread.Sleep(Timeout.Infinite);
                }

                return 0;
            }
            catch (Exception ex)
            {
                Console.Out.WriteLine(ex.Message);
                Console.Out.WriteLine();

                return -1;
            }
        }
    }
}


text:
import { ENV } from 'ember-environment';
import { w } from '@ember/string';
import { moduleFor, AbstractTestCase } from 'internal-test-helpers';

function test(assert, given, expected, description) {
  assert.deepEqual(w(given), expected, description);
  if (ENV.EXTEND_PROTOTYPES.String) {
    assert.deepEqual(given.w(), expected, description);
  }
}

moduleFor(
  'EmberStringUtils.w',
  class extends AbstractTestCase {
    ['@test String.prototype.w is not available without EXTEND_PROTOTYPES'](assert) {
      if (!ENV.EXTEND_PROTOTYPES.String) {
        assert.ok('undefined' === typeof String.prototype.w, 'String.prototype helper disabled');
      } else {
        assert.expect(0);
      }
    }

    ['@test String w tests'](assert) {
      test(
        assert,
        'one two three',
        ['one', 'two', 'three'],
        `w('one two three') => ['one','two','three']`
      );
      test(
        assert,
        'one   two  three',
        ['one', 'two', 'three'],
        `w('one    two    three') with extra spaces between words => ['one','two','three']`
      );
      test(assert, 'one\ttwo  three', ['one', 'two', 'three'], `w('one two three') with tabs`);
    }
  }
);


text:
@interface OneViewController : UIViewController

@property (nonatomic, copy) void(^goToAction)();

@end


text:
import './cosmoz-omnitable-settings';

export { default as useSettings } from './use-settings';


text:
#ifndef __D_ITEMS__
#define __D_ITEMS__

#include "doomdef.h"

#ifdef __GNUG__
#pragma interface
#endif

// Weapon info: sprite frames, ammunition use.
typedef struct
{
    ammotype_t	ammo;
    int		upstate;
    int		downstate;
    int		readystate;
    int		atkstate;
    int		flashstate;

} weaponinfo_t;

extern  const weaponinfo_t    weaponinfo[NUMWEAPONS];

#endif