Map implemetation that preserves order of insertion
Which of the Map implementations guarantees order of insertion? That is, if I iterate through the Map, I should be able to get the keys in the same order in which I inserted. Also, new insertions should always go to the end.
I'm using the jakarta tag libs to build our application front end so we are using Maps for the select tags. The trouble is that TreeMap does not maintain insert order.
The other problem is that we cannot yet migrate to J2SE 1.4 (I really don't know why), so LinkedHashMap won't fly.
I don't suppose anyone out there knows of an implementation of an insert order Map that I can pick up and drop in my development? I'm trying to save myself the pain of reinventing the wheel. I need it in the next couple of days so I've set my line while I get on with other things and I'll see what comes up.
Isn't it frustrating when you get locked into a software version, and no matter how many new features will save you how much dev time... you can't move on it...
Ah well, here's hoping.
Mark
Similar Messages
-
Hi,
I am looking for a Map that preserves the order of the keys and values inserted to that.
I tried TreeMap, but that sorts the items alpabetically. But this is not what I want.
Can somebody help me?
SebI would think it is easy enough to create your own map to do this:
-Make a new class, with 2 Lists.
-Create methods that loop through and access these Lists, for keys and values
-Make your "add" methods tack things on to the ends of the Lists, to preserve order -
How to configure a map of patches names of my midi device in order to insert program changes from Logic?
Thomjinx wrote:
You can usually use a patch editor-librarian program like Sound Diver or MidiQuest to copy and paste the patch names (one bank at a time) into the patch name list of a multi-intsrument object in the environment.
That's what I do. Works like a charm.
Cheer,
Thomjinx
"My first copy of Logic came on Floppy disks"
And you will need to setup bank change commands for your particular instrument, if it does in fact have several banks of internal patches. Logic comes with a selection of bank change commands, one of them will almost always work.
My first copy of Logic came on floppies, two of them I think and was MIDI only, moved up to Logic_Audio at version 3.0 I think. -
Mapping Tables to Preserve R3 Document numbers
We are considering implementing a mapping table that will be called from all extractors that include financial document numbers as a way to preserve historical document numbers in BW after they have been changed in R3. I am interested in comments on this process and anyone who is running with this or a simlar process. This will of course mean that our BW data no longer matches the R3 data. Any SAP documentation which points to the need to keep BW and R3 in sync would also be helpful.
Thanks, CarolHello,
sounds innovative, one thing you can be careful of is that when you enter a bulk documents in those fields, if any of the document is incorrect, system will simply give you a yellow message and almost quietly remove that document from the list. Now imagine if it happens when you enter a bulk document how terrible will it be to identify that incorrect document ? According to me, its better to enter part by part and once you are done you can click on process open item and proceed.
best regds
Subha -
PackedInteger encoding does not preserve order - but it could
Currently, when viewed under the default unsigned lexical ordering, "packed" integers (and longs) do not sort numerically. This is because for values requiring two or more bytes, the "value" bytes are stored little endian.
For example:
<tt> 65910 -> 7a ff 00 01</tt>
<tt> 65911 -> 7a 00 01 01</tt>
However, it's possible to encode packed integers such that they still sort correctly. You can do this by modifying the existing PackedInteger algorithm as follows:
<li>Invert the high-order bit on the first byte
<li>Reverse the order of the second and subsequent bytes (if any)
<li>If the original number was negative, invert (one's complement) the bits in the second and subsequent bytes (if any)
Here's some examples showing the two encodings:
NUMBER ENCODING NEW ENCODING
-9223372036854775808 8189ffffffffffff7f 018000000000000076
-2147483648 8589ffff7f 0580000076
-65911 86000101 06fefeff
-65910 86ff0001 06feff00
-65655 86000001 06feffff
-65654 87ffff 070000
-65400 8701ff 0700fe
-65399 8700ff 0700ff
-375 870001 07feff
-374 88ff 0800
-120 8801 08fe
-119 89 09
-1 ff 7f
0 00 80
1 01 81
119 77 f7
120 7801 f801
374 78ff f8ff
375 790001 f90100
631 790002 f90200
65399 7900ff f9ff00
65400 7901ff f9ff01
65654 79ffff f9ffff
65655 7a000001 fa010000
65910 7aff0001 fa0100ff
65911 7a000101 fa010100
2147483647 7b88ffff7f fb7fffff88
9223372036854775807 7f88ffffffffffff7f ff7fffffffffffff88So the question is.. any particular reason this wasn't done? Would this alternate encoding be a useful addition? (I'm sure it's not possible to replace the current algorithm at this point).
Thanks.greybird wrote:
Thanks Archie. I appreciate this and I know you have good intentions. Unfortunately, we won't be able to incorporate any code from your svn repository. We can only incorporate submissions if the source code is posted here in our OTN forum.Not a problem... Here is the new class:
package org.dellroad.sidekar.util;
import com.sleepycat.bind.tuple.TupleInput;
import com.sleepycat.bind.tuple.TupleOutput;
import java.util.Arrays;
* An improved version of Berkeley DB's {@link com.sleepycat.util.PackedInteger} class that packs values in such
* a way that their order is preserved when compared using the default binary unsigned lexical ordering.
* @see <a href="http://forums.oracle.com/forums/thread.jspa?messageID=4126254">Berkeley DB Java Edition forum posting</a>
public final class PackedLong {
* Maximum possible length of an encoded value.
public static final int MAX_ENCODED_LENGTH = 9;
* Minimum value for the first byte of a single byte encoded value. Lower values indicate a multiple byte encoded negative value.
public static final int MIN_SINGLE_BYTE_ENCODED = 0x08; // values 0x00 ... 0x07 prefix negative values
* Maximum value for the first byte of a single byte encoded value. Higher values indicate a multiple byte encoded positive value.
public static final int MAX_SINGLE_BYTE_ENCODED = 0xf7; // values 0xf8 ... 0xff prefix positive values
* Adjustment applied to single byte encoded values before encoding.
public static final int ZERO_ADJUST = 127; // single byte value that represents zero
* Minimum value that can be encoded as a single byte.
public static final int MIN_SINGLE_BYTE_VALUE = MIN_SINGLE_BYTE_ENCODED - ZERO_ADJUST; // -119
* Maximum value that can be encoded as a singel byte.
public static final int MAX_SINGLE_BYTE_VALUE = MAX_SINGLE_BYTE_ENCODED - ZERO_ADJUST; // 120
* Adjustment applied to multiple byte encoded negative values before encoding.
public static final int NEGATIVE_ADJUST = -MIN_SINGLE_BYTE_VALUE; // 119
* Adjustment applied to multiple byte encoded positive values before encoding.
public static final int POSITIVE_ADJUST = -(MAX_SINGLE_BYTE_VALUE + 1); // -121
// Cutoff values at which the encoded length changes (this field is package private for testing purposes)
static final long[] CUTOFF_VALUES = new long[] {
0xff00000000000000L - NEGATIVE_ADJUST, // [ 0] requires 8 bytes
0xffff000000000000L - NEGATIVE_ADJUST, // [ 1] requires 7 bytes
0xffffff0000000000L - NEGATIVE_ADJUST, // [ 2] requires 6 bytes
0xffffffff00000000L - NEGATIVE_ADJUST, // [ 3] requires 5 bytes
0xffffffffff000000L - NEGATIVE_ADJUST, // [ 4] requires 4 bytes
0xffffffffffff0000L - NEGATIVE_ADJUST, // [ 5] requires 3 bytes
0xffffffffffffff00L - NEGATIVE_ADJUST, // [ 6] requires 2 bytes
MIN_SINGLE_BYTE_VALUE, // [ 7] requires 1 byte
MAX_SINGLE_BYTE_VALUE + 1, // [ 8] requires 2 bytes
0x0000000000000100L - POSITIVE_ADJUST, // [ 9] requires 3 bytes
0x0000000000010000L - POSITIVE_ADJUST, // [10] requires 4 bytes
0x0000000001000000L - POSITIVE_ADJUST, // [11] requires 5 bytes
0x0000000100000000L - POSITIVE_ADJUST, // [12] requires 6 bytes
0x0000010000000000L - POSITIVE_ADJUST, // [13] requires 7 bytes
0x0001000000000000L - POSITIVE_ADJUST, // [14] requires 8 bytes
0x0100000000000000L - POSITIVE_ADJUST, // [15] requires 9 bytes
private PackedLong() {
* Write the encoded value to the output.
* @param output destination for the encoded value
* @param value value to encode
public static void write(TupleOutput output, long value) {
output.makeSpace(MAX_ENCODED_LENGTH);
int len = encode(value, output.getBufferBytes(), output.getBufferLength());
output.addSize(len);
* Read and decode a value from the input.
* @param input input holding an encoded value
* @return the decoded value
public static long read(TupleInput input) {
long value = decode(input.getBufferBytes(), input.getBufferOffset());
input.skipFast(getReadLength(input));
return value;
* Determine the length (in bytes) of an encoded value without advancing the input.
* @param input input holding an encoded value
* @return the length of the encoded value
public static int getReadLength(TupleInput input) {
return getReadLength(input.getBufferBytes(), input.getBufferOffset());
* Determine the length (in bytes) of an encoded value.
* @param buf buffer containing encoded value
* @param off starting offset of encoded value
* @return the length of the encoded value
* @throws ArrayIndexOutOfBoundsException if {@code off} is not a valid offset in {@code buf}
public static int getReadLength(byte[] buf, int off) {
int prefix = buf[off] & 0xff;
if (prefix < MIN_SINGLE_BYTE_ENCODED)
return 1 + MIN_SINGLE_BYTE_ENCODED - prefix;
if (prefix > MAX_SINGLE_BYTE_ENCODED)
return 1 + prefix - MAX_SINGLE_BYTE_ENCODED;
return 1;
* Determine the length (in bytes) of the encoded value.
* @return the length of the encoded value, a value between one and {@link #MAX_ENCODED_LENGTH}
public static int getWriteLength(long value) {
int index = Arrays.binarySearch(CUTOFF_VALUES, value);
if (index < 0)
index = ~index - 1;
return index < 8 ? 8 - index : index - 6;
* Encode the given value into a new buffer.
* @param value value to encode
* @return byte array containing the encoded value
public static byte[] encode(long value) {
byte[] buf = new byte[MAX_ENCODED_LENGTH];
int len = encode(value, buf, 0);
if (len != MAX_ENCODED_LENGTH) {
byte[] newbuf = new byte[len];
System.arraycopy(buf, 0, newbuf, 0, len);
buf = newbuf;
return buf;
* Encode the given value and write the encoded bytes into the given buffer.
* @param value value to encode
* @param buf output buffer
* @param off starting offset into output buffer
* @return the number of encoded bytes written
* @throws ArrayIndexOutOfBoundsException if {@code off} is negative or the encoded value exceeds the given buffer
public static int encode(long value, byte[] buf, int off) {
int len = 1;
if (value < MIN_SINGLE_BYTE_VALUE) {
value += NEGATIVE_ADJUST;
long mask = 0x00ffffffffffffffL;
for (int shift = 56; shift != 0; shift -= 8) {
if ((value | mask) != ~0L)
buf[off + len++] = (byte)(value >> shift);
mask >>= 8;
buf[off] = (byte)(MIN_SINGLE_BYTE_ENCODED - len);
} else if (value > MAX_SINGLE_BYTE_VALUE) {
value += POSITIVE_ADJUST;
long mask = 0xff00000000000000L;
for (int shift = 56; shift != 0; shift -= 8) {
if ((value & mask) != 0L)
buf[off + len++] = (byte)(value >> shift);
mask >>= 8;
buf[off] = (byte)(MAX_SINGLE_BYTE_ENCODED + len);
} else {
buf[off] = (byte)(value + ZERO_ADJUST);
return 1;
buf[off + len++] = (byte)value;
return len;
* Decode a value from the given buffer.
* @param buf buffer containing an encoded value
* @param off starting offset of the encoded value in {@code buf}
* @return the decoded value
* @throws ArrayIndexOutOfBoundsException if {@code off} is negative or the encoded value is truncated
* @see #getReadLength
public static long decode(byte[] buf, int off) {
int first = buf[off++] & 0xff;
if (first < MIN_SINGLE_BYTE_ENCODED) {
long value = ~0L;
while (first++ < MIN_SINGLE_BYTE_ENCODED)
value = (value << 8) | (buf[off++] & 0xff);
return value - NEGATIVE_ADJUST;
if (first > MAX_SINGLE_BYTE_ENCODED) {
long value = 0L;
while (first-- > MAX_SINGLE_BYTE_ENCODED)
value = (value << 8) | (buf[off++] & 0xff);
return value - POSITIVE_ADJUST;
return (byte)(first - ZERO_ADJUST);
}and here is the unit test:
package org.dellroad.sidekar.util;
import com.sleepycat.bind.tuple.TupleInput;
import com.sleepycat.bind.tuple.TupleOutput;
import com.sleepycat.je.DatabaseEntry;
import org.dellroad.sidekar.TestSupport;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
import static org.testng.Assert.assertEquals;
public class PackedLongTest extends TestSupport {
@Test(dataProvider = "encodings")
public void testEncoding(long value, String string) {
// Test direct encoding
byte[] expected = ByteArrayEncoder.decode(string);
byte[] actual = PackedLong.encode(value);
assertEquals(actual, expected);
// Test write()
TupleOutput out = new TupleOutput();
PackedLong.write(out, value);
assertEquals(out.toByteArray(), expected);
// Test getWriteLength()
assertEquals(actual.length, PackedLong.getWriteLength(value));
// Test decoding
long value2 = PackedLong.decode(actual, 0);
assertEquals(value2, value);
// Test read()
TupleInput input = JEUtil.toTupleInput(new DatabaseEntry(actual));
assertEquals(actual.length, PackedLong.getReadLength(input));
value2 = PackedLong.read(input);
assertEquals(value2, value);
// Test getReadLength()
assertEquals(actual.length, PackedLong.getReadLength(actual, 0));
@Test(dataProvider = "lengths")
public void testEncodedLength(long value, int expected) {
int actual = PackedLong.getWriteLength(value);
assertEquals(actual, expected);
byte[] buf = PackedLong.encode(value);
assertEquals(buf.length, expected);
@DataProvider(name = "encodings")
public Object[][] genEncodings() {
return new Object[][] {
// Corner cases
{ 0x8000000000000000L, "008000000000000077" },
{ 0xfeffffffffffff88L, "00feffffffffffffff" },
{ 0xfeffffffffffff89L, "0100000000000000" },
{ 0xfeffffffffffffffL, "0100000000000076" },
{ 0xfffeffffffffff88L, "01feffffffffffff" },
{ 0xfffeffffffffff89L, "02000000000000" },
{ 0xfffeffffffffffffL, "02000000000076" },
{ 0xfffffeffffffff88L, "02feffffffffff" },
{ 0xfffffeffffffff89L, "030000000000" },
{ 0xfffffeffffffffffL, "030000000076" },
{ 0xfffffffeffffff88L, "03feffffffff" },
{ 0xfffffffeffffff89L, "0400000000" },
{ 0xfffffffeffffffffL, "0400000076" },
{ 0xfffffffffeffff88L, "04feffffff" },
{ 0xfffffffffeffff89L, "05000000" },
{ 0xfffffffffeffffffL, "05000076" },
{ 0xfffffffffffeff88L, "05feffff" },
{ 0xfffffffffffeff89L, "060000" },
{ 0xfffffffffffeffffL, "060076" },
{ 0xfffffffffffffe88L, "06feff" },
{ 0xfffffffffffffe89L, "0700" },
{ 0xfffffffffffffeffL, "0776" },
{ 0xffffffffffffff88L, "07ff" },
{ 0xffffffffffffff89L, "08" },
{ 0xffffffffffffffa9L, "28" },
{ 0xffffffffffffffc9L, "48" },
{ 0xffffffffffffffe9L, "68" },
{ 0xffffffffffffffffL, "7e" },
{ 0x0000000000000000L, "7f" },
{ 0x0000000000000001L, "80" },
{ 0x0000000000000071L, "f0" },
{ 0x0000000000000077L, "f6" },
{ 0x0000000000000078L, "f7" },
{ 0x0000000000000079L, "f800" },
{ 0x0000000000000178L, "f8ff" },
{ 0x0000000000000179L, "f90100" },
{ 0x0000000000010078L, "f9ffff" },
{ 0x0000000000010079L, "fa010000" },
{ 0x0000000001000078L, "faffffff" },
{ 0x0000000001000079L, "fb01000000" },
{ 0x0000000100000078L, "fbffffffff" },
{ 0x0000000100000079L, "fc0100000000" },
{ 0x0000010000000078L, "fcffffffffff" },
{ 0x0000010000000079L, "fd010000000000" },
{ 0x0001000000000078L, "fdffffffffffff" },
{ 0x0001000000000079L, "fe01000000000000" },
{ 0x0100000000000078L, "feffffffffffffff" },
{ 0x0100000000000079L, "ff0100000000000000" },
{ 0x7fffffffffffff79L, "ff7fffffffffffff00" },
{ 0x7fffffffffffffffL, "ff7fffffffffffff86" },
// Other cases
{ 0xffffffff80000000L, "0480000077" },
{ 0xfffffffffffefe89L, "05feff00" },
{ 0xfffffffffffefe8aL, "05feff01" },
{ 0xfffffffffffeff86L, "05fefffd" },
{ 0xfffffffffffeff87L, "05fefffe" },
{ 0xfffffffffffeff88L, "05feffff" },
{ 0xfffffffffffeff89L, "060000" },
{ 0xfffffffffffeff8aL, "060001" },
{ 0xffffffffffff0086L, "0600fd" },
{ 0xffffffffffff0087L, "0600fe" },
{ 0xffffffffffff0088L, "0600ff" },
{ 0xffffffffffff0089L, "060100" },
{ 0xfffffffffffffe86L, "06fefd" },
{ 0xfffffffffffffe87L, "06fefe" },
{ 0xfffffffffffffe89L, "0700" },
{ 0xfffffffffffffe8aL, "0701" },
{ 0xffffffffffffff87L, "07fe" },
{ 0xffffffffffffff88L, "07ff" },
{ 0xffffffffffffff89L, "08" },
{ 0xffffffffffffffffL, "7e" },
{ 0x0000000000000000L, "7f" },
{ 0x0000000000000001L, "80" },
{ 0x0000000000000077L, "f6" },
{ 0x0000000000000078L, "f7" },
{ 0x0000000000000176L, "f8fd" },
{ 0x0000000000000177L, "f8fe" },
{ 0x0000000000000178L, "f8ff" },
{ 0x0000000000000277L, "f901fe" },
{ 0x000000000000ff77L, "f9fefe" },
{ 0x000000000000ff78L, "f9feff" },
{ 0x000000000000ff79L, "f9ff00" },
{ 0x000000000000ff7aL, "f9ff01" },
{ 0x0000000000010076L, "f9fffd" },
{ 0x0000000000010077L, "f9fffe" },
{ 0x0000000000010078L, "f9ffff" },
{ 0x0000000000010079L, "fa010000" },
{ 0x000000000001007aL, "fa010001" },
{ 0x0000000000010176L, "fa0100fd" },
{ 0x0000000000010177L, "fa0100fe" },
{ 0x000000007fffffffL, "fb7fffff86" },
{ 0x7fffffffffffffffL, "ff7fffffffffffff86" },
@DataProvider(name = "lengths")
public Object[][] genLengths() {
return new Object[][] {
// Check cutoff values
{ PackedLong.CUTOFF_VALUES[ 0] - 1, 9 },
{ PackedLong.CUTOFF_VALUES[ 0], 8 },
{ PackedLong.CUTOFF_VALUES[ 1] - 1, 8 },
{ PackedLong.CUTOFF_VALUES[ 1], 7 },
{ PackedLong.CUTOFF_VALUES[ 2] - 1, 7 },
{ PackedLong.CUTOFF_VALUES[ 2], 6 },
{ PackedLong.CUTOFF_VALUES[ 3] - 1, 6 },
{ PackedLong.CUTOFF_VALUES[ 3], 5 },
{ PackedLong.CUTOFF_VALUES[ 4] - 1, 5 },
{ PackedLong.CUTOFF_VALUES[ 4], 4 },
{ PackedLong.CUTOFF_VALUES[ 5] - 1, 4 },
{ PackedLong.CUTOFF_VALUES[ 5], 3 },
{ PackedLong.CUTOFF_VALUES[ 6] - 1, 3 },
{ PackedLong.CUTOFF_VALUES[ 6], 2 },
{ PackedLong.CUTOFF_VALUES[ 7] - 1, 2 },
{ PackedLong.CUTOFF_VALUES[ 7], 1 },
{ PackedLong.CUTOFF_VALUES[ 8] - 1, 1 },
{ PackedLong.CUTOFF_VALUES[ 8], 2 },
{ PackedLong.CUTOFF_VALUES[ 9] - 1, 2 },
{ PackedLong.CUTOFF_VALUES[ 9], 3 },
{ PackedLong.CUTOFF_VALUES[10] - 1, 3 },
{ PackedLong.CUTOFF_VALUES[10], 4 },
{ PackedLong.CUTOFF_VALUES[11] - 1, 4 },
{ PackedLong.CUTOFF_VALUES[11], 5 },
{ PackedLong.CUTOFF_VALUES[12] - 1, 5 },
{ PackedLong.CUTOFF_VALUES[12], 6 },
{ PackedLong.CUTOFF_VALUES[13] - 1, 6 },
{ PackedLong.CUTOFF_VALUES[13], 7 },
{ PackedLong.CUTOFF_VALUES[14] - 1, 7 },
{ PackedLong.CUTOFF_VALUES[14], 8 },
{ PackedLong.CUTOFF_VALUES[15] - 1, 8 },
{ PackedLong.CUTOFF_VALUES[15], 9 },
// Check some other values
{ Long.MIN_VALUE, 9 },
{ Long.MAX_VALUE, 9 },
{ (long)Integer.MIN_VALUE, 5 },
{ (long)Integer.MAX_VALUE, 5 },
{ (long)Short.MIN_VALUE, 3 },
{ (long)Short.MAX_VALUE, 3 },
{ (long)Byte.MIN_VALUE, 2 },
{ (long)Byte.MAX_VALUE, 2 },
{ 0, 1 },
}Edited by: archie172 on Mar 3, 2010 12:40 PM
Removed copyright message. -
I've looked in all the manuals to find a way of chaning the order of inserts on an audio track but can't seem to find a solution. Is this possible - am I missing something?
Nah, I'm 7.0.1, but I really think it's time to upgrade.
I'm just so sick of giving money to Apple, esp. since my motherboard died right after the warranty ended. $850.
That is to say, this command-dragging don't work for me unless I'm in the Audio Configuration window.
(Plus there's that crazy auto input monitor not working thing.)
And they're going to come out with 7.3 as soon as I buy the upgrade (I bet). -
The last time I looked for this was back in Oracle 7 so forgive me for trying again. I have an application that transmits large quantities of data between different database instances. This was originally designed (by someone else) using array inserts. The developer relied on the usual chance that the rows when inserted will be in the same order as when they were selected (bad choice). I know that there is not any "guaranteed" relationship between the order the rows were stored in the source database and the order they will be stored in the receiving database. What I need is a way to ensure that the rows go through a trigger on the receiving database in the same order they were selected from the source database. Anything new that might be of use. We are on 9.0.2. Just to be clear, the order the rows are physically stored in the database is not what I am talking about. I could care less about that. I just want to control the order they are processed through the receiving trigger.
I was afraid that might be the answer still. It all still comes back to a bad design to start out with. There is a sequence number assigned when the source row is inserted, but it isn't passed to the second table. There is a batch number created on the secondary table when the rows are inserted from the first table. They also populate another sequence on the incoming table and order by that sequence when processing the records. If they had passed the original sequence from the source table to the destination table as a column of data, and then ordered by the batch number and then the source table sequence, I wouldn't be having this problem. Unfortunately this is a very tightly regulated environment and it would take an act of congress to get a change of that scope pushed through.
Thanks
Chip -
In Places, the map view that shows the pin is too zoomed in.
When using Places, the map view that comes up showing the pin is too zoomed in. I have to zoom out about 4 tines in order to recognize where it is.
Thanks for sharing
LN -
I am looking for a map app that will allow me to place pins where my clients offices are on a map and keep them save every time I open the app. Does anyone out there know of an app that will do this?
"Motion 5" is your friend.
Michael Wohl has a nice 15 video series (free) about Motion 5 at http://www.macprovideo.com/tutorial/motion5101-overview-and-workflow-guide (right side)
This is a "teaser" series to sell his tutorials but it is really good. Just saw it yesterday for the first time.
While all you want is just to place pins, realize that Motion has so much more. All kinds of effects and they can be really customized. Maybe put their street address, contact name, and phone number by the pin?
Motion 5: cheap at $49.99 (just got my download two days ago)
Motion 5: Support Community athttps://discussions.apple.com/community/professional_applications/motion_5
If you're using the map for, say, deliveries, and use an iPad, what you could do is have a general map of the area imported into Motion, create the pins and whatever, then save (share?) it to the iPad.
Disclaimer: I have virtually no relationship with anything connected with this tutorial product, developer, or anything. -
Until this week there was a button next to the device identification that allowed you to refresh the Find My iPhone map. That button is now gone and I cannot see a way to refresh the map without exiting and reentering Find My iPhone. Any help would be appreciated. Thank you.
You need to go to the part where you see your device on the map and then there is a little refresh button next to the name of your device on the map page.
-
In a hurry, I opened an email that said "order was shipped from "ammazon". I downloaded the order document and it ended up being a zip file. I then realized what it was, and did not actually open the file. This was on my Iphone 5. What should I do now!?
Delete the email. The zip file will have no effect on your iPhone.
-
I've beeing having problems with Itunes since about january, wheneveer i click on itunes the error message reads "The file 'ituneslibrary.itl' cannot be opened because it was created by a newer version on of itunes", yet when i try to updat to itunes 11 or uninstall itunes from my computer i keep on getting a message stating "the feature you are trying to use is on a RD-ROM or ohter removable disk that is not available insert the 'itunes' disk and click OK" what is the best way to fix this problem?
yet when i try to updat to itunes 11 or uninstall itunes from my computer i keep on getting a message stating "the feature you are trying to use is on a RD-ROM or ohter removable disk that is not available insert the 'itunes' disk and click OK"
(1) Download the Windows Installer CleanUp utility installer file (msicuu2.exe) from the following Major Geeks page (use one of the links under the "DOWNLOAD LOCATIONS" thingy on the Major Geeks page):
http://majorgeeks.com/download.php?det=4459
(2) Doubleclick the msicuu2.exe file and follow the prompts to install the Windows Installer CleanUp utility. (If you're on a Windows Vista or Windows 7 system and you get a Code 800A0046 error message when doubleclicking the msicuu2.exe file, try instead right-clicking on the msicuu2.exe file and selecting "Run as administrator".)
(3) In your Start menu click All Programs and then click Windows Install Clean Up. The Windows Installer CleanUp utility window appears, listing software that is currently installed on your computer.
(4) In the list of programs that appears in CleanUp, select any iTunes entries and click "Remove", as per the following screenshot:
(5) Quit out of CleanUp, restart the PC and try another iTunes install. Does it go through properly this time? -
If you are not using J2SE 1.4 - OrderedMap - (maintains order of insertion)
Hi,
If you are not using J2SE 1.4 and still want to maintain the order of insertion unlike HashMap or Hashtable(which doesn't allow)
OrderedMap comes to resue!
import java.util.ArrayList;
import java.util.List;
import java.util.TreeMap;
public final class OrderedMap extends TreeMap {
private List list= new ArrayList();
public OrderedMap() {
public Object put(Object key, Object value) {
list.add(key);
return super.put(key, value);
public List getKeysList() {
return list;
};;Mail me how to use it!
Bye
tuniki
[email protected]Hi, Dude!
Probably you have to read the subject b4 posting something!
(Re: If you are not using J2SE 1.4 ->OrderedMap ->(maintains order of insertion))
Tuniki
[email protected] -
When I update my Mac, I get an Installation alert that in order to continue installation, i need to close iTunes. How do I stop the installation and how do I close iTunes?
That sounds like the latest iTunes Version 11.1.5 update.
To continue the installation you must first Quit iTunes.
To Quit iTunes, use
or -
Report on Orders that have Order Lines modified during the period
hi,
I am a Beginner, PLEASE I NEED A HELP
Report on Orders that have Order Lines modified during the periodI don't know a standard report (SE95 does not seem to include selection by date), maybe you can tweak SE16 display of table SMODILOG for your purpose.
Thomas
Maybe you are looking for
-
How to configure network virtualization in SCVMM 2012 R2 with two host
hi everyone... can you teach me how i configure networking in my infrastructure.. i am getting confuse that i have 2 phisical server, i don't know to set the netwokring in scvmm. Every best practice, i found in internet is using more than 2 physical
-
Java script error when using a "Table" component (jsc2)
using a table component, I get a js errors, when lodiing the HTML page, sorting rows etc. can some one helpe me or can some one have the same problem ?
-
Unix Executable Files and VLC index.dat file -Samsung Digimax S800
Hi and thanks for any enlightenment in advance . I got my new iMac in January and it's great . I'm using it mostly for games iWeb and pro apps like Logic . I continue to use my trusty old eMac for email and internet chores . I was preparing to instal
-
Can't pair iPhone 5 with Mac mini or iPad
When I try to pair my iPhone 5 with my Mac mini (current model), I'm able to go through all the steps and the Mac shows the iPhone is connected for about 1-2 secs and then drops the connection. I'm trying to pair them so I can use the TokenLock app
-
Hi there, I had a client want to use a bought flash template, what is the best way to import the files so it will work with dreamweaver so I can add additional text and change wording. Thanks for any help haven't done a web page for some time now.