size_t RandomNumberStore::TransferTo2(BufferedTransformation &target, lword &transferBytes, const std::string &channel, bool blocking)
{
	if (!blocking)
		throw NotImplemented("RandomNumberStore: nonblocking transfer is not implemented by this object");

	transferBytes = UnsignedMin(transferBytes, m_length - m_count);
	m_rng->GenerateIntoBufferedTransformation(target, channel, transferBytes);
	m_count += transferBytes;

	return 0;
}

void RandomNumberGenerator::GenerateBlock(byte *output, size_t size)
{
	CRYPTOPP_UNUSED(output), CRYPTOPP_UNUSED(size);

#if 0
	// This breaks AutoSeededX917RNG<T> generators.
	throw NotImplemented("RandomNumberGenerator: GenerateBlock not implemented");
#endif

	ArraySink s(output, size);
	GenerateIntoBufferedTransformation(s, DEFAULT_CHANNEL, size);
}

Real3 MeshSurface::draw_position(boost::shared_ptr<RandomNumberGenerator>& rng) const
{
#ifdef HAVE_VTK
    vtkPolyData* polydata = reader_->GetOutput();
    std::vector<double> areas(polydata->GetNumberOfCells());
    for (vtkIdType i(0); i < polydata->GetNumberOfCells(); i++)
    {
        vtkCell* cell = polydata->GetCell(i);
        vtkTriangle* triangle = dynamic_cast<vtkTriangle*>(cell);
        double p0[3];
        double p1[3];
        double p2[3];
        triangle->GetPoints()->GetPoint(0, p0);
        triangle->GetPoints()->GetPoint(1, p1);
        triangle->GetPoints()->GetPoint(2, p2);
        const double area = vtkTriangle::TriangleArea(p0, p1, p2);
        // std::cout << "p0: " << p0[0] << " " << p0[1] << " " << p0[2] << std::endl;
        // std::cout << "p1: " << p1[0] << " " << p1[1] << " " << p1[2] << std::endl;
        // std::cout << "p2: " << p2[0] << " " << p2[1] << " " << p2[2] << std::endl;
        // std::cout << "area of triangle " << i << ": " << area << std::endl;
        areas[i] = area;
    }
    const double rnd = rng->uniform(0.0, std::accumulate(areas.begin(), areas.end(), 0.0));
    double totarea = 0.0;
    for (vtkIdType i(0); i < polydata->GetNumberOfCells(); i++)
    {
        totarea += areas[i];
        if (rnd < totarea)
        {
            vtkCell* cell = polydata->GetCell(i);
            vtkTriangle* triangle = dynamic_cast<vtkTriangle*>(cell);
            double p0[3];
            double p1[3];
            double p2[3];
            triangle->GetPoints()->GetPoint(0, p0);
            triangle->GetPoints()->GetPoint(1, p1);
            triangle->GetPoints()->GetPoint(2, p2);
            const Real3 P0(p0[0], p0[1], p0[2]);
            const Real3 P1(p1[0], p1[1], p1[2]);
            const Real3 P2(p2[0], p2[1], p2[2]);
            const Real p(rng->uniform(0.0, 1.0)), q(rng->uniform(0.0, 1.0 - p));
            return (((P1 - P0) * p + (P2 - P0) * q + P0) + shift_) * ratio_;
        }
    }
    throw IllegalState("Never reach here.");
#else
    throw NotImplemented("not implemented yet.");
#endif
}

void TF_SignerBase::InputRecoverableMessage(PK_MessageAccumulator &messageAccumulator, const byte *recoverableMessage, unsigned int recoverableMessageLength) const
{
	PK_MessageAccumulatorBase &ma = static_cast<PK_MessageAccumulatorBase &>(messageAccumulator);
	const MessageEncodingInterface &mei = GetMessageEncodingInterface();
	unsigned int maxRecoverableLength = mei.MaxRecoverableLength(MessageRepresentativeBitLength(), GetHashIdentifier().second, ma.AccessHash().DigestSize());

	if (maxRecoverableLength == 0)
		{throw NotImplemented("TF_SignerBase: this algorithm does not support messsage recovery or the key is too short");}
	if (recoverableMessageLength > maxRecoverableLength)
		throw InvalidArgument("TF_SignerBase: the recoverable message part is too long for the given key and algorithm");

	ma.m_recoverableMessage.Assign(recoverableMessage, recoverableMessageLength);
	mei.ProcessRecoverableMessage(
		ma.AccessHash(), 
		recoverableMessage, recoverableMessageLength,
		NULL, 0, ma.m_semisignature);
}

std::unique_ptr<CanvasCommand> CanvasCommandFactory::create(CommandLine& commandLine)
{
    std::unique_ptr<CanvasCommand> canvasCommand;
    std::string nextToken;
    while ((nextToken = commandLine.nextToken()).length() > 0)
    {
        try
        {
            if (nextToken==CREATE_CANVAS_TOKEN)
            {
                canvasCommand.reset(new CreateCanvasCommand(commandLine.nextParameter(), commandLine.nextParameter()));
            }
            else if (nextToken==DRAW_LINE_TOKEN)
            {
                canvasCommand.reset(new DrawLineCommand(commandLine.nextParameter(), commandLine.nextParameter(), commandLine.nextParameter(), commandLine.nextParameter()));
            }
            else if (nextToken==DRAW_RECTANGLE_TOKEN)
            {
                canvasCommand.reset(new DrawRectangleCommand(commandLine.nextParameter(), commandLine.nextParameter(), commandLine.nextParameter(), commandLine.nextParameter()));
            }
            else if (nextToken==BUCKET_FILL_TOKEN)
            {
                canvasCommand.reset(new BucketFillCommand(commandLine.nextParameter(), commandLine.nextParameter(), commandLine.nextToken().at(0)));
            }
            else if (nextToken==QUIT_TOKEN)
            {
                // return null
            }
            else
            {
                throw NotImplemented("unknown command request");
            }
        }
        catch (std::logic_error& ex)
        {
            throw BadParameter("invalid parameter");
        }
    }
    return std::move(canvasCommand);
}

Type* Op2::getTypeConstant() {
	switch (op) {
	case ADD:
	case SUB:
	case MUL:
	case DIV:
		return Type::higherType(left->getTypeConstant(), right->getTypeConstant());
	case LT:
	case GT:
	case LEQ:
	case GEQ:
	case EQ:
	case NEQ:
	case LOG_AND:
	case LOG_OR:
	case LOG_XOR:
		return &Type::Bool;
	default:
		throw NotImplemented(std::string("constant caculation ") + left->getTypeConstant()->getName() +
			OpNames[op] + right->getTypeConstant()->getName());
	}
}

unsigned int RandomPool::TransferTo2(BufferedTransformation &target, unsigned long &transferBytes, const std::string &channel, bool blocking)
{
    if (!blocking)
        throw NotImplemented("RandomPool: nonblocking transfer is not implemented by this object");

    unsigned int t;
    unsigned long size = transferBytes;

    while (size > (t = pool.size() - getPos))
    {
        target.ChannelPut(channel, pool+getPos, t);
        size -= t;
        Stir();
    }

    if (size)
    {
        target.ChannelPut(channel, pool+getPos, size);
        getPos += size;
    }

    return 0;
}

// virtual
LLSD LLHTTPNode::simplePost(const LLSD& input) const
{
	throw NotImplemented();
}

TEST(PointCloudFactory, Default)
{
    NotImplemented();
}

bool mime::HandlesEverything() const
{
    NotImplemented(_T("mime::HandlesEverything()"));
    return false;
}

TEST(RenderOption, Default)
{
    NotImplemented();
}

 void step(void)
 {
     throw NotImplemented("a step size must be specified.");
 }

IntPoint ClipboardBal::dragLocation() const
{
    // OWB_PRINTF("ClipboardBal::dragLocation\n");
    NotImplemented();
    return IntPoint(0, 0);
}

TEST(RenderOptionWithEditing, Default)
{
    NotImplemented();
}

TEST(GeometryRenderer, Default)
{
    NotImplemented();
}

	byte GenerateByte() {throw NotImplemented("NullRNG: NullRNG should only be passed to functions that don't need to generate random bytes");}